Revert of [Prerender] Restore request priorities when swapped in

chrome/browser/prerender/prerender_test_utils.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 "chrome/browser/prerender/prerender_test_utils.h"
 
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 159 matching lines @@
   }
 
   void Start() override {}
 
  private:
   ~HangingURLRequestJob() override {}
 };
 
 class HangingFirstRequestInterceptor : public net::URLRequestInterceptor {
  public:
-  HangingFirstRequestInterceptor(
-      const base::FilePath& file,
-      base::Callback<void(net::URLRequest*)> callback)
-      : file_(file), callback_(callback), first_run_(true) {}
+  HangingFirstRequestInterceptor(const base::FilePath& file,
+                                 base::Closure callback)
+      : file_(file),
+        callback_(callback),
+        first_run_(true) {
+  }
   ~HangingFirstRequestInterceptor() override {}
 
   net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override {
     if (first_run_) {
       first_run_ = false;
-      if (!callback_.is_null())
-        callback_.Run(request);
+      if (!callback_.is_null()) {
+        BrowserThread::PostTask(
+            BrowserThread::UI, FROM_HERE, callback_);
+      }
       return new HangingURLRequestJob(request, network_delegate);
     }
     return new net::URLRequestMockHTTPJob(
         request,
         network_delegate,
         file_,
         BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
             base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
   }
 
  private:
   base::FilePath file_;
-  base::Callback<void(net::URLRequest*)> callback_;
+  base::Closure callback_;
   mutable bool first_run_;
 };
 
 // An ExternalProtocolHandler that blocks everything and asserts it never is
 // called.
 class NeverRunsExternalProtocolHandlerDelegate
     : public ExternalProtocolHandler::Delegate {
  public:
   scoped_refptr<shell_integration::DefaultProtocolClientWorker>
   CreateShellWorker(
@@ skipping 24 matching lines @@
 
   void LaunchUrlWithoutSecurityCheck(
       const GURL& url,
       content::WebContents* web_contents) override {
     NOTREACHED();
   }
 
   void FinishedProcessingCheck() override { NOTREACHED(); }
 };
 
-void CreateHangingFirstRequestInterceptorOnIO(
-    const GURL& url,
-    const base::FilePath& file,
-    base::Callback<void(net::URLRequest*)> callback_io) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  std::unique_ptr<net::URLRequestInterceptor> interceptor(
-      new HangingFirstRequestInterceptor(file, callback_io));
-  net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
-      url, std::move(interceptor));
-}
-
 }  // namespace
 
 RequestCounter::RequestCounter() : count_(0), expected_count_(-1) {}
 
 RequestCounter::~RequestCounter() {}
 
 void RequestCounter::RequestStarted() {
   count_++;
   if (loop_ && count_ == expected_count_)
     loop_->Quit();
@@ skipping 530 matching lines @@
   CountingInterceptorWithCallback::Initialize(url, counter, callback_io);
 }
 
 void CreateMockInterceptorOnIO(const GURL& url, const base::FilePath& file) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
       url, net::URLRequestMockHTTPJob::CreateInterceptorForSingleFile(
                file, content::BrowserThread::GetBlockingPool()));
 }
 
-void CreateHangingFirstRequestInterceptor(
-    const GURL& url,
-    const base::FilePath& file,
-    base::Callback<void(net::URLRequest*)> callback_io) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO, FROM_HERE,
-      base::Bind(&CreateHangingFirstRequestInterceptorOnIO, url, file,
-                 callback_io));
+void CreateHangingFirstRequestInterceptorOnIO(
+    const GURL& url, const base::FilePath& file, base::Closure callback) {
+  CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  std::unique_ptr<net::URLRequestInterceptor> interceptor(
+      new HangingFirstRequestInterceptor(file, callback));
+  net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
+      url, std::move(interceptor));
 }
 
 }  // namespace test_utils
 
 }  // namespace prerender