Omnibox: Make URLs of Bookmarks Searchable - Try 2

chrome/browser/autocomplete/bookmark_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/bookmark_provider.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 15 matching lines @@
 using bookmarks::BookmarkMatch;
 
 // The bookmark corpus against which we will simulate searches.
 struct BookmarksTestInfo {
   std::string title;
   std::string url;
 } bookmark_provider_test_data[] = {
   { "abc def", "http://www.catsanddogs.com/a" },
   { "abcde", "http://www.catsanddogs.com/b" },
   { "abcdef", "http://www.catsanddogs.com/c" },
-  { "a definition", "http://www.catsanddogs.com/d" },
-  { "carry carbon carefully", "http://www.catsanddogs.com/e" },
+  { "carry carbon carefully", "http://www.catsanddogs.com/d" },
+  { "a definition", "http://www.catsanddogs.com/e" },
   { "ghi jkl", "http://www.catsanddogs.com/f" },
   { "jkl ghi", "http://www.catsanddogs.com/g" },
   { "frankly frankly frank", "http://www.catsanddogs.com/h" },
   { "foobar foobar", "http://www.foobar.com/" },
   { "domain", "http://www.domain.com/http/" },
   { "repeat", "http://www.repeat.com/1/repeat/2/" },
   // For testing inline_autocompletion.
   { "http://blah.com/", "http://blah.com/" },
   { "http://fiddle.com/", "http://fiddle.com/" },
   { "http://www.www.com/", "http://www.www.com/" },
   { "chrome://version", "chrome://version" },
   { "chrome://omnibox", "chrome://omnibox" },
   // For testing ranking with different URLs.
-  {"achlorhydric featherheads resuscitates mockingbirds",
-   "http://www.featherheads.com/a" },
-  {"achlorhydric mockingbirds resuscitates featherhead",
-   "http://www.featherheads.com/b" },
-  {"featherhead resuscitates achlorhydric mockingbirds",
-   "http://www.featherheads.com/c" },
-  {"mockingbirds resuscitates featherheads achlorhydric",
-   "http://www.featherheads.com/d" },
-  // For testing URL boosting.
-  {"burning worms #1", "http://www.burned.com/" },
-  {"burning worms #2", "http://www.worms.com/" },
-  {"worming burns #10", "http://www.burned.com/" },
-  {"worming burns #20", "http://www.worms.com/" },
-  {"jive music", "http://www.worms.com/" },
+  { "achlorhydric featherheads resuscitates mockingbirds",
+    "http://www.manylongwords.com/1a" },
+  { "achlorhydric mockingbirds resuscitates featherhead",
+    "http://www.manylongwords.com/2b" },
+  { "featherhead resuscitates achlorhydric mockingbirds",
+    "http://www.manylongwords.com/3c" },
+  { "mockingbirds resuscitates featherheads achlorhydric",
+    "http://www.manylongwords.com/4d" },
+  // For testing URL boosting.  (URLs referenced multiple times are boosted.)
+  { "burning worms #1",  "http://www.burns.com/" },
+  { "burning worms #2",  "http://www.worms.com/" },
+  { "worming burns #10", "http://www.burns.com/" },
   // For testing strange spacing in bookmark titles.
-  {" hello1  hello2  ", "http://whatever.com/" },
+  { " hello1  hello2  ", "http://whatever.com/" },
+  { "",                  "http://emptytitle.com/" },
 };
 
 class BookmarkProviderTest : public testing::Test {
  public:
   BookmarkProviderTest();
 
  protected:
   virtual void SetUp() OVERRIDE;
 
   test::TestBookmarkClient client_;
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<BookmarkModel> model_;
   scoped_refptr<BookmarkProvider> provider_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BookmarkProviderTest);
 };
 
 BookmarkProviderTest::BookmarkProviderTest() {
-  model_ = client_.CreateModel(false);
+  model_ = client_.CreateModel();
 }
 
 void BookmarkProviderTest::SetUp() {
   profile_.reset(new TestingProfile());
   DCHECK(profile_.get());
   provider_ = new BookmarkProvider(profile_.get());
   DCHECK(provider_.get());
   provider_->set_bookmark_model_for_testing(model_.get());
 
   const BookmarkNode* other_node = model_->other_node();
@@ skipping 131 matching lines @@
                                   {{0, 3}, {0, 0}},
                                   {{0, 3}, {0, 0}}}},
     {"abcde",                 2, {{{0, 5}, {0, 0}},
                                   {{0, 5}, {0, 0}}}},
     {"foo bar",               0, {{{0, 0}}}},
     {"fooey bark",            0, {{{0, 0}}}},
     {"def",                   2, {{{2, 5}, {0, 0}},
                                   {{4, 7}, {0, 0}}}},
     {"ghi jkl",               2, {{{0, 3}, {4, 7}, {0, 0}},
                                   {{0, 3}, {4, 7}, {0, 0}}}},
-    // NB: GetBookmarksWithTitlesMatching(...) uses exact match for "a".
-    {"a",                     1, {{{0, 1}, {0, 0}}}},
+    // NB: GetBookmarksMatching(...) uses exact match for "a" in title or URL.
+    {"a",                     2, {{{0, 1}, {0, 0}},
+                                  {{0, 0}}}},
     {"a d",                   0, {{{0, 0}}}},
     {"carry carbon",          1, {{{0, 5}, {6, 12}, {0, 0}}}},
