Reduce/remove usage of BrowserThread in content/browser/loader.

content/browser/loader/resource_dispatcher_host_impl.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/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <stddef.h>
 
@@ skipping 14 matching lines @@
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "content/browser/appcache/appcache_interceptor.h"
 #include "content/browser/appcache/appcache_navigation_handle_core.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/frame_host/navigation_request_info.h"
 #include "content/browser/loader/async_resource_handler.h"
 #include "content/browser/loader/detachable_resource_handler.h"
@@ skipping 286 matching lines @@
 
 ResourceDispatcherHostImpl::HeaderInterceptorInfo::HeaderInterceptorInfo(
     const HeaderInterceptorInfo& other) {}
 
 // static
 ResourceDispatcherHost* ResourceDispatcherHost::Get() {
   return g_resource_dispatcher_host;
 }
 
 ResourceDispatcherHostImpl::ResourceDispatcherHostImpl(
-    CreateDownloadHandlerIntercept download_handler_intercept)
+    CreateDownloadHandlerIntercept download_handler_intercept,
+    const scoped_refptr<base::SingleThreadTaskRunner>& main_thread_runner,
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_thread_runner)
     : request_id_(-1),
       is_shutdown_(false),
       num_in_flight_requests_(0),
       max_num_in_flight_requests_(base::SharedMemory::GetHandleLimit()),
       max_num_in_flight_requests_per_process_(static_cast<int>(
           max_num_in_flight_requests_ * kMaxRequestsPerProcessRatio)),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
       delegate_(nullptr),
       loader_delegate_(nullptr),
       allow_cross_origin_auth_prompt_(false),
       create_download_handler_intercept_(download_handler_intercept) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(main_thread_runner->BelongsToCurrentThread());
   DCHECK(!g_resource_dispatcher_host);
   g_resource_dispatcher_host = this;
 
   ANNOTATE_BENIGN_RACE(
       &last_user_gesture_time_,
       "We don't care about the precise value, see http://crbug.com/92889");
 
-  BrowserThread::PostTask(BrowserThread::IO,
-                          FROM_HERE,
-                          base::Bind(&ResourceDispatcherHostImpl::OnInit,
-                                     base::Unretained(this)));
+  loader_globals_.reset(
+      new LoaderGlobals(main_thread_runner, io_thread_runner));
+  io_thread_runner->PostTask(
+      FROM_HERE,
+      base::Bind(&ResourceDispatcherHostImpl::OnInit, base::Unretained(this)));
 
   update_load_states_timer_.reset(new base::RepeatingTimer());
 }
 
+// The default ctor is only used by unittests. It is reasonable to assume that
+// the main thread and the IO thread are the same for unittests.
 ResourceDispatcherHostImpl::ResourceDispatcherHostImpl()
