Change Interceptors into URLRequestJobFactory::ProtocolHandlers.

chrome/browser/policy/policy_browsertest.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 <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 113 matching lines @@
 const FilePath::CharType kGoodCrxName[] = FILE_PATH_LITERAL("good.crx");
 const FilePath::CharType kAdBlockCrxName[] = FILE_PATH_LITERAL("adblock.crx");
 
 const char kGoodCrxId[] = "ldnnhddmnhbkjipkidpdiheffobcpfmf";
 const char kAdBlockCrxId[] = "dojnnbeimaimaojcialkkgajdnefpgcn";
 
 const FilePath::CharType kGoodCrxManifestName[] =
     FILE_PATH_LITERAL("good_update_manifest.xml");
 
 const char* kURLs[] = {
-  "http://aaa.com/empty.html",
-  "http://bbb.com/empty.html",
+  "http://aaaa.com/empty.html",
+  "http://bbbb.com/empty.html",
   "http://ccc.com/empty.html",
   "http://ddd.com/empty.html",
   "http://eee.com/empty.html",
 };
 
 // Filters requests to the hosts in |urls| and redirects them to the test data
 // dir through URLRequestMockHTTPJobs.
 void RedirectHostsToTestData(const char* const urls[], size_t size) {
   // Map the given hosts to the test data dir.
   net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
   for (size_t i = 0; i < size; ++i) {
     const GURL url(urls[i]);
     EXPECT_TRUE(url.is_valid());
-    filter->AddHostnameHandler(url.scheme(), url.host(),
-                               URLRequestMockHTTPJob::Factory);
+    filter->AddUrlHandler(url, URLRequestMockHTTPJob::Factory);
   }
 }
 
+// Remove filters for requests to the hosts in |urls|.
+void UndoRedirectHostsToTestData(const char* const urls[], size_t size) {
+  // Map the given hosts to the test data dir.
+  net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
+  for (size_t i = 0; i < size; ++i) {
+    const GURL url(urls[i]);
+    EXPECT_TRUE(url.is_valid());
+    filter->RemoveUrlHandler(url);
+  }
+}
+
 // Fails requests using ERR_CONNECTION_RESET.
 net::URLRequestJob* FailedJobFactory(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     const std::string& scheme) {
   return new content::URLRequestFailedJob(
       request, network_delegate, net::ERR_CONNECTION_RESET);
 }
 
-// Filters requests to the |host| such that they fail. Run on IO thread.
-void MakeRequestFailOnIO(const std::string& host) {
-  net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
-  filter->AddHostnameHandler("http", host, &FailedJobFactory);
-  filter->AddHostnameHandler("https", host, &FailedJobFactory);
-}
+// While |MakeRequestFail| is in scope URLRequests to |host| will fail.
+class MakeRequestFail {
+ public:
+  // Sets up the filter on IO thread such that requests to |host| fail.
+  explicit MakeRequestFail(const std::string& host) : host_(host) {
+    BrowserThread::PostTaskAndReply(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(MakeRequestFailOnIO, host_),
+        MessageLoop::QuitClosure());
+    content::RunMessageLoop();
+  }
+  ~MakeRequestFail() {
+    BrowserThread::PostTaskAndReply(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(UndoMakeRequestFailOnIO, host_),
+        MessageLoop::QuitClosure());
+    content::RunMessageLoop();
+  }
 
-// Sets up the filter on IO thread such that requests to |host| fail.
-void MakeRequestFail(const std::string& host) {
-  BrowserThread::PostTaskAndReply(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(MakeRequestFailOnIO, host),
-      MessageLoop::QuitClosure());
-  content::RunMessageLoop();
-}
+ private:
+  // Filters requests to the |host| such that they fail. Run on IO thread.
+  static void MakeRequestFailOnIO(const std::string& host) {
+    net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
+    filter->AddHostnameHandler("http", host, &FailedJobFactory);
+    filter->AddHostnameHandler("https", host, &FailedJobFactory);
+  }
+
+  // Remove filters for requests to the |host|. Run on IO thread.
+  static void UndoMakeRequestFailOnIO(const std::string& host) {
+    net::URLRequestFilter* filter = net::URLRequestFilter::GetInstance();
+    filter->RemoveHostnameHandler("http", host);
+    filter->RemoveHostnameHandler("https", host);
+  }
+
+  const std::string host_;
+};
 
 // Verifies that the given url |spec| can be opened. This assumes that |spec|
 // points at empty.html in the test data dir.
 void CheckCanOpenURL(Browser* browser, const char* spec) {
   GURL url(spec);
   ui_test_utils::NavigateToURL(browser, url);
   content::WebContents* contents = chrome::GetActiveWebContents(browser);
   EXPECT_EQ(url, contents->GetURL());
   EXPECT_EQ(net::FormatUrl(url, std::string()), contents->GetTitle());
 }
