GTK: Add Recently Closed tabs to the History menu in the global menu bar.

chrome/browser/ui/gtk/global_menu_bar.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_menu_bar.h"
 
 #include <gtk/gtk.h>
 
+#include "base/utf_string_conversions.h"
+#include "base/stl_util-inl.h"
+#include "base/string_number_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
+#include "chrome/browser/favicon_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_tab_restore_service_delegate.h"
 #include "chrome/browser/ui/gtk/accelerators_gtk.h"
+#include "chrome/browser/ui/gtk/gtk_util.h"
+#include "chrome/browser/ui/gtk/gtk_theme_service.h"
+#include "chrome/browser/ui/gtk/owned_widget_gtk.h"
 #include "chrome/common/pref_names.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"
 
 struct GlobalMenuBarCommand {
   int str_id;
   int command;
+  int tag;
+};
+
+struct GlobalMenuBar::ClearMenuClosure {
+  GtkWidget* container;
+  GlobalMenuBar* menu_bar;
+  int tag;
+};
+
+struct GlobalMenuBar::GetIndexClosure {
+  bool found;
+  int current_index;
+  int tag;
 };
 
 namespace {
 
 const int MENU_SEPARATOR =-1;
 const int MENU_END = -2;
+const int MENU_DISABLED_LABEL = -3;
+
+const int TAG_NORMAL = 0;
+const int TAG_MOST_VISITED = 1;
+const int TAG_RECENTLY_CLOSED = 2;
+const int TAG_MOST_VISITED_HEADER = 3;
+const int TAG_RECENTLY_CLOSED_HEADER = 4;
+
+// 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;
 
 GlobalMenuBarCommand file_menu[] = {
   { IDS_NEW_TAB, IDC_NEW_TAB },
   { IDS_NEW_WINDOW, IDC_NEW_WINDOW },
   { IDS_NEW_INCOGNITO_WINDOW, IDC_NEW_INCOGNITO_WINDOW },
   { IDS_REOPEN_CLOSED_TABS_LINUX, IDC_RESTORE_TAB },
   { IDS_OPEN_FILE_LINUX, IDC_OPEN_FILE },
   { IDS_OPEN_LOCATION_LINUX, IDC_FOCUS_LOCATION },
 
   { MENU_SEPARATOR, MENU_SEPARATOR },
@@ skipping 53 matching lines @@
   { MENU_SEPARATOR, MENU_SEPARATOR },
 
   { IDS_FULLSCREEN, IDC_FULLSCREEN },
   { IDS_TEXT_DEFAULT_LINUX, IDC_ZOOM_NORMAL },
   { IDS_TEXT_BIGGER_LINUX, IDC_ZOOM_PLUS },
   { IDS_TEXT_SMALLER_LINUX, IDC_ZOOM_MINUS },
 
   { MENU_END, MENU_END }
 };
 
+GlobalMenuBarCommand history_menu[] = {
+  { IDS_HISTORY_HOME_LINUX, IDC_HOME },
+  { IDS_HISTORY_BACK_LINUX, IDC_BACK },
+  { IDS_HISTORY_FORWARD_LINUX, IDC_FORWARD },
+
+  { MENU_SEPARATOR, MENU_SEPARATOR },
+
+  { IDS_HISTORY_VISITED_LINUX, MENU_DISABLED_LABEL, TAG_MOST_VISITED_HEADER },
+
+  { MENU_SEPARATOR, MENU_SEPARATOR },
+
+  { IDS_HISTORY_CLOSED_LINUX, MENU_DISABLED_LABEL, TAG_RECENTLY_CLOSED_HEADER },
+
+  { MENU_SEPARATOR, MENU_SEPARATOR },
+
+  { IDS_SHOWFULLHISTORY_LINK, IDC_SHOW_HISTORY },
+
+  { MENU_END, MENU_END }
+};
+
+GlobalMenuBarCommand bookmark_menu[] = {
+  { IDS_BOOKMARK_MANAGER, IDC_SHOW_BOOKMARK_MANAGER },
+  { IDS_BOOKMARK_CURRENT_PAGE_LINUX, IDC_BOOKMARK_PAGE },
+  { IDS_BOOKMARK_ALL_TABS_LINUX, IDC_BOOKMARK_ALL_TABS },
+
+  { MENU_SEPARATOR, MENU_SEPARATOR },
+  // TODO(erg): Real implementation of bookmark bar bookmarks!
+  { MENU_SEPARATOR, MENU_SEPARATOR },
+
+  { IDS_BOOMARK_BAR_OPEN_ALL, IDC_BOOKMARK_BAR_OPEN_ALL },
+  { IDS_BOOMARK_BAR_OPEN_ALL_NEW_WINDOW, IDC_BOOKMARK_BAR_OPEN_ALL_NEW_WINDOW },
+  { IDS_BOOMARK_BAR_OPEN_ALL_INCOGNITO, IDC_BOOKMARK_BAR_OPEN_ALL_INCOGNITO },
+
+  { MENU_SEPARATOR, MENU_SEPARATOR },
+  // TODO(erg): "Other bookmarks" bookmarks
+
+  { MENU_END, MENU_END }
+};
+
 GlobalMenuBarCommand tools_menu[] = {
   { IDS_SHOW_DOWNLOADS, IDC_SHOW_DOWNLOADS },
   { IDS_SHOW_HISTORY, IDC_SHOW_HISTORY },
   { IDS_SHOW_EXTENSIONS, IDC_MANAGE_EXTENSIONS },
 
   { MENU_SEPARATOR, MENU_SEPARATOR },
 
   { IDS_TASK_MANAGER, IDC_TASK_MANAGER },
   { IDS_CLEAR_BROWSING_DATA, IDC_CLEAR_BROWSING_DATA },
 
   { MENU_SEPARATOR, MENU_SEPARATOR },
 
   { IDS_VIEW_SOURCE, IDC_VIEW_SOURCE },
   { IDS_DEV_TOOLS, IDC_DEV_TOOLS },
   { IDS_DEV_TOOLS_CONSOLE, IDC_DEV_TOOLS_CONSOLE },
 
   { MENU_END, MENU_END }
 };
 
 GlobalMenuBarCommand help_menu[] = {
   { IDS_FEEDBACK, IDC_FEEDBACK },
   { IDS_HELP_PAGE , IDC_HELP_PAGE },
   { MENU_END, MENU_END }
 };
 
 }  // namespace
 
