Move most visited item state info from InstantController to InstantService.

chrome/browser/ui/search/instant_controller.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/browser/ui/search/instant_controller.h"
 
 #include <iterator>
 
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_provider.h"
 #include "chrome/browser/autocomplete/autocomplete_result.h"
 #include "chrome/browser/autocomplete/search_provider.h"
 #include "chrome/browser/history/history_service.h"
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/history/history_tab_helper.h"
-#include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/search/instant_service.h"
 #include "chrome/browser/search/instant_service_factory.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/ui/browser_instant_controller.h"
 #include "chrome/browser/ui/search/instant_ntp.h"
 #include "chrome/browser/ui/search/instant_overlay.h"
@@ skipping 199 matching lines @@
       active_entry->GetTransitionType(),
       false,
       std::string(),
       contents->GetBrowserContext());
   transient->SetExtraData(sessions::kSearchTermsKey, search_terms);
   controller->SetTransientEntry(transient);
 
   SearchTabHelper::FromWebContents(contents)->NavigationEntryUpdated();
 }
 
-bool GetURLForMostVisitedItemID(Profile* profile,
-                                InstantRestrictedID most_visited_item_id,
-                                GURL* url) {
-  InstantService* instant_service =
-      InstantServiceFactory::GetForProfile(profile);
-  if (!instant_service)
-    return false;
-
-  InstantMostVisitedItem item;
-  if (!instant_service->GetMostVisitedItemForID(most_visited_item_id, &item))
-    return false;
-
-  *url = item.url;
-  return true;
-}
-
 template <typename T>
 void DeletePageSoon(scoped_ptr<T> page) {
   if (page->contents()) {
     base::MessageLoop::current()->DeleteSoon(
         FROM_HERE, page->ReleaseContents().release());
   }
 
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, page.release());
 }
 
 }  // namespace
 
 InstantController::InstantController(BrowserInstantController* browser,
                                      bool extended_enabled)
     : browser_(browser),
       extended_enabled_(extended_enabled),
       instant_enabled_(false),
       use_local_page_only_(true),
       preload_ntp_(true),
       model_(this),
       use_tab_for_suggestions_(false),
       last_omnibox_text_has_inline_autocompletion_(false),
       last_verbatim_(false),
       last_transition_type_(content::PAGE_TRANSITION_LINK),
       last_match_was_search_(false),
       omnibox_focus_state_(OMNIBOX_FOCUS_NONE),
       omnibox_focus_change_reason_(OMNIBOX_FOCUS_CHANGE_EXPLICIT),
       omnibox_bounds_(-1, -1, 0, 0),
-      allow_overlay_to_show_search_suggestions_(false),
-      weak_ptr_factory_(this) {
+      allow_overlay_to_show_search_suggestions_(false) {
 
   // When the InstantController lives, the InstantService should live.
   // InstantService sets up profile-level facilities such as the ThemeSource for
   // the NTP.
   // However, in some tests, browser_ may be null.
   if (browser_)
     InstantServiceFactory::GetForProfile(browser_->profile());
 }
 
 InstantController::~InstantController() {
@@ skipping 823 matching lines @@
       base::Time::Now().ToInternalValue(), info));
   static const size_t kMaxDebugEventSize = 2000;
   if (debug_events_.size() > kMaxDebugEventSize)
     debug_events_.pop_back();
 }
 
 void InstantController::ClearDebugEvents() {
   debug_events_.clear();
 }
 
-void InstantController::DeleteMostVisitedItem(
-    InstantRestrictedID most_visited_item_id) {
-  history::TopSites* top_sites = browser_->profile()->GetTopSites();
-  if (!top_sites)
+void InstantController::UpdateMostVisitedItems() {
+  InstantService* instant_service =
+      InstantServiceFactory::GetForProfile(profile());
+  if (!instant_service)
     return;
 
-  GURL url;
-  if (GetURLForMostVisitedItemID(browser_->profile(),
-                                 most_visited_item_id, &url))
-    top_sites->AddBlacklistedURL(url);
+  std::vector<InstantMostVisitedItemIDPair> items;
+  instant_service->GetCurrentMostVisitedItems(&items);
+
+  if (overlay_)
+    overlay_->SendMostVisitedItems(items);
+  if (ntp_)
+    ntp_->SendMostVisitedItems(items);
+  if (instant_tab_)
+    instant_tab_->SendMostVisitedItems(items);
+
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_INSTANT_SENT_MOST_VISITED_ITEMS,
+      content::Source<InstantController>(this),
+      content::NotificationService::NoDetails());
 }
 
