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

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"
 #include "base/logging.h"
-#include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "chrome/browser/custom_handlers/register_protocol_handler_infobar_delegate.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/custom_handlers/protocol_handler.h"
 #include "chrome/common/pref_names.h"
-#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
-#include "content/public/browser/notification_service.h"
 #include "grit/generated_resources.h"
 #include "net/base/network_delegate.h"
-#include "net/url_request/url_request.h"
-#include "net/url_request/url_request_job.h"
 #include "net/url_request/url_request_redirect_job.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 
 namespace {
 
 const ProtocolHandler& LookupHandler(
     const ProtocolHandlerRegistry::ProtocolHandlerMap& handler_map,
@@ skipping 17 matching lines @@
   // difference (http://crbug.com/88255).
   return false;
 #else
   return ShellIntegration::CanSetAsDefaultProtocolClient() !=
       ShellIntegration::SET_DEFAULT_NOT_ALLOWED;
 #endif
 }
 
 }  // namespace
 
-// Core ------------------------------------------------------------------------
+// IOThreadDelegate ------------------------------------------------------------
 
-// Core is an IO thread specific object. Access to the class should all
-// be done via the IO thread. The registry living on the UI thread makes
+// IOThreadDelegate is an IO thread specific object. Access to the class should
+// all be done via the IO thread. The registry living on the UI thread makes
 // a best effort to update the IO object after local updates are completed.