-GlobalMenuBar::GlobalMenuBar(Browser* browser,
-                             BrowserWindowGtk* window)
+class GlobalMenuBar::HistoryItem {
+ public:
+  HistoryItem()
+      : icon_requested(false),
+        menu_item(NULL),
+        session_id(0) {}
+
+  // The title for the menu item.
+  string16 title;
+  // The URL that will be navigated to if the user selects this item.
+  GURL url;
+
+  // If the icon is being requested from the FaviconService, |icon_requested|
+  // will be true and |icon_handle| will be non-NULL. If this is false, then
+  // |icon_handle| will be NULL.
+  bool icon_requested;
+  // The Handle given to us by the FaviconService for the icon fetch request.
+  FaviconService::Handle icon_handle;
+
+  // The icon as a GtkImage for inclusion in a GtkImageMenuItem.
+  OwnedWidgetGtk icon_image;
+
+  // A pointer to the menu_item. This is a weak reference in the GTK+ version
+  // because the GtkMenu must sink the reference.
+  GtkWidget* menu_item;
+
+  // This ID is unique for a browser session and can be passed to the
+  // TabRestoreService to re-open the closed window or tab that this
+  // references. A non-0 session ID indicates that this is an entry can be
+  // restored that way. Otherwise, the URL will be used to open the item and
+  // this ID will be 0.
+  SessionID::id_type session_id;
+
+  // If the HistoryItem is a window, this will be the vector of tabs. Note
+  // that this is a list of weak references. The |menu_item_map_| is the owner
+  // of all items. If it is not a window, then the entry is a single page and
+  // the vector will be empty.
+  std::vector<HistoryItem*> tabs;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(HistoryItem);
+};
+
+GlobalMenuBar::GlobalMenuBar(Browser* browser)
     : browser_(browser),
