InstantExtended: Adding InstantRestrictedIDCache.

chrome/renderer/searchbox/searchbox.cc

 // Copyright 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/renderer/searchbox/searchbox.h"
 
 #include "base/utf_string_conversions.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/renderer/searchbox/searchbox_extension.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityPolicy.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 
+namespace {
+// Size of the results cache.
+const size_t kMaxInstantAutocompleteResultItemCacheSize = 100;

[palmer, 2013/03/21 22:58:04]

Yes, given this, linear search is not bad (and possibly even preferable, given
the low constant factor of indexing a vector).

[Shishir, 2013/03/21 23:38:41]

Please see reply in the restricted_id.h file.

+}
+
 SearchBox::SearchBox(content::RenderView* render_view)
     : content::RenderViewObserver(render_view),
       content::RenderViewObserverTracker<SearchBox>(render_view),
       verbatim_(false),
       selection_start_(0),
       selection_end_(0),
-      results_base_(0),
       start_margin_(0),
-      last_results_base_(0),
       is_key_capture_enabled_(false),
       display_instant_results_(false),
-      omnibox_font_size_(0) {
+      omnibox_font_size_(0),
+      autocomplete_results_cache_(kMaxInstantAutocompleteResultItemCacheSize),
+      most_visited_items_cache_(kMaxInstantMostVisitedItemCacheSize) {
 }
 
 SearchBox::~SearchBox() {
 }
 
 void SearchBox::SetSuggestions(
     const std::vector<InstantSuggestion>& suggestions) {
   if (!suggestions.empty() &&
       suggestions[0].behavior == INSTANT_COMPLETE_REPLACE) {
     query_ = suggestions[0].text;
@@ skipping 31 matching lines @@
 }
 
 void SearchBox::NavigateToURL(const GURL& url,
                               content::PageTransition transition,
                               WindowOpenDisposition disposition) {
   render_view()->Send(new ChromeViewHostMsg_SearchBoxNavigate(
       render_view()->GetRoutingID(), render_view()->GetPageId(),
       url, transition, disposition));
 }
 
-void SearchBox::DeleteMostVisitedItem(uint64 most_visited_item_id) {
+void SearchBox::DeleteMostVisitedItem(
+    InstantRestrictedID most_visited_item_id) {
   render_view()->Send(new ChromeViewHostMsg_SearchBoxDeleteMostVisitedItem(
       render_view()->GetRoutingID(), most_visited_item_id));
 }
 
-void SearchBox::UndoMostVisitedDeletion(uint64 most_visited_item_id) {
+void SearchBox::UndoMostVisitedDeletion(
+    InstantRestrictedID most_visited_item_id) {
   render_view()->Send(new ChromeViewHostMsg_SearchBoxUndoMostVisitedDeletion(
       render_view()->GetRoutingID(), most_visited_item_id));
 }
 
 void SearchBox::UndoAllMostVisitedDeletions() {
   render_view()->Send(
       new ChromeViewHostMsg_SearchBoxUndoAllMostVisitedDeletions(
       render_view()->GetRoutingID()));
 }
 
@@ skipping 14 matching lines @@
 }
 
 gfx::Rect SearchBox::GetPopupBounds() const {
   double zoom = GetZoom();
   return gfx::Rect(static_cast<int>(popup_bounds_.x() / zoom),
                    static_cast<int>(popup_bounds_.y() / zoom),
                    static_cast<int>(popup_bounds_.width() / zoom),
                    static_cast<int>(popup_bounds_.height() / zoom));
 }
 
-const std::vector<InstantAutocompleteResult>&
-    SearchBox::GetAutocompleteResults() {
-  // Remember the last requested autocomplete_results to account for race
-  // conditions between autocomplete providers returning new data and the user
-  // clicking on a suggestion.
-  last_autocomplete_results_ = autocomplete_results_;
-  last_results_base_ = results_base_;
-  return autocomplete_results_;
+void SearchBox::GetAutocompleteResults(
+    std::vector<InstantAutocompleteResultIDPair>* results) const {
+  autocomplete_results_cache_.GetCurrentItems(results);
 }
 
-const InstantAutocompleteResult* SearchBox::GetAutocompleteResultWithId(
-    size_t autocomplete_result_id) const {
-  if (autocomplete_result_id < last_results_base_ ||
-      autocomplete_result_id >=
-          last_results_base_ + last_autocomplete_results_.size())
-    return NULL;
-  return &last_autocomplete_results_[
-      autocomplete_result_id - last_results_base_];
+bool SearchBox::GetAutocompleteResultWithID(
+    InstantRestrictedID autocomplete_result_id,
+    InstantAutocompleteResult* result) const {
+  return autocomplete_results_cache_.GetItemWithRestrictedID(
+      autocomplete_result_id, result);
 }
 
 const ThemeBackgroundInfo& SearchBox::GetThemeBackgroundInfo() {
   return theme_info_;
 }
 
 bool SearchBox::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SearchBox, message)
     IPC_MESSAGE_HANDLER(ChromeViewMsg_SearchBoxChange, OnChange)
@@ skipping 104 matching lines @@
     bool result = extensions_v8::SearchBoxExtension::PageSupportsInstant(
         render_view()->GetWebView()->mainFrame());
     DVLOG(1) << render_view() << " PageSupportsInstant: " << result;
     render_view()->Send(new ChromeViewHostMsg_InstantSupportDetermined(
         render_view()->GetRoutingID(), render_view()->GetPageId(), result));
   }
 }
 
 void SearchBox::OnAutocompleteResults(
     const std::vector<InstantAutocompleteResult>& results) {
-  results_base_ += autocomplete_results_.size();
-  autocomplete_results_ = results;
+  autocomplete_results_cache_.AddItems(results);
   if (render_view()->GetWebView() && render_view()->GetWebView()->mainFrame()) {
     DVLOG(1) << render_view() << " OnAutocompleteResults";
     extensions_v8::SearchBoxExtension::DispatchAutocompleteResults(
         render_view()->GetWebView()->mainFrame());
   }
 }
 
 void SearchBox::OnUpOrDownKeyPressed(int count) {
   if (render_view()->GetWebView() && render_view()->GetWebView()->mainFrame()) {
     DVLOG(1) << render_view() << " OnKeyPress: " << count;
@@ skipping 69 matching lines @@
       return zoom;
   }
   return 1.0;
 }
 
 void SearchBox::Reset() {
   query_.clear();
   verbatim_ = false;
   selection_start_ = 0;
   selection_end_ = 0;
-  results_base_ = 0;
   popup_bounds_ = gfx::Rect();
   start_margin_ = 0;
-  autocomplete_results_.clear();
   is_key_capture_enabled_ = false;
   theme_info_ = ThemeBackgroundInfo();
   // Don't reset display_instant_results_ to prevent clearing it on committed
   // results pages in extended mode. Otherwise resetting it is a no-op because
   // a new loader is created when it changes; see crbug.com/164662.
   // Also don't reset omnibox_font_ or omnibox_font_size_ since it never
   // changes.
 }
 
 void SearchBox::OnMostVisitedChanged(
-    const std::vector<InstantMostVisitedItem>& items) {
-  most_visited_items_ = items;
+    const std::vector<InstantMostVisitedItemIDPair>& items) {
+  most_visited_items_cache_.AddItemsWithRestrictedID(items);
 
   if (render_view()->GetWebView() && render_view()->GetWebView()->mainFrame()) {
     extensions_v8::SearchBoxExtension::DispatchMostVisitedChanged(
         render_view()->GetWebView()->mainFrame());
   }
 }
 
-const std::vector<InstantMostVisitedItem>&
-SearchBox::GetMostVisitedItems() const {
-  return most_visited_items_;
+void SearchBox::GetMostVisitedItems(
+    std::vector<InstantMostVisitedItemIDPair>* items) const {
+  return most_visited_items_cache_.GetCurrentItems(items);
 }
+
+bool SearchBox::GetMostVisitedItemWithID(
+    InstantRestrictedID most_visited_item_id,
+    InstantMostVisitedItem* item) const {
+  return most_visited_items_cache_.GetItemWithRestrictedID(most_visited_item_id,
+                                                           item);
+}