Move test_url_fetcher_factory.* from content/ to net/url_request

chrome/browser/autocomplete/search_provider_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/autocomplete/search_provider.h"
 
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
-#include "content/public/test/test_url_fetcher_factory.h"
+#include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 
 // The following environment is configured for these tests:
 // . The TemplateURL default_t_url_ is set as the default provider.
 // . The TemplateURL keyword_t_url_ is added to the TemplateURLService. This
 //   TemplateURL has a valid suggest and search URL.
 // . The URL created by using the search term term1_ with default_t_url_ is
@@ skipping 61 matching lines @@
   const string16 term1_;
   GURL term1_url_;
   TemplateURL* keyword_t_url_;
   const string16 keyword_term_;
   GURL keyword_url_;
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread io_thread_;
 
   // URLFetcherFactory implementation registered.
-  TestURLFetcherFactory test_factory_;
+  net::TestURLFetcherFactory test_factory_;
 
   // Profile we use.
   TestingProfile profile_;
 
   // The provider.
   scoped_refptr<SearchProvider> provider_;
 
   // If true, OnProviderUpdate exits out of the current message loop.
   bool quit_when_done_;
 
@@ skipping 140 matching lines @@
        i != provider_->matches().end(); ++i) {
     if (i->destination_url == url) {
       *match = *i;
       return true;
     }
   }
   return false;
 }
 
 void SearchProviderTest::FinishDefaultSuggestQuery() {
-  TestURLFetcher* default_fetcher = test_factory_.GetFetcherByID(
+  net::TestURLFetcher* default_fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDefaultProviderURLFetcherID);
   ASSERT_TRUE(default_fetcher);
 
   // Tell the SearchProvider the default suggest query is done.
   default_fetcher->set_response_code(200);
   default_fetcher->delegate()->OnURLFetchComplete(default_fetcher);
 }
 
 // Tests -----------------------------------------------------------------------
 
 // Make sure we query history for the default provider and a URLFetcher is
 // created for the default provider suggest results.
 TEST_F(SearchProviderTest, QueryDefaultProvider) {
   string16 term = term1_.substr(0, term1_.length() - 1);
   QueryForInput(term, string16(), false);
 
   // Make sure the default providers suggest service was queried.
-  TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
+  net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDefaultProviderURLFetcherID);
   ASSERT_TRUE(fetcher);
 
   // And the URL matches what we expected.
   GURL expected_url(default_t_url_->suggestions_url_ref().ReplaceSearchTerms(
       term, TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(fetcher->GetOriginalURL() == expected_url);
 
   // Tell the SearchProvider the suggest query is done.
   fetcher->set_response_code(200);
@@ skipping 30 matching lines @@
 }
 
 // Issues a query that matches the registered keyword and makes sure history
 // is queried as well as URLFetchers getting created.
 TEST_F(SearchProviderTest, QueryKeywordProvider) {
   string16 term = keyword_term_.substr(0, keyword_term_.length() - 1);
   QueryForInput(keyword_t_url_->keyword() + UTF8ToUTF16(" ") + term,
                 string16(), false);
 
   // Make sure the default providers suggest service was queried.
-  TestURLFetcher* default_fetcher = test_factory_.GetFetcherByID(
+  net::TestURLFetcher* default_fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDefaultProviderURLFetcherID);
   ASSERT_TRUE(default_fetcher);
 
   // Tell the SearchProvider the default suggest query is done.
   default_fetcher->set_response_code(200);
   default_fetcher->delegate()->OnURLFetchComplete(default_fetcher);
   default_fetcher = NULL;
 
   // Make sure the keyword providers suggest service was queried.
-  TestURLFetcher* keyword_fetcher = test_factory_.GetFetcherByID(
+  net::TestURLFetcher* keyword_fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kKeywordProviderURLFetcherID);
   ASSERT_TRUE(keyword_fetcher);
 
   // And the URL matches what we expected.
   GURL expected_url(keyword_t_url_->suggestions_url_ref().ReplaceSearchTerms(
       term, TemplateURLRef::NO_SUGGESTIONS_AVAILABLE, string16()));
   ASSERT_TRUE(keyword_fetcher->GetOriginalURL() == expected_url);
 
   // Tell the SearchProvider the keyword suggest query is done.
   keyword_fetcher->set_response_code(200);
@@ skipping 309 matching lines @@
   EXPECT_FALSE(result.match_at(1).description.empty());
   EXPECT_NE(result.match_at(0).description, result.match_at(1).description);
 }
 
 // Verifies Navsuggest results don't set a TemplateURL, which instant relies on.
 // Also verifies that just the *first* navigational result is listed as a match.
 TEST_F(SearchProviderTest, NavSuggest) {
   QueryForInput(ASCIIToUTF16("a.c"), string16(), false);
 
   // Make sure the default providers suggest service was queried.
-  TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
+  net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDefaultProviderURLFetcherID);
   ASSERT_TRUE(fetcher);
 
   // Tell the SearchProvider the suggest query is done.
   fetcher->set_response_code(200);
   fetcher->SetResponseString(
       "[\"a.c\",[\"a.com\", \"a.com/b\"],[\"a\", \"b\"],[],"
       "{\"google:suggesttype\":[\"NAVIGATION\", \"NAVIGATION\"]}]");
   fetcher->delegate()->OnURLFetchComplete(fetcher);
   fetcher = NULL;
 
   // Run till the history results complete.
   RunTillProviderDone();
 
   // Make sure the only match is 'a.com' and it doesn't have a template_url.
   AutocompleteMatch nav_match;
   EXPECT_TRUE(FindMatchWithDestination(GURL("http://a.com"), &nav_match));
   EXPECT_TRUE(nav_match.keyword.empty());
   EXPECT_FALSE(FindMatchWithDestination(GURL("http://a.com/b"), &nav_match));
 }
 
 // Verifies that the most relevant suggest results are added properly.
 TEST_F(SearchProviderTest, SuggestRelevance) {
   QueryForInput(ASCIIToUTF16("a"), string16(), false);
 
   // Make sure the default provider's suggest service was queried.
-  TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
+  net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
       SearchProvider::kDefaultProviderURLFetcherID);
   ASSERT_TRUE(fetcher);
 
   // Tell the SearchProvider the suggest query is done.
   fetcher->set_response_code(200);
   fetcher->SetResponseString("[\"a\",[\"a1\", \"a2\", \"a3\", \"a4\"]]");
   fetcher->delegate()->OnURLFetchComplete(fetcher);
   fetcher = NULL;
 
   // Run till the history results complete.
