Refactoring: ProtocolHandler::MaybeCreateJob takes NetworkDelegate as argument

content/browser/resource_context_impl.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 "content/browser/resource_context_impl.h"
 
 #include "base/logging.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/fileapi/browser_file_system_helper.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
@@ skipping 76 matching lines @@
     : public net::URLRequestJobFactory::Interceptor {
  public:
   DeveloperProtocolHandler(
       AppCacheService* appcache_service,
       BlobStorageController* blob_storage_controller)
       : appcache_service_(appcache_service),
         blob_storage_controller_(blob_storage_controller) {}
   virtual ~DeveloperProtocolHandler() {}
 
   virtual net::URLRequestJob* MaybeIntercept(
-        net::URLRequest* request) const OVERRIDE {
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE {
     // Check for chrome://view-http-cache/*, which uses its own job type.
     if (ViewHttpCacheJobFactory::IsSupportedURL(request->url()))
-      return ViewHttpCacheJobFactory::CreateJobForRequest(request);
+      return ViewHttpCacheJobFactory::CreateJobForRequest(request,
+                                                          network_delegate);
 
     // Next check for chrome://appcache-internals/, which uses its own job type.
     if (request->url().SchemeIs(chrome::kChromeUIScheme) &&
         request->url().host() == chrome::kChromeUIAppCacheInternalsHost) {
       return appcache::ViewAppCacheInternalsJobFactory::CreateJobForRequest(
-          request, appcache_service_);
+          request, network_delegate, appcache_service_);
     }
 
     // Next check for chrome://blob-internals/, which uses its own job type.
     if (ViewBlobInternalsJobFactory::IsSupportedURL(request->url())) {
       return ViewBlobInternalsJobFactory::CreateJobForRequest(
-          request, blob_storage_controller_);
+          request, network_delegate, blob_storage_controller_);
     }
 
 #if defined(USE_TCMALLOC)
     // Next check for chrome://tcmalloc/, which uses its own job type.
     if (request->url().SchemeIs(chrome::kChromeUIScheme) &&
         request->url().host() == chrome::kChromeUITcmallocHost) {
-      return new TcmallocInternalsRequestJob(request);
+      return new TcmallocInternalsRequestJob(request, network_delegate);
     }
 #endif
 
     // Next check for chrome://histograms/, which uses its own job type.
     if (request->url().SchemeIs(chrome::kChromeUIScheme) &&
         request->url().host() == chrome::kChromeUIHistogramHost) {
-      return new HistogramInternalsRequestJob(request);
+      return new HistogramInternalsRequestJob(request, network_delegate);
     }
 
     return NULL;
   }
 
   virtual net::URLRequestJob* MaybeInterceptRedirect(
         const GURL& location,
-        net::URLRequest* request) const OVERRIDE {
+        net::URLRequest* request,
+        net::NetworkDelegate* network_delegate) const OVERRIDE {
     return NULL;
   }
 
   virtual net::URLRequestJob* MaybeInterceptResponse(
-      net::URLRequest* request) const OVERRIDE {
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE {
     return NULL;
   }
 
   virtual bool WillHandleProtocol(const std::string& protocol) const {
     return protocol == chrome::kChromeUIScheme;
   }
 
  private:
   AppCacheService* appcache_service_;
   BlobStorageController* blob_storage_controller_;
@@ skipping 138 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&InitializeRequestContext,
                    resource_context,
                    make_scoped_refptr(
                        browser_context->GetMediaRequestContext())));
   }
 }
 
 }  // namespace content