Clean up RegisterProtocolFactory calls.

webkit/appcache/appcache_update_job_unittest.cc

 // Copyright (c) 2011 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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/stl_util-inl.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_error_job.h"
+#include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_test_job.h"
 #include "net/url_request/url_request_test_util.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_host.h"
 #include "webkit/appcache/appcache_policy.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_update_job.h"
 #include "webkit/appcache/mock_appcache_service.h"
 
 namespace appcache {
@@ skipping 19 matching lines @@
   }
 
   static GURL GetMockHttpsUrl(const std::string& path) {
     return GURL("https://mockhost/" + path);
   }
 
   static GURL GetMockCrossOriginHttpsUrl(const std::string& path) {
     return GURL("https://cross_origin_host/" + path);
   }
 
-  static net::URLRequestJob* JobFactory(net::URLRequest* request,
-                                        const std::string& scheme) {
+  static net::URLRequestJob* JobFactory(net::URLRequest* request) {
     if (request->url().host() != "mockhost" &&
         request->url().host() != "cross_origin_host")
       return new net::URLRequestErrorJob(request, -1);
 
     std::string headers, body;
     GetMockResponse(request->url().path(), &headers, &body);
     return new net::URLRequestTestJob(request, headers, body, true);
   }
 
  private:
@@ skipping 111 matching lines @@
       (*headers) = std::string(no_store_headers, arraysize(no_store_headers));
       (*body) = "no-store";
     } else {
       (*headers) = std::string(not_found_headers,
                                arraysize(not_found_headers));
       (*body) = "";
     }
   }
 };
 
+class MockHttpServerJobFactory
+    : public net::URLRequestJobFactory::ProtocolHandler {
+ public:
+  virtual net::URLRequestJob* MaybeCreateJob(net::URLRequest* request) const {
+    return MockHttpServer::JobFactory(request);
+  }
+};
+
 }  // namespace
 
 class MockFrontend : public AppCacheFrontend {
  public:
   MockFrontend()
       : ignore_progress_events_(false), verify_progress_events_(false),
         last_progress_total_(-1), last_progress_complete_(-1),
         start_update_trigger_(CHECKING_EVENT), update_(NULL) {
   }
 
@@ skipping 109 matching lines @@
   int last_progress_total_;
   int last_progress_complete_;
 
   // Add ability for frontend to add master entries to an inprogress update.
   EventID start_update_trigger_;
   AppCacheUpdateJob* update_;
   std::vector<AppCacheHost*> update_hosts_;
 };
 
 // Helper factories to simulate redirected URL responses for tests.
-static net::URLRequestJob* RedirectFactory(net::URLRequest* request,
-                                           const std::string& scheme) {
-  return new net::URLRequestTestJob(
-      request,
-      net::URLRequestTestJob::test_redirect_headers(),
-      net::URLRequestTestJob::test_data_1(),
-      true);
-}
+class RedirectFactory : public net::URLRequestJobFactory::ProtocolHandler {
+ public:
+  virtual net::URLRequestJob* MaybeCreateJob(net::URLRequest* request) const {
+    return new net::URLRequestTestJob(
+        request,
+        net::URLRequestTestJob::test_redirect_headers(),
+        net::URLRequestTestJob::test_data_1(),
+        true);
+  }
+};
 
 // Helper class to simulate a URL that returns retry or success.
 class RetryRequestTestJob : public net::URLRequestTestJob {
  public:
   enum RetryHeader {
     NO_RETRY_AFTER,
     NONZERO_RETRY_AFTER,
     RETRY_AFTER_0,
   };
 
   static const GURL kRetryUrl;
 
   // Call this at the start of each retry test.
   static void Initialize(int num_retry_responses, RetryHeader header,
       int expected_requests) {
     num_requests_ = 0;
     num_retries_ = num_retry_responses;
     retry_after_ = header;
     expected_requests_ = expected_requests;
   }
 
   // Verifies results at end of test and resets counters.
   static void Verify() {
     EXPECT_EQ(expected_requests_, num_requests_);
     num_requests_ = 0;
     expected_requests_ = 0;
   }
 
-  static net::URLRequestJob* RetryFactory(net::URLRequest* request,
-                                          const std::string& scheme) {
+  static net::URLRequestJob* RetryFactory(net::URLRequest* request) {
     ++num_requests_;
     if (num_retries_ > 0 && request->original_url() == kRetryUrl) {
       --num_retries_;
       return new RetryRequestTestJob(
           request, RetryRequestTestJob::retry_headers(), 503);
     } else {
       return new RetryRequestTestJob(
           request, RetryRequestTestJob::manifest_headers(), 200);
     }
   }
@@ skipping 48 matching lines @@
   }
 
   int response_code_;
 
   static int num_requests_;
   static int num_retries_;
   static RetryHeader retry_after_;
   static int expected_requests_;
 };
 
