NoStatePrefetch: Add a test to verify request priority

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>
 #include <vector>
 
+#include "base/callback.h"
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/loader/chrome_resource_dispatcher_host_delegate.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/local_database_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
@@ skipping 75 matching lines @@
         content::BrowserThread::UI, FROM_HERE,
         base::Bind(&RequestCounter::RequestStarted, counter_));
   }
 
  private:
   base::FilePath file_;
   base::WeakPtr<RequestCounter> counter_;
   mutable base::WeakPtrFactory<CountingInterceptor> weak_factory_;
 };
 
-// URLRequestInterceptor which asserts that the request is prefetch only. Pings
-// |counter| after the flag is checked.
-class PrefetchOnlyInterceptor : public net::URLRequestInterceptor {
+class CountingInterceptorWithCallback : public net::URLRequestInterceptor {
  public:
-  explicit PrefetchOnlyInterceptor(const base::WeakPtr<RequestCounter>& counter)
-      : counter_(counter) {}
-  ~PrefetchOnlyInterceptor() override {}
+  // Inserts the interceptor object to intercept requests to |url|.  Can be
+  // called on any thread. Assumes that |counter| lives on the UI thread.  The
+  // |callback_io| will be called on IO thread with the net::URLrequest
+  // provided.
+  static void Initialize(const GURL& url,
+                         RequestCounter* counter,
+                         base::Callback<void(net::URLRequest*)> callback_io) {
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&CountingInterceptorWithCallback::CreateAndAddOnIO, url,
+                   counter->AsWeakPtr(), callback_io));
+  }
 
+  // net::URLRequestInterceptor:
   net::URLRequestJob* MaybeInterceptRequest(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate) const override {
-    EXPECT_TRUE(request->load_flags() & net::LOAD_PREFETCH);
+    // Run the callback.
+    callback_.Run(request);
+
+    // Ping the request counter.
     content::BrowserThread::PostTask(
         content::BrowserThread::UI, FROM_HERE,
         base::Bind(&RequestCounter::RequestStarted, counter_));
     return nullptr;
   }
 
  private:
+  CountingInterceptorWithCallback(
+      const base::WeakPtr<RequestCounter>& counter,
+      base::Callback<void(net::URLRequest*)> callback)
+      : callback_(callback), counter_(counter) {}
+
+  static void CreateAndAddOnIO(
+      const GURL& url,
+      const base::WeakPtr<RequestCounter>& counter,
+      base::Callback<void(net::URLRequest*)> callback_io) {
+    DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
+    // Create the object with base::WrapUnique to restrict access to the
+    // constructor.
+    net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
+        url, base::WrapUnique(
+                 new CountingInterceptorWithCallback(counter, callback_io)));
+  }
+
+  base::Callback<void(net::URLRequest*)> callback_;
   base::WeakPtr<RequestCounter> counter_;
+
+  DISALLOW_COPY_AND_ASSIGN(CountingInterceptorWithCallback);
 };
 
 // URLRequestJob (and associated handler) which hangs.
 class HangingURLRequestJob : public net::URLRequestJob {
  public:
   HangingURLRequestJob(net::URLRequest* request,
                           net::NetworkDelegate* network_delegate)
       : net::URLRequestJob(request, network_delegate) {
   }
 
@@ skipping 576 matching lines @@
 
 void CreateCountingInterceptorOnIO(
     const GURL& url,
     const base::FilePath& file,
     const base::WeakPtr<RequestCounter>& counter) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
       url, base::MakeUnique<CountingInterceptor>(file, counter));
 }
 
-void CreatePrefetchOnlyInterceptorOnIO(
+void InterceptRequestAndCount(
     const GURL& url,
-    const base::WeakPtr<RequestCounter>& counter) {
-  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
-  net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
-      url, base::MakeUnique<PrefetchOnlyInterceptor>(counter));
+    RequestCounter* counter,
+    base::Callback<void(net::URLRequest*)> callback_io) {
+  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 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