Rename BookmarkIndex to TitledUrlIndex and BookmarkMatch to TitledUrlMatch

components/bookmarks/browser/bookmark_index_unittest.cc

 // Copyright 2014 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 "components/bookmarks/browser/bookmark_index.h"
-
 #include <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "components/bookmarks/browser/bookmark_match.h"
 #include "components/bookmarks/browser/bookmark_model.h"
+#include "components/bookmarks/browser/titled_url_match.h"
 #include "components/bookmarks/test/bookmark_test_helpers.h"
 #include "components/bookmarks/test/test_bookmark_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 
 namespace bookmarks {
 namespace {
 
@@ skipping 56 matching lines @@
     std::vector<std::string> title_vector;
     for (size_t i = 0; i < expected_count; ++i)
       title_vector.push_back(expected_titles[i]);
     ExpectMatches(query, query_parser::MatchingAlgorithm::DEFAULT,
                   title_vector);
   }
 
   void ExpectMatches(const std::string& query,
                      query_parser::MatchingAlgorithm matching_algorithm,
                      const std::vector<std::string>& expected_titles) {
-    std::vector<BookmarkMatch> matches;
+    std::vector<TitledUrlMatch> matches;
     model_->GetBookmarksMatching(ASCIIToUTF16(query), 1000, matching_algorithm,
                                  &matches);
     ASSERT_EQ(expected_titles.size(), matches.size());
     for (size_t i = 0; i < expected_titles.size(); ++i) {
       bool found = false;
       for (size_t j = 0; j < matches.size(); ++j) {
         const base::string16& title = matches[j].node->GetTitledUrlNodeTitle();
         if (ASCIIToUTF16(expected_titles[i]) == title) {
           matches.erase(matches.begin() + j);
           found = true;
           break;
         }
       }
       ASSERT_TRUE(found);
     }
   }
 
   void ExtractMatchPositions(const std::string& string,
-                             BookmarkMatch::MatchPositions* matches) {
+                             TitledUrlMatch::MatchPositions* matches) {
     for (const base::StringPiece& match :
          base::SplitStringPiece(string, ":",
                                 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
       std::vector<base::StringPiece> chunks = base::SplitStringPiece(
           match, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       ASSERT_EQ(2U, chunks.size());
-      matches->push_back(BookmarkMatch::MatchPosition());
+      matches->push_back(TitledUrlMatch::MatchPosition());
       int chunks0, chunks1;
       EXPECT_TRUE(base::StringToInt(chunks[0], &chunks0));
       EXPECT_TRUE(base::StringToInt(chunks[1], &chunks1));
       matches->back().first = chunks0;
       matches->back().second = chunks1;
     }
   }
 
   void ExpectMatchPositions(
-      const BookmarkMatch::MatchPositions& actual_positions,
-      const BookmarkMatch::MatchPositions& expected_positions) {
+      const TitledUrlMatch::MatchPositions& actual_positions,
+      const TitledUrlMatch::MatchPositions& expected_positions) {
     ASSERT_EQ(expected_positions.size(), actual_positions.size());
     for (size_t i = 0; i < expected_positions.size(); ++i) {
       EXPECT_EQ(expected_positions[i].first, actual_positions[i].first);
       EXPECT_EQ(expected_positions[i].second, actual_positions[i].second);
     }
   }
 
  protected:
   std::unique_ptr<BookmarkModel> model_;
 
@@ skipping 208 matching lines @@
     { "foo\xc3\xa4-test", "fooa\xcc\x88-test" },
     { "foo\xc3\xa4-test", "foo\xc3\xa4" },
     { "foo\xc3\xa4-test", "fooa\xcc\x88" },
     { "foo\xc3\xa4-test", "foo" },
     { "foo", "foo" }
   };
 
   GURL url(kAboutBlankURL);
   for (size_t i = 0; i < arraysize(data); ++i) {
     model_->AddURL(model_->other_node(), 0, UTF8ToUTF16(data[i].title), url);
-    std::vector<BookmarkMatch> matches;
+    std::vector<TitledUrlMatch> matches;
     model_->GetBookmarksMatching(UTF8ToUTF16(data[i].query), 10, &matches);
     EXPECT_EQ(1u, matches.size());
     model_ = TestBookmarkClient::CreateModel();
   }
 }
 
 // Makes sure match positions are updated appropriately for title matches.
 TEST_F(BookmarkIndexTest, MatchPositionsTitles) {
   struct TestData {
     const std::string title;
     const std::string query;
     const std::string expected_title_match_positions;
   } data[] = {
     // Trivial test case of only one term, exact match.
     { "a",                        "A",        "0,1" },
     { "foo bar",                  "bar",      "4,7" },
     { "fooey bark",               "bar foo",  "0,3:6,9" },
     // Non-trivial tests.
     { "foobar foo",               "foobar foo",   "0,6:7,10" },
     { "foobar foo",               "foo foobar",   "0,6:7,10" },
     { "foobar foobar",            "foobar foo",   "0,6:7,13" },
     { "foobar foobar",            "foo foobar",   "0,6:7,13" },
   };
   for (size_t i = 0; i < arraysize(data); ++i) {
     std::vector<TitleAndURL> bookmarks;
     TitleAndURL bookmark(data[i].title, kAboutBlankURL);
     bookmarks.push_back(bookmark);
     AddBookmarks(bookmarks);
 
-    std::vector<BookmarkMatch> matches;
+    std::vector<TitledUrlMatch> matches;
     model_->GetBookmarksMatching(ASCIIToUTF16(data[i].query), 1000, &matches);
     ASSERT_EQ(1U, matches.size());
 
-    BookmarkMatch::MatchPositions expected_title_matches;
+    TitledUrlMatch::MatchPositions expected_title_matches;
     ExtractMatchPositions(data[i].expected_title_match_positions,
                           &expected_title_matches);
     ExpectMatchPositions(matches[0].title_match_positions,
                          expected_title_matches);
 
     model_ = TestBookmarkClient::CreateModel();
   }
 }
 
 // Makes sure match positions are updated appropriately for URL matches.
@@ skipping 27 matching lines @@
                                                          "130,134:139,143"  }
   };
 
   for (size_t i = 0; i < arraysize(data); ++i) {
     model_ = TestBookmarkClient::CreateModel();
     std::vector<TitleAndURL> bookmarks;
     TitleAndURL bookmark("123456", data[i].url);
     bookmarks.push_back(bookmark);
     AddBookmarks(bookmarks);
 
-    std::vector<BookmarkMatch> matches;
+    std::vector<TitledUrlMatch> matches;
     model_->GetBookmarksMatching(UTF8ToUTF16(data[i].query), 1000, &matches);
     ASSERT_EQ(1U, matches.size()) << data[i].url << data[i].query;
 
-    BookmarkMatch::MatchPositions expected_url_matches;
+    TitledUrlMatch::MatchPositions expected_url_matches;
     ExtractMatchPositions(data[i].expected_url_match_positions,
                           &expected_url_matches);
     ExpectMatchPositions(matches[0].url_match_positions, expected_url_matches);
   }
 }
 
 // Makes sure index is updated when a node is removed.
 TEST_F(BookmarkIndexTest, Remove) {
   const char* titles[] = { "a", "b" };
   const char* urls[] = {kAboutBlankURL, kAboutBlankURL};
@@ skipping 27 matching lines @@
   model_->SetURL(model_->other_node()->GetChild(0), GURL("http://blah"));
   ExpectMatches("blah", expected, arraysize(expected));
 }
 
 // Makes sure no more than max queries is returned.
 TEST_F(BookmarkIndexTest, HonorMax) {
   const char* titles[] = { "abcd", "abcde" };
   const char* urls[] = {kAboutBlankURL, kAboutBlankURL};
   AddBookmarks(titles, urls, arraysize(titles));
 
-  std::vector<BookmarkMatch> matches;
+  std::vector<TitledUrlMatch> matches;
   model_->GetBookmarksMatching(ASCIIToUTF16("ABc"), 1, &matches);
   EXPECT_EQ(1U, matches.size());
 }
 
 // Makes sure if the lower case string of a bookmark title is more characters
 // than the upper case string no match positions are returned.
 TEST_F(BookmarkIndexTest, EmptyMatchOnMultiwideLowercaseString) {
   const BookmarkNode* n1 = model_->AddURL(model_->other_node(), 0,
                                           base::WideToUTF16(L"\u0130 i"),
                                           GURL("http://www.google.com"));
 
-  std::vector<BookmarkMatch> matches;
+  std::vector<TitledUrlMatch> matches;
   model_->GetBookmarksMatching(ASCIIToUTF16("i"), 100, &matches);
   ASSERT_EQ(1U, matches.size());
   EXPECT_EQ(n1, matches[0].node);
   EXPECT_TRUE(matches[0].title_match_positions.empty());
 }
 
 TEST_F(BookmarkIndexTest, GetResultsSortedByTypedCount) {
   struct TestData {
     const GURL url;
     const char* title;
@@ skipping 12 matching lines @@
   std::unique_ptr<BookmarkModel> model =
       TestBookmarkClient::CreateModelWithClient(
           base::MakeUnique<BookmarkClientMock>(typed_count_map));
 
   for (size_t i = 0; i < arraysize(data); ++i)
     // Populate the bookmark index.
     model->AddURL(
         model->other_node(), i, UTF8ToUTF16(data[i].title), data[i].url);
 
   // Populate match nodes.
-  std::vector<BookmarkMatch> matches;
+  std::vector<TitledUrlMatch> matches;
   model->GetBookmarksMatching(ASCIIToUTF16("google"), 4, &matches);
 
   // The resulting order should be:
   // 1. Google (google.com) 100
   // 2. Google Reader (google.com/reader) 80
   // 3. Google Docs (docs.google.com) 50
   // 4. Google Maps (maps.google.com) 40
   ASSERT_EQ(4U, matches.size());
   EXPECT_EQ(data[0].url, matches[0].node->GetTitledUrlNodeUrl());
   EXPECT_EQ(data[3].url, matches[1].node->GetTitledUrlNodeUrl());
   EXPECT_EQ(data[2].url, matches[2].node->GetTitledUrlNodeUrl());
   EXPECT_EQ(data[1].url, matches[3].node->GetTitledUrlNodeUrl());
 
   matches.clear();
   // Select top two matches.
   model->GetBookmarksMatching(ASCIIToUTF16("google"), 2, &matches);
 
   ASSERT_EQ(2U, matches.size());
   EXPECT_EQ(data[0].url, matches[0].node->GetTitledUrlNodeUrl());
   EXPECT_EQ(data[3].url, matches[1].node->GetTitledUrlNodeUrl());
 }
 
 }  // namespace
 }  // namespace bookmarks