Remove ProtocolFactory use from appcache_url_request_job_unittest.

content/browser/appcache/appcache_url_request_job_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 <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/pickle.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "content/browser/appcache/mock_appcache_service.h"
 #include "net/base/io_buffer.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_response.h"
 #include "webkit/browser/appcache/appcache_url_request_job.h"
 
 using appcache::AppCacheEntry;
 using appcache::AppCacheStorage;
 using appcache::AppCacheResponseInfo;
 using appcache::AppCacheResponseReader;
 using appcache::AppCacheResponseWriter;
 using appcache::AppCacheURLRequestJob;
 using appcache::HttpResponseInfoIOBuffer;
 using appcache::kNoCacheId;
 using net::IOBuffer;
 using net::WrappedIOBuffer;
 
 namespace content {
 
-static const char kHttpBasicHeaders[] =
-    "HTTP/1.0 200 OK\0Content-Length: 5\0\0";
-static const char kHttpBasicBody[] = "Hello";
+namespace {
 
-static const int kNumBlocks = 4;
-static const int kBlockSize = 1024;
+const char kHttpBasicHeaders[] = "HTTP/1.0 200 OK\0Content-Length: 5\0\0";
+const char kHttpBasicBody[] = "Hello";
+
+const int kNumBlocks = 4;
+const int kBlockSize = 1024;
+
+class MockURLRequestJobFactory : public net::URLRequestJobFactory {
+ public:
+  MockURLRequestJobFactory() : job_(NULL) {
+  }
+
+  virtual ~MockURLRequestJobFactory() {
+    DCHECK(!job_);
+  }
+
+  void SetJob(net::URLRequestJob* job) {
+    job_ = job;
+  }
+
+  bool has_job() const {
+    return job_ != NULL;
+  }
+
+  // net::URLRequestJobFactory implementation.
+  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 {
+      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 AppCacheURLRequestJobTest : public testing::Test {
  public:
 
   // Test Harness -------------------------------------------------------------
   // TODO(michaeln): share this test harness with AppCacheResponseTest
 
   class MockStorageDelegate : public AppCacheStorage::Delegate {
    public:
     explicit MockStorageDelegate(AppCacheURLRequestJobTest* test)
@@ skipping 75 matching lines @@
 
     AppCacheURLRequestJobTest* test_;
     net::HttpResponseInfo received_info_;
     scoped_refptr<net::IOBuffer> received_data_;
     bool did_receive_headers_;
     int amount_received_;
     int kill_after_amount_received_;
     bool kill_with_io_pending_;
   };
 
-  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 {
-      return new net::URLRequestErrorJob(request,
-                                         network_delegate,
-                                         net::ERR_INTERNET_DISCONNECTED);
-    }
-  }
-
   // Helper callback to run a test on our io_thread. The io_thread is spun up
   // once and reused for all tests.
   template <class Method>
   void MethodWrapper(Method method) {
     SetUpTest();
     (this->*method)();
   }
 
   static void SetUpTestCase() {
     io_thread_.reset(new base::Thread("AppCacheURLRequestJobTest Thread"));
@@ skipping 12 matching lines @@
     test_finished_event_ .reset(new base::WaitableEvent(false, false));
     io_thread_->message_loop()->PostTask(
         FROM_HERE, base::Bind(&AppCacheURLRequestJobTest::MethodWrapper<Method>,
                               base::Unretained(this), method));
     test_finished_event_->Wait();
   }
 
   void SetUpTest() {
     DCHECK(base::MessageLoop::current() == io_thread_->message_loop());
     DCHECK(task_stack_.empty());
-    orig_http_factory_ = net::URLRequest::Deprecated::RegisterProtocolFactory(
-        "http", MockHttpJobFactory);
-    url_request_delegate_.reset(new MockURLRequestDelegate(this));
+
     storage_delegate_.reset(new MockStorageDelegate(this));
     service_.reset(new MockAppCacheService());
     expected_read_result_ = 0;
     expected_write_result_ = 0;
     written_response_id_ = 0;
     reader_deletion_count_down_ = 0;
     writer_deletion_count_down_ = 0;
+
+    url_request_delegate_.reset(new MockURLRequestDelegate(this));
+    job_factory_.reset(new MockURLRequestJobFactory());
+    empty_context_.reset(new net::URLRequestContext());
+    empty_context_->set_job_factory(job_factory_.get());
   }
 
   void TearDownTest() {
     DCHECK(base::MessageLoop::current() == io_thread_->message_loop());
-    net::URLRequest::Deprecated::RegisterProtocolFactory("http",
-                                                         orig_http_factory_);
-    orig_http_factory_ = NULL;
     request_.reset();
-    url_request_delegate_.reset();
-    DCHECK(!mock_factory_job_);
 
     while (!task_stack_.empty())
       task_stack_.pop();
 
     reader_.reset();
     read_buffer_ = NULL;
     read_info_buffer_ = NULL;
     writer_.reset();
     write_buffer_ = NULL;
     write_info_buffer_ = NULL;
     storage_delegate_.reset();
     service_.reset();
+
+    DCHECK(!job_factory_->has_job());
+    empty_context_.reset();
+    job_factory_.reset();
+    url_request_delegate_.reset();
   }
 
   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(&AppCacheURLRequestJobTest::TestFinishedUnwound,
                    base::Unretained(this)));
@@ skipping 148 matching lines @@
     return true;
   }
 
   // Individual Tests ---------------------------------------------------------
   // Some of the individual tests involve multiple async steps. Each test
   // is delineated with a section header.
 
   // Basic -------------------------------------------------------------------
   void Basic() {
     AppCacheStorage* storage = service_->storage();
-    net::URLRequest request(
-        GURL("http://blah/"), net::DEFAULT_PRIORITY, NULL, &empty_context_);
+    net::URLRequest request(GURL("http://blah/"), net::DEFAULT_PRIORITY, NULL,
+                            empty_context_.get());
     scoped_refptr<AppCacheURLRequestJob> job;
 
     // Create an instance and see that it looks as expected.
 
     job = new AppCacheURLRequestJob(
         &request, NULL, storage, NULL, false);
     EXPECT_TRUE(job->is_waiting());
     EXPECT_FALSE(job->is_delivering_appcache_response());
     EXPECT_FALSE(job->is_delivering_network_response());
     EXPECT_FALSE(job->is_delivering_error_response());
     EXPECT_FALSE(job->has_been_started());
     EXPECT_FALSE(job->has_been_killed());
     EXPECT_EQ(GURL(), job->manifest_url());
     EXPECT_EQ(kNoCacheId, job->cache_id());
     EXPECT_FALSE(job->entry().has_response_id());
 
     TestFinished();
   }
 
   // DeliveryOrders -----------------------------------------------------
   void DeliveryOrders() {
     AppCacheStorage* storage = service_->storage();
-    net::URLRequest request(
-        GURL("http://blah/"), net::DEFAULT_PRIORITY, NULL, &empty_context_);
+    net::URLRequest request(GURL("http://blah/"), net::DEFAULT_PRIORITY, NULL,
+                            empty_context_.get());
     scoped_refptr<AppCacheURLRequestJob> job;
 
     // Create an instance, give it a delivery order and see that
     // it looks as expected.
 
     job = new AppCacheURLRequestJob(&request, NULL, storage, NULL, false);
     job->DeliverErrorResponse();
     EXPECT_TRUE(job->is_delivering_error_response());
     EXPECT_FALSE(job->has_been_started());
 
@@ skipping 23 matching lines @@
 
   // DeliverNetworkResponse --------------------------------------------------
 
   void DeliverNetworkResponse() {
     // This test has async steps.
     PushNextTask(
         base::Bind(&AppCacheURLRequestJobTest::VerifyDeliverNetworkResponse,
                    base::Unretained(this)));
 
     AppCacheStorage* storage = service_->storage();
-    request_ = empty_context_.CreateRequest(GURL("http://blah/"),
-                                            net::DEFAULT_PRIORITY,
-                                            url_request_delegate_.get(),
-                                            NULL);
+    request_ = empty_context_->CreateRequest(GURL("http://blah/"),
+                                             net::DEFAULT_PRIORITY,
+                                             url_request_delegate_.get(),
+                                             NULL);
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
-    mock_factory_job_ = new AppCacheURLRequestJob(
+    AppCacheURLRequestJob* mock_job = new AppCacheURLRequestJob(
         request_.get(), NULL, storage, NULL, false);
-    mock_factory_job_->DeliverNetworkResponse();
-    EXPECT_TRUE(mock_factory_job_->is_delivering_network_response());
-    EXPECT_FALSE(mock_factory_job_->has_been_started());
+    job_factory_->SetJob(mock_job);
+    mock_job->DeliverNetworkResponse();
+    EXPECT_TRUE(mock_job->is_delivering_network_response());
+    EXPECT_FALSE(mock_job->has_been_started());
 
     // Start the request.
     request_->Start();
 
     // The job should have been picked up.
-    EXPECT_FALSE(mock_factory_job_);
+    EXPECT_FALSE(job_factory_->has_job());
     // Completion is async.
   }
 
   void VerifyDeliverNetworkResponse() {
     EXPECT_EQ(request_->status().error(),
               net::ERR_INTERNET_DISCONNECTED);
     TestFinished();
   }
 
   // DeliverErrorResponse --------------------------------------------------
 
   void DeliverErrorResponse() {
     // This test has async steps.
     PushNextTask(
         base::Bind(&AppCacheURLRequestJobTest::VerifyDeliverErrorResponse,
                    base::Unretained(this)));
 
     AppCacheStorage* storage = service_->storage();
-    request_ = empty_context_.CreateRequest(GURL("http://blah/"),
-                                            net::DEFAULT_PRIORITY,
-                                            url_request_delegate_.get(),
-                                            NULL);
+    request_ = empty_context_->CreateRequest(GURL("http://blah/"),
+                                             net::DEFAULT_PRIORITY,
+                                             url_request_delegate_.get(),
+                                             NULL);
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
-    mock_factory_job_ = new AppCacheURLRequestJob(
+    AppCacheURLRequestJob* mock_job = new AppCacheURLRequestJob(
         request_.get(), NULL, storage, NULL, false);
-    mock_factory_job_->DeliverErrorResponse();
-    EXPECT_TRUE(mock_factory_job_->is_delivering_error_response());
-    EXPECT_FALSE(mock_factory_job_->has_been_started());
+    job_factory_->SetJob(mock_job);
+    mock_job->DeliverErrorResponse();
+    EXPECT_TRUE(mock_job->is_delivering_error_response());
+    EXPECT_FALSE(mock_job->has_been_started());
 
     // Start the request.
     request_->Start();
 
     // The job should have been picked up.
-    EXPECT_FALSE(mock_factory_job_);
+    EXPECT_FALSE(job_factory_->has_job());
     // Completion is async.
   }
 
   void VerifyDeliverErrorResponse() {
     EXPECT_EQ(request_->status().error(), net::ERR_FAILED);
     TestFinished();
   }
 
   // DeliverSmallAppCachedResponse --------------------------------------
   // "Small" being small enough to read completely in a single
@@ skipping 13 matching lines @@
                    base::Unretained(this), false));
 
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
     // Continues async
   }
 
   void RequestAppCachedResource(bool start_after_delivery_orders) {
     AppCacheStorage* storage = service_->storage();
-    request_ = empty_context_.CreateRequest(GURL("http://blah/"),
-                                            net::DEFAULT_PRIORITY,
-                                            url_request_delegate_.get(),
-                                            NULL);
+    request_ = empty_context_->CreateRequest(GURL("http://blah/"),
+                                             net::DEFAULT_PRIORITY,
+                                             url_request_delegate_.get(),
+                                             NULL);
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     scoped_refptr<AppCacheURLRequestJob> job(new AppCacheURLRequestJob(
         request_.get(), NULL, storage, NULL, false));
 
     if (start_after_delivery_orders) {
       job->DeliverAppCachedResponse(
           GURL(), 0, 111,
           AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_),
           false);
       EXPECT_TRUE(job->is_delivering_appcache_response());
     }
 
     // Start the request.
     EXPECT_FALSE(job->has_been_started());
-    mock_factory_job_ = job.get();
+    job_factory_->SetJob(job.get());
     request_->Start();
-    EXPECT_FALSE(mock_factory_job_);
+    EXPECT_FALSE(job_factory_->has_job());
     EXPECT_TRUE(job->has_been_started());
 
     if (!start_after_delivery_orders) {
       job->DeliverAppCachedResponse(
           GURL(), 0, 111,
           AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_),
           false);
       EXPECT_TRUE(job->is_delivering_appcache_response());
     }
 
@@ skipping 72 matching lines @@
     PushNextTask(base::Bind(
        &AppCacheURLRequestJobTest::MakeRangeRequest, base::Unretained(this)));
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
     // Continues async
   }
 
   void MakeRangeRequest() {
     AppCacheStorage* storage = service_->storage();
-    request_ = empty_context_.CreateRequest(GURL("http://blah/"),
-                                            net::DEFAULT_PRIORITY,
-                                            url_request_delegate_.get(),
-                                            NULL);
+    request_ = empty_context_->CreateRequest(GURL("http://blah/"),
+                                             net::DEFAULT_PRIORITY,
+                                             url_request_delegate_.get(),
+                                             NULL);
 
     // Request a range, the 3 middle chars out of 'Hello'
     net::HttpRequestHeaders extra_headers;
     extra_headers.SetHeader("Range", "bytes= 1-3");
     request_->SetExtraRequestHeaders(extra_headers);
 
     // Create job with orders to deliver an appcached entry.
     scoped_refptr<AppCacheURLRequestJob> job(new AppCacheURLRequestJob(
         request_.get(), NULL, storage, NULL, false));
     job->DeliverAppCachedResponse(
         GURL(), 0, 111,
         AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_),
         false);
     EXPECT_TRUE(job->is_delivering_appcache_response());
 
     // Start the request.
     EXPECT_FALSE(job->has_been_started());