+class RetryRequestTestJobFactory
+    : public net::URLRequestJobFactory::ProtocolHandler {
+ public:
+  virtual net::URLRequestJob* MaybeCreateJob(net::URLRequest* request) const {
+    return RetryRequestTestJob::RetryFactory(request);
+  }
+};
+
 // static
 const GURL RetryRequestTestJob::kRetryUrl("http://retry");
 int RetryRequestTestJob::num_requests_ = 0;
 int RetryRequestTestJob::num_retries_;
 RetryRequestTestJob::RetryHeader RetryRequestTestJob::retry_after_;
 int RetryRequestTestJob::expected_requests_ = 0;
 
 // Helper class to check for certain HTTP headers.
 class HttpHeadersRequestTestJob : public net::URLRequestTestJob {
  public:
@@ skipping 12 matching lines @@
       EXPECT_TRUE(saw_if_none_match_);
 
     // Reset.
     expect_if_modified_since_.clear();
     saw_if_modified_since_ = false;
     expect_if_none_match_.clear();
     saw_if_none_match_ = false;
     already_checked_ = false;
   }
 
-  static net::URLRequestJob* IfModifiedSinceFactory(net::URLRequest* request,
-                                                    const std::string& scheme) {
+  static net::URLRequestJob* IfModifiedSinceFactory(net::URLRequest* request) {
     if (!already_checked_) {
       already_checked_ = true;  // only check once for a test
       const net::HttpRequestHeaders& extra_headers =
           request->extra_request_headers();
       std::string header_value;
       saw_if_modified_since_ =
           extra_headers.GetHeader(
               net::HttpRequestHeaders::kIfModifiedSince, &header_value) &&
           header_value == expect_if_modified_since_;
 
       saw_if_none_match_ =
           extra_headers.GetHeader(
               net::HttpRequestHeaders::kIfNoneMatch, &header_value) &&
           header_value == expect_if_none_match_;
     }
-    return MockHttpServer::JobFactory(request, scheme);
+    return MockHttpServer::JobFactory(request);
   }
 
  private:
   static std::string expect_if_modified_since_;
   static bool saw_if_modified_since_;
   static std::string expect_if_none_match_;
   static bool saw_if_none_match_;
   static bool already_checked_;
 };
 
 // static
 std::string HttpHeadersRequestTestJob::expect_if_modified_since_;
 bool HttpHeadersRequestTestJob::saw_if_modified_since_ = false;
 std::string HttpHeadersRequestTestJob::expect_if_none_match_;
 bool HttpHeadersRequestTestJob::saw_if_none_match_ = false;
 bool HttpHeadersRequestTestJob::already_checked_ = false;
 