@@ skipping 145 matching lines @@
 
     // Ensure that verbatim is always generated without other suggestions.
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":1}]",
       { "a", kNotApplicable, kNotApplicable, kNotApplicable } },
     { "[\"a\",[],[],[],{\"google:verbatimrelevance\":0}]",
       { "a", kNotApplicable, kNotApplicable, kNotApplicable } },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     QueryForInput(ASCIIToUTF16("a"), string16(), false);
-    TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
+    net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
         SearchProvider::kDefaultProviderURLFetcherID);
     fetcher->set_response_code(200);
     fetcher->SetResponseString(cases[i].json);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunTillProviderDone();
 
     const ACMatches& matches = provider_->matches();
     // The top match must inline and score as highly as calculated verbatim.
     EXPECT_NE(string16::npos, matches[0].inline_autocomplete_offset);
     EXPECT_GE(matches[0].relevance, 1300);
@@ skipping 74 matching lines @@
                  "\"google:verbatimrelevance\":9999}]",
       { "a.com", "abc.com", "a.com/a", kNotApplicable },
       { AutocompleteMatch::SEARCH_WHAT_YOU_TYPED,
         AutocompleteMatch::NAVSUGGEST,
         AutocompleteMatch::SEARCH_SUGGEST,
         AutocompleteMatch::NUM_TYPES } },
 };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     QueryForInput(ASCIIToUTF16(cases[i].input), string16(), false);
-    TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
+    net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
         SearchProvider::kDefaultProviderURLFetcherID);
     fetcher->set_response_code(200);
     fetcher->SetResponseString(cases[i].json);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunTillProviderDone();
 
     size_t j = 0;
     const ACMatches& matches = provider_->matches();
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j) {
@@ skipping 42 matching lines @@
     // This is needed so that (CTRL+A/C/etc.) doesn't alter inline text.
     { "a", "[\"a\",[\"a.com/a\"],[],[],{\"google:suggestrelevance\":[9999]}]",
       { "a.com/a", "a", kNotApplicable, kNotApplicable },
       { AutocompleteMatch::SEARCH_SUGGEST,
         AutocompleteMatch::SEARCH_WHAT_YOU_TYPED,
         AutocompleteMatch::NUM_TYPES, AutocompleteMatch::NUM_TYPES } },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     QueryForInput(ASCIIToUTF16(cases[i].input), ASCIIToUTF16("com"), false);
-    TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
+    net::TestURLFetcher* fetcher = test_factory_.GetFetcherByID(
         SearchProvider::kDefaultProviderURLFetcherID);
     fetcher->set_response_code(200);
     fetcher->SetResponseString(cases[i].json);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunTillProviderDone();
 
     size_t j = 0;
     const ACMatches& matches = provider_->matches();
     // Ensure that the returned matches equal the expectations.
     for (; j < matches.size(); ++j) {
@@ skipping 185 matching lines @@
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL,
             match.contents_class[0].style);
   EXPECT_EQ(4U, match.contents_class[1].offset);
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL |
             AutocompleteMatch::ACMatchClassification::MATCH,
             match.contents_class[1].style);
   EXPECT_EQ(5U, match.contents_class[2].offset);
   EXPECT_EQ(AutocompleteMatch::ACMatchClassification::URL,
             match.contents_class[2].style);
 }