Refactoring: ProtocolHandler::MaybeCreateJob takes NetworkDelegate as argument

chrome/browser/custom_handlers/protocol_handler_registry.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 "chrome/browser/custom_handlers/protocol_handler_registry.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 72 matching lines @@
   // Clears the default for the provided protocol.
   // Should be called only from the IO thread.
   void ClearDefault(const std::string& scheme);
 
   // Makes this ProtocolHandler the default handler for its protocol.
   // Should be called only from the IO thread.
   void SetDefault(const ProtocolHandler& handler);
 
   // Creates a URL request job for the given request if there is a matching
   // protocol handler, returns NULL otherwise.
-  net::URLRequestJob* MaybeCreateJob(net::URLRequest* request) const;
+  net::URLRequestJob* MaybeCreateJob(
+      net::URLRequest* request, net::NetworkDelegate* network_delegate) const;
 
   // Indicate that the registry has been enabled in the IO thread's
   // copy of the data.
   void Enable() { enabled_ = true; }
 
   // Indicate that the registry has been disabled in the IO thread's copy of
   // the data.
   void Disable() { enabled_ = false; }
 
  private:
@@ skipping 26 matching lines @@
 void ProtocolHandlerRegistry::Core::SetDefault(const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ClearDefault(handler.protocol());
   default_handlers_.insert(std::make_pair(handler.protocol(), handler));
 }
 
 // Create a new job for the supplied |URLRequest| if a default handler
 // is registered and the associated handler is able to interpret
 // the url from |request|.
 net::URLRequestJob* ProtocolHandlerRegistry::Core::MaybeCreateJob(
-    net::URLRequest* request) const {
+    net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   ProtocolHandler handler = LookupHandler(default_handlers_,
                                           request->url().scheme());
   if (handler.IsEmpty())
     return NULL;
 
   GURL translated_url(handler.TranslateUrl(request->url()));
   if (!translated_url.is_valid())
     return NULL;
 
-  return new net::URLRequestRedirectJob(request, translated_url);
+  return new net::URLRequestRedirectJob(
+      request, network_delegate, translated_url);
 }
 
 // URLInterceptor ------------------------------------------------------------
 
 // Instances of this class are produced for ownership by the IO
 // thread where it handler URL requests. We should never hold
 // any pointers on this class, only produce them in response to
 // requests via |ProtocolHandlerRegistry::CreateURLInterceptor|.
 class ProtocolHandlerRegistry::URLInterceptor
     : public net::URLRequestJobFactory::Interceptor {
  public:
   explicit URLInterceptor(Core* core);
   virtual ~URLInterceptor();
 
   virtual net::URLRequestJob* MaybeIntercept(
-      net::URLRequest* request) const OVERRIDE;
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE;
 
   virtual bool WillHandleProtocol(const std::string& protocol) const OVERRIDE;
 
   virtual net::URLRequestJob* MaybeInterceptRedirect(
       const GURL& url, net::URLRequest* request) const OVERRIDE {
     return NULL;
   }
 
   virtual net::URLRequestJob* MaybeInterceptResponse(
       net::URLRequest* request) const OVERRIDE {
     return NULL;
   }
 
  private:
   scoped_refptr<Core> core_;
   DISALLOW_COPY_AND_ASSIGN(URLInterceptor);
 };
 
 ProtocolHandlerRegistry::URLInterceptor::URLInterceptor(Core* core)
     : core_(core) {
   DCHECK(core_);
 }
 
 ProtocolHandlerRegistry::URLInterceptor::~URLInterceptor() {
 }
 
 net::URLRequestJob* ProtocolHandlerRegistry::URLInterceptor::MaybeIntercept(
-    net::URLRequest* request) const {
+    net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  return core_->MaybeCreateJob(request);
+  return core_->MaybeCreateJob(request, network_delegate);
 }
 
 bool ProtocolHandlerRegistry::URLInterceptor::WillHandleProtocol(
     const std::string& protocol) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   return core_->IsHandledProtocol(protocol);
 }
 
 // DefaultClientObserver ------------------------------------------------------
@@ skipping 653 matching lines @@
 }
 
 net::URLRequestJobFactory::Interceptor*
     ProtocolHandlerRegistry::CreateURLInterceptor() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // this is always created on the UI thread (in profile_io's
   // InitializeOnUIThread. Any method calls must be done
   // on the IO thread (this is checked).
   return new URLInterceptor(core_);
 }