+class IfModifiedSinceJobFactory
+    : public net::URLRequestJobFactory::ProtocolHandler {
+ public:
+  virtual net::URLRequestJob* MaybeCreateJob(net::URLRequest* request) const {
+    return HttpHeadersRequestTestJob::IfModifiedSinceFactory(request);
+  }
+};
+
 namespace {
 
 class IOThread : public base::Thread {
  public:
   explicit IOThread(const char* name)
-      : base::Thread(name), old_factory_(NULL), old_factory_https_(NULL) {
+      : base::Thread(name) {
   }
 
   ~IOThread() {
     // We cannot rely on our base class to stop the thread since we want our
     // CleanUp function to run.
     Stop();
   }
 
   const scoped_refptr<net::URLRequestContext>& request_context() {
     return request_context_;
   }
 
+  void SetNewJobFactory(net::URLRequestJobFactory* job_factory) {
+    DCHECK(job_factory);
+    job_factory_.reset(job_factory);
+    request_context_->set_job_factory(job_factory_.get());
+  }
+
   virtual void Init() {
-    old_factory_ = net::URLRequest::RegisterProtocolFactory(
-        "http", MockHttpServer::JobFactory);
-    old_factory_https_ = net::URLRequest::RegisterProtocolFactory(
-        "https", MockHttpServer::JobFactory);
+    job_factory_.reset(new net::URLRequestJobFactory);
+    job_factory_->SetProtocolHandler("http", new MockHttpServerJobFactory);
+    job_factory_->SetProtocolHandler("https", new MockHttpServerJobFactory);
     request_context_ = new TestURLRequestContext();
+    request_context_->set_job_factory(job_factory_.get());
   }
 
   virtual void CleanUp() {
-    net::URLRequest::RegisterProtocolFactory("http", old_factory_);
-    net::URLRequest::RegisterProtocolFactory("https", old_factory_https_);
     request_context_ = NULL;
+    job_factory_.reset();
   }
 
-  net::URLRequest::ProtocolFactory* old_factory_;
-  net::URLRequest::ProtocolFactory* old_factory_https_;
+ private:
+  scoped_ptr<net::URLRequestJobFactory> job_factory_;
   scoped_refptr<net::URLRequestContext> request_context_;
 };
 
 }  // namespace
 
 class AppCacheUpdateJobTest : public testing::Test,
                               public AppCacheGroup::UpdateObserver {
  public:
   class MockAppCachePolicy : public AppCachePolicy {
    public:
@@ skipping 30 matching lines @@
 
 
   AppCacheUpdateJobTest()
       : do_checks_after_update_finished_(false),
         expect_group_obsolete_(false),
         expect_group_has_cache_(false),
         expect_old_cache_(NULL),
         expect_newest_cache_(NULL),
         expect_non_null_update_time_(false),
         tested_manifest_(NONE),
-        tested_manifest_path_override_(NULL),
-        registered_factory_(false),
-        old_factory_(NULL) {
-  }
-
-  static void SetUpTestCase() {
-    io_thread_ = new IOThread("AppCacheUpdateJob IO test thread");
+        tested_manifest_path_override_(NULL) {
+    io_thread_.reset(new IOThread("AppCacheUpdateJob IO test thread"));
     base::Thread::Options options(MessageLoop::TYPE_IO, 0);
     io_thread_->StartWithOptions(options);
   }
 
-  static base::WaitableEvent* io_thread_shutdown_event_;
-
-  // Cleanup function; must be called on the IO Thread.
-  static void CleanupIOThread() {
-    io_thread_shutdown_event_->Signal();
-  }
-
-  static void TearDownTestCase() {
-    io_thread_shutdown_event_ = new base::WaitableEvent(false, false);
-    io_thread_->message_loop()->PostTask(FROM_HERE,
-      NewRunnableFunction(CleanupIOThread));
-    io_thread_shutdown_event_->Wait();
-    delete io_thread_shutdown_event_;
-    delete io_thread_;
-    io_thread_ = NULL;
-  }
-
   // Use a separate IO thread to run a test. Thread will be destroyed
   // when it goes out of scope.
   template <class Method>
   void RunTestOnIOThread(Method method) {
     event_.reset(new base::WaitableEvent(false, false));
     io_thread_->message_loop()->PostTask(
         FROM_HERE, NewRunnableMethod(this, method));
 
     // Wait until task is done before exiting the test.
     event_->Wait();
@@ skipping 203 matching lines @@
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void ManifestRedirectTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
-    old_factory_ =
-        net::URLRequest::RegisterProtocolFactory("http", RedirectFactory);
-    registered_factory_ = true;
+    net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
+    new_factory->SetProtocolHandler("http", new RedirectFactory);
+    io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), GURL("http://testme"),
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
@@ skipping 769 matching lines @@
 
     WaitForUpdateToFinish();
   }
 
   void RetryRequestTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     // Set some large number of times to return retry.
     // Expect 1 manifest fetch and 3 retries.
     RetryRequestTestJob::Initialize(5, RetryRequestTestJob::RETRY_AFTER_0, 4);
-    old_factory_ = net::URLRequest::RegisterProtocolFactory(
-        "http", RetryRequestTestJob::RetryFactory);
-    registered_factory_ = true;
+    net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
+    new_factory->SetProtocolHandler("http", new RetryRequestTestJobFactory);
+    io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void RetryNoRetryAfterTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     // Set some large number of times to return retry.
     // Expect 1 manifest fetch and 0 retries.
     RetryRequestTestJob::Initialize(5, RetryRequestTestJob::NO_RETRY_AFTER, 1);
-    old_factory_ = net::URLRequest::RegisterProtocolFactory(
-        "http", RetryRequestTestJob::RetryFactory);
-    registered_factory_ = true;
+    net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
+    new_factory->SetProtocolHandler("http", new RetryRequestTestJobFactory);
+    io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void RetryNonzeroRetryAfterTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     // Set some large number of times to return retry.
     // Expect 1 request and 0 retry attempts.
     RetryRequestTestJob::Initialize(
         5, RetryRequestTestJob::NONZERO_RETRY_AFTER, 1);
-    old_factory_ = net::URLRequest::RegisterProtocolFactory(
-        "http", RetryRequestTestJob::RetryFactory);
-    registered_factory_ = true;
+    net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
+    new_factory->SetProtocolHandler("http", new RetryRequestTestJobFactory);
+    io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void RetrySuccessTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     // Set 2 as the retry limit (does not exceed the max).
     // Expect 1 manifest fetch, 2 retries, 1 url fetch, 1 manifest refetch.
     RetryRequestTestJob::Initialize(2, RetryRequestTestJob::RETRY_AFTER_0, 5);
-    old_factory_ = net::URLRequest::RegisterProtocolFactory(
-        "http", RetryRequestTestJob::RetryFactory);
-    registered_factory_ = true;
+    net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
+    new_factory->SetProtocolHandler("http", new RetryRequestTestJobFactory);
+    io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void RetryUrlTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     // Set 1 as the retry limit (does not exceed the max).
     // Expect 1 manifest fetch, 1 url fetch, 1 url retry, 1 manifest refetch.
     RetryRequestTestJob::Initialize(1, RetryRequestTestJob::RETRY_AFTER_0, 4);
-    old_factory_ = net::URLRequest::RegisterProtocolFactory(
-        "http", RetryRequestTestJob::RetryFactory);
-    registered_factory_ = true;
+    net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
+    new_factory->SetProtocolHandler("http", new RetryRequestTestJobFactory);
+    io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), GURL("http://retryurl"),
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
@@ skipping 818 matching lines @@
     frontend->AddExpectedEvent(ids1, PROGRESS_EVENT);  // final
     frontend->AddExpectedEvent(ids1, CACHED_EVENT);
 
     // Group status will be IDLE so cannot call WaitForUpdateToFinish.
     group_->AddUpdateObserver(this);
   }
 
   void IfModifiedSinceTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
-    old_factory_ = net::URLRequest::RegisterProtocolFactory(
-        "http", HttpHeadersRequestTestJob::IfModifiedSinceFactory);
-    registered_factory_ = true;
+    net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
+    new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
+    io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), GURL("http://headertest"), 111);
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     // First test against a cache attempt. Will start manifest fetch
     // synchronously.
     HttpHeadersRequestTestJob::Initialize("", "");
     MockFrontend mock_frontend;