-class ProtocolHandlerRegistry::Core
-    : public base::RefCountedThreadSafe<ProtocolHandlerRegistry::Core> {
+class ProtocolHandlerRegistry::IOThreadDelegate
+    : public base::RefCountedThreadSafe<
+          ProtocolHandlerRegistry::IOThreadDelegate> {
  public:
 
   // Creates a new instance. If |enabled| is true the registry is considered
   // enabled on the IO thread.
-  explicit Core(bool enabled);
+  explicit IOThreadDelegate(bool enabled);
 
   // Returns true if the protocol has a default protocol handler.
   // Should be called only from the IO thread.
   bool IsHandledProtocol(const std::string& scheme) const;
 
   // 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, 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:
-  friend class base::RefCountedThreadSafe<Core>;
-  virtual ~Core();
+  friend class base::RefCountedThreadSafe<IOThreadDelegate>;
+  virtual ~IOThreadDelegate();
 
   // Copy of protocol handlers use only on the IO thread.
   ProtocolHandlerRegistry::ProtocolHandlerMap default_handlers_;
 
   // Is the registry enabled on the IO thread.
   bool enabled_;
 
-  DISALLOW_COPY_AND_ASSIGN(Core);
+  DISALLOW_COPY_AND_ASSIGN(IOThreadDelegate);
 };
 
-ProtocolHandlerRegistry::Core::Core(bool) : enabled_(true) {}
-ProtocolHandlerRegistry::Core::~Core() {}
+ProtocolHandlerRegistry::IOThreadDelegate::IOThreadDelegate(bool)
+    : enabled_(true) {}
+ProtocolHandlerRegistry::IOThreadDelegate::~IOThreadDelegate() {}
 
-bool ProtocolHandlerRegistry::Core::IsHandledProtocol(
+bool ProtocolHandlerRegistry::IOThreadDelegate::IsHandledProtocol(
     const std::string& scheme) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return enabled_ && !LookupHandler(default_handlers_, scheme).IsEmpty();
 }
 
-void ProtocolHandlerRegistry::Core::ClearDefault(const std::string& scheme) {
+void ProtocolHandlerRegistry::IOThreadDelegate::ClearDefault(
+    const std::string& scheme) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   default_handlers_.erase(scheme);
 }
 
-void ProtocolHandlerRegistry::Core::SetDefault(const ProtocolHandler& handler) {
+void ProtocolHandlerRegistry::IOThreadDelegate::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::URLRequestJob* ProtocolHandlerRegistry::IOThreadDelegate::MaybeCreateJob(
     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, network_delegate, translated_url,
       net::URLRequestRedirectJob::REDIRECT_302_FOUND);
 }
 
-// URLInterceptor ------------------------------------------------------------
+// JobInterceptorFactory -------------------------------------------------------
 
-// Instances of this class are produced for ownership by the IO
+// Instances of JobInterceptorFactory 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,
-      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,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
-    return NULL;
-  }
-
-  virtual net::URLRequestJob* MaybeInterceptResponse(
-      net::URLRequest* request,
-      net::NetworkDelegate* network_delegate) const OVERRIDE {
-    return NULL;
-  }
-
- private:
-  scoped_refptr<Core> core_;
-  DISALLOW_COPY_AND_ASSIGN(URLInterceptor);
-};
-
-ProtocolHandlerRegistry::URLInterceptor::URLInterceptor(Core* core)
-    : core_(core) {
-  DCHECK(core_);
+// requests via |ProtocolHandlerRegistry::CreateJobInterceptorFactory|.
+ProtocolHandlerRegistry::JobInterceptorFactory::JobInterceptorFactory(
+    IOThreadDelegate* io_thread_delegate)
+    : io_thread_delegate_(io_thread_delegate) {
+  DCHECK(io_thread_delegate_);
+  DetachFromThread();
 }
 
-ProtocolHandlerRegistry::URLInterceptor::~URLInterceptor() {
+ProtocolHandlerRegistry::JobInterceptorFactory::~JobInterceptorFactory() {
 }
 
-net::URLRequestJob* ProtocolHandlerRegistry::URLInterceptor::MaybeIntercept(
-    net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  return core_->MaybeCreateJob(request, network_delegate);
+void ProtocolHandlerRegistry::JobInterceptorFactory::Chain(
+    scoped_ptr<net::URLRequestJobFactory> job_factory) {
+  job_factory_ = job_factory.Pass();
 }
 
-bool ProtocolHandlerRegistry::URLInterceptor::WillHandleProtocol(
-    const std::string& protocol) const {
+bool ProtocolHandlerRegistry::JobInterceptorFactory::SetProtocolHandler(
+    const std::string& scheme, ProtocolHandler* protocol_handler) {
+  return job_factory_->SetProtocolHandler(scheme, protocol_handler);
+}
+
+void ProtocolHandlerRegistry::JobInterceptorFactory::AddInterceptor(
+    Interceptor* interceptor) {
+  return job_factory_->AddInterceptor(interceptor);
+}
+
+net::URLRequestJob*
+ProtocolHandlerRegistry::JobInterceptorFactory::MaybeCreateJobWithInterceptor(
+    net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
+  return job_factory_->MaybeCreateJobWithInterceptor(request, network_delegate);
+}
+
+net::URLRequestJob*
+ProtocolHandlerRegistry::JobInterceptorFactory::
+MaybeCreateJobWithProtocolHandler(
+    const std::string& scheme,
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  net::URLRequestJob* job = io_thread_delegate_->MaybeCreateJob(
+      request, network_delegate);
+  if (job)
+    return job;
+  return job_factory_->MaybeCreateJobWithProtocolHandler(
+      scheme, request, network_delegate);
+}
 
-  return core_->IsHandledProtocol(protocol);
+net::URLRequestJob*
+ProtocolHandlerRegistry::JobInterceptorFactory::MaybeInterceptRedirect(
+    const GURL& location,
+    net::URLRequest* request,
+    net::NetworkDelegate* network_delegate) const {
+  return job_factory_->MaybeInterceptRedirect(
+      location, request, network_delegate);
+}
+
+net::URLRequestJob*
+ProtocolHandlerRegistry::JobInterceptorFactory::MaybeInterceptResponse(
+    net::URLRequest* request, net::NetworkDelegate* network_delegate) const {
+  return job_factory_->MaybeInterceptResponse(request, network_delegate);
+}
+
+bool ProtocolHandlerRegistry::JobInterceptorFactory::IsHandledProtocol(
+    const std::string& scheme) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  return io_thread_delegate_->IsHandledProtocol(scheme) ||
+      job_factory_->IsHandledProtocol(scheme);
+}
+
+bool ProtocolHandlerRegistry::JobInterceptorFactory::IsHandledURL(
+    const GURL& url) const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  return (url.is_valid() &&
+      io_thread_delegate_->IsHandledProtocol(url.scheme())) ||
+      job_factory_->IsHandledURL(url);
 }
 
 // DefaultClientObserver ------------------------------------------------------
 
 ProtocolHandlerRegistry::DefaultClientObserver::DefaultClientObserver(
     ProtocolHandlerRegistry* registry)
     : worker_(NULL),
       registry_(registry) {
   DCHECK(registry_);
 }
@@ skipping 86 matching lines @@
 
 // ProtocolHandlerRegistry -----------------------------------------------------
 
 ProtocolHandlerRegistry::ProtocolHandlerRegistry(Profile* profile,
     Delegate* delegate)
     : profile_(profile),
       delegate_(delegate),
       enabled_(true),
       is_loading_(false),
       is_loaded_(false),
-      core_(new Core(enabled_)){
+      io_thread_delegate_(new IOThreadDelegate(enabled_)){
 }
 
 bool ProtocolHandlerRegistry::SilentlyHandleRegisterHandlerRequest(
     const ProtocolHandler& handler) {
   if (handler.IsEmpty() || !CanSchemeBeOverridden(handler.protocol()))
     return true;
 
   if (!enabled() || IsRegistered(handler) || HasIgnoredEquivalent(handler))
     return true;
 
@@ skipping 64 matching lines @@
   return replaced_handlers;
 }
 
 void ProtocolHandlerRegistry::ClearDefault(const std::string& scheme) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   default_handlers_.erase(scheme);
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&Core::ClearDefault, core_, scheme));
+      base::Bind(&IOThreadDelegate::ClearDefault, io_thread_delegate_, scheme));
   Save();
   NotifyChanged();
 }
 
 bool ProtocolHandlerRegistry::IsDefault(
     const ProtocolHandler& handler) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   return GetHandlerFor(handler.protocol()) == handler;
 }
 
