Correctly integrate StoragePartition into TestingProfile.

chrome/browser/autocomplete/search_provider_unittest.cc

 // Copyright 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/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/run_loop.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/omnibox/omnibox_field_trial.h"
 #include "chrome/browser/search/search.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/chrome_switches.h"
 #include "chrome/common/metrics/entropy_provider.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_browser_thread_bundle.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"
 
 
 // SearchProviderTest ---------------------------------------------------------
 
 // 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
@@ skipping 26 matching lines @@
     const string16 input;
     const size_t num_results;
     const ResultInfo output[3];
   };
 
   SearchProviderTest()
       : default_t_url_(NULL),
         term1_(ASCIIToUTF16("term1")),
         keyword_t_url_(NULL),
         keyword_term_(ASCIIToUTF16("keyword")),
-        ui_thread_(content::BrowserThread::UI, &message_loop_),
-        io_thread_(content::BrowserThread::IO),
-        quit_when_done_(false) {
-    io_thread_.Start();
+        run_loop_(NULL) {
   }
 
   static void SetUpTestCase();
   static void TearDownTestCase();
 
   // See description above class for what this registers.
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   void RunTest(TestData* cases, int num_cases, bool prefer_keyword);
@@ skipping 15 matching lines @@
                              AutocompleteMatch* match);
 
   // Looks for a match in |provider_| with destination |url|.  Sets |match| to
   // it if found.  Returns whether |match| was set.
   bool FindMatchWithDestination(const GURL& url, AutocompleteMatch* match);
 
   // AutocompleteProviderListener:
   // If we're waiting for the provider to finish, this exits the message loop.
   virtual void OnProviderUpdate(bool updated_matches) OVERRIDE;
 
-  // Waits until the provider instantiates a URLFetcher and returns it.
-  net::TestURLFetcher* WaitUntilURLFetcherIsReady(int fetcher_id);
-
   // Runs a nested message loop until provider_ is done. The message loop is
   // exited by way of OnProviderUpdate.
   void RunTillProviderDone();
 
   // Invokes Start on provider_, then runs all pending tasks.
   void QueryForInput(const string16& text,
                      bool prevent_inline_autocomplete,
                      bool prefer_keyword);
 
   // Calls QueryForInput(), finishes any suggest query, then if |wyt_match| is
   // non-NULL, sets it to the "what you typed" entry for |text|.
   void QueryForInputAndSetWYTMatch(const string16& text,
                                    AutocompleteMatch* wyt_match);
 
   // Notifies the URLFetcher for the suggest query corresponding to the default
   // search provider that it's done.
   // Be sure and wrap calls to this in ASSERT_NO_FATAL_FAILURE.
   void FinishDefaultSuggestQuery();
 
   // See description above class for details of these fields.
   TemplateURL* default_t_url_;
   const string16 term1_;
   GURL term1_url_;
   TemplateURL* keyword_t_url_;
   const string16 keyword_term_;
   GURL keyword_url_;
 
-  base::MessageLoopForUI message_loop_;
-  content::TestBrowserThread ui_thread_;
-  content::TestBrowserThread io_thread_;
+  content::TestBrowserThreadBundle thread_bundle_;
 
   // URLFetcherFactory implementation registered.
   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_;