@@ skipping 43 matching lines @@
     HttpHeadersRequestTestJob::Verify();
     delete update;
 
     UpdateFinished();
   }
 
   void IfModifiedSinceUpgradeTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     HttpHeadersRequestTestJob::Initialize("Sat, 29 Oct 1994 19:43:31 GMT", "");
-    old_factory_ = net::URLRequest::RegisterProtocolFactory(
-        "http", HttpHeadersRequestTestJob::IfModifiedSinceFactory);
-    registered_factory_ = true;
+    net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
+    new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
+    io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), MockHttpServer::GetMockUrl("files/manifest1"), 111);
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     // Give the newest cache a manifest enry that is in storage.
     response_writer_.reset(
         service_->storage()->CreateResponseWriter(group_->manifest_url()));
@@ skipping 35 matching lines @@
             &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
     response_writer_->WriteInfo(io_buffer, write_callback_.get());
 
     // Start update after data write completes asynchronously.
   }
 
   void IfNoneMatchUpgradeTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     HttpHeadersRequestTestJob::Initialize("", "\"LadeDade\"");
-    old_factory_ = net::URLRequest::RegisterProtocolFactory(
-        "http", HttpHeadersRequestTestJob::IfModifiedSinceFactory);
-    registered_factory_ = true;
+    net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
+    new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
+    io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), MockHttpServer::GetMockUrl("files/manifest1"), 111);
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     // Give the newest cache a manifest enry that is in storage.
     response_writer_.reset(
         service_->storage()->CreateResponseWriter(group_->manifest_url()));
@@ skipping 35 matching lines @@
             &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
     response_writer_->WriteInfo(io_buffer, write_callback_.get());
 
     // Start update after data write completes asynchronously.
   }
 
   void IfNoneMatchRefetchTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     HttpHeadersRequestTestJob::Initialize("", "\"LadeDade\"");
