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

chrome/browser/custom_handlers/protocol_handler_registry_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 "chrome/browser/custom_handlers/protocol_handler_registry.h"
 
 #include <set>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
@@ skipping 12 matching lines @@
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 
 namespace {
 
 void AssertInterceptedIO(
     const GURL& url,
-    net::URLRequestJobFactory::Interceptor* interceptor) {
+    net::URLRequestJobFactory* interceptor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   net::URLRequestContext context;
   net::URLRequest request(url, NULL, &context);
-  scoped_refptr<net::URLRequestJob> job = interceptor->MaybeIntercept(
-      &request, context.network_delegate());
+  scoped_refptr<net::URLRequestJob> job =
+      interceptor->MaybeCreateJobWithProtocolHandler(
+          url.scheme(), &request, context.network_delegate());
   ASSERT_TRUE(job.get() != NULL);
 }
 
 void AssertIntercepted(
     const GURL& url,
-    net::URLRequestJobFactory::Interceptor* interceptor) {
+    net::URLRequestJobFactory* interceptor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(AssertInterceptedIO,
                                      url,
                                      base::Unretained(interceptor)));
   MessageLoop::current()->RunUntilIdle();
 }
 
+class FakeURLRequestJobFactory : public net::URLRequestJobFactory {
+  // net::URLRequestJobFactory implementation:
+  virtual bool SetProtocolHandler(const std::string& scheme,
+                                  ProtocolHandler* protocol_handler) OVERRIDE {
+    return false;
+  }
+  virtual void AddInterceptor(Interceptor* interceptor) OVERRIDE {
+  }
+  virtual net::URLRequestJob* MaybeCreateJobWithInterceptor(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE {
+    return NULL;
+  }
+  net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
+      const std::string& scheme,
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE {
+    return NULL;
+  }
+  net::URLRequestJob* MaybeInterceptRedirect(
+      const GURL& location,
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE {
+    return NULL;
+  }
+  net::URLRequestJob* MaybeInterceptResponse(
+      net::URLRequest* request,
+      net::NetworkDelegate* network_delegate) const OVERRIDE {
+    return NULL;
+  }
+  virtual bool IsHandledProtocol(const std::string& scheme) const OVERRIDE {
+    return false;
+  }
+  virtual bool IsHandledURL(const GURL& url) const OVERRIDE {
+    return false;
+  }
+};
+
 void AssertWillHandleIO(
     const std::string& scheme,
     bool expected,
-    net::URLRequestJobFactory::Interceptor* interceptor) {
+    ProtocolHandlerRegistry::JobInterceptorFactory* interceptor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  ASSERT_EQ(expected, interceptor->WillHandleProtocol(scheme));
+  interceptor->Chain(scoped_ptr<net::URLRequestJobFactory>(
+      new FakeURLRequestJobFactory()));
+  ASSERT_EQ(expected, interceptor->IsHandledProtocol(scheme));
+  interceptor->Chain(scoped_ptr<net::URLRequestJobFactory>(NULL));
 }
 
 void AssertWillHandle(
     const std::string& scheme,
     bool expected,
-    net::URLRequestJobFactory::Interceptor* interceptor) {
+    ProtocolHandlerRegistry::JobInterceptorFactory* interceptor) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(AssertWillHandleIO,
                                      scheme,
                                      expected,
                                      base::Unretained(interceptor)));
   MessageLoop::current()->RunUntilIdle();
 }
 
