[Reland] Post loading tasks on the appropriate WebFrameScheduler's queue

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 "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 96 matching lines @@
   if (!request_info->deferred_message_queue.empty()) {
     FlushDeferredMessages(request_id);
     request_info = GetPendingRequestInfo(request_id);
     DCHECK(request_info);
     if (request_info->is_deferred) {
       request_info->deferred_message_queue.push_back(new IPC::Message(message));
       return true;
     }
   }
 
-  DispatchMessage(message);
+  // If the request is associated with a specific loading task queue then
+  // dispatch the message there, otherwise dispatch it here.

[Sami, 2015/09/25 13:31:27]

I guess the other alternative would be to dispatch this on the correct runner
from the IO thread. Would it make sense to have a message filter which does
that? That would avoid this extra main thread hop.

I was thinking back to your earlier patch that forwards ranges of IPC messages
to different task runners, but this would need to be more general since we need
to inspect the message before we can route it. Also, |request_info| is probably
not thread safe so we might need to be smarter about how we read it.

WDYT?

[alex clarke (OOO till 29th), 2015/09/28 17:24:53]

Done. Turned out to be much less invasive than I'd expected.

+  if (request_info->loading_task_queue) {
+    request_info->loading_task_queue->PostTask(
+        FROM_HERE, base::Bind(&ResourceDispatcher::DispatchMessage,
+                              base::Unretained(this), message));
+  } else {
+    DispatchMessage(message);
+  }
   return true;
 }
 
 ResourceDispatcher::PendingRequestInfo*
 ResourceDispatcher::GetPendingRequestInfo(int request_id) {
   PendingRequestList::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end()) {
     // This might happen for kill()ed requests on the webkit end.
     return NULL;
   }
@@ skipping 345 matching lines @@
       download_to_file(false),
       buffer_size(0) {
 }
 
 ResourceDispatcher::PendingRequestInfo::PendingRequestInfo(
     RequestPeer* peer,
     ResourceType resource_type,
     int origin_pid,
     const GURL& frame_origin,
     const GURL& request_url,
-    bool download_to_file)
+    bool download_to_file,
+    scoped_refptr<base::SingleThreadTaskRunner> loading_task_queue)
     : peer(peer),
       threaded_data_provider(NULL),
       resource_type(resource_type),
       origin_pid(origin_pid),
       is_deferred(false),
       url(request_url),
       frame_origin(frame_origin),
       response_url(request_url),
       download_to_file(download_to_file),
-      request_start(base::TimeTicks::Now()) {
+      request_start(base::TimeTicks::Now()),
+      loading_task_queue(loading_task_queue) {
 }
 
 ResourceDispatcher::PendingRequestInfo::~PendingRequestInfo() {
   if (threaded_data_provider)
     threaded_data_provider->Stop();
 }
 
 void ResourceDispatcher::DispatchMessage(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(ResourceDispatcher, message)
     IPC_MESSAGE_HANDLER(ResourceMsg_UploadProgress, OnUploadProgress)
@@ skipping 77 matching lines @@
       CreateRequest(request_info, request_body, &frame_origin);
 
   // Compute a unique request_id for this renderer process.
   int request_id = MakeRequestID();
   pending_requests_[request_id] =
       PendingRequestInfo(peer,
                          request->resource_type,
                          request->origin_pid,
                          frame_origin,
                          request->url,
-                         request_info.download_to_file);
+                         request_info.download_to_file,
+                         request_info.loading_task_queue);
 
   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,
@@ skipping 188 matching lines @@
       extra_data->transferred_request_request_id();
   request->service_worker_provider_id =
       extra_data->service_worker_provider_id();
   request->request_body = request_body;
   if (frame_origin)
     *frame_origin = extra_data->frame_origin();
   return request.Pass();
 }
 
 }  // namespace content