+  // If non-NULL, OnProviderUpdate quits the current |run_loop_|.
+  base::RunLoop* run_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(SearchProviderTest);
 };
 
 // static
 base::FieldTrialList* SearchProviderTest::field_trial_list_ = NULL;
 const std::string SearchProviderTest::kNotApplicable = "Not Applicable";
 
 // static
 void SearchProviderTest::SetUpTestCase() {
@@ skipping 56 matching lines @@
   // Keywords are updated by the InMemoryHistoryBackend only after the message
   // has been processed on the history thread. Block until history processes all
   // requests to ensure the InMemoryDatabase is the state we expect it.
   profile_.BlockUntilHistoryProcessesPendingRequests();
 
   provider_ = new SearchProvider(this, &profile_);
   provider_->kMinimumTimeBetweenSuggestQueriesMs = 0;
 }
 
 void SearchProviderTest::TearDown() {
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Shutdown the provider before the profile.
   provider_ = NULL;
 }
 
 void SearchProviderTest::RunTest(TestData* cases,
                                  int num_cases,
                                  bool prefer_keyword) {
   ACMatches matches;
   for (int i = 0; i < num_cases; ++i) {
@@ skipping 14 matching lines @@
             diagnostic_details;
         EXPECT_EQ(cases[i].output[j].fill_into_edit,
                   matches[j].fill_into_edit) <<
             diagnostic_details;
       }
     }
   }
 }
 
 void SearchProviderTest::OnProviderUpdate(bool updated_matches) {
-  if (quit_when_done_ && provider_->done()) {
-    quit_when_done_ = false;
-    message_loop_.Quit();
+  if (run_loop_ && provider_->done()) {
+    run_loop_->Quit();
+    run_loop_ = NULL;
   }
 }
 
-net::TestURLFetcher* SearchProviderTest::WaitUntilURLFetcherIsReady(
-    int fetcher_id) {
-  net::TestURLFetcher* url_fetcher = test_factory_.GetFetcherByID(fetcher_id);
-  for (; !url_fetcher; url_fetcher = test_factory_.GetFetcherByID(fetcher_id))
-    message_loop_.RunUntilIdle();
-  return url_fetcher;
-}
-
 void SearchProviderTest::RunTillProviderDone() {
   if (provider_->done())
     return;
 
-  quit_when_done_ = true;
-#if defined(OS_ANDROID)
-  // Android doesn't have Run(), only Start().
-  message_loop_.Start();
-#else
   base::RunLoop run_loop;
+  run_loop_ = &run_loop;
   run_loop.Run();
-#endif
 }
 
 void SearchProviderTest::QueryForInput(const string16& text,
                                        bool prevent_inline_autocomplete,
                                        bool prefer_keyword) {
   // Start a query.
   AutocompleteInput input(text, string16::npos, string16(), GURL(),
                           prevent_inline_autocomplete,
                           prefer_keyword, true, AutocompleteInput::ALL_MATCHES);
   provider_->Start(input, false);
 
   // RunUntilIdle so that the task scheduled by SearchProvider to create the
   // URLFetchers runs.
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 void SearchProviderTest::QueryForInputAndSetWYTMatch(
     const string16& text,
     AutocompleteMatch* wyt_match) {
   QueryForInput(text, false, false);
   profile_.BlockUntilHistoryProcessesPendingRequests();
   ASSERT_NO_FATAL_FAILURE(FinishDefaultSuggestQuery());
   if (!wyt_match)
     return;
@@ skipping 39 matching lines @@
        i != provider_->matches().end(); ++i) {
     if (i->destination_url == url) {
       *match = *i;
       return true;
     }
   }
   return false;
 }
 
 void SearchProviderTest::FinishDefaultSuggestQuery() {
-  net::TestURLFetcher* default_fetcher = WaitUntilURLFetcherIsReady(
-      SearchProvider::kDefaultProviderURLFetcherID);
+  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);
 }
 
 
 // Actual Tests ---------------------------------------------------------------
 
@@ skipping 646 matching lines @@
     // Ensure that verbatim is always generated without other suggestions.
     // TODO(msw): Ensure verbatimrelevance is respected (except suppression).
     { "[\"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"), false, false);
-    net::TestURLFetcher* fetcher = WaitUntilURLFetcherIsReady(
-        SearchProvider::kDefaultProviderURLFetcherID);
+    net::TestURLFetcher* fetcher =
+        test_factory_.GetFetcherByID(
+            SearchProvider::kDefaultProviderURLFetcherID);
     ASSERT_TRUE(fetcher);
     fetcher->set_response_code(200);
     fetcher->SetResponseString(cases[i].json);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunTillProviderDone();
 
     const std::string description = "for input with json=" + cases[i].json;
     const ACMatches& matches = provider_->matches();
     // The top match must inline and score as highly as calculated verbatim.
     ASSERT_FALSE(matches.empty());
