linux_aura: Implement the dynamic History menu in the dbusmenu.

chrome/browser/ui/views/frame/global_menu_bar_x11.cc

 // Copyright 2013 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/views/frame/global_menu_bar_x11.h"
 
 #include <dlfcn.h>
 #include <glib-object.h>
 
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
+#include "base/stl_util.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
+#include "chrome/browser/chrome_notification_types.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_commands.h"
+#include "chrome/browser/ui/browser_tab_restore_service_delegate.h"
 #include "chrome/browser/ui/views/frame/browser_desktop_root_window_host_x11.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/frame/global_menu_bar_registrar_x11.h"
 #include "chrome/common/pref_names.h"
+#include "content/public/browser/notification_source.h"
 #include "grit/generated_resources.h"
 #include "ui/base/accelerators/menu_label_accelerator_util_linux.h"
 #include "ui/base/keycodes/keyboard_code_conversion_x.h"
 #include "ui/base/l10n/l10n_util.h"
+#include "ui/base/text/text_elider.h"
 
 // libdbusmenu-glib types
 typedef struct _DbusmenuMenuitem DbusmenuMenuitem;
 typedef DbusmenuMenuitem* (*dbusmenu_menuitem_new_func)();
 typedef DbusmenuMenuitem* (*dbusmenu_menuitem_new_with_id_func)(int id);
-
-typedef int (*dbusmenu_menuitem_get_id_func)(DbusmenuMenuitem* item);
+typedef bool (*dbusmenu_menuitem_child_add_position_func)(
+    DbusmenuMenuitem* parent,
+    DbusmenuMenuitem* child,
+    unsigned int position);
 typedef DbusmenuMenuitem* (*dbusmenu_menuitem_child_append_func)(
     DbusmenuMenuitem* parent,
     DbusmenuMenuitem* child);
+typedef bool (*dbusmenu_menuitem_child_delete_func)(
+    DbusmenuMenuitem* parent,
+    DbusmenuMenuitem* child);
+typedef void (*dbusmenu_menuitem_foreach_func)(
+    DbusmenuMenuitem* mi,
+    void (*func)(DbusmenuMenuitem* mi, void* data),
+    void* data);
+typedef GList* (*dbusmenu_menuitem_get_children_func)(
+    DbusmenuMenuitem* item);
+typedef int (*dbusmenu_menuitem_get_id_func)(DbusmenuMenuitem* item);
+typedef DbusmenuMenuitem* (*dbusmenu_menuitem_get_parent_func)(
+    DbusmenuMenuitem* item);
 typedef DbusmenuMenuitem* (*dbusmenu_menuitem_property_set_func)(
     DbusmenuMenuitem* item,
     const char* property,
     const char* value);
 typedef DbusmenuMenuitem* (*dbusmenu_menuitem_property_set_variant_func)(
     DbusmenuMenuitem* item,
     const char* property,
     GVariant* value);
 typedef DbusmenuMenuitem* (*dbusmenu_menuitem_property_set_bool_func)(
     DbusmenuMenuitem* item,
@@ skipping 16 matching lines @@
   int tag;
 };
 
 namespace {
 
 // Retrieved functions from libdbusmenu-glib.
 
 // DbusmenuMenuItem methods:
 dbusmenu_menuitem_new_func menuitem_new = NULL;
 dbusmenu_menuitem_new_with_id_func menuitem_new_with_id = NULL;
+dbusmenu_menuitem_foreach_func menuitem_foreach = NULL;
+dbusmenu_menuitem_get_children_func menuitem_get_children = NULL;
 dbusmenu_menuitem_get_id_func menuitem_get_id = NULL;
+dbusmenu_menuitem_get_parent_func menuitem_get_parent = NULL;
+dbusmenu_menuitem_child_add_position_func menuitem_child_add_position = NULL;
 dbusmenu_menuitem_child_append_func menuitem_child_append = NULL;
+dbusmenu_menuitem_child_delete_func menuitem_child_delete = NULL;
 dbusmenu_menuitem_property_set_func menuitem_property_set = NULL;
 dbusmenu_menuitem_property_set_variant_func menuitem_property_set_variant =
     NULL;
 dbusmenu_menuitem_property_set_bool_func menuitem_property_set_bool = NULL;
 dbusmenu_menuitem_property_set_int_func menuitem_property_set_int = NULL;
 
 // DbusmenuServer methods:
 dbusmenu_server_new_func server_new = NULL;
 dbusmenu_server_set_root_func server_set_root = NULL;
 
 // Properties that we set on menu items:
 const char kPropertyEnabled[] = "enabled";
 const char kPropertyLabel[] = "label";
 const char kPropertyShortcut[] = "shortcut";
 const char kPropertyType[] = "type";
 const char kPropertyToggleType[] = "toggle-type";
 const char kPropertyToggleState[] = "toggle-state";
 const char kPropertyVisible[] = "visible";
 
 const char kTypeCheckmark[] = "checkmark";
 const char kTypeSeparator[] = "separator";
 
+// The maximum number of most visited items to display.
+const unsigned int kMostVisitedCount = 8;
+
+// The number of recently closed items to get.
+const unsigned int kRecentlyClosedCount = 8;
+
+// Menus more than this many chars long will get trimmed.
+const int kMaximumMenuWidthInChars = 50;
+
 // Constants used in menu definitions
 const int MENU_SEPARATOR =-1;
 const int MENU_END = -2;
 const int MENU_DISABLED_LABEL = -3;
 
 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 },