-    old_factory_ = net::URLRequest::RegisterProtocolFactory(
-        "http", HttpHeadersRequestTestJob::IfModifiedSinceFactory);
-    registered_factory_ = true;
+    net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
+    new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
+    io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), GURL("http://headertest"), 111);
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     // Simulate a refetch manifest request that uses an ETag header.
     const char data[] =
         "HTTP/1.1 200 OK\0"
         "ETag: \"LadeDade\"\0"
@@ skipping 12 matching lines @@
 
     UpdateFinished();
   }
 
   void MultipleHeadersRefetchTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     // Verify that code is correct when building multiple extra headers.
     HttpHeadersRequestTestJob::Initialize(
         "Sat, 29 Oct 1994 19:43:31 GMT", "\"LadeDade\"");
-    old_factory_ = net::URLRequest::RegisterProtocolFactory(
-        "http", HttpHeadersRequestTestJob::IfModifiedSinceFactory);
-    registered_factory_ = true;
+    net::URLRequestJobFactory* new_factory(new net::URLRequestJobFactory);
+    new_factory->SetProtocolHandler("http", new IfModifiedSinceJobFactory);
+    io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), GURL("http://headertest"), 111);
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     // Simulate a refetch manifest request that uses an ETag header.
     const char data[] =
         "HTTP/1.1 200 OK\0"
         "Last-Modified: Sat, 29 Oct 1994 19:43:31 GMT\0"
@@ skipping 101 matching lines @@
     if (do_checks_after_update_finished_)
       VerifyExpectations();
 
     // Clean up everything that was created on the IO thread.
     protect_newest_cache_ = NULL;
     group_ = NULL;
     STLDeleteContainerPointers(hosts_.begin(), hosts_.end());
     STLDeleteContainerPointers(frontends_.begin(), frontends_.end());
     response_infos_.clear();
     service_.reset(NULL);
-    if (registered_factory_)
-      net::URLRequest::RegisterProtocolFactory("http", old_factory_);
 
     event_->Signal();
   }
 
   void MakeService() {
     service_.reset(new MockAppCacheService());
     service_->set_request_context(io_thread_->request_context());
     service_->set_appcache_policy(&policy_);
   }
 
@@ skipping 294 matching lines @@
   // Various manifest files used in this test.
   enum TestedManifest {
     NONE,
     MANIFEST1,
     MANIFEST_MERGED_TYPES,
     EMPTY_MANIFEST,
     EMPTY_FILE_MANIFEST,
     PENDING_MASTER_NO_UPDATE,
   };
 
-  static IOThread* io_thread_;
+  scoped_ptr<IOThread> io_thread_;
 
   scoped_ptr<MockAppCacheService> service_;
   scoped_refptr<AppCacheGroup> group_;
   scoped_refptr<AppCache> protect_newest_cache_;
   scoped_ptr<base::WaitableEvent> event_;
   MockAppCachePolicy policy_;
 
   scoped_ptr<AppCacheResponseWriter> response_writer_;
   scoped_ptr<net::CompletionCallbackImpl<AppCacheUpdateJobTest> >
       write_callback_;
@@ skipping 11 matching lines @@
   bool expect_group_obsolete_;
   bool expect_group_has_cache_;
   AppCache* expect_old_cache_;
   AppCache* expect_newest_cache_;
   bool expect_non_null_update_time_;
   std::vector<MockFrontend*> frontends_;  // to check expected events
   TestedManifest tested_manifest_;
   const char* tested_manifest_path_override_;
   AppCache::EntryMap expect_extra_entries_;
   std::map<GURL, int64> expect_response_ids_;
-
-  bool registered_factory_;
-  net::URLRequest::ProtocolFactory* old_factory_;
 };
 
-// static
-IOThread* AppCacheUpdateJobTest::io_thread_ = NULL;
-base::WaitableEvent* AppCacheUpdateJobTest::io_thread_shutdown_event_ = NULL;
-
-
 TEST_F(AppCacheUpdateJobTest, AlreadyChecking) {
   MockAppCacheService service;
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(&service, GURL("http://manifesturl.com"),
                         service.storage()->NewGroupId()));
 
   AppCacheUpdateJob update(&service, group);
 
   // Pretend group is in checking state.
   group->update_job_ = &update;
@@ skipping 263 matching lines @@
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace appcache
 
 // AppCacheUpdateJobTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheUpdateJobTest);
 DISABLE_RUNNABLE_METHOD_REFCOUNT(
     appcache::AppCacheUpdateJobTest::MockAppCachePolicy);