Convert ProtocolHandlerRegistry::Interceptor to a net::URLRequestJobFactory.

chrome/browser/custom_handlers/protocol_handler_registry.h

 // 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.
 
 #ifndef CHROME_BROWSER_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_
 #define CHROME_BROWSER_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/common/custom_handlers/protocol_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_job_factory.h"
@@ skipping 53 matching lines @@
     virtual ShellIntegration::DefaultProtocolClientWorker* CreateShellWorker(
         ShellIntegration::DefaultWebClientObserver* observer,
         const std::string& protocol);
     virtual DefaultClientObserver* CreateShellObserver(
         ProtocolHandlerRegistry* registry);
     virtual void RegisterWithOSAsDefaultClient(
         const std::string& protocol,
         ProtocolHandlerRegistry* registry);
   };
 
+  // Forward declaration of the internal implementation class.
+  class Core;

[James Hawkins, 2013/01/07 18:57:49]

nit: Make this class name a bit more descriptive.  It's easy to have a 'Core'
disconnected from its parent object.

[pauljensen, 2013/01/07 20:48:58]

I could rename it IOThreadDelegate?  I wanted to check with you first as I
didn't write or modify the Core class in this CL.
I'm not sure I understand.  The ProtocolHandlerRegistry and
JobInterceptorFactory each always hold a scoped_refptr to Core.  So other than
at construction and destruction time, Core should always be connected to its
parent.

+
+  // JobInterceptorFactory intercepts URLRequestJob creation for URLRequests the
+  // ProtocolHandlerRegistry is registered to handle.  When no handler is
+  // registered the URLRequest is passed along to the chained

[James Hawkins, 2013/01/07 18:57:49]

nit: 'registered, the'

+  // URLRequestJobFactory (set with |JobInterceptorFactory::Chain|).
+  // JobInterceptorFactory's are created via
+  // |ProtocolHandlerRegistry::CreateJobInterceptorFactory|.
+  class JobInterceptorFactory : public net::URLRequestJobFactory {
+   public:
+    explicit JobInterceptorFactory(Core* core);

[James Hawkins, 2013/01/07 18:57:49]

nit: Document |core|.

+    virtual ~JobInterceptorFactory();
+
+    // Set the URLRequestJobFactory where requests are passed if
+    // JobInterceptorFactory decides to pass on them.
+    void Chain(scoped_ptr<net::URLRequestJobFactory> job_factory);

[James Hawkins, 2013/01/07 18:57:49]

nit: Document |job_factory|.

+
+    // URLRequestJobFactory implementation

[James Hawkins, 2013/01/07 18:57:49]

nit: Add missing period at end of comment.

+    virtual bool SetProtocolHandler(const std::string& scheme,
+                                    ProtocolHandler* protocol_handler) OVERRIDE;
+    virtual void AddInterceptor(Interceptor* interceptor) OVERRIDE;
+    virtual net::URLRequestJob* MaybeCreateJobWithInterceptor(

[James Hawkins, 2013/01/07 18:57:49]

ugh. Methods that have the word 'maybe' in it are awful; however, you didn't
write the interface in this CL, so I'm not asking you to change it.

+        net::URLRequest* request,
+        net::NetworkDelegate* network_delegate) const OVERRIDE;
+    virtual net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
+        const std::string& scheme,
+        net::URLRequest* request,
+        net::NetworkDelegate* network_delegate) const OVERRIDE;
+    virtual net::URLRequestJob* MaybeInterceptRedirect(
+        const GURL& location,
+        net::URLRequest* request,
+        net::NetworkDelegate* network_delegate) const OVERRIDE;
+    virtual net::URLRequestJob* MaybeInterceptResponse(
+        net::URLRequest* request,
+        net::NetworkDelegate* network_delegate) const OVERRIDE;
+    virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE;
+    virtual bool IsHandledURL(const GURL& url) const OVERRIDE;
+
+   private:
+    scoped_ptr<URLRequestJobFactory> job_factory_;

[James Hawkins, 2013/01/07 18:57:49]

nit: Document member variables.

+    scoped_refptr<Core> core_;
+
+    DISALLOW_COPY_AND_ASSIGN(JobInterceptorFactory);
+  };
+
   typedef std::map<std::string, ProtocolHandler> ProtocolHandlerMap;
   typedef std::vector<ProtocolHandler> ProtocolHandlerList;
   typedef std::map<std::string, ProtocolHandlerList> ProtocolHandlerMultiMap;
   typedef std::vector<DefaultClientObserver*> DefaultClientObserverList;
 
   // Creates a new instance. Assumes ownership of |delegate|.
   ProtocolHandlerRegistry(Profile* profile, Delegate* delegate);
   virtual ~ProtocolHandlerRegistry();
 
-  // Returns a net::URLRequestJobFactory::Interceptor suitable
-  // for use on the IO thread, but is initialized on the UI thread.
-  // Callers assume responsibility for deleting this object.
-  net::URLRequestJobFactory::Interceptor* CreateURLInterceptor();
+  // Returns a net::URLRequestJobFactory suitable for use on the IO thread, but
+  // is initialized on the UI thread.
+  scoped_ptr<JobInterceptorFactory> CreateJobInterceptorFactory();
 
   // Called when a site tries to register as a protocol handler. If the request
   // can be handled silently by the registry - either to ignore the request
   // or to update an existing handler - the request will succeed. If this
   // function returns false the user needs to be prompted for confirmation.
   bool SilentlyHandleRegisterHandlerRequest(const ProtocolHandler& handler);
 
   // Called when the user accepts the registration of a given protocol handler.
   void OnAcceptRegisterProtocolHandler(const ProtocolHandler& handler);
 
@@ skipping 95 matching lines @@
   friend class base::DeleteHelper<ProtocolHandlerRegistry>;
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::IO>;
 
   // for access to InstallDefaultsForChromeOS
   friend class ProtocolHandlerRegistryFactory;
 
   friend class ProtocolHandlerRegistryTest;
   friend class RegisterProtocolHandlerBrowserTest;
 
-  // Forward declaration of the internal implementation classes.
-  class Core;
-  class URLInterceptor;
-
   // Puts the given handler at the top of the list of handlers for its
   // protocol.
   void PromoteHandler(const ProtocolHandler& handler);
 
   // Saves a user's registered protocol handlers.
   void Save();
 
   // Returns a pointer to the list of handlers registered for the given scheme,
   // or NULL if there are none.
   const ProtocolHandlerList* GetHandlerList(const std::string& scheme) const;
@@ skipping 58 matching lines @@
 
   // Copy of registry data for use on the IO thread. Changes to the registry
   // are posted to the IO thread where updates are applied to this object.
   scoped_refptr<Core> core_;
 
   DefaultClientObserverList default_client_observers_;
 
   DISALLOW_COPY_AND_ASSIGN(ProtocolHandlerRegistry);
 };
 #endif  // CHROME_BROWSER_CUSTOM_HANDLERS_PROTOCOL_HANDLER_REGISTRY_H_