-    mock_factory_job_ = job.get();
+    job_factory_->SetJob(job.get());
     request_->Start();
-    EXPECT_FALSE(mock_factory_job_);
+    EXPECT_FALSE(job_factory_->has_job());
     EXPECT_TRUE(job->has_been_started());
     // Completion is async.
   }
 
   void VerifyDeliverPartialResponse() {
     EXPECT_TRUE(request_->status().is_success());
     EXPECT_EQ(3, url_request_delegate_->amount_received_);
     EXPECT_EQ(0, memcmp(kHttpBasicBody + 1,
                         url_request_delegate_->received_data_->data(),
                         3));
@@ skipping 76 matching lines @@
   int expected_read_result_;
   int reader_deletion_count_down_;
 
   int64 written_response_id_;
   scoped_ptr<AppCacheResponseWriter> writer_;
   scoped_refptr<HttpResponseInfoIOBuffer> write_info_buffer_;
   scoped_refptr<IOBuffer> write_buffer_;
   int expected_write_result_;
   int writer_deletion_count_down_;
 
-  net::URLRequest::ProtocolFactory* orig_http_factory_;
-  net::URLRequestContext empty_context_;
+  scoped_ptr<MockURLRequestJobFactory> job_factory_;
+  scoped_ptr<net::URLRequestContext> empty_context_;
   scoped_ptr<net::URLRequest> request_;
   scoped_ptr<MockURLRequestDelegate> url_request_delegate_;
 
   static scoped_ptr<base::Thread> io_thread_;
-  static AppCacheURLRequestJob* mock_factory_job_;
 };
 
 // static
 scoped_ptr<base::Thread> AppCacheURLRequestJobTest::io_thread_;
-AppCacheURLRequestJob* AppCacheURLRequestJobTest::mock_factory_job_ = NULL;
 
 TEST_F(AppCacheURLRequestJobTest, Basic) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::Basic);
 }
 
 TEST_F(AppCacheURLRequestJobTest, DeliveryOrders) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::DeliveryOrders);
 }
 
 TEST_F(AppCacheURLRequestJobTest, DeliverNetworkResponse) {
@@ skipping 17 matching lines @@
 }
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequest) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequest);
 }
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequestWithIOPending) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequestWithIOPending);
 }
 
+}  // namespace
+
 }  // namespace content