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

content/browser/loader/resource_dispatcher_host_browsertest.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.
 
 #include "content/public/browser/resource_dispatcher_host.h"
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "build/build_config.h"
 #include "content/browser/download/download_manager_impl.h"
+#include "content/browser/loader/loader_globals.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/previews_state.h"
 #include "content/public/common/url_constants.h"
@@ skipping 20 matching lines @@
 namespace content {
 
 class ResourceDispatcherHostBrowserTest : public ContentBrowserTest,
                                           public DownloadManager::Observer {
  public:
   ResourceDispatcherHostBrowserTest() : got_downloads_(false) {}
 
  protected:
   void SetUpOnMainThread() override {
     base::FilePath path = GetTestFilePath("", "");
-    BrowserThread::PostTask(

[jam, 2017/03/29 15:44:32]

ditto, this is a browser test so it won't move. no need to change it.

[ananta, 2017/03/29 19:41:04]

Done.

-        BrowserThread::IO, FROM_HERE,
-        base::Bind(
-            &net::URLRequestMockHTTPJob::AddUrlHandlers, path,
-            make_scoped_refptr(content::BrowserThread::GetBlockingPool())));
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&net::URLRequestFailedJob::AddUrlHandler));
+    LoaderGlobals::Get()->io_thread_task_runner()->PostTask(
+        FROM_HERE, base::Bind(&net::URLRequestMockHTTPJob::AddUrlHandlers, path,
+                              make_scoped_refptr(
+                                  content::BrowserThread::GetBlockingPool())));
+    LoaderGlobals::Get()->io_thread_task_runner()->PostTask(
+        FROM_HERE, base::Bind(&net::URLRequestFailedJob::AddUrlHandler));
   }
 
   void OnDownloadCreated(DownloadManager* manager,
                          DownloadItem* item) override {
     if (!got_downloads_)
       got_downloads_ = !!manager->InProgressCount();
   }
 
   void CheckTitleTest(const GURL& url,
                       const std::string& expected_title) {
@@ skipping 168 matching lines @@
 
 // Responses with a HungResponse for the specified URL to hang on the request,
 // and cancells all requests from specifield |child_id|.
 std::unique_ptr<net::test_server::HttpResponse> CancelOnRequest(
     const std::string& relative_url,
     int child_id,
     const net::test_server::HttpRequest& request) {
   if (request.relative_url != relative_url)
     return nullptr;
 
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
+  LoaderGlobals::Get()->io_thread_task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&ResourceDispatcherHostImpl::CancelRequestsForProcess,
                  base::Unretained(ResourceDispatcherHostImpl::Get()),
                  child_id));
 
   return base::MakeUnique<net::test_server::HungResponse>();
 }
 
 }  // namespace
 
@@ skipping 345 matching lines @@
 
   ~PreviewsStateResourceDispatcherHostDelegate() override {}
 
   // ResourceDispatcherHostDelegate implementation:
   void RequestBeginning(
       net::URLRequest* request,
       ResourceContext* resource_context,
       AppCacheService* appcache_service,
       ResourceType resource_type,
       std::vector<std::unique_ptr<ResourceThrottle>>* throttles) override {
-    DCHECK_CURRENTLY_ON(BrowserThread::IO);
+    DCHECK(LoaderGlobals::Get()
+               ->io_thread_task_runner()
+               ->BelongsToCurrentThread());
     const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request);
     if (request->url() != main_frame_url_ && request->url() != subresource_url_
         && request->url() != iframe_url_)
       return;
     if (request->url() == main_frame_url_) {
       EXPECT_FALSE(main_frame_url_seen_);
       main_frame_url_seen_ = true;
     } else if (request->url() == subresource_url_) {
       EXPECT_TRUE(main_frame_url_seen_);
       EXPECT_FALSE(subresource_url_seen_);
       subresource_url_seen_ = true;
     } else if (request->url() == iframe_url_) {
       EXPECT_TRUE(main_frame_url_seen_);
       EXPECT_FALSE(iframe_url_seen_);
       iframe_url_seen_ = true;
     }
     EXPECT_EQ(previews_state_, info->GetPreviewsState());
   }
 
   void SetDelegate() {
-    DCHECK_CURRENTLY_ON(BrowserThread::IO);
+    DCHECK(LoaderGlobals::Get()
+               ->io_thread_task_runner()
+               ->BelongsToCurrentThread());
     ResourceDispatcherHost::Get()->SetDelegate(this);
   }
 
   PreviewsState GetPreviewsState(
       const net::URLRequest& request,
       content::ResourceContext* resource_context) override {
-    DCHECK_CURRENTLY_ON(BrowserThread::IO);
+    DCHECK(LoaderGlobals::Get()
+               ->io_thread_task_runner()
+               ->BelongsToCurrentThread());
     EXPECT_FALSE(should_get_previews_state_called_);
     should_get_previews_state_called_ = true;
     EXPECT_EQ(main_frame_url_, request.url());
     return previews_state_;
   }
 
   void Reset(PreviewsState previews_state) {
-    DCHECK_CURRENTLY_ON(BrowserThread::IO);
+    DCHECK(LoaderGlobals::Get()
+               ->io_thread_task_runner()
+               ->BelongsToCurrentThread());
     main_frame_url_seen_ = false;
     subresource_url_seen_ = false;
     iframe_url_seen_ = false;
     previews_state_ = previews_state;
     should_get_previews_state_called_ = false;
   }
 
   void CheckResourcesRequested(bool should_get_previews_state_called) {
-    DCHECK_CURRENTLY_ON(BrowserThread::IO);
+    DCHECK(LoaderGlobals::Get()
+               ->io_thread_task_runner()
+               ->BelongsToCurrentThread());
     EXPECT_EQ(should_get_previews_state_called,
               should_get_previews_state_called_);
     EXPECT_TRUE(main_frame_url_seen_);
     EXPECT_TRUE(subresource_url_seen_);
     EXPECT_TRUE(iframe_url_seen_);
   }
 
  private:
   const GURL main_frame_url_;
   const GURL subresource_url_;
