Handle Search suggest subtypes for Shortcuts DB

chrome/browser/autocomplete/shortcuts_backend_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/shortcuts_backend.h"
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/shortcuts_backend_factory.h"
 #include "chrome/browser/history/shortcuts_database.h"
+#include "chrome/browser/search_engines/template_url_service.h"
+#include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/ui_test_utils.h"
 #include "content/public/test/test_browser_thread.h"
 #include "sql/statement.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 
 // ShortcutsBackendTest -------------------------------------------------------
 
 class ShortcutsBackendTest : public testing::Test,
                              public ShortcutsBackend::ShortcutsBackendObserver {
  public:
   ShortcutsBackendTest();
 
   history::ShortcutsDatabase::Shortcut::MatchCore MatchCoreForTesting(
     const std::string& url,
     const std::string& contents_class = std::string(),
     const std::string& description_class = std::string(),
     AutocompleteMatch::Type type = AutocompleteMatchType::URL_WHAT_YOU_TYPED);
+  void SetSearchProvider();
 
   virtual void SetUp();
   virtual void TearDown();
 
   virtual void OnShortcutsLoaded() OVERRIDE;
   virtual void OnShortcutsChanged() OVERRIDE;
 
   const ShortcutsBackend::ShortcutMap& shortcuts_map() const {
     return backend_->shortcuts_map();
   }
   bool changed_notified() const { return changed_notified_; }
   void set_changed_notified(bool changed_notified) {
       changed_notified_ = changed_notified;
   }
 
   void InitBackend();
   bool AddShortcut(const history::ShortcutsDatabase::Shortcut& shortcut);
   bool UpdateShortcut(const history::ShortcutsDatabase::Shortcut& shortcut);
   bool DeleteShortcutsWithURL(const GURL& url);
   bool DeleteShortcutsWithIDs(
       const history::ShortcutsDatabase::ShortcutIDs& deleted_ids);
 
+ protected:
+  TestingProfile profile_;
 
  private:
-  TestingProfile profile_;
   scoped_refptr<ShortcutsBackend> backend_;
   base::MessageLoopForUI ui_message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread db_thread_;
 
   bool load_notified_;
   bool changed_notified_;
 
   DISALLOW_COPY_AND_ASSIGN(ShortcutsBackendTest);
 };
@@ skipping 11 matching lines @@
     const std::string& contents_class,
     const std::string& description_class,
     AutocompleteMatch::Type type) {
   AutocompleteMatch match(NULL, 0, 0, type);
   match.destination_url = GURL(url);
   match.contents = base::ASCIIToUTF16("test");
   match.contents_class =
       AutocompleteMatch::ClassificationsFromString(contents_class);
   match.description_class =
       AutocompleteMatch::ClassificationsFromString(description_class);
-  return ShortcutsBackend::MatchToMatchCore(match);
+  match.search_terms_args.reset(
+      new TemplateURLRef::SearchTermsArgs(match.contents));
+  return ShortcutsBackend::MatchToMatchCore(match, &profile_);
+}
+
+void ShortcutsBackendTest::SetSearchProvider() {
+  TemplateURLService* template_url_service =
+      TemplateURLServiceFactory::GetForProfile(&profile_);
+  TemplateURLData data;
+  data.SetURL("http://foo.com/search?bar={searchTerms}");
+  data.SetKeyword(base::UTF8ToUTF16("foo"));
+
+  TemplateURL* template_url = new TemplateURL(&profile_, data);
+  // Takes ownership of |template_url|.
+  template_url_service->Add(template_url);
+  template_url_service->SetDefaultSearchProvider(template_url);
 }
 
 void ShortcutsBackendTest::SetUp() {
   db_thread_.Start();
   ShortcutsBackendFactory::GetInstance()->SetTestingFactoryAndUse(
       &profile_, &ShortcutsBackendFactory::BuildProfileForTesting);
   backend_ = ShortcutsBackendFactory::GetForProfile(&profile_);
   ASSERT_TRUE(backend_.get());
   backend_->AddObserver(this);
+
+  TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
+      &profile_, &TemplateURLServiceFactory::BuildInstanceFor);
+  TemplateURLService* template_url_service =
+      TemplateURLServiceFactory::GetForProfile(&profile_);
+  ui_test_utils::WaitForTemplateURLServiceToLoad(template_url_service);
 }
 
 void ShortcutsBackendTest::TearDown() {
   backend_->RemoveObserver(this);
   db_thread_.Stop();
 }
 
 void ShortcutsBackendTest::OnShortcutsLoaded() {
   load_notified_ = true;
   base::MessageLoop::current()->Quit();
@@ skipping 40 matching lines @@
 // types.
 TEST_F(ShortcutsBackendTest, SanitizeMatchCore) {
   struct {
     std::string input_contents_class;
     std::string input_description_class;
     AutocompleteMatch::Type input_type;
     std::string output_contents_class;
     std::string output_description_class;
     AutocompleteMatch::Type output_type;
   } cases[] = {
-    { "0,1,4,0", "0,3,4,1",       AutocompleteMatchType::URL_WHAT_YOU_TYPED,
-      "0,1,4,0", "0,1",           AutocompleteMatchType::HISTORY_URL },
-    { "0,3,5,1", "0,2,5,0",       AutocompleteMatchType::NAVSUGGEST,
-      "0,1",     "0,0",           AutocompleteMatchType::HISTORY_URL },
-    { "0,1",     "0,0,11,2,15,0", AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
-      "0,1",     "0,0",           AutocompleteMatchType::SEARCH_HISTORY },
-    { "0,1",     "0,0",           AutocompleteMatchType::SEARCH_SUGGEST,
-      "0,1",     "0,0",           AutocompleteMatchType::SEARCH_HISTORY },
+    { "0,1,4,0", "0,3,4,1",  AutocompleteMatchType::URL_WHAT_YOU_TYPED,
+      "0,1,4,0", "0,1",      AutocompleteMatchType::HISTORY_URL },
+    { "0,3,5,1", "0,2,5,0",  AutocompleteMatchType::NAVSUGGEST,
+      "0,1",     "0,0",      AutocompleteMatchType::HISTORY_URL },
+    { "0,1",     "0,0,11,2,15,0",
+                             AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED,
+      "0,1",     "0,0",      AutocompleteMatchType::SEARCH_HISTORY },
+    { "0,1",     "0,0",      AutocompleteMatchType::SEARCH_SUGGEST,
+      "0,1",     "0,0",      AutocompleteMatchType::SEARCH_HISTORY },
+    { "0,1",     "0,0",      AutocompleteMatchType::SEARCH_SUGGEST_ENTITY,
+      "",        "",         AutocompleteMatchType::SEARCH_HISTORY },
+    { "0,1",     "0,0",      AutocompleteMatchType::SEARCH_SUGGEST_INFINITE,
+      "",        "",         AutocompleteMatchType::SEARCH_HISTORY },
+    { "0,1",     "0,0",      AutocompleteMatchType::SEARCH_SUGGEST_PERSONALIZED,
+      "",        "",         AutocompleteMatchType::SEARCH_HISTORY },
+    { "0,1",     "0,0",      AutocompleteMatchType::SEARCH_SUGGEST_PROFILE,
+      "",        "",         AutocompleteMatchType::SEARCH_HISTORY },
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); ++i) {
     history::ShortcutsDatabase::Shortcut::MatchCore match_core(
         MatchCoreForTesting(std::string(), cases[i].input_contents_class,
                             cases[i].input_description_class,
                             cases[i].input_type));
-    EXPECT_EQ(cases[i].output_contents_class, match_core.contents_class);
-    EXPECT_EQ(cases[i].output_description_class, match_core.description_class);
-    EXPECT_EQ(cases[i].output_type, match_core.type);
+    EXPECT_EQ(cases[i].output_contents_class, match_core.contents_class)
+        << ":i:" << i << ":type:" << cases[i].input_type;
+    EXPECT_EQ(cases[i].output_description_class, match_core.description_class)
+        << ":i:" << i << ":type:" << cases[i].input_type;
+    EXPECT_EQ(cases[i].output_type, match_core.type)
+        << ":i:" << i << ":type:" << cases[i].input_type;
   }
 }
 