@@ skipping 418 matching lines @@
                POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
   provider_.UpdateChromePolicy(policies);
 }
 
 IN_PROC_BROWSER_TEST_F(PolicyTest, ClearSiteDataOnExit) {
   // Verify that the cookie is gone.
   EXPECT_TRUE(GetCookies(browser()->profile(), GURL(kURL)).empty());
 }
 
 IN_PROC_BROWSER_TEST_F(PolicyTest, DefaultSearchProvider) {
-  MakeRequestFail("search.example");
+  MakeRequestFail make_request_fail("search.example");
 
   // Verifies that a default search is made using the provider configured via
   // policy. Also checks that default search can be completely disabled.
   const string16 kKeyword(ASCIIToUTF16("testsearch"));
   const std::string kSearchURL("http://search.example/search?q={searchTerms}");
   const std::string kAlternateURL0(
       "http://search.example/search#q={searchTerms}");
   const std::string kAlternateURL1("http://search.example/#q={searchTerms}");
 
   TemplateURLService* service = TemplateURLServiceFactory::GetForProfile(
@@ skipping 49 matching lines @@
   EXPECT_FALSE(service->GetDefaultSearchProvider());
   ui_test_utils::SendToOmniboxAndSubmit(location_bar, "should not work");
   // This means that submitting won't trigger any action.
   EXPECT_FALSE(model->CurrentMatch().destination_url.is_valid());
   EXPECT_EQ(GURL(chrome::kAboutBlankURL), web_contents->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(PolicyTest, ForceSafeSearch) {
   // Makes the requests fail since all we want to check is that the redirection
   // is done properly.
-  MakeRequestFail("google.com");
+  MakeRequestFail make_request_fail("google.com");
 
   // Verifies that requests to Google Search engine with the SafeSearch
   // enabled set the safe=active&ssui=on parameters at the end of the query.
   TemplateURLService* service = TemplateURLServiceFactory::GetForProfile(
       browser()->profile());
   ui_test_utils::WaitForTemplateURLServiceToLoad(service);
 
   // First check that nothing happens.
   content::TestNavigationObserver no_safesearch_observer(
       content::NotificationService::AllSources());
@@ skipping 32 matching lines @@
   EXPECT_TRUE(model->CurrentMatch().destination_url.is_valid());
   web_contents = chrome::GetActiveWebContents(browser());
   std::string expected_url("http://google.com/?");
   expected_url += std::string(chrome::kSafeSearchSafeParameter) + "&" +
                   chrome::kSafeSearchSsuiParameter;
   GURL expected_with_parameters(expected_url);
   EXPECT_EQ(expected_with_parameters, web_contents->GetURL());
 }
 
 IN_PROC_BROWSER_TEST_F(PolicyTest, ReplaceSearchTerms) {
-  MakeRequestFail("search.example");
+  MakeRequestFail make_request_fail("search.example");
 
   chrome::search::EnableInstantExtendedAPIForTesting();
 
   // Verifies that a default search is made using the provider configured via
   // policy. Also checks that default search can be completely disabled.
   const string16 kKeyword(ASCIIToUTF16("testsearch"));
   const std::string kSearchURL("https://www.google.com/search?q={searchTerms}");
   const std::string kAlternateURL0(
       "https://www.google.com/search#q={searchTerms}");
   const std::string kAlternateURL1("https://www.google.com/#q={searchTerms}");
@@ skipping 629 matching lines @@
   whitelist.Append(base::Value::CreateStringValue("sub.bbb.com"));
   whitelist.Append(base::Value::CreateStringValue("bbb.com/policy"));
   policies.Set(key::kURLWhitelist, POLICY_LEVEL_MANDATORY,
                POLICY_SCOPE_USER, whitelist.DeepCopy());
   provider_.UpdateChromePolicy(policies);
   FlushBlacklistPolicy();
   CheckCanOpenURL(browser(), kURLS[0]);
   CheckURLIsBlocked(browser(), kURLS[1]);
   CheckCanOpenURL(browser(), kURLS[2]);
   CheckCanOpenURL(browser(), kURLS[3]);
+
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(UndoRedirectHostsToTestData, kURLS, arraysize(kURLS)),
+      MessageLoop::QuitClosure());
+  content::RunMessageLoop();
 }
 
 // Flaky on Linux. http://crbug.com/155459
 #if defined(OS_LINUX)
 #define MAYBE_DisableScreenshotsFeedback DISABLED_DisableScreenshotsFeedback
 #else
 #define MAYBE_DisableScreenshotsFeedback DisableScreenshotsFeedback
 #endif
 IN_PROC_BROWSER_TEST_F(PolicyTest, MAYBE_DisableScreenshotsFeedback) {
   // Make sure current screenshot can be taken and displayed on feedback page.
@@ skipping 268 matching lines @@
   EXPECT_EQ(kExpectedLabel, text.substr(0, kExpectedLabel.size()));
   // HomepageLocation has policy ID 1.
   EXPECT_NE(std::string::npos, text.find("<br>1   ---"));
   // ShowHomeButton has policy ID 35.
   EXPECT_NE(std::string::npos, text.find("<br>35  ---"));
   // BookmarkBarEnabled has policy ID 82.
   EXPECT_NE(std::string::npos, text.find("<br>82  ---"));
 }
 
 }  // namespace policy