Refactoring: ProtocolHandler::MaybeCreateJob takes NetworkDelegate as argument

webkit/appcache/appcache_update_job_unittest.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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/stl_util.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.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 "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_response.h"
 #include "webkit/appcache/appcache_update_job.h"
 #include "webkit/appcache/mock_appcache_service.h"
 
@@ skipping 20 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) {
+  static net::URLRequestJob* JobFactory(
+      net::URLRequest* request, net::NetworkDelegate* network_delegate) {
     if (request->url().host() != "mockhost" &&
         request->url().host() != "cross_origin_host")
-      return new net::URLRequestErrorJob(request, -100);
+      return new net::URLRequestErrorJob(request, network_delegate, -100);
 
     std::string headers, body;
     GetMockResponse(request->url().path(), &headers, &body);
-    return new net::URLRequestTestJob(request, headers, body, true);
+    return new net::URLRequestTestJob(
+        request, network_delegate, headers, body, true);
   }
 
  private:
   static void GetMockResponse(const std::string& path,
                               std::string* headers,
                               std::string* body) {
     const char ok_headers[] =
         "HTTP/1.1 200 OK\0"
         "\0";
     const char error_headers[] =
@@ skipping 115 matching lines @@
       (*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);
+  virtual net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
+    return MockHttpServer::JobFactory(request, network_delegate);
   }
 };
 
 inline bool operator==(const Namespace& lhs, const Namespace& rhs) {
   return lhs.type == rhs.type &&
          lhs.namespace_url == rhs.namespace_url &&
          lhs.target_url == rhs.target_url;
 }
 
 }  // namespace
@@ skipping 120 matching lines @@
 
   // 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.
 class RedirectFactory : public net::URLRequestJobFactory::ProtocolHandler {
  public:
-  virtual net::URLRequestJob* MaybeCreateJob(net::URLRequest* request) const {
+  virtual net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
     return new net::URLRequestTestJob(
         request,
+        network_delegate,
         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 {
@@ skipping 13 matching lines @@
     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) {
+  static net::URLRequestJob* RetryFactory(
+      net::URLRequest* request, net::NetworkDelegate* network_delegate) {
     ++num_requests_;
     if (num_retries_ > 0 && request->original_url() == kRetryUrl) {
       --num_retries_;
       return new RetryRequestTestJob(
-          request, RetryRequestTestJob::retry_headers(), 503);
+          request, network_delegate, RetryRequestTestJob::retry_headers(), 503);
     } else {
       return new RetryRequestTestJob(
-          request, RetryRequestTestJob::manifest_headers(), 200);
+          request,
+          network_delegate,
+          RetryRequestTestJob::manifest_headers(), 200);
     }
   }
 
   virtual int GetResponseCode() const { return response_code_; }
 
  private:
   ~RetryRequestTestJob() {}
 
   static std::string retry_headers() {
     const char no_retry_after[] =
@@ skipping 26 matching lines @@
         "\0";
     return std::string(headers, arraysize(headers));
   }
 
   static std::string data() {
     return std::string("CACHE MANIFEST\r"
         "http://retry\r");  // must be same as kRetryUrl
   }
 
   RetryRequestTestJob(net::URLRequest* request,
+                      net::NetworkDelegate* network_delegate,
                       const std::string& headers,
                       int response_code)
-      : net::URLRequestTestJob(request, headers, data(), true),
+      : net::URLRequestTestJob(
+            request, network_delegate, headers, data(), true),
         response_code_(response_code) {
   }
 
   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);
+  virtual net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
+    return RetryRequestTestJob::RetryFactory(request, network_delegate);
   }
 };
 
 // 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;
 
@@ skipping 15 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) {
+  static net::URLRequestJob* IfModifiedSinceFactory(
+      net::URLRequest* request, net::NetworkDelegate* network_delegate) {
     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);
+    return MockHttpServer::JobFactory(request, network_delegate);
   }
 
  protected:
   virtual ~HttpHeadersRequestTestJob() {}
 
  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);
+  virtual net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
+    return HttpHeadersRequestTestJob::IfModifiedSinceFactory(
+        request, network_delegate);
   }
 };
 
 class IOThread : public base::Thread {
  public:
   explicit IOThread(const char* name)
       : base::Thread(name) {
   }
 
   ~IOThread() {
@@ skipping 3031 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace appcache