-    : ResourceDispatcherHostImpl(CreateDownloadHandlerIntercept()) {}
+    : ResourceDispatcherHostImpl(CreateDownloadHandlerIntercept(),
+                                 base::ThreadTaskRunnerHandle::Get(),
+                                 base::ThreadTaskRunnerHandle::Get()) {}
 
 ResourceDispatcherHostImpl::~ResourceDispatcherHostImpl() {
   DCHECK(outstanding_requests_stats_map_.empty());
   DCHECK(g_resource_dispatcher_host);
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(loader_globals_->main_thread_task_runner()->BelongsToCurrentThread());
   g_resource_dispatcher_host = NULL;
 }
 
 // static
 ResourceDispatcherHostImpl* ResourceDispatcherHostImpl::Get() {
   return g_resource_dispatcher_host;
 }
 
 void ResourceDispatcherHostImpl::SetDelegate(
     ResourceDispatcherHostDelegate* delegate) {
   delegate_ = delegate;
 }
 
 void ResourceDispatcherHostImpl::SetAllowCrossOriginAuthPrompt(bool value) {
   allow_cross_origin_auth_prompt_ = value;
 }
 
 void ResourceDispatcherHostImpl::CancelRequestsForContext(
     ResourceContext* context) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(loader_globals_->io_thread_task_runner()->BelongsToCurrentThread());
   DCHECK(context);
 
   // Note that request cancellation has side effects. Therefore, we gather all
   // the requests to cancel first, and then we start cancelling. We assert at
   // the end that there are no more to cancel since the context is about to go
   // away.
   typedef std::vector<std::unique_ptr<ResourceLoader>> LoaderList;
   LoaderList loaders_to_cancel;
 
   for (LoaderMap::iterator i = pending_loaders_.begin();
@@ skipping 78 matching lines @@
          http_header_interceptor_map_.end());
 
   HeaderInterceptorInfo interceptor_info;
   interceptor_info.starts_with = starts_with;
   interceptor_info.interceptor = interceptor;
 
   http_header_interceptor_map_[http_header] = interceptor_info;
 }
 
 void ResourceDispatcherHostImpl::Shutdown() {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  BrowserThread::PostTask(BrowserThread::IO,
-                          FROM_HERE,
-                          base::Bind(&ResourceDispatcherHostImpl::OnShutdown,
-                                     base::Unretained(this)));
+  DCHECK(loader_globals_->main_thread_task_runner()->BelongsToCurrentThread());
+  loader_globals_->io_thread_task_runner()->PostTask(
+      FROM_HERE, base::Bind(&ResourceDispatcherHostImpl::OnShutdown,
+                            base::Unretained(this)));
 }
 
 std::unique_ptr<ResourceHandler>
 ResourceDispatcherHostImpl::CreateResourceHandlerForDownload(
     net::URLRequest* request,
     bool is_content_initiated,
     bool must_download,
     bool is_new_request) {
   DCHECK(!create_download_handler_intercept_.is_null());
   // TODO(ananta)
@@ skipping 263 matching lines @@
     ResourceDispatcherHostImpl::CreateClientCertStore(ResourceLoader* loader) {
   return delegate_->CreateClientCertStore(
       loader->GetRequestInfo()->GetContext());
 }
 
 void ResourceDispatcherHostImpl::OnInit() {
   scheduler_.reset(new ResourceScheduler);
 }
 
 void ResourceDispatcherHostImpl::OnShutdown() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(loader_globals_->io_thread_task_runner()->BelongsToCurrentThread());
 
   is_shutdown_ = true;
   pending_loaders_.clear();
 
   // Make sure we shutdown the timer now, otherwise by the time our destructor
   // runs if the timer is still running the Task is deleted twice (once by
   // the MessageLoop and the second time by RepeatingTimer).
   update_load_states_timer_.reset();
 
   // Clear blocked requests if any left.
@@ skipping 10 matching lines @@
   for (const auto& routing_id : ids) {
     CancelBlockedRequestsForRoute(routing_id);
   }
 
   scheduler_.reset();
 }
 
 bool ResourceDispatcherHostImpl::OnMessageReceived(
     const IPC::Message& message,
     ResourceRequesterInfo* requester_info) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(loader_globals_->io_thread_task_runner()->BelongsToCurrentThread());
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(ResourceDispatcherHostImpl, message,
                                    requester_info)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_RequestResource, OnRequestResource)
     IPC_MESSAGE_HANDLER_WITH_PARAM_DELAY_REPLY(ResourceHostMsg_SyncLoad,
                                                OnSyncLoad)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_ReleaseDownloadedFile,
                         OnReleaseDownloadedFile)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_CancelRequest, OnCancelRequest)
