Add HttpProtocolHandler and convert everything to use it

content/browser/service_worker/service_worker_read_from_cache_job_unittest.cc

 // Copyright 2015 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/browser/service_worker/service_worker_read_from_cache_job.h"
 
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "content/browser/fileapi/mock_url_request_delegate.h"
 #include "content/browser/service_worker/embedded_worker_test_helper.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/io_buffer.h"
 #include "net/base/test_completion_callback.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_intercepting_job_factory.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
 const int64_t kRegistrationId = 1;
@@ skipping 23 matching lines @@
 class ServiceWorkerReadFromCacheJobTest : public testing::Test {
  public:
   ServiceWorkerReadFromCacheJobTest()
       : thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
         main_script_(kMainScriptResourceId,
                      GURL("http://example.com/main.js"),
                      kResourceSize),
         imported_script_(kImportedScriptResourceId,
                          GURL("http://example.com/imported.js"),
                          kResourceSize),
-        test_job_interceptor_(nullptr) {}
+        test_job_interceptor_(nullptr),
+        test_job_factory_(nullptr) {}
   ~ServiceWorkerReadFromCacheJobTest() override {}
 
   void SetUp() override {
     helper_.reset(new EmbeddedWorkerTestHelper(base::FilePath()));
     InitializeStorage();
 
     url_request_context_.reset(new net::TestURLRequestContext(true));
 
     // The |test_job_factory_| takes ownership of the interceptor.
     test_job_interceptor_ = new net::TestJobInterceptor();
-    EXPECT_TRUE(test_job_factory_.SetProtocolHandler(
-        url::kHttpScheme, base::WrapUnique(test_job_interceptor_)));
-    url_request_context_->set_job_factory(&test_job_factory_);
+    test_job_factory_.reset(new net::URLRequestInterceptingJobFactory(
+        net::URLRequestJobFactoryImpl::CreateWithHttpProtocolHandlers(),
+        base::WrapUnique(test_job_interceptor_)));
+    url_request_context_->set_job_factory(test_job_factory_.get());
 
     url_request_context_->Init();
   }
 
   void InitializeStorage() {
     base::RunLoop run_loop;
     context()->storage()->LazyInitialize(run_loop.QuitClosure());
     run_loop.Run();
 
     // Populate a registration in the storage.
@@ skipping 84 matching lines @@
   TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<EmbeddedWorkerTestHelper> helper_;
 
   scoped_refptr<ServiceWorkerRegistration> registration_;
   scoped_refptr<ServiceWorkerVersion> version_;
   ServiceWorkerDatabase::ResourceRecord main_script_;
   ServiceWorkerDatabase::ResourceRecord imported_script_;
 
   // |test_job_interceptor_| is owned by |test_job_factory_|.
   net::TestJobInterceptor* test_job_interceptor_;
-  net::URLRequestJobFactoryImpl test_job_factory_;
+  std::unique_ptr<net::URLRequestJobFactory> test_job_factory_;
 
   std::unique_ptr<net::TestURLRequestContext> url_request_context_;
   MockURLRequestDelegate delegate_;
 };
 
 TEST_F(ServiceWorkerReadFromCacheJobTest, ReadMainScript) {
   // Read the main script from the diskcache.
   std::unique_ptr<net::URLRequest> request =
       url_request_context_->CreateRequest(main_script_.url,
                                           net::DEFAULT_PRIORITY, &delegate_);
@@ skipping 47 matching lines @@
   EXPECT_EQ(net::ERR_CACHE_MISS, request->status().error());
   EXPECT_EQ(SERVICE_WORKER_ERROR_DISK_CACHE,
             DeduceStartWorkerFailureReason(SERVICE_WORKER_OK));
 
   // The version should be doomed by the job.
   EXPECT_EQ(ServiceWorkerVersion::REDUNDANT, version_->status());
   EXPECT_EQ(SERVICE_WORKER_ERROR_NOT_FOUND, FindRegistration());
 }
 
 }  // namespace content