Omnibox: Make URLs of Bookmarks Searchable

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>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/metrics/field_trial.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_provider.h"
 #include "chrome/browser/autocomplete/autocomplete_provider_listener.h"
+#include "chrome/browser/bookmarks/bookmark_match.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
-#include "chrome/browser/bookmarks/bookmark_title_match.h"
+#include "chrome/browser/omnibox/omnibox_field_trial.h"
+#include "chrome/common/metrics/variations/variations_util.h"
 #include "chrome/test/base/testing_profile.h"
+#include "components/variations/entropy_provider.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // 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" },
   { "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/" },
 };
 
 class BookmarkProviderTest : public testing::Test,
                              public AutocompleteProviderListener {
  public:
-  BookmarkProviderTest() : model_(new BookmarkModel(NULL)) {}
+  BookmarkProviderTest();
 
   // AutocompleteProviderListener: Not called.
   virtual void OnProviderUpdate(bool updated_matches) OVERRIDE {}
 
  protected:
   virtual void SetUp() OVERRIDE;
 
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<BookmarkModel> model_;
   scoped_refptr<BookmarkProvider> provider_;
 
  private:
+  scoped_ptr<base::FieldTrialList> field_trial_list_;
+
   DISALLOW_COPY_AND_ASSIGN(BookmarkProviderTest);
 };
 
+BookmarkProviderTest::BookmarkProviderTest() {
+  model_.reset(new BookmarkModel(NULL));
+  // Destroy the existing FieldTrialList before creating a new one to avoid
+  // a DCHECK.
+  field_trial_list_.reset();
+  field_trial_list_.reset(new base::FieldTrialList(
+      new metrics::SHA1EntropyProvider("foo")));
+  chrome_variations::testing::ClearAllVariationParams();
+}
+
 void BookmarkProviderTest::SetUp() {
   profile_.reset(new TestingProfile());
   DCHECK(profile_.get());
   provider_ = new BookmarkProvider(this, profile_.get());
   DCHECK(provider_.get());
   provider_->set_bookmark_model_for_testing(model_.get());
 
   const BookmarkNode* other_node = model_->other_node();
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(bookmark_provider_test_data); ++i) {
     const BookmarksTestInfo& cur(bookmark_provider_test_data[i]);
@@ skipping 290 matching lines @@
     const std::string description = "for query=" + query_data[i].query +
         " and url=" + query_data[i].url;
     AutocompleteInput input(base::ASCIIToUTF16(query_data[i].query),
                             base::string16::npos, base::string16(), GURL(),
                             AutocompleteInput::INVALID_SPEC, false, false,
                             false, AutocompleteInput::ALL_MATCHES);
     AutocompleteInput fixed_up_input(input);
     provider_->FixupUserInput(&fixed_up_input);
     BookmarkNode node(GURL(query_data[i].url));
     node.SetTitle(base::ASCIIToUTF16(query_data[i].url));
-    BookmarkTitleMatch bookmark_match;
+    BookmarkMatch bookmark_match;
     bookmark_match.node = &node;
-    const AutocompleteMatch& ac_match =
-        provider_->TitleMatchToACMatch(input, fixed_up_input, bookmark_match);
+    const AutocompleteMatch& ac_match = provider_->BookmarkMatchToACMatch(
+        input, fixed_up_input, bookmark_match);
     EXPECT_EQ(query_data[i].allowed_to_be_default_match,
               ac_match.allowed_to_be_default_match) << description;
     EXPECT_EQ(base::ASCIIToUTF16(query_data[i].inline_autocompletion),
               ac_match.inline_autocompletion) << description;
   }
 }
+
+TEST_F(BookmarkProviderTest, StripHttpAndAdjustOffsets) {
+  // Simulate searches.
+  struct QueryData {
+    const std::string query;
+    const std::string expected_contents;
+    // |expected_contents_class| is in format offset:style,offset:style,...
+    const std::string expected_contents_class;
+  } query_data[] = {
+    { "foo",       "www.foobar.com",             "0:1,4:3,7:1"           },
+    { "www foo",   "www.foobar.com",             "0:3,3:1,4:3,7:1"       },
+    { "foo www",   "www.foobar.com",             "0:3,3:1,4:3,7:1"       },
+    { "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"          }
+  };
+
+  // Set the field trial parameter to enable indexing URLs.
+  {
+    std::map<std::string, std::string> params;
+    params[OmniboxFieldTrial::kBookmarksIndexURLsRule] = "true";
+    ASSERT_TRUE(chrome_variations::AssociateVariationParams(
+        OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A", params));
+  }
+  base::FieldTrialList::CreateFieldTrial(
+      OmniboxFieldTrial::kBundledExperimentFieldTrialName, "A");
+  // Reload the bookmarks index now that the field trial is set.
+  model_.reset(new BookmarkModel(NULL));
+  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(),
+                            AutocompleteInput::INVALID_SPEC, false, false,
+                            false, AutocompleteInput::ALL_MATCHES);
+    provider_->Start(input, false);
+    const ACMatches& matches(provider_->matches());
+    ASSERT_EQ(1U, matches.size()) << description;
+    const AutocompleteMatch& match = matches[0];
+    EXPECT_EQ(base::ASCIIToUTF16(query_data[i].expected_contents),
+              match.contents) << description;
+    std::vector<std::string> class_strings;
+    base::SplitString(
+        query_data[i].expected_contents_class, ',', &class_strings);
+    ASSERT_EQ(class_strings.size(), match.contents_class.size())
+        << description;
+    for (size_t i = 0; i < class_strings.size(); ++i) {
+      std::vector<std::string> chunks;
+      base::SplitString(class_strings[i], ':', &chunks);
+      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;
+    }
+  }
+}