autocomplete: Add AutocompleteProvider::Type enum.

chrome/browser/autocomplete/autocomplete_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/autocomplete_provider.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string16.h"
@@ skipping 27 matching lines @@
 const char kTestTemplateURLKeyword[] = "t";
 }
 
 // Autocomplete provider that provides known results. Note that this is
 // refcounted so that it can also be a task on the message loop.
 class TestProvider : public AutocompleteProvider {
  public:
   TestProvider(int relevance, const string16& prefix,
                Profile* profile,
                const string16 match_keyword)
-      : AutocompleteProvider(NULL, profile, ""),
+      : AutocompleteProvider(NULL, profile, AutocompleteProvider::TYPE_SEARCH),
         relevance_(relevance),
         prefix_(prefix),
         match_keyword_(match_keyword) {
   }
 
   virtual void Start(const AutocompleteInput& input,
                      bool minimal_changes);
 
   void set_listener(AutocompleteProviderListener* listener) {
     listener_ = listener;
@@ skipping 97 matching lines @@
   struct AssistedQueryStatsTestData {
     const AutocompleteMatch::Type match_type;
     const std::string expected_aqs;
   };
 
  protected:
    // Registers a test TemplateURL under the given keyword.
   void RegisterTemplateURL(const string16 keyword,
                            const std::string& template_url);
 
-  void ResetControllerWithTestProviders(bool same_destinations);
+  // Resets |controller_| with two TestProviders.  |provider1_ptr| and
+  // |provider2_ptr| are updated to point to the new providers if non-NULL.
+  void ResetControllerWithTestProviders(bool same_destinations,
+                                        TestProvider** provider1_ptr,
+                                        TestProvider** provider2_ptr);
 
   // Runs a query on the input "a", and makes sure both providers' input is
   // properly collected.
   void RunTest();
 
   void RunRedundantKeywordTest(const KeywordTestData* match_data, size_t size);
 
   void RunAssistedQueryStatsTest(
       const AssistedQueryStatsTestData* aqs_test_data,
       size_t size);
 
   void RunQuery(const string16 query);
 
-  void ResetControllerWithTestProvidersWithKeywordAndSearchProviders();
+  void ResetControllerWithKeywordAndSearchProviders();
   void ResetControllerWithKeywordProvider();
   void RunExactKeymatchTest(bool allow_exact_keyword_match);
 
-  // These providers are owned by the controller once it's created.
-  ACProviders providers_;
+  // Returns the provider of type |type| from |controller_|.  NULL is returned
+  // if no provider of this type has been created.
+  AutocompleteProvider* GetProvider(AutocompleteProvider::Type type);
 
   AutocompleteResult result_;
   scoped_ptr<AutocompleteController> controller_;
 
  private:
   // content::NotificationObserver
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details);
 
@@ skipping 13 matching lines @@
   TemplateURL* default_t_url = new TemplateURL(&profile_, data);
   TemplateURLService* turl_model =
       TemplateURLServiceFactory::GetForProfile(&profile_);
   turl_model->Add(default_t_url);
   turl_model->SetDefaultSearchProvider(default_t_url);
   TemplateURLID default_provider_id = default_t_url->id();
   ASSERT_NE(0, default_provider_id);
 }
 
 void AutocompleteProviderTest::ResetControllerWithTestProviders(
-    bool same_destinations) {
-  // Forget about any existing providers.  The controller owns them and will
-  // Release() them below, when we delete it during the call to reset().
-  providers_.clear();
-
+    bool same_destinations,
+    TestProvider** provider1_ptr,
+    TestProvider** provider2_ptr) {
   // TODO: Move it outside this method, after refactoring the existing
   // unit tests.  Specifically:
   //   (1) Make sure that AutocompleteMatch.keyword is set iff there is
   //       a corresponding call to RegisterTemplateURL; otherwise the
   //       controller flow will crash; this practically means that
   //       RunTests/ResetControllerXXX/RegisterTemplateURL should
   //       be coordinated with each other.
   //   (2) Inject test arguments rather than rely on the hardcoded values, e.g.
   //       don't rely on kResultsPerProvided and default relevance ordering
   //       (B > A).
   RegisterTemplateURL(ASCIIToUTF16(kTestTemplateURLKeyword),
                       "http://aqs/{searchTerms}/{google:assistedQueryStats}");
 
+  ACProviders providers;
+
   // Construct two new providers, with either the same or different prefixes.
-  TestProvider* providerA =
-      new TestProvider(kResultsPerProvider,
-                       ASCIIToUTF16("http://a"),
-                       &profile_,
-                       ASCIIToUTF16(kTestTemplateURLKeyword));
-  providerA->AddRef();
-  providers_.push_back(providerA);
+  TestProvider* provider1 = new TestProvider(
+      kResultsPerProvider,
+      ASCIIToUTF16("http://a"),
+      &profile_,
+      ASCIIToUTF16(kTestTemplateURLKeyword));
+  provider1->AddRef();
+  providers.push_back(provider1);
 
-  TestProvider* providerB = new TestProvider(
+  TestProvider* provider2 = new TestProvider(
       kResultsPerProvider * 2,
       same_destinations ? ASCIIToUTF16("http://a") : ASCIIToUTF16("http://b"),
       &profile_,
       string16());
-  providerB->AddRef();
-  providers_.push_back(providerB);
+  provider2->AddRef();
+  providers.push_back(provider2);
 
   // Reset the controller to contain our new providers.
   AutocompleteController* controller =
-      new AutocompleteController(providers_, &profile_);
+      new AutocompleteController(providers, &profile_);

[Peter Kasting, 2012/09/11 01:38:42]

Wait a minute.  AutocompleteController declares AutocompleteProviderTest as a
friend class (which is how you managed to access its providers directly for
GetProvider()).  So why can't we kill the UNIT_TEST constructor entirely and do
the following here:

  controller_.reset(new AutocompleteController(&profile_, NULL, 0);
  controller_->providers_.swap(providers);

We shouldn't even need to set the |search_provider_| or |keyword_provider_|
members of the controller -- the former because no one will care about it, the
latter because TestProvider is of type SEARCH and thus this was always NULL
before.

[Daniel Erat, 2012/09/11 02:09:22]

Nice!  Done.

   controller_.reset(controller);
-  providerA->set_listener(controller);
-  providerB->set_listener(controller);
+  provider1->set_listener(controller);
+  provider2->set_listener(controller);
 
   // The providers don't complete synchronously, so listen for "result updated"
   // notifications.
   registrar_.Add(this,
                  chrome::NOTIFICATION_AUTOCOMPLETE_CONTROLLER_RESULT_READY,
                  content::Source<AutocompleteController>(controller));
+
+  if (provider1_ptr)
+    *provider1_ptr = provider1;
+  if (provider2_ptr)
+    *provider2_ptr = provider2;
 }
 
 void AutocompleteProviderTest::
-    ResetControllerWithTestProvidersWithKeywordAndSearchProviders() {
+    ResetControllerWithKeywordAndSearchProviders() {
   TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       &profile_, &TemplateURLServiceFactory::BuildInstanceFor);
 
   // Reset the default TemplateURL.
   TemplateURLData data;
   data.SetURL("http://defaultturl/{searchTerms}");
   TemplateURL* default_t_url = new TemplateURL(&profile_, data);
   TemplateURLService* turl_model =
       TemplateURLServiceFactory::GetForProfile(&profile_);
   turl_model->Add(default_t_url);
   turl_model->SetDefaultSearchProvider(default_t_url);
   TemplateURLID default_provider_id = default_t_url->id();
   ASSERT_NE(0, default_provider_id);
 
   // Create another TemplateURL for KeywordProvider.
   data.short_name = ASCIIToUTF16("k");
   data.SetKeyword(ASCIIToUTF16("k"));
   data.SetURL("http://keyword/{searchTerms}");
   TemplateURL* keyword_t_url = new TemplateURL(&profile_, data);
   turl_model->Add(keyword_t_url);
   ASSERT_NE(0, keyword_t_url->id());
 
-  // Forget about any existing providers.  The controller owns them and will
-  // Release() them below, when we delete it during the call to reset().
-  providers_.clear();
-
-  // Create both a keyword and search provider, and add them in that order.
-  // (Order is important; see comments in RunExactKeymatchTest().)
-  AutocompleteProvider* keyword_provider = new KeywordProvider(NULL, &profile_);
-  keyword_provider->AddRef();
-  providers_.push_back(keyword_provider);
-  AutocompleteProvider* search_provider = new SearchProvider(NULL, &profile_);
-  search_provider->AddRef();
-  providers_.push_back(search_provider);
-
-  controller_.reset(new AutocompleteController(providers_, &profile_));
+  controller_.reset(new AutocompleteController(
+      &profile_, NULL,
+      AutocompleteProvider::TYPE_KEYWORD | AutocompleteProvider::TYPE_SEARCH));
 }
 
 void AutocompleteProviderTest::ResetControllerWithKeywordProvider() {
   TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
       &profile_, &TemplateURLServiceFactory::BuildInstanceFor);
 
   TemplateURLService* turl_model =
       TemplateURLServiceFactory::GetForProfile(&profile_);
 
   // Create a TemplateURL for KeywordProvider.
   TemplateURLData data;
   data.short_name = ASCIIToUTF16("foo.com");
   data.SetKeyword(ASCIIToUTF16("foo.com"));
   data.SetURL("http://foo.com/{searchTerms}");
   TemplateURL* keyword_t_url = new TemplateURL(&profile_, data);
   turl_model->Add(keyword_t_url);
   ASSERT_NE(0, keyword_t_url->id());
 
   // Create another TemplateURL for KeywordProvider.
   data.short_name = ASCIIToUTF16("bar.com");
   data.SetKeyword(ASCIIToUTF16("bar.com"));
   data.SetURL("http://bar.com/{searchTerms}");
   keyword_t_url = new TemplateURL(&profile_, data);
   turl_model->Add(keyword_t_url);
   ASSERT_NE(0, keyword_t_url->id());
 
-  // Forget about any existing providers.  The controller owns them and will
-  // Release() them below, when we delete it during the call to reset().
-  providers_.clear();
-
-  // Create both a keyword and search provider, and add them in that order.
-  // (Order is important; see comments in RunExactKeymatchTest().)
-  KeywordProvider* keyword_provider = new KeywordProvider(NULL, &profile_);
-  keyword_provider->AddRef();
-  providers_.push_back(keyword_provider);
-
-  AutocompleteController* controller =
-      new AutocompleteController(providers_, &profile_);
-  controller->set_keyword_provider(keyword_provider);
-  controller_.reset(controller);
+  controller_.reset(new AutocompleteController(
+      &profile_, NULL, AutocompleteProvider::TYPE_KEYWORD));
 }
 
 void AutocompleteProviderTest::RunTest() {
   RunQuery(ASCIIToUTF16("a"));
 }
 
 void AutocompleteProviderTest::RunRedundantKeywordTest(
     const KeywordTestData* match_data,
     size_t size) {
   ACMatches matches;
@@ skipping 56 matching lines @@
 void AutocompleteProviderTest::RunExactKeymatchTest(
     bool allow_exact_keyword_match) {
   // Send the controller input which exactly matches the keyword provider we
   // created in ResetControllerWithKeywordAndSearchProviders().  The default
   // match should thus be a keyword match iff |allow_exact_keyword_match| is
   // true.
   controller_->Start(ASCIIToUTF16("k test"), string16(), true, false,
                      allow_exact_keyword_match,
                      AutocompleteInput::SYNCHRONOUS_MATCHES);
   EXPECT_TRUE(controller_->done());
-  // ResetControllerWithKeywordAndSearchProviders() adds the keyword provider
-  // first, then the search provider.  So if the default match is a keyword
-  // match, it will come from provider 0, otherwise from provider 1.
-  EXPECT_EQ(providers_[allow_exact_keyword_match ? 0 : 1],
+  EXPECT_EQ(GetProvider(allow_exact_keyword_match ?

[Peter Kasting, 2012/09/11 01:38:42]

Nit: Simpler, because you can kill GetProvider() entirely:

  EXPECT_EQ(allow_exact_keyword_match ?
      AutocompleteProvider::TYPE_KEYWORD : AutocompleteProvider::TYPE_SEARCH,
      controller_->result().default_match()->provider->type());

[Daniel Erat, 2012/09/11 02:09:22]

Duh.  Done.

+      AutocompleteProvider::TYPE_KEYWORD : AutocompleteProvider::TYPE_SEARCH),
       controller_->result().default_match()->provider);
 }
 
+AutocompleteProvider* AutocompleteProviderTest::GetProvider(
+    AutocompleteProvider::Type type) {
+  for (ACProviders::const_iterator it = controller_->providers()->begin();
+       it != controller_->providers()->end(); ++it) {
+    if ((*it)->type() == type)
+      return *it;
+  }
+  return NULL;
+}
+
 void AutocompleteProviderTest::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (controller_->done()) {
     result_.CopyFrom(controller_->result());
     MessageLoop::current()->Quit();
   }
 }
 
 // Tests that the default selection is set properly when updating results.
 TEST_F(AutocompleteProviderTest, Query) {
-  ResetControllerWithTestProviders(false);
+  TestProvider* provider1 = NULL;
+  TestProvider* provider2 = NULL;
+  ResetControllerWithTestProviders(false, &provider1, &provider2);
   RunTest();
 
   // Make sure the default match gets set to the highest relevance match.  The
   // highest relevance matches should come from the second provider.
   EXPECT_EQ(kResultsPerProvider * 2, result_.size());  // two providers
   ASSERT_NE(result_.end(), result_.default_match());
-  EXPECT_EQ(providers_[1], result_.default_match()->provider);
+  EXPECT_EQ(provider2, result_.default_match()->provider);
 }
 
 // Tests assisted query stats.
 TEST_F(AutocompleteProviderTest, AssistedQueryStats) {
-  ResetControllerWithTestProviders(false);
+  ResetControllerWithTestProviders(false, NULL, NULL);
   RunTest();
 
   EXPECT_EQ(kResultsPerProvider * 2, result_.size());  // two providers
 
   // Now, check the results from the second provider, as they should not have
   // assisted query stats set.
   for (size_t i = 0; i < kResultsPerProvider; ++i) {
     EXPECT_TRUE(
         result_.match_at(i)->search_terms_args->assisted_query_stats.empty());
   }
   // The first provider has a test keyword, so AQS should be non-empty.
   for (size_t i = kResultsPerProvider; i < kResultsPerProvider * 2; ++i) {
     EXPECT_FALSE(
         result_.match_at(i)->search_terms_args->assisted_query_stats.empty());
   }
 }
 
 TEST_F(AutocompleteProviderTest, RemoveDuplicates) {
-  ResetControllerWithTestProviders(true);
+  TestProvider* provider1 = NULL;
+  TestProvider* provider2 = NULL;
+  ResetControllerWithTestProviders(true, &provider1, &provider2);
   RunTest();
 
   // Make sure all the first provider's results were eliminated by the second
   // provider's.
   EXPECT_EQ(kResultsPerProvider, result_.size());
   for (AutocompleteResult::const_iterator i(result_.begin());
        i != result_.end(); ++i)
-    EXPECT_EQ(providers_[1], i->provider);
+    EXPECT_EQ(provider2, i->provider);
 }
 
 TEST_F(AutocompleteProviderTest, AllowExactKeywordMatch) {
-  ResetControllerWithTestProvidersWithKeywordAndSearchProviders();
+  ResetControllerWithKeywordAndSearchProviders();
   RunExactKeymatchTest(true);
   RunExactKeymatchTest(false);
 }
 
 // Test that redundant associated keywords are removed.
 TEST_F(AutocompleteProviderTest, RedundantKeywordsIgnoredInResult) {
   ResetControllerWithKeywordProvider();
 
   // Get the controller's internal members in the correct state.
   RunQuery(ASCIIToUTF16("fo"));
@@ skipping 27 matching lines @@
       { ASCIIToUTF16("bar.com"), string16(), true },
     };
 
     SCOPED_TRACE("Duplicate url with multiple keywords");
     RunRedundantKeywordTest(multiple_keyword,
         ARRAYSIZE_UNSAFE(multiple_keyword));
   }
 }
 
 TEST_F(AutocompleteProviderTest, UpdateAssistedQueryStats) {
-  ResetControllerWithTestProviders(false);
+  ResetControllerWithTestProviders(false, NULL, NULL);
 
   {
     AssistedQueryStatsTestData test_data[] = {
       //  MSVC doesn't support zero-length arrays, so supply some dummy data.
       { AutocompleteMatch::SEARCH_WHAT_YOU_TYPED, "" }
     };
     SCOPED_TRACE("No matches");
     // Note: We pass 0 here to ignore the dummy data above.
     RunAssistedQueryStatsTest(test_data, 0);
   }
@@ skipping 14 matching lines @@
       { AutocompleteMatch::NAVSUGGEST, "chrome.3.57j58j5l2j0l3j59" },
       { AutocompleteMatch::SEARCH_SUGGEST, "chrome.4.57j58j5l2j0l3j59" },
       { AutocompleteMatch::SEARCH_SUGGEST, "chrome.5.57j58j5l2j0l3j59" },
       { AutocompleteMatch::SEARCH_SUGGEST, "chrome.6.57j58j5l2j0l3j59" },
       { AutocompleteMatch::SEARCH_HISTORY, "chrome.7.57j58j5l2j0l3j59" },
     };
     SCOPED_TRACE("Multiple matches");
     RunAssistedQueryStatsTest(test_data, ARRAYSIZE_UNSAFE(test_data));
   }
 }
-