Factor out bookmark-specific sorting logic from BookmarkIndex

components/bookmarks/browser/bookmark_index.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 <stdint.h>
 
 #include "base/i18n/case_conversion.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_offset_string_conversions.h"
 #include "build/build_config.h"
-#include "components/bookmarks/browser/bookmark_client.h"
 #include "components/bookmarks/browser/bookmark_match.h"
 #include "components/bookmarks/browser/bookmark_utils.h"
 #include "components/bookmarks/browser/titled_url_node.h"
+#include "components/bookmarks/browser/titled_url_node_sorter.h"
 #include "components/query_parser/snippet.h"
 #include "third_party/icu/source/common/unicode/normalizer2.h"
 #include "third_party/icu/source/common/unicode/utypes.h"
 
 namespace bookmarks {
 
-using UrlTypedCountMap = BookmarkClient::UrlTypedCountMap;
-
 namespace {
 
-using UrlNodeMap = std::unordered_map<const GURL*, const TitledUrlNode*>;
-using UrlTypedCountPair = std::pair<const GURL*, int>;
-using UrlTypedCountPairs = std::vector<UrlTypedCountPair>;
-
 // Returns a normalized version of the UTF16 string |text|.  If it fails to
 // normalize the string, returns |text| itself as a best-effort.
 base::string16 Normalize(const base::string16& text) {
   UErrorCode status = U_ZERO_ERROR;
   const icu::Normalizer2* normalizer2 =
       icu::Normalizer2::getInstance(nullptr, "nfkc", UNORM2_COMPOSE, status);
   if (U_FAILURE(status)) {
     // Log and crash right away to capture the error code in the crash report.
     LOG(FATAL) << "failed to create a normalizer: " << u_errorName(status);
   }
   icu::UnicodeString unicode_text(
       text.data(), static_cast<int32_t>(text.length()));
   icu::UnicodeString unicode_normalized_text;
   normalizer2->normalize(unicode_text, unicode_normalized_text, status);
   if (U_FAILURE(status)) {
     // This should not happen. Log the error and fall back.
     LOG(ERROR) << "normalization failed: " << u_errorName(status);
     return text;
   }
   return base::string16(unicode_normalized_text.getBuffer(),
                         unicode_normalized_text.length());
 }
 
-// Sort functor for UrlTypedCountPairs. We sort in decreasing order of typed
-// count so that the best matches will always be added to the results.
-struct UrlTypedCountPairSortFunctor {
-  bool operator()(const UrlTypedCountPair& a,
-                  const UrlTypedCountPair& b) const {
-    return a.second > b.second;
-  }
-};
-
-// Extract the GURL stored in an UrlTypedCountPair and use it to look up the
-// corresponding TitledUrlNode.
-class UrlTypedCountPairNodeLookupFunctor {
- public:
-  explicit UrlTypedCountPairNodeLookupFunctor(UrlNodeMap& url_node_map)
-      : url_node_map_(url_node_map) {
-  }
-
-  const TitledUrlNode* operator()(const UrlTypedCountPair& pair) const {
-    return url_node_map_[pair.first];
-  }
-
- private:
-  UrlNodeMap& url_node_map_;
-};
-
 }  // namespace
 
-BookmarkIndex::BookmarkIndex(BookmarkClient* client)
-    : client_(client) {
-  DCHECK(client_);
+BookmarkIndex::BookmarkIndex(std::unique_ptr<TitledUrlNodeSorter> sorter)
+    : sorter_(std::move(sorter)) {
 }
 
 BookmarkIndex::~BookmarkIndex() {
 }
 
 void BookmarkIndex::Add(const TitledUrlNode* node) {
   std::vector<base::string16> terms =
       ExtractQueryWords(Normalize(node->GetTitledUrlNodeTitle()));
   for (size_t i = 0; i < terms.size(); ++i)
     RegisterNode(terms[i], node);
@@ skipping 48 matching lines @@
   // will run backwards to assure higher relevance will be attributed to the
   // best matches.
   for (TitledUrlNodes::const_iterator i = sorted_nodes.begin();
        i != sorted_nodes.end() && results->size() < max_count;
        ++i)
     AddMatchToResults(*i, &parser, query_nodes, results);
 }
 
 void BookmarkIndex::SortMatches(const TitledUrlNodeSet& matches,
                                 TitledUrlNodes* sorted_nodes) const {
-  sorted_nodes->reserve(matches.size());
-  if (client_->SupportsTypedCountForUrls()) {
-    UrlNodeMap url_node_map;
-    UrlTypedCountMap url_typed_count_map;
-    for (auto node : matches) {
-      const GURL& url = node->GetTitledUrlNodeUrl();
-      url_node_map.insert(std::make_pair(&url, node));
-      url_typed_count_map.insert(std::make_pair(&url, 0));
-    }
-
-    client_->GetTypedCountForUrls(&url_typed_count_map);
-
-    UrlTypedCountPairs url_typed_counts;
-    std::copy(url_typed_count_map.begin(),
-              url_typed_count_map.end(),
-              std::back_inserter(url_typed_counts));
-    std::sort(url_typed_counts.begin(),
-              url_typed_counts.end(),
-              UrlTypedCountPairSortFunctor());
-    std::transform(url_typed_counts.begin(),
-                   url_typed_counts.end(),
-                   std::back_inserter(*sorted_nodes),
-                   UrlTypedCountPairNodeLookupFunctor(url_node_map));
+  if (sorter_) {
+    sorter_->SortMatches(matches, sorted_nodes);
   } else {
     sorted_nodes->insert(sorted_nodes->end(), matches.begin(), matches.end());
   }
 }
 
 void BookmarkIndex::AddMatchToResults(
     const TitledUrlNode* node,
     query_parser::QueryParser* parser,
     const query_parser::QueryNodeVector& query_nodes,
     std::vector<BookmarkMatch>* results) {
@@ skipping 118 matching lines @@
     // We can get here if the node has the same term more than once. For
     // example, a node with the title 'foo foo' would end up here.
     return;
   }
   i->second.erase(node);
   if (i->second.empty())
     index_.erase(i);
 }
 
 }  // namespace bookmarks