backup for dynamic recent tabs submenu

chrome/browser/ui/views/wrench_menu.h

 // Copyright (c) 2012 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_WRENCH_MENU_H_
 #define CHROME_BROWSER_UI_VIEWS_WRENCH_MENU_H_
 
 #include <map>
 #include <utility>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "chrome/browser/bookmarks/base_bookmark_model_observer.h"
+#include "chrome/browser/ui/views/menu_items_changed_delegate.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/views/controls/menu/menu_delegate.h"
 
 class BookmarkMenuDelegate;
 class Browser;
+class RecentTabsMenuModelDelegate;
 class WrenchMenuObserver;
 
 namespace ui {
 class NativeTheme;
 }
 
 namespace views {
 class MenuButton;
 struct MenuConfig;
 class MenuItemView;
 class MenuRunner;
 class View;
 }  // namespace views
 
 // WrenchMenu adapts the WrenchMenuModel to view's menu related classes.
 class WrenchMenu : public views::MenuDelegate,
+                   public MenuItemsChangedDelegate,
                    public BaseBookmarkModelObserver,
                    public content::NotificationObserver {
  public:
   // TODO: remove |use_new_menu| and |supports_new_separators|.
   WrenchMenu(Browser* browser,
              bool use_new_menu,
              bool supports_new_separators);
   virtual ~WrenchMenu();
 
   void Init(ui::MenuModel* model);
 
   // Shows the menu relative to the specified view.
   void RunMenu(views::MenuButton* host);
 
   // Whether the menu is currently visible to the user.
   bool IsShowing();
 
   const views::MenuConfig& GetMenuConfig() const;
 
   bool use_new_menu() const { return use_new_menu_; }
 
   void AddObserver(WrenchMenuObserver* observer);
   void RemoveObserver(WrenchMenuObserver* observer);
 
   // MenuDelegate overrides:
-  virtual const gfx::Font* GetLabelFont(int index) const OVERRIDE;
+  virtual const gfx::Font* GetLabelFont(int id) const OVERRIDE;
   virtual bool GetForegroundColor(int command_id,
                                   bool is_hovered,
                                   SkColor* override_color) const OVERRIDE;
   virtual string16 GetTooltipText(int id, const gfx::Point& p) const OVERRIDE;
   virtual bool IsTriggerableEvent(views::MenuItemView* menu,
                                   const ui::Event& e) OVERRIDE;
   virtual bool GetDropFormats(
       views::MenuItemView* menu,
       int* formats,
       std::set<ui::OSExchangeData::CustomFormat>* custom_formats) OVERRIDE;
@@ skipping 15 matching lines @@
                              ui::OSExchangeData* data) OVERRIDE;
   virtual int GetDragOperations(views::MenuItemView* sender) OVERRIDE;
   virtual int GetMaxWidthForMenu(views::MenuItemView* menu) OVERRIDE;
   virtual bool IsItemChecked(int id) const OVERRIDE;
   virtual bool IsCommandEnabled(int id) const OVERRIDE;
   virtual void ExecuteCommand(int id, int mouse_event_flags) OVERRIDE;
   virtual bool GetAccelerator(int id, ui::Accelerator* accelerator) OVERRIDE;
   virtual void WillShowMenu(views::MenuItemView* menu) OVERRIDE;
   virtual void WillHideMenu(views::MenuItemView* menu) OVERRIDE;
 
+  // MenuItemsChangedDelegate overrides:
+  void OnItemAdded(views::MenuItemView* parent, int menu_index,
+                   ui::MenuModel* model, int model_index,
+                   int item_id) OVERRIDE;
+  void OnItemRemoved(views::MenuItemView* parent, int menu_index,
+                     int item_id) OVERRIDE;
+  virtual void UpdateMapOfMenuItemIdAndModel(
+      ui::MenuModel* model, std::vector<int>& item_ids) OVERRIDE;
+
   // BaseBookmarkModelObserver overrides:
   virtual void BookmarkModelChanged() OVERRIDE;
 
   // content::NotificationObserver overrides:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  private:
