Remove ProtocolFactory use from appcache_request_handler_unittest

content/browser/appcache/appcache_request_handler_unittest.cc

 // Copyright 2014 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 <stack>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "content/browser/appcache/mock_appcache_policy.h"
 #include "content/browser/appcache/mock_appcache_service.h"
 #include "net/base/net_errors.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
+#include "net/url_request/url_request_job_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/appcache/appcache.h"
 #include "webkit/browser/appcache/appcache_backend_impl.h"
 #include "webkit/browser/appcache/appcache_request_handler.h"
 #include "webkit/browser/appcache/appcache_url_request_job.h"
 
 using appcache::AppCache;
 using appcache::AppCacheBackendImpl;
 using appcache::AppCacheEntry;
 using appcache::AppCacheFrontend;
@@ skipping 88 matching lines @@
         return;
       *info = response_info_;
     }
 
   private:
     int response_code_;
     bool has_response_info_;
     net::HttpResponseInfo response_info_;
   };
 
+  class MockURLRequestJobFactory : public net::URLRequestJobFactory {
+   public:
+    MockURLRequestJobFactory() : job_(NULL) {
+    }
+
+    virtual ~MockURLRequestJobFactory() {
+      DCHECK(!job_);
+    }
+
+    void SetJob(net::URLRequestJob* job) {
+      job_ = job;
+    }
+
+    virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
+        const std::string& scheme,
+        net::URLRequest* request,
+        net::NetworkDelegate* network_delegate) const OVERRIDE {
+      if (job_) {
+        net::URLRequestJob* temp = job_;
+        job_ = NULL;
+        return temp;
+      } else {
+        // Some of these tests trigger UpdateJobs which start URLRequests.
+        // We short circuit those be returning error jobs.
+        return new net::URLRequestErrorJob(request,
+                                           network_delegate,
+                                           net::ERR_INTERNET_DISCONNECTED);
+      }
+    }
+
+    virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE {
+      return scheme == "http";
+    };
+
+    virtual bool IsHandledURL(const GURL& url) const OVERRIDE {
+      return url.SchemeIs("http");
+    }
+
+    virtual bool IsSafeRedirectTarget(const GURL& location) const OVERRIDE {
+      return false;
+    }
+
+   private:
+    mutable net::URLRequestJob* job_;
+  };
+
   class MockURLRequest : public net::URLRequest {
    public:
     MockURLRequest(const GURL& url, net::URLRequestContext* context)
         : net::URLRequest(url, net::DEFAULT_PRIORITY, NULL, context) {}
 
-    void SimulateResponseCode(int http_response_code) {
-      mock_factory_job_ = new MockURLRequestJob(
-          this, context()->network_delegate(), http_response_code);
-      Start();
-      DCHECK(!mock_factory_job_);
-      // All our simulation needs  to satisfy are the following two DCHECKs
-      DCHECK(status().is_success());
-      DCHECK_EQ(http_response_code, GetResponseCode());
-    }
-
-    void SimulateResponseInfo(const net::HttpResponseInfo& info) {
-      mock_factory_job_ =
-          new MockURLRequestJob(this, context()->network_delegate(), info);
-      set_delegate(&delegate_);  // needed to get the info back out
-      Start();
-      DCHECK(!mock_factory_job_);
-    }
 
     MockURLRequestDelegate delegate_;
   };
 
-  static net::URLRequestJob* MockHttpJobFactory(
-      net::URLRequest* request,
-      net::NetworkDelegate* network_delegate,
-      const std::string& scheme) {
-    if (mock_factory_job_) {
-      net::URLRequestJob* temp = mock_factory_job_;
-      mock_factory_job_ = NULL;
-      return temp;
-    } else {
-      // Some of these tests trigger UpdateJobs which start URLRequests.
-      // We short circuit those be returning error jobs.
-      return new net::URLRequestErrorJob(request,
-                                         network_delegate,
-                                         net::ERR_INTERNET_DISCONNECTED);
-    }
-  }
-
   static void SetUpTestCase() {
     io_thread_.reset(new base::Thread("AppCacheRequestHandlerTest Thread"));
     base::Thread::Options options(base::MessageLoop::TYPE_IO, 0);
     io_thread_->StartWithOptions(options);
   }
 
   static void TearDownTestCase() {
     io_thread_.reset(NULL);
   }
 
   // Test harness --------------------------------------------------
 