-    // NB: GetBookmarksWithTitlesMatching(...) sorts the match positions.
+    // NB: GetBookmarksMatching(...) sorts the match positions.
     {"carbon carry",          1, {{{0, 5}, {6, 12}, {0, 0}}}},
     {"arbon",                 0, {{{0, 0}}}},
     {"ar",                    0, {{{0, 0}}}},
     {"arry",                  0, {{{0, 0}}}},
     // Quoted terms are single terms.
     {"\"carry carbon\"",      1, {{{0, 12}, {0, 0}}}},
     {"\"carry carbon\" care", 1, {{{0, 12}, {13, 17}, {0, 0}}}},
     // Quoted terms require complete word matches.
     {"\"carry carbo\"",       0, {{{0, 0}}}},
     // This set uses duplicated and/or overlaps search terms in the title.
     {"frank",                 1, {{{0, 5}, {8, 13}, {16, 21}, {0, 0}}}},
     {"frankly",               1, {{{0, 7}, {8, 15}, {0, 0}}}},
     {"frankly frankly",       1, {{{0, 7}, {8, 15}, {0, 0}}}},
     {"foobar foo",            1, {{{0, 6}, {7, 13}, {0, 0}}}},
     {"foo foobar",            1, {{{0, 6}, {7, 13}, {0, 0}}}},
-    // This one makes sure that leading whitespace in the title is removed.
+    // This ensures that leading whitespace in the title is removed.
     {"hello",                 1, {{{0, 5}, {7, 12}, {0, 0}}}},
+    // This ensures that empty titles yield empty classifications.
+    {"emptytitle",            1, {}},
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(query_data); ++i) {
     AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
                             base::string16::npos, base::string16(), GURL(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, false, true,
                             ChromeAutocompleteSchemeClassifier(profile_.get()));
     provider_->Start(input, false);
     const ACMatches& matches(provider_->matches());
@@ skipping 49 matching lines @@
                       "achlorhydric featherheads resuscitates mockingbirds",
                       "featherhead resuscitates achlorhydric mockingbirds"}},
     {"achlorhydric featherheads",
                   2, {"achlorhydric featherheads resuscitates mockingbirds",
                       "mockingbirds resuscitates featherheads achlorhydric",
                       ""}},
     {"mockingbirds resuscitates",
                   3, {"mockingbirds resuscitates featherheads achlorhydric",
                       "achlorhydric mockingbirds resuscitates featherhead",
                       "featherhead resuscitates achlorhydric mockingbirds"}},
-    // Ranking of exact-word matches with URL boost.
-    {"worms",     2, {"burning worms #2",    // boosted
-                      "burning worms #1",    // not boosted
+    // Ranking of exact-word matches with URL boosts.
+    {"worms",     2, {"burning worms #1",    // boosted
+                      "burning worms #2",    // not boosted
                       ""}},
-    // Ranking of prefix matches with URL boost. Note that a query of
-    // "worm burn" will have the same results.
-    {"burn worm", 3, {"burning worms #2",    // boosted
-                      "worming burns #20",   // boosted
-                      "burning worms #1"}},  // not boosted but shorter
+    // Ranking of prefix matches with URL boost.
+    {"burn worm", 3, {"burning worms #1",    // boosted
+                      "worming burns #10",   // boosted but longer title
+                      "burning worms #2"}},  // not boosted
+    // A query of "worm burn" will have the same results.
+    {"worm burn", 3, {"burning worms #1",    // boosted
+                      "worming burns #10",   // boosted but longer title
+                      "burning worms #2"}},  // not boosted
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(query_data); ++i) {
     AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
                             base::string16::npos, base::string16(), GURL(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, false, true,
                             ChromeAutocompleteSchemeClassifier(profile_.get()));
     provider_->Start(input, false);
     const ACMatches& matches(provider_->matches());
@@ skipping 81 matching lines @@
     { "foo http",  "http://www.foobar.com",      "0:3,4:1,11:3,14:1"     },
     { "blah",      "blah.com",                   "0:3,4:1"               },
     { "http blah", "http://blah.com",            "0:3,4:1,7:3,11:1"      },
     { "dom",       "www.domain.com/http/",       "0:1,4:3,7:1"           },
     { "dom http",  "http://www.domain.com/http/",
       "0:3,4:1,11:3,14:1,22:3,26:1"                                      },
     { "rep",       "www.repeat.com/1/repeat/2/", "0:1,4:3,7:1,17:3,20:1" },
     { "versi",     "chrome://version",           "0:1,9:3,14:1"          }
   };
 
-  // Reload the bookmarks index with |index_urls| == true.
-  model_ = client_.CreateModel(true);
-  SetUp();
-
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(query_data); ++i) {
     std::string description = "for query=" + query_data[i].query;
     AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
                             base::string16::npos, base::string16(), GURL(),
                             metrics::OmniboxEventProto::INVALID_SPEC, false,
                             false, false, true,
                             ChromeAutocompleteSchemeClassifier(profile_.get()));
     provider_->Start(input, false);
     const ACMatches& matches(provider_->matches());
     ASSERT_EQ(1U, matches.size()) << description;
@@ skipping 11 matching lines @@
       ASSERT_EQ(2U, chunks.size()) << description;
       size_t offset;
       EXPECT_TRUE(base::StringToSizeT(chunks[0], &offset)) << description;
       EXPECT_EQ(offset, match.contents_class[i].offset) << description;
       int style;
       EXPECT_TRUE(base::StringToInt(chunks[1], &style)) << description;
       EXPECT_EQ(style, match.contents_class[i].style) << description;
     }
   }
 }