Make NetworkMenuModel a ui::MenuModel again.

chrome/browser/chromeos/status/network_menu.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/chromeos/status/network_menu.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/command_line.h"
@@ skipping 15 matching lines @@
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/escape.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "views/controls/menu/menu_item_view.h"
+#include "views/controls/menu/menu_model_adapter.h"
 #include "views/controls/menu/submenu_view.h"
 #include "views/widget/widget.h"
 
 namespace {
 
 // Offsets for views menu ids (main menu and submenu ids use the same
 // namespace).
-const int kItemIndexMask = 0x0fff;
 const int kMainIndexMask = 0x1000;
 const int kVPNIndexMask  = 0x2000;
 const int kMoreIndexMask = 0x4000;
 
 // Default minimum width in pixels of the menu to prevent unnecessary
 // resizing as networks are updated.
 const int kDefaultMinimumWidth = 280;
 
 // Menu item margins.
 const int kTopMargin = 5;
 const int kBottomMargin = 7;
 
 // Replace '&' in a string with "&&" to allow it to be a menu item label.
 std::string EscapeAmpersands(const std::string& input) {
   std::string str = input;
   size_t found = str.find('&');
   while (found != std::string::npos) {
     str.replace(found, 1, "&&");
     found = str.find('&', found + 2);
   }
   return str;
 }
 
+// Set vertical menu margins for entire menu hierarchy.
+void SetMenuMargins(views::MenuItemView* menu_item_view, int top, int bottom) {
+  menu_item_view->set_margins(top, bottom);
+  if (menu_item_view->HasSubmenu()) {
+    views::SubmenuView* submenu = menu_item_view->GetSubmenu();
+    for (int i = 0; i < submenu->child_count(); ++i) {
+      // Must skip separators.
+      views::View* item = submenu->child_at(i);
+      if (item->id() == views::MenuItemView::kMenuItemViewID) {
+        views::MenuItemView* menu_item =
+            static_cast<views::MenuItemView*>(item);
+        SetMenuMargins(menu_item, top, bottom);
+      }
+    }
+  }
+}
+
 }  // namespace
 
 namespace chromeos {
 
-class NetworkMenuModel : public views::MenuDelegate {
+class NetworkMenuModel : public ui::MenuModel {
  public:
   struct NetworkInfo {
     NetworkInfo() : need_passphrase(false),
                     remembered(true),
                     auto_connect(true) {
     }
     ~NetworkInfo() {}
 
     // "ethernet" | "wifi" | "cellular" | "other".
     std::string network_type;
@@ skipping 53 matching lines @@
   // If remember >= 0, set the favorite state of the network.
   void ConnectToNetworkAt(int index,
                           const std::string& passphrase,
                           const std::string& ssid,
                           int remember) const;
 
   // Called by NetworkMenu::RunMenu to initialize list of menu items.
   virtual void InitMenuItems(bool is_browser_mode,
                              bool should_open_button_options) = 0;
 
-  // PopulateMenu() clears and reinstalls the menu items defined in this
-  // instance by calling PopulateMenuItem() on each one.  Subclasses override
-  // PopulateMenuItem(), transform command_id into the correct range for
-  // the menu, and call the base class PopulateMenuItem().
-  virtual void PopulateMenu(views::MenuItemView* menu);
-  virtual void PopulateMenuItem(views::MenuItemView* menu,
-                                int index,
-                                int command_id);
-
   // Menu item field accessors.
   const MenuItemVector& menu_items() const { return menu_items_; }
-  int GetItemCount() const;
-  ui::MenuModel::ItemType GetTypeAt(int index) const;
-  string16 GetLabelAt(int index) const;
-  const gfx::Font* GetLabelFontAt(int index) const;
-  bool IsItemCheckedAt(int index) const;
-  bool GetIconAt(int index, SkBitmap* icon);
-  bool IsEnabledAt(int index) const;
-  NetworkMenuModel* GetSubmenuModelAt(int index) const;
-  void ActivatedAt(int index);
+
+  // ui::MenuModel implementation
+  // GetCommandIdAt() must be implemented by subclasses.
+  virtual bool HasIcons() const OVERRIDE;
+  virtual int GetItemCount() const OVERRIDE;
+  virtual ui::MenuModel::ItemType GetTypeAt(int index) const OVERRIDE;
+  virtual string16 GetLabelAt(int index) const OVERRIDE;
+  virtual bool IsItemDynamicAt(int index) const OVERRIDE;
+  virtual const gfx::Font* GetLabelFontAt(int index) const OVERRIDE;
+  virtual bool GetAcceleratorAt(int index,
+                                ui::Accelerator* accelerator) const OVERRIDE;
+  virtual bool IsItemCheckedAt(int index) const OVERRIDE;
+  virtual int GetGroupIdAt(int index) const OVERRIDE;
+  virtual bool GetIconAt(int index, SkBitmap* icon) OVERRIDE;
+  virtual ui::ButtonMenuItemModel* GetButtonMenuItemAt(
+      int index) const OVERRIDE;
+  virtual bool IsEnabledAt(int index) const OVERRIDE;
+  virtual bool IsVisibleAt(int index) const OVERRIDE;
+  virtual ui::MenuModel* GetSubmenuModelAt(int index) const OVERRIDE;
+  virtual void HighlightChangedTo(int index) OVERRIDE;
+  virtual void ActivatedAt(int index) OVERRIDE;
+  virtual void SetMenuModelDelegate(ui::MenuModelDelegate* delegate) OVERRIDE;
 
  protected:
   enum MenuItemFlags {
     FLAG_NONE              = 0,
     FLAG_DISABLED          = 1 << 0,
     FLAG_TOGGLE_ETHERNET   = 1 << 1,
     FLAG_TOGGLE_WIFI       = 1 << 2,
     FLAG_TOGGLE_CELLULAR   = 1 << 3,
     FLAG_TOGGLE_OFFLINE    = 1 << 4,
     FLAG_ASSOCIATED        = 1 << 5,
@@ skipping 35 matching lines @@
 
 
 class MoreMenuModel : public NetworkMenuModel {
  public:
   explicit MoreMenuModel(NetworkMenu* owner) : NetworkMenuModel(owner) {}
   virtual ~MoreMenuModel() {}
 
   // NetworkMenuModel implementation.
   virtual void InitMenuItems(bool is_browser_mode,
                              bool should_open_button_options) OVERRIDE;
-  virtual void PopulateMenuItem(views::MenuItemView* menu,
-                                int index,
-                                int command_id) OVERRIDE;
+
+  // ui::MenuModel implementation
+  virtual int GetCommandIdAt(int index) const OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MoreMenuModel);
 };
 
 class VPNMenuModel : public NetworkMenuModel {
  public:
   explicit VPNMenuModel(NetworkMenu* owner) : NetworkMenuModel(owner) {}
   virtual ~VPNMenuModel() {}
 
   // NetworkMenuModel implementation.
   virtual void InitMenuItems(bool is_browser_mode,
                              bool should_open_button_options) OVERRIDE;
-  virtual void PopulateMenuItem(views::MenuItemView* menu,
-                                int index,
-                                int command_id) OVERRIDE;
+
+  // ui::MenuModel implementation
+  virtual int GetCommandIdAt(int index) const OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VPNMenuModel);
 };
 
 class MainMenuModel : public NetworkMenuModel {
  public:
   explicit MainMenuModel(NetworkMenu* owner)
       : NetworkMenuModel(owner),
         vpn_menu_model_(new VPNMenuModel(owner)),
         more_menu_model_(new MoreMenuModel(owner)) {
   }
   virtual ~MainMenuModel() {}
 
   // NetworkMenuModel implementation.
   virtual void InitMenuItems(bool is_browser_mode,
                              bool should_open_button_options) OVERRIDE;
-  virtual void PopulateMenuItem(views::MenuItemView* menu,
-                                int index,
-                                int command_id) OVERRIDE;
 
-  // views::MenuDelegate implementation.
-  virtual const gfx::Font& GetLabelFont(int id) const OVERRIDE;
-  virtual bool IsItemChecked(int id) const OVERRIDE;
-  virtual bool IsCommandEnabled(int id) const OVERRIDE;
-  virtual void ExecuteCommand(int id) OVERRIDE;
+  // ui::MenuModel implementation
+  virtual int GetCommandIdAt(int index) const OVERRIDE;
 
  private:
-  const NetworkMenuModel* GetMenuItemModel(int id) const;
-
   scoped_ptr<NetworkMenuModel> vpn_menu_model_;
   scoped_ptr<MoreMenuModel> more_menu_model_;
 
   DISALLOW_COPY_AND_ASSIGN(MainMenuModel);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenuModel, public methods:
 
-void NetworkMenuModel::PopulateMenu(views::MenuItemView* menu) {
-  if (menu->HasSubmenu()) {
-    const int old_count = menu->GetSubmenu()->child_count();
-    for (int i = 0; i < old_count; ++i)
-      menu->RemoveMenuItemAt(0);
-  }
-
-  const int menu_items_count = GetItemCount();
-  for (int i = 0; i < menu_items_count; ++i)
-    PopulateMenuItem(menu, i, i);
-}
-
-void NetworkMenuModel::PopulateMenuItem(
-    views::MenuItemView* menu, int index, int command_id) {
-  DCHECK_GT(GetItemCount(), index);
-  switch (GetTypeAt(index)) {
-    case ui::MenuModel::TYPE_SEPARATOR:
-      menu->AppendSeparator();
-      break;
-    case ui::MenuModel::TYPE_COMMAND: {
-      views::MenuItemView* item = NULL;
-      SkBitmap icon;
-      if (GetIconAt(index, &icon)) {
-        item = menu->AppendMenuItemWithIcon(command_id,
-                                            UTF16ToWide(GetLabelAt(index)),
-                                            icon);
-      } else {
-        item = menu->AppendMenuItemWithLabel(command_id,
-                                             UTF16ToWide(GetLabelAt(index)));
-      }
-      item->set_margins(kTopMargin, kBottomMargin);
-      break;
-    }
-    case ui::MenuModel::TYPE_SUBMENU: {
-      views::MenuItemView* submenu = NULL;
-      SkBitmap icon;
-      if (GetIconAt(index, &icon)) {
-        submenu = menu->AppendSubMenuWithIcon(command_id,
-                                              UTF16ToWide(GetLabelAt(index)),
-                                              icon);
-      } else {
-        submenu = menu->AppendSubMenu(command_id,
-                                      UTF16ToWide(GetLabelAt(index)));
-      }
-      submenu->set_margins(kTopMargin, kBottomMargin);
-      GetSubmenuModelAt(index)->PopulateMenu(submenu);
-      break;
-    }
-    default:
-      NOTREACHED();
-  }
-}
-
 void NetworkMenuModel::ConnectToNetworkAt(int index,
                                           const std::string& passphrase,
                                           const std::string& ssid,
                                           int auto_connect) const {
   int flags = menu_items_[index].flags;
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   const std::string& service_path = menu_items_[index].service_path;
   if (flags & FLAG_WIFI) {
     WifiNetwork* wifi = cros->FindWifiNetworkByPath(service_path);
     if (wifi) {
@@ skipping 68 matching lines @@
       // display a notification.
       LOG(WARNING) << "VPN does not exist to connect to: " << service_path;
       // TODO(stevenjb): Show notification.
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenuModel, ui::MenuModel implementation:
 
+bool NetworkMenuModel::HasIcons() const {
+  return true;
+}
+
 int NetworkMenuModel::GetItemCount() const {
   return static_cast<int>(menu_items_.size());
 }
 
 ui::MenuModel::ItemType NetworkMenuModel::GetTypeAt(int index) const {
   return menu_items_[index].type;
 }
 
 string16 NetworkMenuModel::GetLabelAt(int index) const {
   return menu_items_[index].label;
 }
 
+bool NetworkMenuModel::IsItemDynamicAt(int index) const {
+  return false;
+}
+
 const gfx::Font* NetworkMenuModel::GetLabelFontAt(int index) const {
   const gfx::Font* font = NULL;
   if (menu_items_[index].flags & FLAG_ASSOCIATED) {
     ResourceBundle& resource_bundle = ResourceBundle::GetSharedInstance();
     font = &resource_bundle.GetFont(
         browser_defaults::kAssociatedNetworkFontStyle);
   }
 
   return font;
 }
 
+bool NetworkMenuModel::GetAcceleratorAt(int index,
+                                        ui::Accelerator* accelerator) const {
+  return false;
+}
+
 bool NetworkMenuModel::IsItemCheckedAt(int index) const {
   // All ui::MenuModel::TYPE_CHECK menu items are checked.
   return true;
 }
 
+int NetworkMenuModel::GetGroupIdAt(int index) const {
+  return 0;
+}
+
 bool NetworkMenuModel::GetIconAt(int index, SkBitmap* icon) {
   if (!menu_items_[index].icon.empty()) {
     *icon = menu_items_[index].icon;
     return true;
   }
   return false;
 }
 
+ui::ButtonMenuItemModel* NetworkMenuModel::GetButtonMenuItemAt(
+    int index) const {
+  return NULL;
+}
+
 bool NetworkMenuModel::IsEnabledAt(int index) const {
   return !(menu_items_[index].flags & FLAG_DISABLED);
 }
 
-NetworkMenuModel* NetworkMenuModel::GetSubmenuModelAt(int index) const {
+bool NetworkMenuModel::IsVisibleAt(int index) const {
+  return true;
+}
+
+ui::MenuModel* NetworkMenuModel::GetSubmenuModelAt(int index) const {
   return menu_items_[index].sub_menu_model;
 }
 
+void NetworkMenuModel::HighlightChangedTo(int index) {
+}
+
 void NetworkMenuModel::ActivatedAt(int index) {
   // When we are refreshing the menu, ignore menu item activation.
   if (owner_->refreshing_menu_)
     return;
 
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   int flags = menu_items_[index].flags;
   if (flags & FLAG_OPTIONS) {
     owner_->delegate()->OpenButtonOptions();
   } else if (flags & FLAG_TOGGLE_ETHERNET) {
@@ skipping 26 matching lines @@
     const VirtualNetwork* active_vpn = cros->virtual_network();
     if (active_vpn)
       cros->DisconnectFromNetwork(active_vpn);
   } else if (flags & FLAG_VIEW_ACCOUNT) {
     Browser* browser = BrowserList::GetLastActive();
     if (browser)
       browser->ShowSingletonTab(GURL(top_up_url_));
   }
 }
 
+void NetworkMenuModel::SetMenuModelDelegate(ui::MenuModelDelegate* delegate) {
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenuModel, private methods:
 
 void NetworkMenuModel::ShowNetworkConfigView(NetworkConfigView* view) const {
   views::Widget* window = browser::CreateViewsWindow(
       owner_->delegate()->GetNativeWindow(), gfx::Rect(), view);
   window->SetAlwaysOnTop(true);
   window->Show();
 }
 
@@ skipping 10 matching lines @@
     ChooseMobileNetworkDialog::ShowDialog(
         owner_->delegate()->GetNativeWindow());
   } else {
     ShowNetworkConfigView(new NetworkConfigView(type));
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MainMenuModel
 
-const NetworkMenuModel* MainMenuModel::GetMenuItemModel(int id) const {
-  if (id & kMoreIndexMask)
-    return more_menu_model_.get();
-  else if (id & kVPNIndexMask)
-    return vpn_menu_model_.get();
-  else if (id & kMainIndexMask)
-    return this;
-  return NULL;
-}
-
 void MainMenuModel::InitMenuItems(bool is_browser_mode,
                                   bool should_open_button_options) {
   // This gets called on initialization, so any changes should be reflected
   // in CrosMock::SetNetworkLibraryStatusAreaExpectations().
 
   menu_items_.clear();
 
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   if (cros->IsLocked()) {
     menu_items_.push_back(
@@ skipping 298 matching lines @@
   } else {
     if (!more_menu_model_->menu_items().empty()) {
       menu_items_.push_back(MenuItem(
           ui::MenuModel::TYPE_SUBMENU,
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_MORE),
           SkBitmap(), more_menu_model_.get(), FLAG_NONE));
     }
   }
 }
 
-void MainMenuModel::PopulateMenuItem(
-    views::MenuItemView* menu, int index, int command_id) {
-  int main_command_id = command_id | kMainIndexMask;
-  NetworkMenuModel::PopulateMenuItem(menu, index, main_command_id);
-}
-
-// views::MenuDelegate implementation.
-
-const gfx::Font& MainMenuModel::GetLabelFont(int id) const {
-  const NetworkMenuModel* model = GetMenuItemModel(id);
-  const gfx::Font* font = NULL;
-  if (model)
-    font = model->GetLabelFontAt(id & kItemIndexMask);
-  return font ? *font : views::MenuDelegate::GetLabelFont(id);
-}
-
-bool MainMenuModel::IsItemChecked(int id) const {
-  const NetworkMenuModel* model = GetMenuItemModel(id);
-  if (model)
-    return model->IsItemCheckedAt(id & kItemIndexMask);
-  return views::MenuDelegate::IsItemChecked(id);
-}
-
-bool MainMenuModel::IsCommandEnabled(int id) const {
-  const NetworkMenuModel* model = GetMenuItemModel(id);
-  if (model)
-    return model->IsEnabledAt(id & kItemIndexMask);
-  return views::MenuDelegate::IsCommandEnabled(id);
-}
-
-// Not const, so can not use GetMenuItemModel().
-void MainMenuModel::ExecuteCommand(int id) {
-  int index = id & kItemIndexMask;
-  if (id & kMoreIndexMask)
-    return more_menu_model_->ActivatedAt(index);
-  else if (id & kVPNIndexMask)
-    return vpn_menu_model_->ActivatedAt(index);
-  else if (id & kMainIndexMask)
-    return ActivatedAt(index);
+int MainMenuModel::GetCommandIdAt(int index) const {
+  return index + kMainIndexMask;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // VPNMenuModel
 
 void VPNMenuModel::InitMenuItems(bool is_browser_mode,
                                  bool should_open_button_options) {
   // This gets called on initialization, so any changes should be reflected
   // in CrosMock::SetNetworkLibraryStatusAreaExpectations().
 
@@ skipping 51 matching lines @@
       l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_ADD_VPN),
       SkBitmap(), std::string(), FLAG_ADD_VPN));
   if (active_vpn) {
     menu_items_.push_back(MenuItem(
         ui::MenuModel::TYPE_COMMAND,
         l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DISCONNECT_VPN),
         SkBitmap(), std::string(), FLAG_DISCONNECT_VPN));
   }
 }
 
-void VPNMenuModel::PopulateMenuItem(
-      views::MenuItemView* menu, int index, int command_id) {
-  int vpn_command_id = command_id | kVPNIndexMask;
-  NetworkMenuModel::PopulateMenuItem(menu, index, vpn_command_id);
+int VPNMenuModel::GetCommandIdAt(int index) const {
+  return index + kVPNIndexMask;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MoreMenuModel
 
 void MoreMenuModel::InitMenuItems(
     bool is_browser_mode, bool should_open_button_options) {
   // This gets called on initialization, so any changes should be reflected
   // in CrosMock::SetNetworkLibraryStatusAreaExpectations().
 
@@ skipping 61 matching lines @@
     }
   }
 
   menu_items_ = link_items;
   if (!menu_items_.empty() && address_items.size() > 1)
     menu_items_.push_back(MenuItem());  // Separator
   menu_items_.insert(menu_items_.end(),
       address_items.begin(), address_items.end());
 }
 
-void MoreMenuModel::PopulateMenuItem(
-      views::MenuItemView* menu, int index, int command_id) {
-  int more_command_id = command_id | kMoreIndexMask;
-  NetworkMenuModel::PopulateMenuItem(menu, index, more_command_id);
+int MoreMenuModel::GetCommandIdAt(int index) const {
+  return index + kMoreIndexMask;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenu
 
 NetworkMenu::NetworkMenu(Delegate* delegate, bool is_browser_mode)
     : delegate_(delegate),
       is_browser_mode_(is_browser_mode),
       refreshing_menu_(false),
       min_width_(kDefaultMinimumWidth) {
   main_menu_model_.reset(new MainMenuModel(this));
-  menu_item_view_.reset(new views::MenuItemView(main_menu_model_.get()));
+  menu_model_adapter_.reset(
+      new views::MenuModelAdapter(main_menu_model_.get()));
+  menu_item_view_.reset(new views::MenuItemView(menu_model_adapter_.get()));
   menu_item_view_->set_has_icons(true);
   menu_item_view_->set_menu_position(
       views::MenuItemView::POSITION_BELOW_BOUNDS);
 }
 
 NetworkMenu::~NetworkMenu() {
 }
 
 void NetworkMenu::CancelMenu() {
   menu_item_view_->Cancel();
 }
 
 void NetworkMenu::UpdateMenu() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   refreshing_menu_ = true;
   main_menu_model_->InitMenuItems(
       is_browser_mode(), delegate_->ShouldOpenButtonOptions());
-  main_menu_model_->PopulateMenu(menu_item_view_.get());
+
+  menu_model_adapter_->BuildMenu(menu_item_view_.get());
+  SetMenuMargins(menu_item_view_.get(), kTopMargin, kBottomMargin);
   menu_item_view_->ChildrenChanged();
+
   refreshing_menu_ = false;
 }
 
 void NetworkMenu::RunMenu(views::View* source) {
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   cros->RequestNetworkScan();
 
   UpdateMenu();
 
   gfx::Point screen_location;
@@ skipping 18 matching lines @@
   std::string page = StringPrintf(
       "%s?servicePath=%s&networkType=%d&networkName=%s",
       chrome::kInternetOptionsSubPage,
       EscapeUrlEncodedData(network->service_path(), true).c_str(),
       network->type(),
       EscapeUrlEncodedData(network_name, false).c_str());
   browser->ShowOptionsTab(page);
 }
 
 }  // namespace chromeos