Rename BookmarkIndex to TitledUrlIndex and BookmarkMatch to TitledUrlMatch

components/omnibox/browser/bookmark_provider.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 "components/omnibox/browser/bookmark_provider.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/trace_event/trace_event.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/metrics/proto/omnibox_input_type.pb.h"
 #include "components/omnibox/browser/autocomplete_provider_client.h"
 #include "components/omnibox/browser/autocomplete_result.h"
 #include "components/omnibox/browser/history_provider.h"
 #include "components/omnibox/browser/url_prefix.h"
 #include "components/prefs/pref_service.h"
 #include "components/url_formatter/url_formatter.h"
 #include "url/url_constants.h"
 
-using bookmarks::BookmarkMatch;
-using BookmarkMatches = std::vector<BookmarkMatch>;
 using bookmarks::BookmarkNode;
+using bookmarks::TitledUrlMatch;
+using TitledUrlMatches = std::vector<TitledUrlMatch>;
 
 namespace {
 
 // Removes leading spaces from |title| before displaying, otherwise it looks
 // funny.  In the process, corrects |title_match_positions| so the correct
 // characters are highlighted.
 void CorrectTitleAndMatchPositions(
     base::string16* title,
-    BookmarkMatch::MatchPositions* title_match_positions) {
+    TitledUrlMatch::MatchPositions* title_match_positions) {
   size_t leading_whitespace_chars = title->length();
   base::TrimWhitespace(*title, base::TRIM_LEADING, title);
   leading_whitespace_chars-= title->length();
   if (leading_whitespace_chars == 0)
     return;
   for (query_parser::Snippet::MatchPositions::iterator it =
            title_match_positions->begin();
        it != title_match_positions->end(); ++it) {
     (*it) = query_parser::Snippet::MatchPosition(
         it->first - leading_whitespace_chars,
@@ skipping 23 matching lines @@
   DoAutocomplete(input);
 }
 
 BookmarkProvider::~BookmarkProvider() {}
 
 void BookmarkProvider::DoAutocomplete(const AutocompleteInput& input) {
   // We may not have a bookmark model for some unit tests.
   if (!bookmark_model_)
     return;
 
-  BookmarkMatches matches;
+  TitledUrlMatches matches;
   // Retrieve enough bookmarks so that we have a reasonable probability of
   // suggesting the one that the user desires.
   const size_t kMaxBookmarkMatches = 50;
 
   // GetBookmarksMatching returns bookmarks matching the user's
   // search terms using the following rules:
   //  - The search text is broken up into search terms. Each term is searched
   //    for separately.
   //  - Term matches are always performed against the start of a word. 'def'
   //    will match against 'define' but not against 'indefinite'.
   //  - Terms must be at least three characters in length in order to perform
   //    partial word matches. Any term of lesser length will only be used as an
   //    exact match. 'def' will match against 'define' but 'de' will not match.
   //  - A search containing multiple terms will return results with those words
   //    occuring in any order.
   //  - Terms enclosed in quotes comprises a phrase that must match exactly.
   //  - Multiple terms enclosed in quotes will require those exact words in that
   //    exact order to match.
   //
-  // Please refer to the code for BookmarkIndex::GetBookmarksMatching for
+  // Please refer to the code for TitledUrlIndex::GetResultsMatching for
   // complete details of how searches are performed against the user's
   // bookmarks.
   bookmark_model_->GetBookmarksMatching(input.text(),
                                         kMaxBookmarkMatches,
                                         &matches);
   if (matches.empty())
     return;  // There were no matches.
   const base::string16 fixed_up_input(FixupUserInput(input).second);
-  for (BookmarkMatches::const_iterator i = matches.begin(); i != matches.end();
+  for (TitledUrlMatches::const_iterator i = matches.begin(); i != matches.end();
        ++i) {
     // Create and score the AutocompleteMatch. If its score is 0 then the
     // match is discarded.
-    AutocompleteMatch match(BookmarkMatchToACMatch(input, fixed_up_input, *i));
+    AutocompleteMatch match(TitledUrlMatchToACMatch(input, fixed_up_input, *i));
     if (match.relevance > 0)
       matches_.push_back(match);
   }
 
   // Sort and clip the resulting matches.
   size_t num_matches =
       std::min(matches_.size(), AutocompleteProvider::kMaxMatches);
   std::partial_sort(matches_.begin(), matches_.begin() + num_matches,
                     matches_.end(), AutocompleteMatch::MoreRelevant);
   matches_.resize(num_matches);
@@ skipping 23 matching lines @@
 
   double ScoringFactor() { return scoring_factor_; }
 
  private:
   double title_length_;
   double scoring_factor_;
 };
 
 }  // namespace
 
-AutocompleteMatch BookmarkProvider::BookmarkMatchToACMatch(
+AutocompleteMatch BookmarkProvider::TitledUrlMatchToACMatch(
     const AutocompleteInput& input,
     const base::string16& fixed_up_input_text,
-    const BookmarkMatch& bookmark_match) {
+    const TitledUrlMatch& bookmark_match) {
   // The AutocompleteMatch we construct is non-deletable because the only
   // way to support this would be to delete the underlying bookmark, which is
   // unlikely to be what the user intends.
   AutocompleteMatch match(this, 0, false,
                           AutocompleteMatchType::BOOKMARK_TITLE);
   base::string16 title(bookmark_match.node->GetTitledUrlNodeTitle());
-  BookmarkMatch::MatchPositions new_title_match_positions =
+  TitledUrlMatch::MatchPositions new_title_match_positions =
       bookmark_match.title_match_positions;
   CorrectTitleAndMatchPositions(&title, &new_title_match_positions);
   const GURL& url(bookmark_match.node->GetTitledUrlNodeUrl());
   const base::string16& url_utf16 = base::UTF8ToUTF16(url.spec());
   size_t inline_autocomplete_offset = URLPrefix::GetInlineAutocompleteOffset(
       input.text(), fixed_up_input_text, false, url_utf16);
   match.destination_url = url;
   const size_t match_start = bookmark_match.url_match_positions.empty() ?
       0 : bookmark_match.url_match_positions[0].first;
   const bool trim_http = !AutocompleteInput::HasHTTPScheme(input.text()) &&
       ((match_start == base::string16::npos) || (match_start != 0));
-  std::vector<size_t> offsets = BookmarkMatch::OffsetsFromMatchPositions(
+  std::vector<size_t> offsets = TitledUrlMatch::OffsetsFromMatchPositions(
       bookmark_match.url_match_positions);
   // In addition to knowing how |offsets| is transformed, we need to know how
   // |inline_autocomplete_offset| is transformed.  We add it to the end of
   // |offsets|, compute how everything is transformed, then remove it from the
   // end.
   offsets.push_back(inline_autocomplete_offset);
   match.contents = url_formatter::FormatUrlWithOffsets(
       url, url_formatter::kFormatUrlOmitAll &
                ~(trim_http ? 0 : url_formatter::kFormatUrlOmitHTTP),
       net::UnescapeRule::SPACES, nullptr, nullptr, &offsets);
   inline_autocomplete_offset = offsets.back();
   offsets.pop_back();
-  BookmarkMatch::MatchPositions new_url_match_positions =
-      BookmarkMatch::ReplaceOffsetsInMatchPositions(
+  TitledUrlMatch::MatchPositions new_url_match_positions =
+      TitledUrlMatch::ReplaceOffsetsInMatchPositions(
           bookmark_match.url_match_positions, offsets);
   match.contents_class =
       ClassificationsFromMatch(new_url_match_positions,
                                match.contents.size(),
                                true);
   match.fill_into_edit =
       AutocompleteInput::FormattedStringWithEquivalentMeaning(
           url, match.contents, client_->GetSchemeClassifier());
   if (inline_autocomplete_offset != base::string16::npos) {
     // |inline_autocomplete_offset| may be beyond the end of the
@@ skipping 128 matching lines @@
        i != positions.end();
        ++i) {
     AutocompleteMatch::ACMatchClassifications new_class;
     AutocompleteMatch::ClassifyLocationInString(i->first, i->second - i->first,
         text_length, url_style, &new_class);
     classifications = AutocompleteMatch::MergeClassifications(
         classifications, new_class);
   }
   return classifications;
 }