+  friend class RecentTabsMenuModelDelegate;
+
   class CutCopyPasteView;
-  class RecentTabsMenuModelDelegate;
   class ZoomView;
 
   typedef std::pair<ui::MenuModel*,int> Entry;
   typedef std::map<int,Entry> IDToEntry;
 
   const ui::NativeTheme* GetNativeTheme() const;
 
   // Populates |parent| with all the child menus in |model|. Recursively invokes
   // |PopulateMenu| for any submenu. |next_id| is incremented for every menu
   // that is created.
   void PopulateMenu(views::MenuItemView* parent,
                     ui::MenuModel* model,
                     int* next_id);
 
-  // Adds a new menu to |parent| to represent the MenuModel/index pair passed
-  // in.
+  // Adds a new menu to |parent| at |menu_index| to represent the
+  // MenuModel/model_index pair passed in.
   // Fur button containing menu items a |height| override can be specified with
   // a number bigger then 0.
-  views::MenuItemView* AppendMenuItem(views::MenuItemView* parent,
-                                      ui::MenuModel* model,
-                                      int index,
-                                      ui::MenuModel::ItemType menu_type,
-                                      int* next_id,
-                                      int height);
+  views::MenuItemView* AddMenuItem(views::MenuItemView* parent,
+                                    int menu_index,
+                                    ui::MenuModel* model,
+                                    int model_index,
+                                    ui::MenuModel::ItemType menu_type,
+                                    int* next_id,
+                                    int height);
 
   // Invoked from the cut/copy/paste menus. Cancels the current active menu and
   // activates the menu item in |model| at |index|.
   void CancelAndEvaluate(ui::MenuModel* model, int index);
 
   // Creates the bookmark menu if necessary. Does nothing if already created or
   // the bookmark model isn't loaded.
   void CreateBookmarkMenu();
 
   // Returns true if |id| identifies a bookmark menu item.
-  bool is_bookmark_command(int id) const {
-    return bookmark_menu_delegate_.get() && id >= first_bookmark_command_id_;
-  }
+  bool IsBookmarkCommand(int id) const;
 
   // Returns true if |id| identifies a recent tabs menu item.
-  bool is_recent_tabs_command(int id) const {
-    return (recent_tabs_menu_model_delegate_.get() &&
-            id >= first_recent_tabs_command_id_ &&
-            id <= last_recent_tabs_command_id_);
-  }
+  bool IsRecentTabsCommand(int id) const;
 
   // The views menu. Owned by |menu_runner_|.
   views::MenuItemView* root_;
 
   scoped_ptr<views::MenuRunner> menu_runner_;
 
   // Maps from the ID as understood by MenuItemView to the model/index pair the
   // item came from.
   IDToEntry id_to_entry_;
 
@@ skipping 12 matching lines @@
 
   // Menu corresponding to IDC_BOOKMARKS_MENU.
   views::MenuItemView* bookmark_menu_;
 
   // Menu corresponding to IDC_FEEDBACK.
   views::MenuItemView* feedback_menu_item_;
 
   // Used for managing "Recent tabs" menu items.
   scoped_ptr<RecentTabsMenuModelDelegate> recent_tabs_menu_model_delegate_;
 
-  // First ID to use for the items representing bookmarks in the bookmark menu.
-  int first_bookmark_command_id_;
-
-  // First/last IDs to use for the items of the recent tabs sub-menu.
-  int first_recent_tabs_command_id_;
+  // ID of the last item in the recent tabs submenu.
   int last_recent_tabs_command_id_;
 
   content::NotificationRegistrar registrar_;
 
   const bool use_new_menu_;
 
   const bool supports_new_separators_;
 
   ObserverList<WrenchMenuObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(WrenchMenu);
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_WRENCH_MENU_H_