Revert "Revert 85330 - GTK: Bring global menu out of about:flags."

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"
@@ skipping 95 matching lines @@
 
 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;
+void GlobalHistoryMenu::Init(GtkWidget* history_menu,
+                             GtkWidget* history_menu_item) {
+  history_menu_.Own(history_menu);
+
+  // We have to connect to |history_menu_item|'s "activate" signal instead of
+  // |history_menu|'s "show" signal because we are not supposed to modify the
+  // menu during "show"
+  g_signal_connect(history_menu_item, "activate",
+                   G_CALLBACK(OnMenuActivateThunk), this);
 
   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);
+  ClearMenuSection(history_menu_.get(), GlobalMenuBar::TAG_MOST_VISITED);
 
   int index = GetIndexOfMenuItemWithTag(
-      history_menu_,
+      history_menu_.get(),
       GlobalMenuBar::TAG_MOST_VISITED_HEADER) + 1;
 
   for (size_t i = 0; i < visited_list.size() && i < 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.
+    // 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_,
+                         history_menu_.get(),
                          GlobalMenuBar::TAG_MOST_VISITED,
                          index++);
   }
 }
 
 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;
 }
@@ skipping 179 matching lines @@
 
 void GlobalHistoryMenu::Observe(NotificationType type,
                                 const NotificationSource& source,
                                 const NotificationDetails& details) {
   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();
+    if (Source<history::TopSites>(source).ptr() == top_sites_)
+      GetTopSitesData();
   } else {
     NOTREACHED();
   }
 }
 
 void GlobalHistoryMenu::TabRestoreServiceChanged(TabRestoreService* service) {
   const TabRestoreService::Entries& entries = service->entries();
 
-  ClearMenuSection(history_menu_, GlobalMenuBar::TAG_RECENTLY_CLOSED);
+  ClearMenuSection(history_menu_.get(), 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(
-      history_menu_,
+      history_menu_.get(),
       GlobalMenuBar::TAG_RECENTLY_CLOSED_HEADER) + 1;
 
   unsigned int added_count = 0;
   for (TabRestoreService::Entries::const_iterator it = entries.begin();
        it != entries.end() && added_count < kRecentlyClosedCount; ++it) {
     TabRestoreService::Entry* entry = *it;
 
     if (entry->type == TabRestoreService::WINDOW) {
       TabRestoreService::Window* entry_win =
           static_cast<TabRestoreService::Window*>(entry);
@@ skipping 67 matching lines @@
               base::IntToString16(item->tabs.size()));
 
       // Create the menu item parent. Unlike mac, it's can't be activated.
       GtkWidget* parent_item = gtk_image_menu_item_new_with_label(
           title.c_str());
       gtk_widget_show(parent_item);
       g_object_set_data(G_OBJECT(parent_item), "type-tag",
                         GINT_TO_POINTER(GlobalMenuBar::TAG_RECENTLY_CLOSED));
       gtk_menu_item_set_submenu(GTK_MENU_ITEM(parent_item), submenu);
 
-      gtk_menu_shell_insert(GTK_MENU_SHELL(history_menu_), parent_item,
+      gtk_menu_shell_insert(GTK_MENU_SHELL(history_menu_.get()), parent_item,
                             index++);
       ++added_count;
     } else if (entry->type == TabRestoreService::TAB) {
       TabRestoreService::Tab* tab =
           static_cast<TabRestoreService::Tab*>(entry);
       HistoryItem* item = HistoryItemForTab(*tab);
       if (item) {
         AddHistoryItemToMenu(item,
-                             history_menu_,
+                             history_menu_.get(),
                              GlobalMenuBar::TAG_RECENTLY_CLOSED,
                              index++);
         ++added_count;
       }
     }
   }
 }
 
 void GlobalHistoryMenu::TabRestoreServiceDestroyed(
     TabRestoreService* service) {
@@ skipping 11 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);
   }
 }
+
+void GlobalHistoryMenu::OnMenuActivate(GtkWidget* sender) {
+  if (!tab_restore_service_) {
+    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_);
+    }
+  }
+}