@@ skipping 693 matching lines @@
     delegate_->RequestBeginning(request,
                                 resource_context,
                                 appcache_service,
                                 resource_type,
                                 &throttles);
   }
 
   if (request->has_upload()) {
     // Block power save while uploading data.
     throttles.push_back(base::MakeUnique<PowerSaveBlockResourceThrottle>(
-        request->url().host(),
-        BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
+        request->url().host(), loader_globals_->main_thread_task_runner(),
         BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
   }
 
   // TODO(ricea): Stop looking this up so much.
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request);
   throttles.push_back(scheduler_->ScheduleRequest(child_id, route_id,
                                                   info->IsAsync(), request));
 
   // Split the handler in two groups: the ones that need to execute
   // WillProcessResponse before mime sniffing and the others.
@@ skipping 655 matching lines @@
 
 void ResourceDispatcherHostImpl::InitializeURLRequest(
     net::URLRequest* request,
     const Referrer& referrer,
     bool is_download,
     int render_process_host_id,
     int render_view_routing_id,
     int render_frame_routing_id,
     PreviewsState previews_state,
     ResourceContext* context) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(loader_globals_->io_thread_task_runner()->BelongsToCurrentThread());
   DCHECK(!request->is_pending());
 
   Referrer::SetReferrerForRequest(request, referrer);
 
   ResourceRequestInfoImpl* info = CreateRequestInfo(
       render_process_host_id, render_view_routing_id, render_frame_routing_id,
       previews_state, is_download, context);
   // Request takes ownership.
   info->AssociateWithRequest(request);
 }
 
 void ResourceDispatcherHostImpl::BeginURLRequest(
     std::unique_ptr<net::URLRequest> request,
     std::unique_ptr<ResourceHandler> handler,
     bool is_download,
     bool is_content_initiated,
     bool do_not_prompt_for_login,
     ResourceContext* context) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(loader_globals_->io_thread_task_runner()->BelongsToCurrentThread());
   DCHECK(!request->is_pending());
 
   ResourceRequestInfoImpl* info =
       ResourceRequestInfoImpl::ForRequest(request.get());
   DCHECK(info);
   info->set_do_not_prompt_for_login(do_not_prompt_for_login);
 
   // TODO(ananta)
   // Find a better place for notifying the delegate about the download start.
   if (is_download && delegate()) {
@@ skipping 11 matching lines @@
               request->original_url()));
     }
     handler = HandleDownloadStarted(
         request.get(), std::move(handler), is_content_initiated,
         true /* force_download */, true /* is_new_request */);
   }
   BeginRequestInternal(std::move(request), std::move(handler));
 }
 
 int ResourceDispatcherHostImpl::MakeRequestID() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(loader_globals_->io_thread_task_runner()->BelongsToCurrentThread());
   return --request_id_;
 }
 
 void ResourceDispatcherHostImpl::CancelRequestFromRenderer(
     GlobalRequestID request_id) {
   // When the old renderer dies, it sends a message to us to cancel its
   // requests.
   if (IsTransferredNavigation(request_id))
     return;
 
@@ skipping 53 matching lines @@
 
   if (a_uploading_size != b_uploading_size)
     return a_uploading_size > b_uploading_size;
 
   return a.load_state.state > b.load_state.state;
 }
 
 // static
 void ResourceDispatcherHostImpl::UpdateLoadStateOnUI(
     LoaderDelegate* loader_delegate, std::unique_ptr<LoadInfoList> infos) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(LoaderGlobals::Get()
+             ->main_thread_task_runner()
+             ->BelongsToCurrentThread());
   std::unique_ptr<LoadInfoMap> info_map =
       PickMoreInterestingLoadInfos(std::move(infos));
   for (const auto& load_info: *info_map) {
     loader_delegate->LoadStateChanged(
         load_info.first,
         load_info.second.url, load_info.second.load_state,
         load_info.second.upload_position, load_info.second.upload_size);
   }
 }
 
@@ skipping 46 matching lines @@
   if (infos->empty() || !scheduler_->HasLoadingClients()) {
     update_load_states_timer_->Stop();
     return;
   }
 
   // We need to be able to compare all requests to find the most important one
   // per tab. Since some requests may be navigation requests and we don't have
   // their render frame routing IDs yet (which is what we have for subresource
   // requests), we must go to the UI thread and compare the requests using their
   // WebContents.
-  BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(UpdateLoadStateOnUI,
-                   loader_delegate_, base::Passed(&infos)));
+  loader_globals_->main_thread_task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(UpdateLoadStateOnUI, loader_delegate_, base::Passed(&infos)));
 }
 
 void ResourceDispatcherHostImpl::BlockRequestsForRoute(
     const GlobalFrameRoutingId& global_routing_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(loader_globals_->io_thread_task_runner()->BelongsToCurrentThread());
   DCHECK(blocked_loaders_map_.find(global_routing_id) ==
          blocked_loaders_map_.end())
       << "BlockRequestsForRoute called  multiple time for the same RFH";
   blocked_loaders_map_[global_routing_id] =
       base::MakeUnique<BlockedLoadersList>();
 }
 
 void ResourceDispatcherHostImpl::ResumeBlockedRequestsForRoute(
     const GlobalFrameRoutingId& global_routing_id) {
   ProcessBlockedRequestsForRoute(global_routing_id, false);
@@ skipping 54 matching lines @@
 }
 
 bool ResourceDispatcherHostImpl::IsTransferredNavigation(
     const GlobalRequestID& id) const {
   ResourceLoader* loader = GetLoader(id);
   return loader ? loader->is_transferring() : false;
 }
 
 ResourceLoader* ResourceDispatcherHostImpl::GetLoader(
     const GlobalRequestID& id) const {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  DCHECK(loader_globals_->io_thread_task_runner()->BelongsToCurrentThread());
 
   LoaderMap::const_iterator i = pending_loaders_.find(id);
   if (i == pending_loaders_.end())
     return NULL;
 
   return i->second.get();
 }
 
 ResourceLoader* ResourceDispatcherHostImpl::GetLoader(int child_id,
                                                       int request_id) const {
@@ skipping 121 matching lines @@
                                  &throttles);
     if (!throttles.empty()) {
       handler.reset(new ThrottlingResourceHandler(std::move(handler), request,
                                                   std::move(throttles)));
     }
   }
   return handler;
 }
 
 }  // namespace content