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 GList* (*dbusmenu_menuitem_get_children_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 15 matching lines @@
   int command;
   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_get_id_func menuitem_get_id = NULL;
+dbusmenu_menuitem_get_children_func menuitem_get_children = 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;
+const int MENU_DISABLED_ID = -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 },
   { IDS_OPEN_FILE_LINUX, IDC_OPEN_FILE },
   { IDS_OPEN_LOCATION_LINUX, IDC_FOCUS_LOCATION },
 
   { MENU_SEPARATOR, MENU_SEPARATOR },
@@ skipping 22 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_ID,
+    GlobalMenuBarX11::TAG_MOST_VISITED_HEADER },
+
+  { MENU_SEPARATOR, MENU_SEPARATOR },
+
+  { IDS_HISTORY_CLOSED_LINUX, MENU_DISABLED_ID,
+    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 20 matching lines @@
     return;
   attempted_load = true;
 
   void* dbusmenu_lib = dlopen("libdbusmenu-glib.so", RTLD_LAZY);
   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_get_children = reinterpret_cast<dbusmenu_menuitem_get_children_func>(
+      dlsym(dbusmenu_lib, "dbusmenu_menuitem_get_children"));
   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
 
+class GlobalMenuBarX11::HistoryItem {

[sadrul, 2013/08/09 06:38:54]

This should probably be struct?

+ 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),
+      tab_restore_service_(NULL),
+      weak_ptr_factory_(this) {
   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_ID) {
+        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) {

[sadrul, 2013/08/09 06:38:54]

This could be a separate function in the anonymous namespace.

[Elliot Glaysher, 2013/08/09 20:19:25]

It actually can't without making HistoryItem public instead of a private class
implementation detail.

+  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));

[sadrul, 2013/08/09 06:38:54]

Instead of using the map, can you use g_object_set_data_full()? That would be
consistent with the use of g_object_set_data for type-tag, command-id. (and this
too could be a separate function in the anonymous namespace).

[Elliot Glaysher, 2013/08/09 20:19:25]

This is a really good point. I forgot that you could do that with gobjects.
Done.

+  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);

[sadrul, 2013/08/09 06:38:54]

childs

+  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) {
+  std::vector<DbusmenuMenuitem*> menuitems_to_delete;
+
+  GList* childs = menuitem_get_children(menu);
+  for (; childs != NULL; childs = childs->next) {
+    DbusmenuMenuitem* current_item = reinterpret_cast<DbusmenuMenuitem*>(
+        childs->data);
+    ClearMenuSection(current_item, tag_id);
+
+    int tag =
+        GPOINTER_TO_INT(g_object_get_data(G_OBJECT(childs->data), "type-tag"));
+    if (tag == tag_id)
+      menuitems_to_delete.push_back(current_item);
+  }
+
+  for (std::vector<DbusmenuMenuitem*>::const_iterator it =
+           menuitems_to_delete.begin(); it != menuitems_to_delete.end(); ++it) {
+    HistoryItem* item = HistoryItemForMenuItem(*it);
+    if (item) {
+      menu_item_history_map_.erase(*it);
+      delete item;
+    }
+
+    menuitem_child_delete(menu, *it);
+  }
+}
+
 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);

[sadrul, 2013/08/09 06:38:54]

Should AddObserver() happen before LoadTabsFromLastSession()?

[Elliot Glaysher, 2013/08/09 20:19:25]

I think so. All other cases I could find ordered things this way (however the
only other one that I could find where we both loaded tabs and added an observer
was in RecnetlyClosedTabsHandler in the webui code).

+
+      // 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_);
+    }
+  }
+}