Use mojo for Chrome Loading, Part 1

content/child/resource_dispatcher.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/child/resource_dispatcher.h"
 
 #include <utility>
 
@@ skipping 10 matching lines @@
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/request_info.h"
 #include "content/child/resource_scheduling_filter.h"
 #include "content/child/shared_memory_received_data_factory.h"
 #include "content/child/site_isolation_stats_gatherer.h"
 #include "content/child/sync_load_response.h"
+#include "content/child/url_response_body_consumer.h"
 #include "content/common/inter_process_time_ticks_converter.h"
 #include "content/common/navigation_params.h"
 #include "content/common/resource_messages.h"
 #include "content/common/resource_request.h"
 #include "content/common/resource_request_completion_status.h"
 #include "content/public/child/fixed_received_data.h"
 #include "content/public/child/request_peer.h"
 #include "content/public/child/resource_dispatcher_delegate.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/resource_response.h"
 #include "content/public/common/resource_type.h"
+#include "mojo/public/cpp/bindings/binding.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_response_headers.h"
 
 namespace content {
 
 namespace {
 
 // Converts |time| from a remote to local TimeTicks, overwriting the original
 // value.
@@ skipping 14 matching lines @@
 
 // Each resource request is assigned an ID scoped to this process.
 int MakeRequestID() {
   // NOTE: The resource_dispatcher_host also needs probably unique
   // request_ids, so they count down from -2 (-1 is a special we're
   // screwed value), while the renderer process counts up.
   static int next_request_id = 0;
   return next_request_id++;
 }
 
+class URLLoaderClientImpl final : public mojom::URLLoaderClient {
+ public:
+  URLLoaderClientImpl(int request_id, ResourceDispatcher* resource_dispatcher)
+      : binding_(this),
+        request_id_(request_id),
+        resource_dispatcher_(resource_dispatcher) {}
+  ~URLLoaderClientImpl() override {
+    if (body_consumer_)
+      body_consumer_->Cancel();
+  }
+
+  void OnReceiveResponse(const ResourceResponseHead& response_head) override {
+    resource_dispatcher_->OnMessageReceived(
+        ResourceMsg_ReceivedResponse(request_id_, response_head));
+  }
+
+  void OnStartLoadingResponseBody(
+      mojo::ScopedDataPipeConsumerHandle body) override {
+    DCHECK(!body_consumer_);
+    body_consumer_ = new URLResponseBodyConsumer(
+        request_id_, resource_dispatcher_, std::move(body));
+  }
+
+  void OnComplete(const ResourceRequestCompletionStatus& status) override {
+    body_consumer_->OnComplete(status);
+  }
+
+  mojom::URLLoaderClientPtr CreateInterfacePtrAndBind() {
+    return binding_.CreateInterfacePtrAndBind();
+  }
+
+ private:
+  mojo::Binding<mojom::URLLoaderClient> binding_;
+  scoped_refptr<URLResponseBodyConsumer> body_consumer_;
+  const int request_id_;
+  ResourceDispatcher* const resource_dispatcher_;
+};
+
 }  // namespace
 
 ResourceDispatcher::ResourceDispatcher(
     IPC::Sender* sender,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner)
     : message_sender_(sender),
       delegate_(NULL),
       io_timestamp_(base::TimeTicks()),
       main_thread_task_runner_(main_thread_task_runner),
       weak_factory_(this) {
@@ skipping 452 matching lines @@
     if (index != pending_requests_.end()) {
       PendingRequestInfo* pending_request = index->second.get();
       if (pending_request->is_deferred) {
         pending_request->deferred_message_queue.swap(q);
         return;
       }
     }
   }
 }
 
