Prerender: Test that prefetch flags are set correctly on redirect.

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 13 matching lines @@
 #include "chrome/grit/generated_resources.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/ppapi_test_utils.h"
+#include "net/base/load_flags.h"
 #include "net/test/embedded_test_server/request_handler_util.h"
 #include "net/url_request/url_request_filter.h"
 #include "ppapi/shared_impl/ppapi_switches.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 using content::RenderViewHost;
 
 namespace prerender {
@@ skipping 53 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 {
+ public:
+  explicit PrefetchOnlyInterceptor(const base::WeakPtr<RequestCounter>& counter)
+      : counter_(counter) {}
+  ~PrefetchOnlyInterceptor() override {}
+
+  net::URLRequestJob* MaybeInterceptRequest(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const override {
+    EXPECT_TRUE(request->load_flags() & net::LOAD_PREFETCH);
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&RequestCounter::RequestStarted, counter_));
+    return NULL;

[droger, 2016/11/23 15:20:10]

nullptr

[mattcary, 2016/11/23 15:28:32]

Yikes, how 2010 of me.

+  }
+
+ private:
+  base::WeakPtr<RequestCounter> counter_;
+};
+
 // 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) {
   }
 
   void Start() override {}
 
@@ skipping 574 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(
+    const GURL& url,
+    const base::WeakPtr<RequestCounter>& counter) {
+  CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
+      url, base::MakeUnique<PrefetchOnlyInterceptor>(counter));
+}
+
 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