@@ skipping 207 matching lines @@
   }
   ProtocolHandlerMap::iterator q = default_handlers_.find(handler.protocol());
   if (q != default_handlers_.end() && q->second == handler) {
     // Make the new top handler in the list the default.
     if (!handlers.empty()) {
       // NOTE We pass a copy because SetDefault() modifies handlers.
       SetDefault(ProtocolHandler(handlers[0]));
     } else {
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
-          base::Bind(&Core::ClearDefault, core_, q->second.protocol()));
+          base::Bind(&IOThreadDelegate::ClearDefault, io_thread_delegate_,
+                     q->second.protocol()));
 
       default_handlers_.erase(q);
     }
   }
 
   if (!IsHandledProtocol(handler.protocol())) {
     delegate_->DeregisterExternalHandler(handler.protocol());
   }
   Save();
   NotifyChanged();
@@ skipping 14 matching lines @@
 
 void ProtocolHandlerRegistry::Enable() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (enabled_) {
     return;
   }
   enabled_ = true;
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&Core::Enable, core_));
+      base::Bind(&IOThreadDelegate::Enable, io_thread_delegate_));
 
   ProtocolHandlerMap::const_iterator p;
   for (p = default_handlers_.begin(); p != default_handlers_.end(); ++p) {
     delegate_->RegisterExternalHandler(p->first);
   }
   Save();
   NotifyChanged();
 }
 
 void ProtocolHandlerRegistry::Disable() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!enabled_) {
     return;
   }
   enabled_ = false;
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&Core::Disable, core_));
+      base::Bind(&IOThreadDelegate::Disable, io_thread_delegate_));
 
   ProtocolHandlerMap::const_iterator p;
   for (p = default_handlers_.begin(); p != default_handlers_.end(); ++p) {
     delegate_->DeregisterExternalHandler(p->first);
   }
   Save();
   NotifyChanged();
 }
 
 void ProtocolHandlerRegistry::Shutdown() {
@@ skipping 68 matching lines @@
   // If we're not loading, and we are setting a default for a new protocol,
   // register with the OS.
   if (!is_loading_ && p == default_handlers_.end())
       delegate_->RegisterWithOSAsDefaultClient(handler.protocol(), this);
   default_handlers_.erase(handler.protocol());
   default_handlers_.insert(std::make_pair(handler.protocol(), handler));
   PromoteHandler(handler);
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
-      base::Bind(&Core::SetDefault, core_, handler));
+      base::Bind(&IOThreadDelegate::SetDefault, io_thread_delegate_, handler));
 }
 
 void ProtocolHandlerRegistry::InsertHandler(const ProtocolHandler& handler) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ProtocolHandlerMultiMap::iterator p =
       protocol_handlers_.find(handler.protocol());
 
   if (p != protocol_handlers_.end()) {
     p->second.push_back(handler);
     return;
@@ skipping 81 matching lines @@
   ignored_protocol_handlers_.push_back(handler);
 }
 
 void ProtocolHandlerRegistry::AddPredefinedHandler(
     const ProtocolHandler& handler) {
   DCHECK(!is_loaded_);  // Must be called prior InitProtocolSettings.
   RegisterProtocolHandler(handler);
   SetDefault(handler);
 }
 
-net::URLRequestJobFactory::Interceptor*
-    ProtocolHandlerRegistry::CreateURLInterceptor() {
+scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory>
+ProtocolHandlerRegistry::CreateJobInterceptorFactory() {
   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_);
+  return scoped_ptr<JobInterceptorFactory>(new JobInterceptorFactory(
+      io_thread_delegate_));
 }