-  AppCacheRequestHandlerTest() : host_(NULL), orig_http_factory_(NULL) {}
+  AppCacheRequestHandlerTest() : host_(NULL) {}
 
   template <class Method>
   void RunTestOnIOThread(Method method) {
     test_finished_event_ .reset(new base::WaitableEvent(false, false));
     io_thread_->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&AppCacheRequestHandlerTest::MethodWrapper<Method>,
                    base::Unretained(this), method));
     test_finished_event_->Wait();
   }
 
   void SetUpTest() {
     DCHECK(base::MessageLoop::current() == io_thread_->message_loop());
-    orig_http_factory_ = net::URLRequest::Deprecated::RegisterProtocolFactory(
-        "http", MockHttpJobFactory);
     mock_service_.reset(new MockAppCacheService);
     mock_service_->set_request_context(&empty_context_);
     mock_policy_.reset(new MockAppCachePolicy);
     mock_service_->set_appcache_policy(mock_policy_.get());
     mock_frontend_.reset(new MockFrontend);
     backend_impl_.reset(new AppCacheBackendImpl);
     backend_impl_->Initialize(mock_service_.get(), mock_frontend_.get(),
                               kMockProcessId);
     const int kHostId = 1;
     backend_impl_->RegisterHost(kHostId);
     host_ = backend_impl_->GetHost(kHostId);
+    job_factory_.reset(new MockURLRequestJobFactory());
+    empty_context_.set_job_factory(job_factory_.get());
   }
 
   void TearDownTest() {
     DCHECK(base::MessageLoop::current() == io_thread_->message_loop());
-    DCHECK(!mock_factory_job_);
-    net::URLRequest::Deprecated::RegisterProtocolFactory(
-        "http", orig_http_factory_);
-    orig_http_factory_ = NULL;
     job_ = NULL;
     handler_.reset();
     request_.reset();
     backend_impl_.reset();
     mock_frontend_.reset();
     mock_service_.reset();
     mock_policy_.reset();
+    job_factory_.reset();
     host_ = NULL;
   }
 
   void TestFinished() {
     // We unwind the stack prior to finishing up to let stack
     // based objects get deleted.
     DCHECK(base::MessageLoop::current() == io_thread_->message_loop());
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&AppCacheRequestHandlerTest::TestFinishedUnwound,
@@ skipping 134 matching lines @@
 
     job_ = handler_->MaybeLoadResource(request_.get(),
                                        request_->context()->network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     // We have to wait for completion of storage->FindResponseForMainRequest.
     ScheduleNextTask();
   }
 
+  void SimulateResponseCode(int response_code) {
+    job_factory_->SetJob(
+        new MockURLRequestJob(
+            request_.get(),
+            request_->context()->network_delegate(),
+            response_code));
+    request_->Start();
+    // All our simulation needs  to satisfy are the following two DCHECKs
+    DCHECK(request_->status().is_success());
+    DCHECK_EQ(response_code, request_->GetResponseCode());
+  }
+
+  void SimulateResponseInfo(const net::HttpResponseInfo& info) {
+    job_factory_->SetJob(
+        new MockURLRequestJob(
+            request_.get(),
+            request_->context()->network_delegate(), info));
+    request_->set_delegate(&request_->delegate_);
+    request_->Start();
+  }
+
   void Verify_MainResource_Fallback() {
     EXPECT_FALSE(job_->is_waiting());
     EXPECT_TRUE(job_->is_delivering_network_response());
 
     // When the request is restarted, the existing job is dropped so a
     // real network job gets created. We expect NULL here which will cause
     // the net library to create a real job.
     job_ = handler_->MaybeLoadResource(request_.get(),
                                        request_->context()->network_delegate());
     EXPECT_FALSE(job_.get());
 
     // Simulate an http error of the real network job.
-    request_->SimulateResponseCode(500);
+    SimulateResponseCode(500);
 
     job_ = handler_->MaybeLoadFallbackForResponse(
         request_.get(), request_->context()->network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_delivering_appcache_response());
 
     int64 cache_id = kNoCacheId;
     GURL manifest_url;
     handler_->GetExtraResponseInfo(&cache_id, &manifest_url);
     EXPECT_EQ(1, cache_id);
@@ skipping 48 matching lines @@
 
     // Simulate an http error of the real network job, but with custom
     // headers that override the fallback behavior.
     const char kOverrideHeaders[] =
         "HTTP/1.1 404 BOO HOO\0"
         "x-chromium-appcache-fallback-override: disallow-fallback\0"
         "\0";
     net::HttpResponseInfo info;
     info.headers = new net::HttpResponseHeaders(
         std::string(kOverrideHeaders, arraysize(kOverrideHeaders)));
-    request_->SimulateResponseInfo(info);
+    SimulateResponseInfo(info);
 
     job_ = handler_->MaybeLoadFallbackForResponse(
         request_.get(), request_->context()->network_delegate());
     EXPECT_FALSE(job_.get());
 
     TestFinished();
   }
 
   // SubResource_Miss_WithNoCacheSelected ----------------------------------
 
@@ skipping 154 matching lines @@
                                        request_->context()->network_delegate());
     EXPECT_FALSE(job_.get());
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForRedirect(
         request_.get(),
         request_->context()->network_delegate(),
         GURL("http://blah/redirect"));
     EXPECT_FALSE(fallback_job);
 