-void InstantController::UndoMostVisitedDeletion(
-    InstantRestrictedID most_visited_item_id) {
-  history::TopSites* top_sites = browser_->profile()->GetTopSites();
-  if (!top_sites)
+void InstantController::DeleteMostVisitedItem(const GURL& url) {
+  DCHECK(!url.is_empty());
+  InstantService* instant_service =
+      InstantServiceFactory::GetForProfile(profile());
+  if (!instant_service)
     return;
 
-  GURL url;
-  if (GetURLForMostVisitedItemID(browser_->profile(),
-                                 most_visited_item_id, &url))
-    top_sites->RemoveBlacklistedURL(url);
+  instant_service->DeleteMostVisitedItem(url);
+}
+
+void InstantController::UndoMostVisitedDeletion(const GURL& url) {
+  DCHECK(!url.is_empty());
+  InstantService* instant_service =
+      InstantServiceFactory::GetForProfile(profile());
+  if (!instant_service)
+    return;
+
+  instant_service->UndoMostVisitedDeletion(url);
 }
 
 void InstantController::UndoAllMostVisitedDeletions() {
-  history::TopSites* top_sites = browser_->profile()->GetTopSites();
-  if (!top_sites)
+  InstantService* instant_service =
+      InstantServiceFactory::GetForProfile(profile());
+  if (!instant_service)
     return;
 
-  top_sites->ClearBlacklistedURLs();
+  instant_service->UndoAllMostVisitedDeletions();
 }
 
 Profile* InstantController::profile() const {
   return browser_->profile();
 }
 
 InstantOverlay* InstantController::overlay() const {
   return overlay_.get();
 }
 
 InstantTab* InstantController::instant_tab() const {
   return instant_tab_.get();
 }
 
 InstantNTP* InstantController::ntp() const {
   return ntp_.get();
 }
 
-void InstantController::Observe(int type,
-                                const content::NotificationSource& source,
-                                const content::NotificationDetails& details) {
-  DCHECK_EQ(type, chrome::NOTIFICATION_TOP_SITES_CHANGED);
-  RequestMostVisitedItems();
-}
-
 // TODO(shishir): We assume that the WebContent's current RenderViewHost is the
 // RenderViewHost being created which is not always true. Fix this.
 void InstantController::InstantPageRenderViewCreated(
     const content::WebContents* contents) {
   if (!extended_enabled())
     return;
 
   // Update theme info so that the page picks it up.
   browser_->UpdateThemeInfo();
 
   // Ensure the searchbox API has the correct initial state.
   if (IsContentsFrom(overlay(), contents)) {
     overlay_->SetDisplayInstantResults(instant_enabled_);
     overlay_->FocusChanged(omnibox_focus_state_, omnibox_focus_change_reason_);
     overlay_->SetOmniboxBounds(omnibox_bounds_);
     overlay_->InitializeFonts();
   } else if (IsContentsFrom(ntp(), contents)) {
     ntp_->SetDisplayInstantResults(instant_enabled_);
     ntp_->SetOmniboxBounds(omnibox_bounds_);
     ntp_->InitializeFonts();
   } else {
     NOTREACHED();
   }
-  StartListeningToMostVisitedChanges();
+  UpdateMostVisitedItems();
 }
 
 void InstantController::InstantSupportDetermined(
     const content::WebContents* contents,
     bool supports_instant) {
   if (IsContentsFrom(instant_tab(), contents)) {
     if (!supports_instant)
       base::MessageLoop::current()->DeleteSoon(FROM_HERE,
                                                instant_tab_.release());
 
@@ skipping 401 matching lines @@
     instant_tab_.reset();
   }
 }
 
 void InstantController::UpdateInfoForInstantTab() {
   if (instant_tab_) {
     browser_->UpdateThemeInfo();
     instant_tab_->SetDisplayInstantResults(instant_enabled_);
     instant_tab_->SetOmniboxBounds(omnibox_bounds_);
     instant_tab_->InitializeFonts();
-    StartListeningToMostVisitedChanges();
+    UpdateMostVisitedItems();
     instant_tab_->FocusChanged(omnibox_focus_state_,
-        omnibox_focus_change_reason_);
+                               omnibox_focus_change_reason_);
   }
 }
 
 void InstantController::HideOverlay() {
   HideInternal();
   ReloadOverlayIfStale();
 }
 
 void InstantController::HideInternal() {
   LOG_INSTANT_DEBUG_EVENT(this, "Hide");
@@ skipping 76 matching lines @@
   // There is no point in sanity-checking |intersection.y()| because the omnibox
   // can be placed anywhere vertically relative to the overlay (for example, in
   // Mac fullscreen mode, the omnibox is fully enclosed by the overlay bounds).
   DCHECK_LE(0, intersection.x());
   DCHECK_LE(0, intersection.width());
   DCHECK_LE(0, intersection.height());
 
   overlay_->SetPopupBounds(intersection);
 }
 
