GTK: Query TopSites for the Most Visited pages and populate fill in the global History menu.

chrome/browser/ui/gtk/global_history_menu.cc

 // Copyright (c) 2011 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/gtk/global_history_menu.h"
 
 #include <gtk/gtk.h>
 
 #include "base/stl_util-inl.h"
+#include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
-#include "base/string_number_conversions.h"
 #include "chrome/browser/favicon/favicon_service.h"
+#include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tab_restore_service_delegate.h"
 #include "chrome/browser/ui/gtk/global_menu_bar.h"
 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/gtk/owned_widget_gtk.h"
 #include "chrome/common/url_constants.h"
 #include "content/common/notification_service.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/text/text_elider.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/gtk_util.h"
 
 namespace {
 
+// The maximum number of most visited items to display.
+const unsigned int kMostVisitedCount = 12;
+
 // The number of recently closed items to get.
 const unsigned int kRecentlyClosedCount = 10;
 
 // Menus more than this many chars long will get trimmed.
 const int kMaximumMenuWidthInChars = 50;
 
 }  // namespace
 
 struct GlobalHistoryMenu::ClearMenuClosure {
   GtkWidget* container;
@@ skipping 46 matching lines @@
   // the vector will be empty.
   std::vector<HistoryItem*> tabs;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HistoryItem);
 };
 
 GlobalHistoryMenu::GlobalHistoryMenu(Browser* browser)
     : browser_(browser),
       profile_(browser_->profile()),
+      top_sites_(NULL),
       default_favicon_(NULL),
       tab_restore_service_(NULL) {
 }
 
 GlobalHistoryMenu::~GlobalHistoryMenu() {
   if (tab_restore_service_)
     tab_restore_service_->RemoveObserver(this);
 
   STLDeleteContainerPairSecondPointers(menu_item_history_map_.begin(),
                                        menu_item_history_map_.end());
   menu_item_history_map_.clear();
 }
 
 void GlobalHistoryMenu::Init(GtkWidget* history_menu) {
   history_menu_ = history_menu;
 
   default_favicon_ = GtkThemeService::GetDefaultFavicon(true);
 
   if (profile_) {
+    top_sites_ = profile_->GetTopSites();
+    if (top_sites_) {
+      GetTopSitesData();
+
+      // Register for notification when TopSites changes so that we can update
+      // ourself.
+      registrar_.Add(this, NotificationType::TOP_SITES_CHANGED,
+                     Source<history::TopSites>(top_sites_));
+    }
+
     tab_restore_service_ = TabRestoreServiceFactory::GetForProfile(profile_);
     if (tab_restore_service_) {
       tab_restore_service_->LoadTabsFromLastSession();
       tab_restore_service_->AddObserver(this);
 
       // If LoadTabsFromLastSession doesn't load tabs, it won't call
       // TabRestoreServiceChanged(). This ensures that all new windows after
       // the first one will have their menus populated correctly.
       TabRestoreServiceChanged(tab_restore_service_);
     }
 
     registrar_.Add(this, NotificationType::BROWSER_THEME_CHANGED,
                    Source<Profile>(profile_));
   }
 }
 
+void GlobalHistoryMenu::GetTopSitesData() {
+  DCHECK(top_sites_);
+
+  top_sites_->GetMostVisitedURLs(
+      &top_sites_consumer_,
+      NewCallback(this, &GlobalHistoryMenu::OnTopSitesReceived));
+}
+
+void GlobalHistoryMenu::OnTopSitesReceived(
+    const history::MostVisitedURLList& visited_list) {
+  ClearMenuSection(history_menu_, GlobalMenuBar::TAG_MOST_VISITED);
+
+  int index = GetIndexOfMenuItemWithTag(
+      history_menu_,
+      GlobalMenuBar::TAG_MOST_VISITED_HEADER) + 1;
+
+  unsigned int added_count = 0;
+  for (size_t i = 0;
+       i < visited_list.size() && added_count < kMostVisitedCount; ++i) {
+    const history::MostVisitedURL& visited = visited_list[i];
+    if (visited.url.spec().empty())
+      break;  // This is the signal that there are no more real visited sites.
+
+    HistoryItem* item = new HistoryItem();
+    item->title = visited.title;
+    item->url = visited.url;
+
+    // The TopSites system doesn't give us icons; it gives us chrome:// urls to
+    // icons so fetch the icons normally.
+    GetFaviconForHistoryItem(item);
+
+    AddHistoryItemToMenu(item,
+                         history_menu_,
+                         GlobalMenuBar::TAG_MOST_VISITED,
+                         index++);
+    added_count++;

[Evan Stade, 2011/04/28 23:19:35]

isn't added_count the same as i?

[Elliot Glaysher, 2011/04/28 23:25:13]

The thought process was: ooh, I do this later on in the file, just copy the
counting logic. Yes and fixed.

+  }
+}
+
 GlobalHistoryMenu::HistoryItem* GlobalHistoryMenu::HistoryItemForMenuItem(
     GtkWidget* menu_item) {
   MenuItemToHistoryMap::iterator it = menu_item_history_map_.find(menu_item);
   return it != menu_item_history_map_.end() ? it->second : NULL;
 }
 
 bool GlobalHistoryMenu::HasValidHistoryItemForTab(
     const TabRestoreService::Tab& entry) {
   if (entry.navigations.empty())
     return false;
@@ skipping 168 matching lines @@
     if (submenu)
       closure->menu_bar->ClearMenuSection(submenu, closure->tag);
 
     gtk_container_remove(GTK_CONTAINER(closure->container), menu_item);
   }
 }
 
 void GlobalHistoryMenu::Observe(NotificationType type,
                                 const NotificationSource& source,
                                 const NotificationDetails& details) {
-  DCHECK(type.value == NotificationType::BROWSER_THEME_CHANGED);
-
-  // Keeping track of which menu items have the default icon is going an
-  // error-prone pain, so instead just store the new default favicon and
-  // we'll update on the next menu change event.
-  default_favicon_ = GtkThemeService::GetDefaultFavicon(true);
+  if (type.value == NotificationType::BROWSER_THEME_CHANGED) {
+    // Keeping track of which menu items have the default icon is going an
+    // error-prone pain, so instead just store the new default favicon and
+    // we'll update on the next menu change event.
+    default_favicon_ = GtkThemeService::GetDefaultFavicon(true);
+  } else if (type.value == NotificationType::TOP_SITES_CHANGED) {
+    GetTopSitesData();
+  } else {
+    NOTREACHED();
+  }
 }
 
 void GlobalHistoryMenu::TabRestoreServiceChanged(TabRestoreService* service) {
   const TabRestoreService::Entries& entries = service->entries();
 
   ClearMenuSection(history_menu_, GlobalMenuBar::TAG_RECENTLY_CLOSED);
 
   // We'll get the index the "Recently Closed" header. (This can vary depending
   // on the number of "Most Visited" items.
   int index = GetIndexOfMenuItemWithTag(
@@ skipping 119 matching lines @@
       TabRestoreServiceFactory::GetForProfile(browser_->profile());
   if (item->session_id && service) {
     service->RestoreEntryById(browser_->tab_restore_service_delegate(),
                               item->session_id, false);
   } else {
     DCHECK(item->url.is_valid());
     browser_->OpenURL(item->url, GURL(), disposition,
                       PageTransition::AUTO_BOOKMARK);
   }
 }