linux_aura: Implement the dynamic History menu in the dbusmenu.

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

 // 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.
 
 #ifndef CHROME_BROWSER_UI_VIEWS_FRAME_GLOBAL_MENU_BAR_X11_H_
 #define CHROME_BROWSER_UI_VIEWS_FRAME_GLOBAL_MENU_BAR_X11_H_
 
 #include <map>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "chrome/browser/command_observer.h"
+#include "chrome/browser/common/cancelable_request.h"
+#include "chrome/browser/history/history_types.h"
+#include "chrome/browser/sessions/tab_restore_service.h"
+#include "chrome/browser/sessions/tab_restore_service_observer.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
 #include "ui/base/glib/glib_signal.h"
 #include "ui/views/widget/desktop_aura/desktop_root_window_host_observer_x11.h"
 
 typedef struct _DbusmenuMenuitem DbusmenuMenuitem;
 typedef struct _DbusmenuServer   DbusmenuServer;
 
+namespace history {
+class TopSites;
+}
+
 namespace ui {
 class Accelerator;
 }
 
 class Browser;
 class BrowserView;
+class Profile;
 
 class BrowserDesktopRootWindowHostX11;
 struct GlobalMenuBarCommand;
 
 // Controls the Mac style menu bar on Unity.
 //
 // Unity has an Apple-like menu bar at the top of the screen that changes
 // depending on the active window. In the GTK port, we had a hidden GtkMenuBar
 // object in each GtkWindow which existed only to be scrapped by the
 // libdbusmenu-gtk code. Since we don't have GtkWindows anymore, we need to
 // interface directly with the lower level libdbusmenu-glib, which we
 // opportunistically dlopen() since not everyone is running Ubuntu.
 class GlobalMenuBarX11 : public CommandObserver,