-      browser_window_(window),
+      profile_(browser_->profile()),
+      default_favicon_(NULL),
       menu_bar_(gtk_menu_bar_new()),
       dummy_accel_group_(gtk_accel_group_new()),
-      block_activation_(false) {
+      block_activation_(false),
+      history_menu_(NULL),
+      tab_restore_service_(NULL) {
   // The global menu bar should never actually be shown in the app; it should
   // instead remain in our widget hierarchy simply to be noticed by third party
   // components.
-  gtk_widget_set_no_show_all(menu_bar_, TRUE);
+  gtk_widget_set_no_show_all(menu_bar_.get(), TRUE);
 
   // Set a nice name so it shows up in gtkparasite and others.
-  gtk_widget_set_name(menu_bar_, "chrome-hidden-global-menubar");
+  gtk_widget_set_name(menu_bar_.get(), "chrome-hidden-global-menubar");
 
   BuildGtkMenuFrom(IDS_FILE_MENU_LINUX, &id_to_menu_item_, file_menu);
   BuildGtkMenuFrom(IDS_EDIT_MENU_LINUX, &id_to_menu_item_, edit_menu);
   BuildGtkMenuFrom(IDS_VIEW_MENU_LINUX, &id_to_menu_item_, view_menu);
+  history_menu_ = BuildGtkMenuFrom(IDS_HISTORY_MENU_LINUX, &id_to_menu_item_,
+                                   history_menu);
+  BuildGtkMenuFrom(IDS_BOOKMARKS_MENU_LINUX, &id_to_menu_item_, bookmark_menu);
   BuildGtkMenuFrom(IDS_TOOLS_MENU_LINUX, &id_to_menu_item_, tools_menu);
   BuildGtkMenuFrom(IDS_HELP_MENU_LINUX, &id_to_menu_item_, help_menu);
 
-  for (IDMenuItemMap::const_iterator it = id_to_menu_item_.begin();
+  for (CommandIDMenuItemMap::const_iterator it = id_to_menu_item_.begin();
        it != id_to_menu_item_.end(); ++it) {
     // Get the starting enabled state.
     gtk_widget_set_sensitive(
         it->second,
         browser_->command_updater()->IsCommandEnabled(it->first));
 
     // Set the accelerator for each menu item.
     const ui::AcceleratorGtk* accelerator_gtk =
         AcceleratorsGtk::GetInstance()->GetPrimaryAcceleratorForCommand(
             it->first);
     if (accelerator_gtk) {
       gtk_widget_add_accelerator(it->second,
                                  "activate",
                                  dummy_accel_group_,
                                  accelerator_gtk->GetGdkKeyCode(),
                                  accelerator_gtk->gdk_modifier_type(),
                                  GTK_ACCEL_VISIBLE);
     }
 
     browser_->command_updater()->AddCommandObserver(it->first, this);
   }
 
+  default_favicon_ = GtkThemeService::GetDefaultFavicon(true);
+
+  if (profile_) {
+    tab_restore_service_ = profile_->GetTabRestoreService();
+    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_));
+  }
+
   // Listen for bookmark bar visibility changes and set the initial state.
   registrar_.Add(this, NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
                  NotificationService::AllSources());
   Observe(NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED,
           NotificationService::AllSources(),
           NotificationService::NoDetails());
 }
 
 GlobalMenuBar::~GlobalMenuBar() {
-  for (IDMenuItemMap::const_iterator it = id_to_menu_item_.begin();
+  for (CommandIDMenuItemMap::const_iterator it = id_to_menu_item_.begin();
        it != id_to_menu_item_.end(); ++it) {
     browser_->command_updater()->RemoveCommandObserver(it->first, this);
   }
 
+  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();
+
   g_object_unref(dummy_accel_group_);
 }
 
-void GlobalMenuBar::BuildGtkMenuFrom(int menu_str_id,
-                                     std::map<int, GtkWidget*>* id_to_menu_item,
-                                     GlobalMenuBarCommand* commands) {
+GtkWidget* GlobalMenuBar::BuildGtkMenuFrom(
+    int menu_str_id,
+    std::map<int, GtkWidget*>* id_to_menu_item,
+    GlobalMenuBarCommand* commands) {
   GtkWidget* menu = gtk_menu_new();
   for (int i = 0; commands[i].str_id != MENU_END; ++i) {
-    GtkWidget* menu_item = NULL;
-    if (commands[i].str_id == MENU_SEPARATOR) {
-      menu_item = gtk_separator_menu_item_new();
+    GtkWidget* menu_item = BuildMenuItem(
+        commands[i].str_id, commands[i].command, commands[i].tag,
+        id_to_menu_item, menu);
+    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
+  }
+
+  gtk_widget_show(menu);
+
+  GtkWidget* menu_item = gtk_menu_item_new_with_mnemonic(
+      gfx::ConvertAcceleratorsFromWindowsStyle(
+          l10n_util::GetStringUTF8(menu_str_id)).c_str());
+  gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu);
+  gtk_widget_show(menu_item);
+  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar_.get()), menu_item);
+
+  return menu;
+}
+
+GtkWidget* GlobalMenuBar::BuildMenuItem(
+    int string_id,
+    int command_id,
+    int tag_id,
+    std::map<int, GtkWidget*>* id_to_menu_item,
+    GtkWidget* menu_to_add_to) {
+  GtkWidget* menu_item = NULL;
+  if (string_id == MENU_SEPARATOR) {
+    menu_item = gtk_separator_menu_item_new();
+  } else {
+    std::string label =
+        gfx::ConvertAcceleratorsFromWindowsStyle(
+            l10n_util::GetStringUTF8(string_id));
+
+    if (command_id == IDC_SHOW_BOOKMARK_BAR)
+      menu_item = gtk_check_menu_item_new_with_mnemonic(label.c_str());
+    else
+      menu_item = gtk_menu_item_new_with_mnemonic(label.c_str());
+
+    if (tag_id) {
+      g_object_set_data(G_OBJECT(menu_item), "type-tag",
+                        GINT_TO_POINTER(tag_id));
+    }
+
+    if (command_id == MENU_DISABLED_LABEL) {
+      gtk_widget_set_sensitive(menu_item, FALSE);
     } else {
-      int command_id = commands[i].command;
-      std::string label =
-          gfx::ConvertAcceleratorsFromWindowsStyle(
-              l10n_util::GetStringUTF8(commands[i].str_id));
-
-      if (command_id == IDC_SHOW_BOOKMARK_BAR)
-        menu_item = gtk_check_menu_item_new_with_mnemonic(label.c_str());
-      else
-        menu_item = gtk_menu_item_new_with_mnemonic(label.c_str());
-
       id_to_menu_item->insert(std::make_pair(command_id, menu_item));
       g_object_set_data(G_OBJECT(menu_item), "command-id",
                         GINT_TO_POINTER(command_id));
       g_signal_connect(menu_item, "activate",
                        G_CALLBACK(OnItemActivatedThunk), this);
     }
-    gtk_widget_show(menu_item);
-    gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
-  }
-
-  gtk_widget_show(menu);
-
-  GtkWidget* menu_item = gtk_menu_item_new_with_mnemonic(
-      gfx::ConvertAcceleratorsFromWindowsStyle(
-          l10n_util::GetStringUTF8(menu_str_id)).c_str());
-  gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_item), menu);
+  }
   gtk_widget_show(menu_item);