-void InstantController::StartListeningToMostVisitedChanges() {
-  history::TopSites* top_sites = browser_->profile()->GetTopSites();
-  if (top_sites) {
-    if (!registrar_.IsRegistered(
-      this, chrome::NOTIFICATION_TOP_SITES_CHANGED,
-      content::Source<history::TopSites>(top_sites))) {
-      // TopSites updates itself after a delay. This is especially noticable
-      // when your profile is empty. Ask TopSites to update itself when we're
-      // about to show the new tab page.
-      top_sites->SyncWithHistory();
 
-      RequestMostVisitedItems();
-
-      // Register for notification when TopSites changes.
-      registrar_.Add(this, chrome::NOTIFICATION_TOP_SITES_CHANGED,
-                     content::Source<history::TopSites>(top_sites));
-    } else {
-      // We are already registered, so just get and send the most visited data.
-      RequestMostVisitedItems();
-    }
-  }
-}
-
-void InstantController::RequestMostVisitedItems() {
-  history::TopSites* top_sites = browser_->profile()->GetTopSites();
-  if (top_sites) {
-    top_sites->GetMostVisitedURLs(
-        base::Bind(&InstantController::OnMostVisitedItemsReceived,
-                   weak_ptr_factory_.GetWeakPtr()));
-  }
-}
-
-void InstantController::OnMostVisitedItemsReceived(
-    const history::MostVisitedURLList& data) {
-  InstantService* instant_service =
-      InstantServiceFactory::GetForProfile(browser_->profile());
-  if (!instant_service)
-    return;
-
-  history::MostVisitedURLList reordered_data(data);
-  history::TopSites::MaybeShuffle(&reordered_data);
-
-  std::vector<InstantMostVisitedItem> most_visited_items;
-  for (size_t i = 0; i < reordered_data.size(); i++) {
-    const history::MostVisitedURL& url = reordered_data[i];
-    InstantMostVisitedItem item;
-    item.url = url.url;
-    item.title = url.title;
-    most_visited_items.push_back(item);
-  }
-
-  instant_service->AddMostVisitedItems(most_visited_items);
-
-  std::vector<InstantMostVisitedItemIDPair> items_with_ids;
-  instant_service->GetCurrentMostVisitedItems(&items_with_ids);
-  SendMostVisitedItems(items_with_ids);
-}
-
-void InstantController::SendMostVisitedItems(
-    const std::vector<InstantMostVisitedItemIDPair>& items) {
-  if (overlay_)
-    overlay_->SendMostVisitedItems(items);
-  if (ntp_)
-    ntp_->SendMostVisitedItems(items);
-  if (instant_tab_)
-    instant_tab_->SendMostVisitedItems(items);
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_INSTANT_SENT_MOST_VISITED_ITEMS,
-      content::Source<InstantController>(this),
-      content::NotificationService::NoDetails());
-}
 
 bool InstantController::FixSuggestion(InstantSuggestion* suggestion) const {
   // We only accept suggestions if the user has typed text. If the user is
   // arrowing up/down (|last_user_text_| is empty), we reject suggestions.
   if (last_user_text_.empty())
     return false;
 
   // If the page is trying to set inline autocompletion in verbatim mode,
   // instead try suggesting the exact omnibox text. This makes the omnibox
   // interpret user text as an URL if possible while preventing unwanted
@@ skipping 81 matching lines @@
   result->transition = match.transition;
   result->relevance = match.relevance;
   result->autocomplete_match_index = autocomplete_match_index;
 
   DVLOG(1) << "    " << result->relevance << " "
       << UTF8ToUTF16(AutocompleteMatchType::ToString(result->type)) << " "
       << result->provider << " " << result->destination_url << " '"
       << result->description << "' '" << result->search_query << "' "
       << result->transition <<  " " << result->autocomplete_match_index;
 }