+                         public content::NotificationObserver,
+                         public TabRestoreServiceObserver,
                          public views::DesktopRootWindowHostObserverX11 {
  public:
+  static const int TAG_NORMAL = 0;
+  static const int TAG_MOST_VISITED = 1;
+  static const int TAG_RECENTLY_CLOSED = 2;
+  static const int TAG_MOST_VISITED_HEADER = 3;
+  static const int TAG_RECENTLY_CLOSED_HEADER = 4;

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

Can they be in the .cc instead?

+
   GlobalMenuBarX11(BrowserView* browser_view,
                    BrowserDesktopRootWindowHostX11* host);
   virtual ~GlobalMenuBarX11();
 
   // Creates the object path for DbusemenuServer which is attached to |xid|.
   static std::string GetPathForWindow(unsigned long xid);
 
+  // Builds a separator.
+  DbusmenuMenuitem* BuildSeparator();
+
+  // Creates an individual menu item from a title and command, and subscribes
+  // to the activation signal.
+  DbusmenuMenuitem* BuildMenuItem(const std::string& label, int tag_id);

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

Do these need to be public?

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

no. done.

+
  private:
+  class HistoryItem;
+  typedef std::map<DbusmenuMenuitem*, HistoryItem*> MenuItemToHistoryMap;
   typedef std::map<int, DbusmenuMenuitem*> CommandIDMenuItemMap;
 
   // Creates a DbusmenuServer, and attaches all the menu items.
   void InitServer(unsigned long xid);
 
   // Stops listening to enable state changed events.
   void Disable();
 
   // Creates a whole menu defined with |commands| and titled with the string
   // |menu_str_id|. Then appends it to |parent|.
-  void BuildMenuFrom(DbusmenuMenuitem* parent,
-                     int menu_str_id,
-                     CommandIDMenuItemMap* id_to_menu_item,
-                     GlobalMenuBarCommand* commands);
-
-  // Creates an individual menu item from a title and command, and subscribes
-  // to the activation signal.
-  DbusmenuMenuitem* BuildMenuItem(
-      int string_id,
-      int command_id,
-      int tag_id,
-      CommandIDMenuItemMap* id_to_menu_item);
+  DbusmenuMenuitem* BuildStaticMenu(DbusmenuMenuitem* parent,
+                                    int menu_str_id,
+                                    GlobalMenuBarCommand* commands);
 
   // Sets the accelerator for |item|.
   void RegisterAccelerator(DbusmenuMenuitem* item,
                            const ui::Accelerator& accelerator);
 
+  // Returns the currently existing HistoryItem associated with
+  // |menu_item|. Can return NULL.
+  HistoryItem* HistoryItemForMenuItem(DbusmenuMenuitem* menu_item);
+
+  // Creates a HistoryItem from the data in |entry|.
+  HistoryItem* HistoryItemForTab(const TabRestoreService::Tab& entry);
+
+  // Creates a menu item form |item| and inserts it in |menu| at |index|.
+  void AddHistoryItemToMenu(HistoryItem* item,
+                            DbusmenuMenuitem* menu,
+                            int tag,
+                            int index);
+
+  // Sends a message off to History for data.
+  void GetTopSitesData();
+
+  // Callback to receive data requested from GetTopSitesData().
+  void OnTopSitesReceived(const history::MostVisitedURLList& visited_list);
+
   // Updates the visibility of the bookmark bar on pref changes.
   void OnBookmarkBarVisibilityChanged();
 
+  // Find the first index of the item in |menu| with the tag |tag_id|.
+  int GetIndexOfMenuItemWithTag(DbusmenuMenuitem* menu, int tag_id);

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

Please add a note that the invisible entries are also taken into account (so the
index returned from this function is not the 'visible index').

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

I'm not sure what you're saying here. All entries in the menu are visible. All
times that I set the visible property, I'm setting it to true and I'm doing it
immediately after construction.

[sadrul, 2013/08/09 20:31:34]

Ah, I noticed that the visibility property was being set, and assumed there
could be invisible items in the list.

+
+  // This will remove all menu items in |menu| with |tag| as their tag. This
+  // clears state about HistoryItems* that we keep to prevent that data from
+  // going stale. That's why this method recurses into its child menus.
+  void ClearMenuSection(DbusmenuMenuitem* menu, int tag_id);
+
   // Overridden from CommandObserver:
   virtual void EnabledStateChangedForCommand(int id, bool enabled) OVERRIDE;
 
-  // Overridden from DesktopRootWindowHostObserverX11:
+  // Overridden from content::NotificationObserver:
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
+  // Overridden from TabRestoreServiceObserver:
+  virtual void TabRestoreServiceChanged(TabRestoreService* service) OVERRIDE;
+  virtual void TabRestoreServiceDestroyed(TabRestoreService* service) OVERRIDE;
+
+  // Overridden from views::DesktopRootWindowHostObserverX11:
   virtual void OnWindowMapped(unsigned long xid) OVERRIDE;
   virtual void OnWindowUnmapped(unsigned long xid) OVERRIDE;
 
   CHROMEG_CALLBACK_1(GlobalMenuBarX11, void, OnItemActivated, DbusmenuMenuitem*,
                      unsigned int);
+  CHROMEG_CALLBACK_1(GlobalMenuBarX11, void, OnHistoryItemActivated,
+                     DbusmenuMenuitem*, unsigned int);
+  CHROMEG_CALLBACK_0(GlobalMenuBarX11, void, OnHistoryMenuAboutToShow,
+                     DbusmenuMenuitem*);
 
   Browser* browser_;
+  Profile* profile_;
   BrowserView* browser_view_;
   BrowserDesktopRootWindowHostX11* host_;
 
   // Maps command ids to DbusmenuMenuitems so we can modify their
   // enabled/checked state in response to state change notifications.
   CommandIDMenuItemMap id_to_menu_item_;
 
   DbusmenuServer* server_;
   DbusmenuMenuitem* root_item_;
+  DbusmenuMenuitem* history_menu_;
 
   // Tracks value of the kShowBookmarkBar preference.
   PrefChangeRegistrar pref_change_registrar_;
 
+  history::TopSites* top_sites_;
+
+  TabRestoreService* tab_restore_service_;  // weak
+
+  // A mapping from DbusmenuMenuitems to HistoryItems that maintain data.
+  MenuItemToHistoryMap menu_item_history_map_;
+
+  content::NotificationRegistrar registrar_;
+
+  // For callbacks may be run after destruction.
+  base::WeakPtrFactory<GlobalMenuBarX11> weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(GlobalMenuBarX11);
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_FRAME_GLOBAL_MENU_BAR_X11_H_