@@ skipping 26 matching lines @@
 
   { IDS_FIND, IDC_FIND },
 
   { MENU_SEPARATOR, MENU_SEPARATOR },
 
   { IDS_PREFERENCES, IDC_OPTIONS },
 
   { MENU_END, MENU_END }
 };
 
-
 GlobalMenuBarCommand view_menu[] = {
   { IDS_SHOW_BOOKMARK_BAR, IDC_SHOW_BOOKMARK_BAR },
 
   { MENU_SEPARATOR, MENU_SEPARATOR },
 
   { IDS_STOP_MENU_LINUX, IDC_STOP },
   { IDS_RELOAD_MENU_LINUX, IDC_RELOAD },
 
   { 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 }
 };
 
-// TODO(erg): History menu.
+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,
+    GlobalMenuBarX11::TAG_MOST_VISITED_HEADER },
+
+  { MENU_SEPARATOR, MENU_SEPARATOR },
+
+  { IDS_HISTORY_CLOSED_LINUX, MENU_DISABLED_LABEL,
+    GlobalMenuBarX11::TAG_RECENTLY_CLOSED_HEADER },
+
+  { MENU_SEPARATOR, MENU_SEPARATOR },
+
+  { IDS_SHOWFULLHISTORY_LINK, IDC_SHOW_HISTORY },
+
+  { 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 },
@@ skipping 24 matching lines @@
   if (!dbusmenu_lib)
     return;
 
   // DbusmenuMenuItem methods.
   menuitem_new = reinterpret_cast<dbusmenu_menuitem_new_func>(
       dlsym(dbusmenu_lib, "dbusmenu_menuitem_new"));
   menuitem_new_with_id = reinterpret_cast<dbusmenu_menuitem_new_with_id_func>(
       dlsym(dbusmenu_lib, "dbusmenu_menuitem_new_with_id"));
   menuitem_get_id = reinterpret_cast<dbusmenu_menuitem_get_id_func>(
       dlsym(dbusmenu_lib, "dbusmenu_menuitem_get_id"));
+  menuitem_child_add_position =
+      reinterpret_cast<dbusmenu_menuitem_child_add_position_func>(
+          dlsym(dbusmenu_lib, "dbusmenu_menuitem_child_add_position"));
   menuitem_child_append = reinterpret_cast<dbusmenu_menuitem_child_append_func>(
       dlsym(dbusmenu_lib, "dbusmenu_menuitem_child_append"));