@@ skipping 19 matching lines @@
   void SetUpOnMainThread() override {
     ContentBrowserTest::SetUpOnMainThread();
 
     ASSERT_TRUE(embedded_test_server()->Start());
 
     delegate_.reset(new PreviewsStateResourceDispatcherHostDelegate(
         embedded_test_server()->GetURL("/page_with_iframe.html"),
         embedded_test_server()->GetURL("/image.jpg"),
         embedded_test_server()->GetURL("/title1.html")));
 
-    content::BrowserThread::PostTask(
-           content::BrowserThread::IO,
-           FROM_HERE,
-           base::Bind(&PreviewsStateResourceDispatcherHostDelegate::SetDelegate,
-                      base::Unretained(delegate_.get())));
+    LoaderGlobals::Get()->io_thread_task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&PreviewsStateResourceDispatcherHostDelegate::SetDelegate,
+                   base::Unretained(delegate_.get())));
   }
 
   void Reset(PreviewsState previews_state) {
-    content::BrowserThread::PostTask(
-        content::BrowserThread::IO, FROM_HERE,
+    LoaderGlobals::Get()->io_thread_task_runner()->PostTask(
+        FROM_HERE,
         base::Bind(&PreviewsStateResourceDispatcherHostDelegate::Reset,
                    base::Unretained(delegate_.get()), previews_state));
   }
 
   void CheckResourcesRequested(
       bool should_get_previews_state_called) {
-    content::BrowserThread::PostTask(
-        content::BrowserThread::IO, FROM_HERE,
-        base::Bind(&PreviewsStateResourceDispatcherHostDelegate::
-                       CheckResourcesRequested,
-                   base::Unretained(delegate_.get()),
-                   should_get_previews_state_called));
+    LoaderGlobals::Get()->io_thread_task_runner()->PostTask(
+        FROM_HERE, base::Bind(&PreviewsStateResourceDispatcherHostDelegate::
+                                  CheckResourcesRequested,
+                              base::Unretained(delegate_.get()),
+                              should_get_previews_state_called));
   }
 
  private:
   std::unique_ptr<PreviewsStateResourceDispatcherHostDelegate> delegate_;
 };
 
 // Test that navigating calls GetPreviewsState with SERVER_LOFI_ON.
 IN_PROC_BROWSER_TEST_F(PreviewsStateResourceDispatcherHostBrowserTest,
                        ShouldEnableLoFiModeOn) {
   // Navigate with ShouldEnableLoFiMode returning true.
@@ skipping 119 matching lines @@
   ~RequestDataResourceDispatcherHostBrowserTest() override {}
 
  protected:
   void SetUpOnMainThread() override {
     ContentBrowserTest::SetUpOnMainThread();
 
     ASSERT_TRUE(embedded_test_server()->Start());
 
     delegate_.reset(new RequestDataResourceDispatcherHostDelegate());
 
-    content::BrowserThread::PostTask(
-        content::BrowserThread::IO, FROM_HERE,
+    LoaderGlobals::Get()->io_thread_task_runner()->PostTask(
+        FROM_HERE,
         base::Bind(&RequestDataResourceDispatcherHostDelegate::SetDelegate,
                    base::Unretained(delegate_.get())));
   }
 
  protected:
   std::unique_ptr<RequestDataResourceDispatcherHostDelegate> delegate_;
 };
 
 IN_PROC_BROWSER_TEST_F(RequestDataResourceDispatcherHostBrowserTest, Basic) {
   GURL top_url(embedded_test_server()->GetURL("/page_with_subresources.html"));
@@ skipping 254 matching lines @@
   EXPECT_EQ(top_origin, delegate_->data()[2]->initiator);
 
   // Cross-origin subresource requests have a unique first-party, and an
   // initiator that matches the document in which they're embedded.
   EXPECT_EQ(nested_js_url, delegate_->data()[3]->url);
   EXPECT_EQ(kURLWithUniqueOrigin, delegate_->data()[3]->first_party);
   EXPECT_EQ(nested_origin, delegate_->data()[3]->initiator);
 }
 
 }  // namespace content