-
-  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar_), menu_item);
+  return menu_item;
+}
+
+GlobalMenuBar::HistoryItem* GlobalMenuBar::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 GlobalMenuBar::HasValidHistoryItemForTab(
+    const TabRestoreService::Tab& entry) {
+  if (entry.navigations.empty())
+    return false;
+
+  const TabNavigation& current_navigation =
+      entry.navigations.at(entry.current_navigation_index);
+  if (current_navigation.virtual_url() == GURL(chrome::kChromeUINewTabURL))
+    return false;
+
+  return true;
+}
+
+GlobalMenuBar::HistoryItem* GlobalMenuBar::HistoryItemForTab(
+    const TabRestoreService::Tab& entry) {
+  if (!HasValidHistoryItemForTab(entry))
+    return NULL;
+
+  const TabNavigation& current_navigation =
+      entry.navigations.at(entry.current_navigation_index);
+  HistoryItem* item = new HistoryItem();
+  item->title = current_navigation.title();
+  item->url = current_navigation.virtual_url();
+  item->session_id = entry.id;
+
+  // Tab navigations don't come with icons, so we always have to request them.
+  GetFaviconForHistoryItem(item);
+
+  return item;
+
+}
+
+GtkWidget* GlobalMenuBar::AddHistoryItemToMenu(HistoryItem* item,
+                                               GtkWidget* menu,
+                                               int tag,
+                                               int index) {
+  string16 title = item->title;
+  std::string url_string = item->url.possibly_invalid_spec();
+
+  if (title.empty())
+    title = UTF8ToUTF16(url_string);
+  ui::ElideString(title, kMaximumMenuWidthInChars, &title);
+
+  GtkWidget* menu_item = gtk_image_menu_item_new_with_label(
+      UTF16ToUTF8(title).c_str());
+  gtk_util::SetAlwaysShowImage(menu_item);
+
+  item->menu_item = menu_item;
+  gtk_widget_show(menu_item);
+  g_object_set_data(G_OBJECT(menu_item), "type-tag", GINT_TO_POINTER(tag));
+  g_signal_connect(menu_item, "activate",
+                   G_CALLBACK(OnRecentlyClosedItemActivatedThunk), this);
+  if (item->icon_image.get()) {
+    gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),
+                                  item->icon_image.get());
+  } else if (!item->tabs.size()) {
+    gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),
+                                  gtk_image_new_from_pixbuf(default_favicon_));
+  }
+
+  std::string tooltip = gtk_util::BuildTooltipTitleFor(item->title, item->url);
+  gtk_widget_set_tooltip_markup(menu_item, tooltip.c_str());
+
+  menu_item_history_map_.insert(std::make_pair(menu_item, item));
+  gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menu_item, index);
+
+  return menu_item;
+}
+
+void GlobalMenuBar::GetFaviconForHistoryItem(HistoryItem* item) {
+  FaviconService* service =
+      profile_->GetFaviconService(Profile::EXPLICIT_ACCESS);
+  FaviconService::Handle handle = service->GetFaviconForURL(
+      item->url,
+      history::FAVICON,
+      &favicon_consumer_,
+      NewCallback(this, &GlobalMenuBar::GotFaviconData));
+  favicon_consumer_.SetClientData(service, handle, item);
+  item->icon_handle = handle;
+  item->icon_requested = true;
+}
+
+void GlobalMenuBar::GotFaviconData(FaviconService::Handle handle,
+                                   history::FaviconData favicon) {
+  HistoryItem* item =
+      favicon_consumer_.GetClientData(
+          profile_->GetFaviconService(Profile::EXPLICIT_ACCESS), handle);
+  DCHECK(item);
+  item->icon_requested = false;
+  item->icon_handle = NULL;
+
+  SkBitmap icon;
+  if (favicon.is_valid() &&
+      gfx::PNGCodec::Decode(favicon.image_data->front(),
+                            favicon.image_data->size(), &icon)) {
+    GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(&icon);
+    if (pixbuf) {
+      item->icon_image.Own(gtk_image_new_from_pixbuf(pixbuf));
+      g_object_unref(pixbuf);
+
+      if (item->menu_item) {
+        gtk_image_menu_item_set_image(
+            GTK_IMAGE_MENU_ITEM(item->menu_item),
+            item->icon_image.get());
+      }
+    }
+  }
+}
+
+void GlobalMenuBar::CancelFaviconRequest(HistoryItem* item) {
+  DCHECK(item);
+  if (item->icon_requested) {
+    FaviconService* service =
+        profile_->GetFaviconService(Profile::EXPLICIT_ACCESS);
+    service->CancelRequest(item->icon_handle);
+    item->icon_requested = false;
+    item->icon_handle = NULL;
+  }
+}
+
+int GlobalMenuBar::GetIndexOfMenuItemWithTag(GtkWidget* menu, int tag_id) {
+  GetIndexClosure closure;
+  closure.found = false;
+  closure.current_index = 0;
+  closure.tag = tag_id;
+
+  gtk_container_foreach(
+      GTK_CONTAINER(menu),
+      reinterpret_cast<void (*)(GtkWidget*, void*)>(GetIndexCallback),
+      &closure);
+
+  return closure.current_index;
+}
+
+void GlobalMenuBar::ClearMenuSection(GtkWidget* menu, int tag) {
+  ClearMenuClosure closure;
+  closure.container = menu;
+  closure.menu_bar = this;
+  closure.tag = tag;
+
+  gtk_container_foreach(
+      GTK_CONTAINER(menu),
+      reinterpret_cast<void (*)(GtkWidget*, void*)>(ClearMenuCallback),
+      &closure);
+}
+
+// static
+void GlobalMenuBar::GetIndexCallback(GtkWidget* menu_item,
+                                     GetIndexClosure* closure) {
+  int tag = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu_item), "type-tag"));
+  if (tag == closure->tag)
+    closure->found = true;
+
+  if (!closure->found)
+    closure->current_index++;
+}
+
+// static
+void GlobalMenuBar::ClearMenuCallback(GtkWidget* menu_item,
+                                      ClearMenuClosure* closure) {
+  DCHECK_NE(closure->tag, 0);
+
+  int tag = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(menu_item), "type-tag"));
+  if (closure->tag == tag) {
+    HistoryItem* item = closure->menu_bar->HistoryItemForMenuItem(menu_item);
+
+    if (item) {
+      closure->menu_bar->CancelFaviconRequest(item);
+      closure->menu_bar->menu_item_history_map_.erase(menu_item);
+      delete item;
+    }
+
+    GtkWidget* submenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(menu_item));
+    if (submenu)
+      closure->menu_bar->ClearMenuSection(submenu, closure->tag);
+
+    gtk_container_remove(GTK_CONTAINER(closure->container), menu_item);
+  }
 }
 
 void GlobalMenuBar::EnabledStateChangedForCommand(int id, bool enabled) {
-  IDMenuItemMap::iterator it = id_to_menu_item_.find(id);
+  CommandIDMenuItemMap::iterator it = id_to_menu_item_.find(id);
   if (it != id_to_menu_item_.end())
     gtk_widget_set_sensitive(it->second, enabled);
 }
 
 void GlobalMenuBar::Observe(NotificationType type,
                             const NotificationSource& source,
                             const NotificationDetails& details) {
-  DCHECK(type.value == NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED);
+  if (type.value == NotificationType::BOOKMARK_BAR_VISIBILITY_PREF_CHANGED) {
+    CommandIDMenuItemMap::iterator it =
+        id_to_menu_item_.find(IDC_SHOW_BOOKMARK_BAR);
+    if (it != id_to_menu_item_.end()) {
+      PrefService* prefs = browser_->profile()->GetPrefs();
 
-  IDMenuItemMap::iterator it = id_to_menu_item_.find(IDC_SHOW_BOOKMARK_BAR);
-  if (it != id_to_menu_item_.end()) {
-    PrefService* prefs = browser_->profile()->GetPrefs();
+      block_activation_ = true;
+      gtk_check_menu_item_set_active(
+          GTK_CHECK_MENU_ITEM(it->second),
+          prefs->GetBoolean(prefs::kShowBookmarkBar));
+      block_activation_ = false;
+    }
+  } else 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 {
+    NOTREACHED();
+  }
+}
 
-    block_activation_ = true;
-    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(it->second),
-                                   prefs->GetBoolean(prefs::kShowBookmarkBar));
-    block_activation_ = false;
+void GlobalMenuBar::TabRestoreServiceChanged(TabRestoreService* service) {
+  const TabRestoreService::Entries& entries = service->entries();
+
+  ClearMenuSection(history_menu_, 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_,
+                                        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);
+      std::vector<TabRestoreService::Tab>& tabs = entry_win->tabs;
+      if (tabs.empty())
+        continue;
+
+      // Check that this window has valid content. Sometimes it is possible for
+      // there to not be any subitems for a given window; if that is the case,
+      // do not add the entry to the main menu.
+      int valid_tab_count = 0;
+      std::vector<TabRestoreService::Tab>::const_iterator it;
+      for (it = tabs.begin(); it != tabs.end(); ++it) {
+        if (HasValidHistoryItemForTab(*it))
+          valid_tab_count++;
+      }
+      if (valid_tab_count == 0)
+        continue;
+
+      // Create the item for the parent/window. Do not set the title yet
+      // because the actual number of items that are in the menu will not be
+      // known until things like the NTP are filtered out, which is done when
+      // the tab items are actually created.
+      HistoryItem* item = new HistoryItem();
+      item->session_id = entry_win->id;
+
+      GtkWidget* submenu = gtk_menu_new();
+
+      GtkWidget* restore_item = gtk_menu_item_new_with_label(
+          l10n_util::GetStringUTF8(
+              IDS_HISTORY_CLOSED_RESTORE_WINDOW_LINUX).c_str());
+      g_object_set_data(G_OBJECT(restore_item), "type-tag",
+                        GINT_TO_POINTER(TAG_RECENTLY_CLOSED));
+      g_signal_connect(restore_item, "activate",
+                       G_CALLBACK(OnRecentlyClosedItemActivatedThunk), this);
+      gtk_widget_show(restore_item);
+
+      // The mac version of this code allows the user to click on the parent
+      // menu item to have the same effect as clicking the restore window
+      // submenu item. GTK+ helpfully activates a menu item when it shows a
+      // submenu so toss that feature out.
+      menu_item_history_map_.insert(std::make_pair(restore_item, item));
+      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), restore_item);
+
+      GtkWidget* separator = gtk_separator_menu_item_new();
+      gtk_widget_show(separator);
+      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), separator);
+
+      // Loop over the window's tabs and add them to the submenu.
+      int subindex = 2;
+      for (it = tabs.begin(); it != tabs.end(); ++it) {
+        TabRestoreService::Tab tab = *it;
+        HistoryItem* tab_item = HistoryItemForTab(tab);
+        if (tab_item) {
+          item->tabs.push_back(tab_item);
+          AddHistoryItemToMenu(tab_item, submenu, TAG_RECENTLY_CLOSED,
+                               subindex++);
+        }
+      }
+
+      // Now that the number of tabs that has been added is known, set the
+      // title of the parent menu item.
+      std::string title =
+          (item->tabs.size() == 1) ?
+          l10n_util::GetStringUTF8(
+              IDS_NEW_TAB_RECENTLY_CLOSED_WINDOW_SINGLE) :
+          l10n_util::GetStringFUTF8(
+              IDS_NEW_TAB_RECENTLY_CLOSED_WINDOW_MULTIPLE,
+              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(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,
+                            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_, TAG_RECENTLY_CLOSED, index++);
+        ++added_count;
+      }
+    }
   }
 }
 
+void GlobalMenuBar::TabRestoreServiceDestroyed(
+    TabRestoreService* service) {
+  // Intentionally left blank. We hold a weak reference to the service.

[Evan Stade, 2011/04/18 18:11:19]

I think observers usually do hold weak refs. The idea is to null out that ref.

+}
+
 void GlobalMenuBar::OnItemActivated(GtkWidget* sender) {
   if (block_activation_)
     return;
 
   int id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(sender), "command-id"));
   browser_->ExecuteCommandIfEnabled(id);
 }
+
+void GlobalMenuBar::OnRecentlyClosedItemActivated(GtkWidget* sender) {
+  WindowOpenDisposition disposition =
+      gtk_util::DispositionForCurrentButtonPressEvent();
+  HistoryItem* item = HistoryItemForMenuItem(sender);
+
+  // If this item can be restored using TabRestoreService, do so. Otherwise,
+  // just load the URL.
+  TabRestoreService* service = browser_->profile()->GetTabRestoreService();
+  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);
+  }
+}