+  menuitem_child_delete = reinterpret_cast<dbusmenu_menuitem_child_delete_func>(
+      dlsym(dbusmenu_lib, "dbusmenu_menuitem_child_delete"));
+  menuitem_foreach = reinterpret_cast<dbusmenu_menuitem_foreach_func>(
+      dlsym(dbusmenu_lib, "dbusmenu_menuitem_foreach"));
+  menuitem_get_children = reinterpret_cast<dbusmenu_menuitem_get_children_func>(
+      dlsym(dbusmenu_lib, "dbusmenu_menuitem_get_children"));
+  menuitem_get_parent = reinterpret_cast<dbusmenu_menuitem_get_parent_func>(
+      dlsym(dbusmenu_lib, "dbusmenu_menuitem_get_parent"));
   menuitem_property_set = reinterpret_cast<dbusmenu_menuitem_property_set_func>(
       dlsym(dbusmenu_lib, "dbusmenu_menuitem_property_set"));
   menuitem_property_set_variant =
       reinterpret_cast<dbusmenu_menuitem_property_set_variant_func>(
           dlsym(dbusmenu_lib, "dbusmenu_menuitem_property_set_variant"));
   menuitem_property_set_bool =
       reinterpret_cast<dbusmenu_menuitem_property_set_bool_func>(
           dlsym(dbusmenu_lib, "dbusmenu_menuitem_property_set_bool"));
   menuitem_property_set_int =
       reinterpret_cast<dbusmenu_menuitem_property_set_int_func>(
           dlsym(dbusmenu_lib, "dbusmenu_menuitem_property_set_int"));
 
   // DbusmenuServer methods.
   server_new = reinterpret_cast<dbusmenu_server_new_func>(
       dlsym(dbusmenu_lib, "dbusmenu_server_new"));
   server_set_root = reinterpret_cast<dbusmenu_server_set_root_func>(
       dlsym(dbusmenu_lib, "dbusmenu_server_set_root"));
 }
 
 }  // namespace
 
+struct GlobalMenuBarX11::ClearMenuClosure {
+  DbusmenuMenuitem* parent_menu;
+  GlobalMenuBarX11* menu_bar;
+  int tag;
+};
+
+class GlobalMenuBarX11::HistoryItem {
+ public:
+  HistoryItem() : 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;
+
+  // 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);
+};
+
 GlobalMenuBarX11::GlobalMenuBarX11(BrowserView* browser_view,
                                    BrowserDesktopRootWindowHostX11* host)
     : browser_(browser_view->browser()),
+      profile_(browser_->profile()),
       browser_view_(browser_view),
       host_(host),
       server_(NULL),
