[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"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/files/file_path.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.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/threaded_data_provider.h"
 #include "content/common/inter_process_time_ticks_converter.h"
 #include "content/common/resource_messages.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/resource_response.h"
 #include "content/public/common/resource_type.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_response_headers.h"
+#include "third_party/WebKit/public/platform/WebTaskRunner.h"
 
 namespace content {
 
 namespace {
 
 // Converts |time| from a remote to local TimeTicks, overwriting the original
 // value.
 void RemoteToLocalTimeTicks(
     const InterProcessTimeTicksConverter& converter,
     base::TimeTicks* time) {
@@ skipping 350 matching lines @@
   bool release_downloaded_file = request_info.download_to_file;
 
   ReleaseResourcesInMessageQueue(&request_info.deferred_message_queue);
   pending_requests_.erase(it);
 
   if (release_downloaded_file) {
     message_sender_->Send(
         new ResourceHostMsg_ReleaseDownloadedFile(request_id));
   }
 
+  if (resource_scheduling_filter_.get())
+    resource_scheduling_filter_->ClearRequestIdTaskRunner(request_id);
+
   return true;
 }
 
 void ResourceDispatcher::Cancel(int request_id) {
   PendingRequestList::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end()) {
     DVLOG(1) << "unknown request";
     return;
   }
 
@@ skipping 165 matching lines @@
   // 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);
 
+  if (resource_scheduling_filter_.get()) {
+    resource_scheduling_filter_->SetRequestIdTaskRunner(
+        request_id, request_info.loading_web_task_runner->clone());

[Sami, 2015/09/29 11:22:46]

|loading_web_task_runner| was optional so should we null check?

[alex clarke (OOO till 29th), 2015/09/29 16:10:36]

Done.

+  }
+
   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 {
@@ skipping 186 matching lines @@
   request->transferred_request_request_id =
       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();
 }
 
+void ResourceDispatcher::SetResourceSchedulingFilter(
+    ResourceSchedulingFilter* resource_scheduling_filter) {
+  resource_scheduling_filter_ = resource_scheduling_filter;
+}
+
 }  // namespace content