-void ResourceDispatcher::StartSync(const RequestInfo& request_info,
-                                   ResourceRequestBodyImpl* request_body,
-                                   SyncLoadResponse* response) {
+void ResourceDispatcher::StartSync(
+    const RequestInfo& request_info,
+    ResourceRequestBodyImpl* request_body,
+    SyncLoadResponse* response,
+    blink::WebURLRequest::LoadingIPCType ipc_type,
+    mojom::URLLoaderFactory* url_loader_factory) {
   std::unique_ptr<ResourceRequest> request =
       CreateRequest(request_info, request_body, NULL);
+  // TODO(yhirano): Use url_loader_factory otherwise.
+  DCHECK_EQ(blink::WebURLRequest::LoadingIPCType::ChromeIPC, ipc_type);
 
   SyncLoadResult result;
   IPC::SyncMessage* msg = new ResourceHostMsg_SyncLoad(
       request_info.routing_id, MakeRequestID(), *request, &result);
 
   // NOTE: This may pump events (see RenderThread::Send).
   if (!message_sender_->Send(msg)) {
     response->error_code = net::ERR_FAILED;
     return;
   }
 
   response->error_code = result.error_code;
   response->url = result.final_url;
   response->headers = result.headers;
   response->mime_type = result.mime_type;
   response->charset = result.charset;
   response->request_time = result.request_time;
   response->response_time = result.response_time;
   response->encoded_data_length = result.encoded_data_length;
   response->load_timing = result.load_timing;
   response->devtools_info = result.devtools_info;
   response->data.swap(result.data);
   response->download_file_path = result.download_file_path;
   response->socket_address = result.socket_address;
   response->encoded_data_length = result.encoded_data_length;
   response->encoded_body_length = result.encoded_body_length;
 }
 
-int ResourceDispatcher::StartAsync(const RequestInfo& request_info,
-                                   ResourceRequestBodyImpl* request_body,
-                                   std::unique_ptr<RequestPeer> peer) {
+int ResourceDispatcher::StartAsync(
+    const RequestInfo& request_info,
+    ResourceRequestBodyImpl* request_body,
+    std::unique_ptr<RequestPeer> peer,
+    blink::WebURLRequest::LoadingIPCType ipc_type,
+    mojom::URLLoaderFactory* url_loader_factory) {
   GURL frame_origin;
   std::unique_ptr<ResourceRequest> request =
       CreateRequest(request_info, request_body, &frame_origin);
 
   // Compute a unique request_id for this renderer process.
   int request_id = MakeRequestID();
   pending_requests_[request_id] = base::WrapUnique(new PendingRequestInfo(
       std::move(peer), request->resource_type, request->origin_pid,
       frame_origin, request->url, request_info.download_to_file));
 
   if (resource_scheduling_filter_.get() &&
       request_info.loading_web_task_runner) {
     resource_scheduling_filter_->SetRequestIdTaskRunner(
         request_id,
         request_info.loading_web_task_runner->clone());
   }
 
-  message_sender_->Send(new ResourceHostMsg_RequestResource(
-      request_info.routing_id, request_id, *request));
+  if (ipc_type == blink::WebURLRequest::LoadingIPCType::Mojo) {
+    std::unique_ptr<URLLoaderClientImpl> client(
+        new URLLoaderClientImpl(request_id, this));
+    mojom::URLLoaderPtr url_loader;
+    url_loader_factory->CreateLoaderAndStart(
+        GetProxy(&url_loader), request_id, *request,
+        client->CreateInterfacePtrAndBind());
+    pending_requests_[request_id]->url_loader = std::move(url_loader);
+    pending_requests_[request_id]->url_loader_client = std::move(client);
+  } else {
+    message_sender_->Send(new ResourceHostMsg_RequestResource(
+        request_info.routing_id, request_id, *request));
+  }
 
   return request_id;
 }
 
 void ResourceDispatcher::ToResourceResponseInfo(
     const PendingRequestInfo& request_info,
     const ResourceResponseHead& browser_info,
     ResourceResponseInfo* renderer_info) const {
   *renderer_info = browser_info;
   if (base::TimeTicks::IsConsistentAcrossProcesses() ||
@@ skipping 201 matching lines @@
     *frame_origin = extra_data->frame_origin();
   return request;
 }
 
 void ResourceDispatcher::SetResourceSchedulingFilter(
     scoped_refptr<ResourceSchedulingFilter> resource_scheduling_filter) {
   resource_scheduling_filter_ = resource_scheduling_filter;
 }
 
 }  // namespace content