-      root_item_(NULL) {
+      root_item_(NULL),
+      history_menu_(NULL),
+      top_sites_(NULL),
+      weak_ptr_factory_(this),
+      tab_restore_service_(NULL) {
   EnsureMethodsLoaded();
 
   if (server_new)
     host_->AddObserver(this);
 }
 
 GlobalMenuBarX11::~GlobalMenuBarX11() {
   if (server_) {
     Disable();
+
+    if (tab_restore_service_)
+      tab_restore_service_->RemoveObserver(this);
+
+#ifndef NDEBUG
+    // In debug mode, do the slower cleanup of every HistoryItem that we know
+    // about just to assert that we didn't leak any of them during normal
+    // running.
+    ClearMenuSection(history_menu_, GlobalMenuBarX11::TAG_RECENTLY_CLOSED);
+    ClearMenuSection(history_menu_, GlobalMenuBarX11::TAG_MOST_VISITED);
+    DCHECK(menu_item_history_map_.empty());
+#endif  // NDEBUG
+
+    STLDeleteContainerPairSecondPointers(menu_item_history_map_.begin(),
+                                         menu_item_history_map_.end());
+    menu_item_history_map_.clear();
+
     g_object_unref(server_);
     host_->RemoveObserver(this);
   }
 }
 
 // static
 std::string GlobalMenuBarX11::GetPathForWindow(unsigned long xid) {
   return base::StringPrintf("/com/canonical/menu/%lX", xid);
 }
 
+DbusmenuMenuitem* GlobalMenuBarX11::BuildSeparator() {
+  DbusmenuMenuitem* item = menuitem_new();
+  menuitem_property_set(item, kPropertyType, kTypeSeparator);
+  menuitem_property_set_bool(item, kPropertyVisible, true);
+  return item;
+}
+
+DbusmenuMenuitem* GlobalMenuBarX11::BuildMenuItem(
+    const std::string& label,
+    int tag_id) {
+  DbusmenuMenuitem* item = menuitem_new();
+  menuitem_property_set(item, kPropertyLabel, label.c_str());
+  menuitem_property_set_bool(item, kPropertyVisible, true);
+
+  if (tag_id)
+    g_object_set_data(G_OBJECT(item), "type-tag", GINT_TO_POINTER(tag_id));
+
+  return item;
+}
+
 void GlobalMenuBarX11::InitServer(unsigned long xid) {
   std::string path = GetPathForWindow(xid);
   server_ = server_new(path.c_str());
 
   root_item_ = menuitem_new();
   menuitem_property_set(root_item_, kPropertyLabel, "Root");
   menuitem_property_set_bool(root_item_, kPropertyVisible, true);
 
-  BuildMenuFrom(root_item_, IDS_FILE_MENU_LINUX, &id_to_menu_item_, file_menu);
-  BuildMenuFrom(root_item_, IDS_EDIT_MENU_LINUX, &id_to_menu_item_, edit_menu);
-  BuildMenuFrom(root_item_, IDS_VIEW_MENU_LINUX, &id_to_menu_item_, view_menu);
-  // TODO(erg): History menu.
-  BuildMenuFrom(root_item_, IDS_TOOLS_MENU_LINUX, &id_to_menu_item_,
-                tools_menu);
-  BuildMenuFrom(root_item_, IDS_HELP_MENU_LINUX, &id_to_menu_item_, help_menu);
+  // First build static menu content.
+  BuildStaticMenu(root_item_, IDS_FILE_MENU_LINUX, file_menu);
+  BuildStaticMenu(root_item_, IDS_EDIT_MENU_LINUX, edit_menu);
+  BuildStaticMenu(root_item_, IDS_VIEW_MENU_LINUX, view_menu);
+  history_menu_ = BuildStaticMenu(
+      root_item_, IDS_HISTORY_MENU_LINUX, history_menu);
+  BuildStaticMenu(root_item_, IDS_TOOLS_MENU_LINUX, tools_menu);
+  BuildStaticMenu(root_item_, IDS_HELP_MENU_LINUX, help_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_, "about-to-show",
+                   G_CALLBACK(OnHistoryMenuAboutToShowThunk), this);
 
   for (CommandIDMenuItemMap::const_iterator it = id_to_menu_item_.begin();
        it != id_to_menu_item_.end(); ++it) {
     menuitem_property_set_bool(it->second, kPropertyEnabled,
                                chrome::IsCommandEnabled(browser_, it->first));
 
     ui::Accelerator accelerator;
     if (browser_view_->GetAccelerator(it->first, &accelerator))
       RegisterAccelerator(it->second, accelerator);
 
     chrome::AddCommandObserver(browser_, it->first, this);
   }
 
   pref_change_registrar_.Init(browser_->profile()->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kShowBookmarkBar,
       base::Bind(&GlobalMenuBarX11::OnBookmarkBarVisibilityChanged,
                  base::Unretained(this)));
   OnBookmarkBarVisibilityChanged();
 
+  top_sites_ = profile_->GetTopSites();
+  if (top_sites_) {
+    GetTopSitesData();
+
+    // Register for notification when TopSites changes so that we can update
+    // ourself.
+    registrar_.Add(this, chrome::NOTIFICATION_TOP_SITES_CHANGED,
+                   content::Source<history::TopSites>(top_sites_));
+  }
+
   server_set_root(server_, root_item_);
 }
 
 void GlobalMenuBarX11::Disable() {
   for (CommandIDMenuItemMap::const_iterator it = id_to_menu_item_.begin();
        it != id_to_menu_item_.end(); ++it) {
     chrome::RemoveCommandObserver(browser_, it->first, this);
   }
   id_to_menu_item_.clear();
 
   pref_change_registrar_.RemoveAll();
 }
 
-void GlobalMenuBarX11::BuildMenuFrom(
+DbusmenuMenuitem* GlobalMenuBarX11::BuildStaticMenu(
     DbusmenuMenuitem* parent,
     int menu_str_id,
-    std::map<int, DbusmenuMenuitem*>* id_to_menu_item,
     GlobalMenuBarCommand* commands) {
   DbusmenuMenuitem* top = menuitem_new();
   menuitem_property_set(
       top, kPropertyLabel,
       ui::RemoveWindowsStyleAccelerators(
           l10n_util::GetStringUTF8(menu_str_id)).c_str());
   menuitem_property_set_bool(top, kPropertyVisible, true);
 
   for (int i = 0; commands[i].str_id != MENU_END; ++i) {
-    DbusmenuMenuitem* menu_item = BuildMenuItem(
-        commands[i].str_id, commands[i].command, commands[i].tag,
-        id_to_menu_item);
+    DbusmenuMenuitem* menu_item = NULL;
+    int command_id = commands[i].command;
+    if (commands[i].str_id == MENU_SEPARATOR) {
+      menu_item = BuildSeparator();
+    } else {
+      std::string label = ui::ConvertAcceleratorsFromWindowsStyle(
+          l10n_util::GetStringUTF8(commands[i].str_id));
+
+      menu_item = BuildMenuItem(label, commands[i].tag);
+
+      if (command_id == MENU_DISABLED_LABEL) {

[James Cook, 2013/08/08 18:42:16]

optional nit: It feels a little weird that MENU_DISABLED_LABEL isn't called
MENU_DISABLED_ID to imply that it is a command id.  I thought at first that it
was a special label string.

+        menuitem_property_set_bool(menu_item, kPropertyEnabled, false);
+      } else {
+        if (command_id == IDC_SHOW_BOOKMARK_BAR)
+          menuitem_property_set(menu_item, kPropertyToggleType, kTypeCheckmark);
+
+        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, "item-activated",
+                         G_CALLBACK(OnItemActivatedThunk), this);
+      }
+    }
+
     menuitem_child_append(top, menu_item);
   }
 
   menuitem_child_append(parent, top);
-}
-
-DbusmenuMenuitem* GlobalMenuBarX11::BuildMenuItem(
-    int string_id,
-    int command_id,
-    int tag_id,
-    std::map<int, DbusmenuMenuitem*>* id_to_menu_item) {
-  DbusmenuMenuitem* item = menuitem_new();
-
-  if (string_id == MENU_SEPARATOR) {
-    menuitem_property_set(item, kPropertyType, kTypeSeparator);
-  } else {
-    std::string label = ui::ConvertAcceleratorsFromWindowsStyle(
-        l10n_util::GetStringUTF8(string_id));
-    menuitem_property_set(item, kPropertyLabel, label.c_str());
-
-    if (command_id == IDC_SHOW_BOOKMARK_BAR)
-      menuitem_property_set(item, kPropertyToggleType, kTypeCheckmark);
-
-    if (tag_id)
-      g_object_set_data(G_OBJECT(item), "type-tag", GINT_TO_POINTER(tag_id));
-
-    if (command_id == MENU_DISABLED_LABEL) {
-      menuitem_property_set_bool(item, kPropertyEnabled, false);
-    } else {
-      id_to_menu_item->insert(std::make_pair(command_id, item));
-      g_object_set_data(G_OBJECT(item), "command-id",
-                        GINT_TO_POINTER(command_id));
-      g_signal_connect(item, "item-activated",
-                       G_CALLBACK(OnItemActivatedThunk), this);
-    }
-  }
-
-  menuitem_property_set_bool(item, kPropertyVisible, true);
-  return item;
+  return top;
 }
 
 void GlobalMenuBarX11::RegisterAccelerator(DbusmenuMenuitem* item,
                                            const ui::Accelerator& accelerator) {
   // A translation of libdbusmenu-gtk's menuitem_property_set_shortcut()
   // translated from GDK types to ui::Accelerator types.
   GVariantBuilder builder;
   g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
 
   if (accelerator.IsCtrlDown())
@@ skipping 12 matching lines @@
   g_variant_builder_add(&builder, "s", name);
 
   GVariant* inside_array = g_variant_builder_end(&builder);
   g_variant_builder_init(&builder, G_VARIANT_TYPE_ARRAY);
   g_variant_builder_add_value(&builder, inside_array);
   GVariant* outside_array = g_variant_builder_end(&builder);
 
   menuitem_property_set_variant(item, kPropertyShortcut, outside_array);
 }
 
+GlobalMenuBarX11::HistoryItem* GlobalMenuBarX11::HistoryItemForMenuItem(
+    DbusmenuMenuitem* menu_item) {
+  MenuItemToHistoryMap::iterator it = menu_item_history_map_.find(menu_item);
+  return it != menu_item_history_map_.end() ? it->second : NULL;
+}
+
+GlobalMenuBarX11::HistoryItem* GlobalMenuBarX11::HistoryItemForTab(
+    const TabRestoreService::Tab& entry) {
+  const sessions::SerializedNavigationEntry& 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;
+
+  return item;
+}
+
+void GlobalMenuBarX11::AddHistoryItemToMenu(HistoryItem* item,
+                                            DbusmenuMenuitem* 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);
+
+  DbusmenuMenuitem* menu_item = BuildMenuItem(UTF16ToUTF8(title), tag);
+  g_signal_connect(menu_item, "item-activated",
+                   G_CALLBACK(OnHistoryItemActivatedThunk), this);
+
+  menu_item_history_map_.insert(std::make_pair(menu_item, item));
+  menuitem_child_add_position(menu, menu_item, index);
+}
+
+void GlobalMenuBarX11::GetTopSitesData() {
+  DCHECK(top_sites_);
+
+  top_sites_->GetMostVisitedURLs(
+      base::Bind(&GlobalMenuBarX11::OnTopSitesReceived,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void GlobalMenuBarX11::OnTopSitesReceived(
+    const history::MostVisitedURLList& visited_list) {
+  ClearMenuSection(history_menu_, GlobalMenuBarX11::TAG_MOST_VISITED);
+
+  int index = GetIndexOfMenuItemWithTag(
+      history_menu_,
+      GlobalMenuBarX11::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;
+
+    AddHistoryItemToMenu(item,
+                         history_menu_,
+                         GlobalMenuBarX11::TAG_MOST_VISITED,
+                         index++);
+  }
+}
+
 void GlobalMenuBarX11::OnBookmarkBarVisibilityChanged() {
   CommandIDMenuItemMap::iterator it =
       id_to_menu_item_.find(IDC_SHOW_BOOKMARK_BAR);
   if (it != id_to_menu_item_.end()) {
     PrefService* prefs = browser_->profile()->GetPrefs();
     // Note: Unlike the GTK version, we don't appear to need to do tricks where
     // we block activation while setting the toggle.
     menuitem_property_set_int(it->second, kPropertyToggleState,
                               prefs->GetBoolean(prefs::kShowBookmarkBar));
   }
 }
 
+int GlobalMenuBarX11::GetIndexOfMenuItemWithTag(DbusmenuMenuitem* menu,
+                                                int tag_id) {
+  GList* childs = menuitem_get_children(menu);
+  int i = 0;
+  for (; childs != NULL; childs = childs->next, i++) {
+    int tag =
+        GPOINTER_TO_INT(g_object_get_data(G_OBJECT(childs->data), "type-tag"));
+    if (tag == tag_id)
+      return i;
+  }
+
+  NOTREACHED();
+  return -1;
+}
+
+void GlobalMenuBarX11::ClearMenuSection(DbusmenuMenuitem* menu, int tag_id) {
+  ClearMenuClosure closure;
+  closure.parent_menu = menu;
+  closure.menu_bar = this;
+  closure.tag = tag_id;
+
+  menuitem_foreach(

[James Cook, 2013/08/08 18:42:16]

Do you know if this is smart enough to handle having items deleted out from
under it in the middle of the iteration?

I presume there's some reason why you can't do this by iterating over the list
from menuitem_get_children -- the docs I find for that function suggest the list
may be invalidated.  It might be worth a comment here explaining why you're
doing it this way.

[Elliot Glaysher, 2013/08/08 21:13:08]

After reading the implementation, I'm pretty sure it isn't smart enough, even if
it appears to work. I've rewritten this entire method to not use their foreach
(and deleted three looked-up function pointers in the process.)

+      menu,
+      reinterpret_cast<void (*)(DbusmenuMenuitem*, void*)>(ClearMenuCallback),
+      &closure);
+}
+
+// static
+void GlobalMenuBarX11::ClearMenuCallback(DbusmenuMenuitem* 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->menu_item_history_map_.erase(menu_item);
+      delete item;
+    }
+
+    menuitem_child_delete(menuitem_get_parent(menu_item), menu_item);
+  }
+}
+
 void GlobalMenuBarX11::EnabledStateChangedForCommand(int id, bool enabled) {
   CommandIDMenuItemMap::iterator it = id_to_menu_item_.find(id);
   if (it != id_to_menu_item_.end())
     menuitem_property_set_bool(it->second, kPropertyEnabled, enabled);
 }
 
+void GlobalMenuBarX11::Observe(int type,
+                               const content::NotificationSource& source,
+                               const content::NotificationDetails& details) {
+  if (type == chrome::NOTIFICATION_TOP_SITES_CHANGED) {
+    GetTopSitesData();
+  } else {
+    NOTREACHED();
+  }
+}
+
+void GlobalMenuBarX11::TabRestoreServiceChanged(TabRestoreService* service) {
+  const TabRestoreService::Entries& entries = service->entries();
+
+  ClearMenuSection(history_menu_, GlobalMenuBarX11::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_,
+      GlobalMenuBarX11::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;
+
+      // Create the item for the parent/window.
+      HistoryItem* item = new HistoryItem();
+      item->session_id = entry_win->id;
+
+      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()));
+      DbusmenuMenuitem* parent_item = BuildMenuItem(
+          title, GlobalMenuBarX11::TAG_RECENTLY_CLOSED);
+      menuitem_child_add_position(history_menu_, parent_item, index++);
+
+      // 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.
+      DbusmenuMenuitem* restore_item = BuildMenuItem(
+          l10n_util::GetStringUTF8(
+              IDS_HISTORY_CLOSED_RESTORE_WINDOW_LINUX).c_str(),
+          GlobalMenuBarX11::TAG_RECENTLY_CLOSED);
+      g_signal_connect(restore_item, "item-activated",
+                       G_CALLBACK(OnHistoryItemActivatedThunk), this);
+      menu_item_history_map_.insert(std::make_pair(restore_item, item));
+      menuitem_child_append(parent_item, restore_item);
+
+      menuitem_child_append(parent_item, BuildSeparator());
+
+      // Loop over the window's tabs and add them to the submenu.
+      int subindex = 2;
+      std::vector<TabRestoreService::Tab>::const_iterator iter;
+      for (iter = tabs.begin(); iter != tabs.end(); ++iter) {
+        TabRestoreService::Tab tab = *iter;
+        HistoryItem* tab_item = HistoryItemForTab(tab);
+        item->tabs.push_back(tab_item);
+        AddHistoryItemToMenu(tab_item,
+                             parent_item,
+                             GlobalMenuBarX11::TAG_RECENTLY_CLOSED,
+                             subindex++);
+      }
+
+      ++added_count;
+    } else if (entry->type == TabRestoreService::TAB) {
+      TabRestoreService::Tab* tab = static_cast<TabRestoreService::Tab*>(entry);
+      HistoryItem* item = HistoryItemForTab(*tab);
+      AddHistoryItemToMenu(item,
+                           history_menu_,
+                           GlobalMenuBarX11::TAG_RECENTLY_CLOSED,
+                           index++);
+      ++added_count;
+    }
+  }
+}
+
+void GlobalMenuBarX11::TabRestoreServiceDestroyed(
+    TabRestoreService* service) {
+  tab_restore_service_ = NULL;
+}
+
 void GlobalMenuBarX11::OnWindowMapped(unsigned long xid) {
   if (!server_)
     InitServer(xid);
 
   GlobalMenuBarRegistrarX11::GetInstance()->OnWindowMapped(xid);
 }
 
 void GlobalMenuBarX11::OnWindowUnmapped(unsigned long xid) {
   GlobalMenuBarRegistrarX11::GetInstance()->OnWindowUnmapped(xid);
 }
 
 void GlobalMenuBarX11::OnItemActivated(DbusmenuMenuitem* item,
                                        unsigned int timestamp) {
   int id = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(item), "command-id"));
   chrome::ExecuteCommand(browser_, id);
 }
+
+void GlobalMenuBarX11::OnHistoryItemActivated(DbusmenuMenuitem* sender,
+                                              unsigned int timestamp) {
+  // Note: We don't have access to the event modifiers used to click the menu
+  // item since that happens in a different process.
+  HistoryItem* item = HistoryItemForMenuItem(sender);
+
+  // If this item can be restored using TabRestoreService, do so. Otherwise,
+  // just load the URL.
+  TabRestoreService* service =
+      TabRestoreServiceFactory::GetForProfile(profile_);
+  if (item->session_id && service) {
+    service->RestoreEntryById(browser_->tab_restore_service_delegate(),
+                              item->session_id, browser_->host_desktop_type(),
+                              UNKNOWN);
+  } else {
+    DCHECK(item->url.is_valid());
+    browser_->OpenURL(content::OpenURLParams(
+        item->url,
+        content::Referrer(),
+        NEW_FOREGROUND_TAB,
+        content::PAGE_TRANSITION_AUTO_BOOKMARK,
+        false));
+  }
+}
+
+void GlobalMenuBarX11::OnHistoryMenuAboutToShow(DbusmenuMenuitem* item) {
+  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_);
+    }
+  }
+}