@@ skipping 671 matching lines @@
   ASSERT_EQ(static_cast<size_t>(1), registry()->GetHandlersFor("do").size());
   ASSERT_FALSE(registry()->IsHandledProtocol("dont"));
   ASSERT_EQ(static_cast<size_t>(1), registry()->GetHandlersFor("dont").size());
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestMaybeCreateTaskWorksFromIOThread) {
   ProtocolHandler ph1 = CreateProtocolHandler("mailto", "test1");
   registry()->OnAcceptRegisterProtocolHandler(ph1);
   GURL url("mailto:someone@something.com");
 
-  scoped_ptr<net::URLRequestJobFactory::Interceptor> interceptor(
-      registry()->CreateURLInterceptor());
+  scoped_ptr<net::URLRequestJobFactory> interceptor(
+      registry()->CreateJobInterceptorFactory());
   AssertIntercepted(url, interceptor.get());
 }
 
 TEST_F(ProtocolHandlerRegistryTest,
        MAYBE_TestIsHandledProtocolWorksOnIOThread) {
   std::string scheme("mailto");
   ProtocolHandler ph1 = CreateProtocolHandler(scheme, "test1");
   registry()->OnAcceptRegisterProtocolHandler(ph1);
 
-  scoped_ptr<net::URLRequestJobFactory::Interceptor> interceptor(
-      registry()->CreateURLInterceptor());
+  scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> interceptor(
+      registry()->CreateJobInterceptorFactory());
   AssertWillHandle(scheme, true, interceptor.get());
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestRemovingDefaultFallsBackToOldDefault) {
   ProtocolHandler ph1 = CreateProtocolHandler("mailto", "test1");
   ProtocolHandler ph2 = CreateProtocolHandler("mailto", "test2");
   ProtocolHandler ph3 = CreateProtocolHandler("mailto", "test3");
   registry()->OnAcceptRegisterProtocolHandler(ph1);
   registry()->OnAcceptRegisterProtocolHandler(ph2);
   registry()->OnAcceptRegisterProtocolHandler(ph3);
@@ skipping 25 matching lines @@
   ASSERT_EQ(ph2, handlers[0]);
   ASSERT_EQ(ph1, handlers[1]);
 }
 
 TEST_F(ProtocolHandlerRegistryTest, MAYBE_TestClearDefaultGetsPropagatedToIO) {
   std::string scheme("mailto");
   ProtocolHandler ph1 = CreateProtocolHandler(scheme, "test1");
   registry()->OnAcceptRegisterProtocolHandler(ph1);
   registry()->ClearDefault(scheme);
 
-  scoped_ptr<net::URLRequestJobFactory::Interceptor> interceptor(
-      registry()->CreateURLInterceptor());
+  scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> interceptor(
+      registry()->CreateJobInterceptorFactory());
   AssertWillHandle(scheme, false, interceptor.get());
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestLoadEnabledGetsPropogatedToIO) {
   std::string mailto("mailto");
   ProtocolHandler ph1 = CreateProtocolHandler(mailto, "MailtoHandler");
   registry()->OnAcceptRegisterProtocolHandler(ph1);
 
-  scoped_ptr<net::URLRequestJobFactory::Interceptor> interceptor(
-      registry()->CreateURLInterceptor());
+  scoped_ptr<ProtocolHandlerRegistry::JobInterceptorFactory> interceptor(
+      registry()->CreateJobInterceptorFactory());
   AssertWillHandle(mailto, true, interceptor.get());
   registry()->Disable();
   AssertWillHandle(mailto, false, interceptor.get());
 }
 
 TEST_F(ProtocolHandlerRegistryTest, TestReplaceHandler) {
   ProtocolHandler ph1 = CreateProtocolHandler("mailto",
       GURL("http://test.com/%s"), "test1");
   ProtocolHandler ph2 = CreateProtocolHandler("mailto",
       GURL("http://test.com/updated-url/%s"), "test2");
@@ skipping 54 matching lines @@
 
 TEST_F(ProtocolHandlerRegistryTest, MAYBE_TestInstallDefaultHandler) {
   RecreateRegistry(false);
   registry()->AddPredefinedHandler(CreateProtocolHandler(
       "test", GURL("http://test.com/%s"), "Test"));
   registry()->InitProtocolSettings();
   std::vector<std::string> protocols;
   registry()->GetRegisteredProtocols(&protocols);
   ASSERT_EQ(static_cast<size_t>(1), protocols.size());
 }