@@ skipping 402 matching lines @@
         { "a1.com", false },
         { "a2.com", false },
         { "a", true },
         { "k a", false } } },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     QueryForInput(ASCIIToUTF16("k a"), false, true);
 
     // Set up a default fetcher with no results.
-    net::TestURLFetcher* default_fetcher = WaitUntilURLFetcherIsReady(
-        SearchProvider::kDefaultProviderURLFetcherID);
+    net::TestURLFetcher* default_fetcher =
+        test_factory_.GetFetcherByID(
+            SearchProvider::kDefaultProviderURLFetcherID);
     ASSERT_TRUE(default_fetcher);
     default_fetcher->set_response_code(200);
     default_fetcher->delegate()->OnURLFetchComplete(default_fetcher);
     default_fetcher = NULL;
 
     // Set up a keyword fetcher with provided results.
-    net::TestURLFetcher* keyword_fetcher = WaitUntilURLFetcherIsReady(
-        SearchProvider::kKeywordProviderURLFetcherID);
+    net::TestURLFetcher* keyword_fetcher =
+        test_factory_.GetFetcherByID(
+            SearchProvider::kKeywordProviderURLFetcherID);
     ASSERT_TRUE(keyword_fetcher);
     keyword_fetcher->set_response_code(200);
     keyword_fetcher->SetResponseString(cases[i].json);
     keyword_fetcher->delegate()->OnURLFetchComplete(keyword_fetcher);
     keyword_fetcher = NULL;
     RunTillProviderDone();
 
     const std::string description = "for input with json=" + cases[i].json;
     const ACMatches& matches = provider_->matches();
     // The top match must inline and score as highly as calculated verbatim.
@@ skipping 90 matching lines @@
        "{\"google:suggesttype\":[\"QUERY\", \"QUERY\", \"NAVIGATION\","
                                 "\"NAVIGATION\"],"
         // A verbatim query for URL-like input scores 850, so the navigation
         // scores here should bracket it.
         "\"google:suggestrelevance\":[9999, 9998, 900, 800]}]",
       { "a.com/1", "a.com", "a.com/2", "a1", kNotApplicable, kNotApplicable } },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     QueryForInput(cases[i].input, false, false);
-    net::TestURLFetcher* fetcher = WaitUntilURLFetcherIsReady(
-        SearchProvider::kDefaultProviderURLFetcherID);
+    net::TestURLFetcher* fetcher =
+        test_factory_.GetFetcherByID(
+            SearchProvider::kDefaultProviderURLFetcherID);
     ASSERT_TRUE(fetcher);
     fetcher->set_response_code(200);
     fetcher->SetResponseString(cases[i].json);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     RunTillProviderDone();
 
     const std::string description = "for input with json=" + cases[i].json;
     const ACMatches& matches = provider_->matches();
 
     // Ensure no extra matches are present.
@@ skipping 78 matching lines @@
                  "\"google:verbatimrelevance\":9999}]",
       { "a.com", "abc.com", "a.com/a", kNotApplicable },
       { AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
         AutocompleteMatchType::NAVSUGGEST,
         AutocompleteMatchType::SEARCH_SUGGEST,
         AutocompleteMatchType::NUM_TYPES } },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
     QueryForInput(ASCIIToUTF16(cases[i].input), false, false);
-    net::TestURLFetcher* fetcher = WaitUntilURLFetcherIsReady(
-        SearchProvider::kDefaultProviderURLFetcherID);
+    net::TestURLFetcher* fetcher =
+        test_factory_.GetFetcherByID(
+            SearchProvider::kDefaultProviderURLFetcherID);
     ASSERT_TRUE(fetcher);
     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 418 matching lines @@
       } else {
         ASSERT_NE(sug_end, sug_it) << "Failed to find " << suggestion;
         EXPECT_EQ(ASCIIToUTF16(suggestion), sug_it->suggestion());
         ++sug_it;
       }
     }
     EXPECT_EQ(sug_end, sug_it);
     EXPECT_EQ(nav_end, nav_it);
   }
 }