Cleaning up test only variables.

components/omnibox/browser/url_index_private_data.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/url_index_private_data.h"
 
 #include <stdint.h>
 
 #include <functional>
 #include <iterator>
@@ skipping 123 matching lines @@
 }
 
 
 // URLIndexPrivateData ---------------------------------------------------------
 
 // static
 constexpr size_t URLIndexPrivateData::kMaxVisitsToStoreInCache;
 
 URLIndexPrivateData::URLIndexPrivateData()
     : restored_cache_version_(0),
-      saved_cache_version_(kCurrentCacheFileVersion),
-      pre_filter_item_count_(0),
-      post_filter_item_count_(0),
-      post_scoring_item_count_(0) {
-}
+      saved_cache_version_(kCurrentCacheFileVersion) {}
 
 ScoredHistoryMatches URLIndexPrivateData::HistoryItemsForTerms(
     base::string16 original_search_string,
     size_t cursor_position,
     size_t max_matches,
     bookmarks::BookmarkModel* bookmark_model,
     TemplateURLService* template_url_service) {
-  pre_filter_item_count_ = 0;
-  post_filter_item_count_ = 0;
-  post_scoring_item_count_ = 0;
-
   // This list will contain the original search string and any other string
   // transformations.
   String16Vector search_strings;
   search_strings.push_back(original_search_string);
   if ((cursor_position != base::string16::npos) &&
       (cursor_position < original_search_string.length()) &&
       (cursor_position > 0)) {
     // The original search_string broken at cursor position. This is one type of
     // transformation.
     base::string16 transformed_search_string(original_search_string);
     transformed_search_string.insert(cursor_position, base::ASCIIToUTF16(" "));
     search_strings.push_back(transformed_search_string);
   }
 
   ScoredHistoryMatches scored_items;
   // Invalidate the term cache and return if we have indexed no words (probably
   // because we've not been initialized yet).
   if (word_list_.empty()) {
     search_term_cache_.clear();
     return scored_items;
   }
   // Reset used_ flags for search_term_cache_. We use a basic mark-and-sweep
   // approach.
   ResetSearchTermCache();
 
+  bool history_ids_were_trimmed = false;
   for (const base::string16& search_string : search_strings) {
     // The search string we receive may contain escaped characters. For reducing
     // the index we need individual, lower-cased words, ignoring escapings. For
     // the final filtering we need whitespace separated substrings possibly
     // containing escaped characters.
     base::string16 lower_raw_string(base::i18n::ToLower(search_string));
     base::string16 lower_unescaped_string = net::UnescapeURLComponent(
         lower_raw_string,
         net::UnescapeRule::SPACES | net::UnescapeRule::PATH_SEPARATORS |
             net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS);
 
     // Extract individual 'words' (as opposed to 'terms'; see comment in
     // HistoryIdSetToScoredMatches()) from the search string. When the user
     // types "colspec=ID%20Mstone Release" we get four 'words': "colspec", "id",
     // "mstone" and "release".
     String16Vector lower_words(
         String16VectorFromString16(lower_unescaped_string, false, nullptr));
     if (lower_words.empty())
       continue;
     HistoryIDSet history_id_set = HistoryIDSetFromWords(lower_words);
-    pre_filter_item_count_ += history_id_set.size();
-    // Trim the candidate pool if it is large. Note that we do not filter out
-    // items that do not contain the search terms as proper substrings --
-    // doing so is the performance-costly operation we are trying to avoid in
-    // order to maintain omnibox responsiveness.
-    const size_t kItemsToScoreLimit = 500;
-    if (history_id_set.size() > kItemsToScoreLimit) {
-      HistoryIDVector history_ids;
-      std::copy(history_id_set.begin(), history_id_set.end(),
-                std::back_inserter(history_ids));
-      // Trim down the set by sorting by typed-count, visit-count, and last
-      // visit.
-      HistoryItemFactorGreater item_factor_functor(history_info_map_);
-      std::partial_sort(history_ids.begin(),
-                        history_ids.begin() + kItemsToScoreLimit,
-                        history_ids.end(), item_factor_functor);
-      history_id_set.clear();
-      std::copy(history_ids.begin(), history_ids.begin() + kItemsToScoreLimit,
-                std::inserter(history_id_set, history_id_set.end()));
-      post_filter_item_count_ += history_id_set.size();
-    } else {
-      post_filter_item_count_ += pre_filter_item_count_;
-    }
+    history_ids_were_trimmed =

[Peter Kasting, 2017/02/23 01:04:45]

Nit: Use |=

[dyaroshev, 2017/02/23 01:41:26]

This would be a bit operation - is it ok? 
I think that you are correct and compiler won't do lazy evaluation for bitwise
or but to doublecheck, are you sure?

[Peter Kasting, 2017/02/23 01:46:06]

As you note, A |= B is equivalent to A = A | B.  Bitwise-or never
short-circuits, no matter the types of its arguments, so this is safe.

[dyaroshev, 2017/02/24 01:27:03]

Done.

+        TrimHistoryIdsPool(&history_id_set) || history_ids_were_trimmed;
+
     ScoredHistoryMatches temp_scored_items;
     HistoryIdSetToScoredMatches(history_id_set, lower_raw_string,
                                 template_url_service, bookmark_model,
                                 &temp_scored_items);
     scored_items.insert(scored_items.end(), temp_scored_items.begin(),
                         temp_scored_items.end());
   }
   // Select and sort only the top |max_matches| results.
   if (scored_items.size() > max_matches) {
     std::partial_sort(scored_items.begin(), scored_items.begin() + max_matches,
                       scored_items.end(),
                       ScoredHistoryMatch::MatchScoreGreater);
     scored_items.resize(max_matches);
   } else {
     std::sort(scored_items.begin(), scored_items.end(),
               ScoredHistoryMatch::MatchScoreGreater);
   }
-  post_scoring_item_count_ = scored_items.size();
-  if (pre_filter_item_count_ > post_filter_item_count_) {
+  if (history_ids_were_trimmed) {
     // If we trim the results set we do not want to cache the results for next
     // time as the user's ultimately desired result could easily be eliminated
     // in the early rough filter.
     search_term_cache_.clear();
   } else {
     // Remove any stale SearchTermCacheItems.
     for (SearchTermCacheMap::iterator cache_iter = search_term_cache_.begin();
          cache_iter != search_term_cache_.end(); ) {
       if (!cache_iter->second.used_)
         cache_iter = search_term_cache_.erase(cache_iter);
@@ skipping 208 matching lines @@
   data_copy->available_words_ = available_words_;
   data_copy->word_map_ = word_map_;
   data_copy->char_word_map_ = char_word_map_;
   data_copy->word_id_history_map_ = word_id_history_map_;
   data_copy->history_id_word_map_ = history_id_word_map_;
   data_copy->history_info_map_ = history_info_map_;
   data_copy->word_starts_map_ = word_starts_map_;
   return data_copy;
   // Not copied:
   //    search_term_cache_
-  //    pre_filter_item_count_
-  //    post_filter_item_count_
-  //    post_scoring_item_count_
 }
 
 bool URLIndexPrivateData::Empty() const {
   return history_info_map_.empty();
 }
 
 void URLIndexPrivateData::Clear() {
   last_time_rebuilt_from_history_ = base::Time();
   word_list_.clear();
   available_words_.clear();
@@ skipping 33 matching lines @@
       history_id_set.swap(term_history_set);
     } else {
       HistoryIDSet new_history_id_set = base::STLSetIntersection<HistoryIDSet>(
           history_id_set, term_history_set);
       history_id_set.swap(new_history_id_set);
     }
   }
   return history_id_set;
 }
 
+bool URLIndexPrivateData::TrimHistoryIdsPool(
+    HistoryIDSet* history_id_set) const {
+  constexpr size_t kItemsToScoreLimit = 500;
+  if (history_id_set->size() < kItemsToScoreLimit)
+    return false;
+
+  HistoryIDVector history_ids(history_id_set->begin(), history_id_set->end());
+
+  // Trim down the set by sorting by typed-count, visit-count, and last
+  // visit.
+  auto new_end = history_ids.begin() + kItemsToScoreLimit;
+  HistoryItemFactorGreater item_factor_functor(history_info_map_);
+
+  std::nth_element(history_ids.begin(), new_end, history_ids.end(),
+                   item_factor_functor);
+  history_ids.erase(new_end, history_ids.end());
+
+  *history_id_set = {history_ids.begin(), history_ids.end()};
+  return true;
+}
+
 HistoryIDSet URLIndexPrivateData::HistoryIDsForTerm(
     const base::string16& term) {
   if (term.empty())
     return HistoryIDSet();
 
   // TODO(mrossetti): Consider optimizing for very common terms such as
   // 'http[s]', 'www', 'com', etc. Or collect the top 100 more frequently
   // occuring words in the user's searches.
 
   size_t term_length = term.length();
@@ skipping 840 matching lines @@
   // First cut: typed count, visit count, recency.
   // TODO(mrossetti): This is too simplistic. Consider an approach which ranks
   // recently visited (within the last 12/24 hours) as highly important. Get
   // input from mpearson.
   if (r1.typed_count() != r2.typed_count())
     return (r1.typed_count() > r2.typed_count());
   if (r1.visit_count() != r2.visit_count())
     return (r1.visit_count() > r2.visit_count());
   return (r1.last_visit() > r2.last_visit());
 }