Prerender: add true simultaneous nostate prefetch test.

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 86 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_;
 };
 
+// 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 {}
+
+ private:
+  ~HangingURLRequestJob() override {}
+};
+
+class HangingFirstRequestInterceptor : public net::URLRequestInterceptor {
+ public:
+  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()) {
+        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::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(
       const shell_integration::DefaultWebClientWorkerCallback& callback,
       const std::string& protocol) override {
     NOTREACHED();
@@ skipping 532 matching lines @@
       url, base::MakeUnique<CountingInterceptor>(file, 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> never_respond_handler(

[pasko, 2016/11/17 17:19:28]

nit: 'never' sounds confusing since it will respond eventually, perhaps just
'interceptor'?

[mattcary, 2016/11/18 08:22:55]

Done.

This was old code that was moved, but since I didn't warn you about it, I
suppose it's fair game ;)

+      new HangingFirstRequestInterceptor(file, callback));
+  net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
+      url, std::move(never_respond_handler));
+}
+
 }  // namespace test_utils
 
 }  // namespace prerender