-    request_->SimulateResponseCode(200);
+    SimulateResponseCode(200);
     fallback_job = handler_->MaybeLoadFallbackForResponse(
         request_.get(), request_->context()->network_delegate());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_Network -----------------------------
 
   void SubResource_Network() {
@@ skipping 116 matching lines @@
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     job_ = handler_->MaybeLoadResource(request_.get(),
                                        request_->context()->network_delegate());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
     EXPECT_FALSE(job_->has_been_started());
 
-    mock_factory_job_ = job_.get();
+    job_factory_->SetJob(job_);
     request_->Start();
     EXPECT_TRUE(job_->has_been_started());
 
     request_->Cancel();
     EXPECT_TRUE(job_->has_been_killed());
 
     EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
         request_.get(), request_->context()->network_delegate()));
 
     TestFinished();
@@ skipping 102 matching lines @@
   // Data members --------------------------------------------------
 
   scoped_ptr<base::WaitableEvent> test_finished_event_;
   std::stack<base::Closure> task_stack_;
   scoped_ptr<MockAppCacheService> mock_service_;
   scoped_ptr<AppCacheBackendImpl> backend_impl_;
   scoped_ptr<MockFrontend> mock_frontend_;
   scoped_ptr<MockAppCachePolicy> mock_policy_;
   AppCacheHost* host_;
   net::URLRequestContext empty_context_;
+  scoped_ptr<MockURLRequestJobFactory> job_factory_;
   scoped_ptr<MockURLRequest> request_;
   scoped_ptr<AppCacheRequestHandler> handler_;
   scoped_refptr<AppCacheURLRequestJob> job_;
-  net::URLRequest::ProtocolFactory* orig_http_factory_;
 
   static scoped_ptr<base::Thread> io_thread_;
-  static net::URLRequestJob* mock_factory_job_;
 };
 
 // static
 scoped_ptr<base::Thread> AppCacheRequestHandlerTest::io_thread_;
-net::URLRequestJob* AppCacheRequestHandlerTest::mock_factory_job_ = NULL;
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Miss) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Miss);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Hit) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Hit);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Fallback) {
@@ skipping 56 matching lines @@
 
 TEST_F(AppCacheRequestHandlerTest, WorkerRequest) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::WorkerRequest);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Blocked) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Blocked);
 }
 
 }  // namespace content