+TEST_F(ShortcutsBackendTest, EntitySuggestionTest) {
+  SetSearchProvider();
+  AutocompleteMatch match;
+  match.fill_into_edit = base::UTF8ToUTF16("franklin d roosevelt");
+  match.type = AutocompleteMatchType::SEARCH_SUGGEST_ENTITY;
+  match.contents = base::UTF8ToUTF16("roosevelt");
+  match.contents_class =
+      AutocompleteMatch::ClassificationsFromString("0,0,5,2");
+  match.description = base::UTF8ToUTF16("Franklin D. Roosevelt");
+  match.description_class = AutocompleteMatch::ClassificationsFromString("0,4");
+  match.destination_url = GURL(
+      "http://www.foo.com/search?bar=franklin+d+roosevelt&gs_ssp=1234");
+  match.keyword = base::UTF8ToUTF16("foo");
+  match.search_terms_args.reset(
+      new TemplateURLRef::SearchTermsArgs(match.fill_into_edit));
+
+  history::ShortcutsDatabase::Shortcut::MatchCore match_core =
+      ShortcutsBackend::MatchToMatchCore(match, &profile_);
+
+  EXPECT_EQ("http://foo.com/search?bar=franklin+d+roosevelt",
+            match_core.destination_url.spec());
+  EXPECT_EQ(match.fill_into_edit, match_core.contents);
+  EXPECT_EQ("0,0", match_core.contents_class);
+  EXPECT_EQ(base::string16(), match_core.description);
+  EXPECT_TRUE(match_core.description_class.empty());
+}
+
 TEST_F(ShortcutsBackendTest, AddAndUpdateShortcut) {
   InitBackend();
   EXPECT_FALSE(changed_notified());
 
   history::ShortcutsDatabase::Shortcut shortcut(
       "BD85DBA2-8C29-49F9-84AE-48E1E90880DF", base::ASCIIToUTF16("goog"),
       MatchCoreForTesting("http://www.google.com"), base::Time::Now(), 100);
   EXPECT_TRUE(AddShortcut(shortcut));
   EXPECT_TRUE(changed_notified());
   ShortcutsBackend::ShortcutMap::const_iterator shortcut_iter(
@@ skipping 56 matching lines @@
   ASSERT_TRUE(shortcut4_iter != shortcuts_map().end());
   EXPECT_EQ(shortcut4.id, shortcut4_iter->second.id);
 
   history::ShortcutsDatabase::ShortcutIDs deleted_ids;
   deleted_ids.push_back(shortcut3.id);
   deleted_ids.push_back(shortcut4.id);
   EXPECT_TRUE(DeleteShortcutsWithIDs(deleted_ids));
 
   ASSERT_EQ(0U, shortcuts_map().size());
 }