[cros] Network dropdown button in WebUI.

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 128 matching lines @@
                           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,
+  virtual void PopulateMenu(views::MenuItemInterface* menu);
+  virtual void PopulateMenuItem(views::MenuItemInterface* 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;
@@ skipping 49 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,
+  virtual void PopulateMenuItem(views::MenuItemInterface* menu,
                                 int index,
                                 int command_id) 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,
+  virtual void PopulateMenuItem(views::MenuItemInterface* menu,
                                 int index,
                                 int command_id) 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,
+  virtual void PopulateMenuItem(views::MenuItemInterface* 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;
 
  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);
-  }
+void NetworkMenuModel::PopulateMenu(views::MenuItemInterface* menu) {
+  menu->ClearSubmenu();
 
   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) {
+    views::MenuItemInterface* 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;
+      views::MenuItemInterface* 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;
+      views::MenuItemInterface* 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);
@@ skipping 535 matching lines @@
     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) {
+    views::MenuItemInterface* 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)
@@ skipping 89 matching lines @@
       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) {
+      views::MenuItemInterface* menu, int index, int command_id) {
   int vpn_command_id = command_id | kVPNIndexMask;
   NetworkMenuModel::PopulateMenuItem(menu, index, vpn_command_id);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // MoreMenuModel
 
 void MoreMenuModel::InitMenuItems(
     bool is_browser_mode, bool should_open_button_options) {
   // This gets called on initialization, so any changes should be reflected
@@ skipping 64 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) {
+      views::MenuItemInterface* menu, int index, int command_id) {
   int more_command_id = command_id | kMoreIndexMask;
   NetworkMenuModel::PopulateMenuItem(menu, index, more_command_id);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenu
 
-NetworkMenu::NetworkMenu(Delegate* delegate, bool is_browser_mode)
-    : delegate_(delegate),
+
+NetworkMenu::NetworkMenu(Delegate* delegate,
+                         bool is_browser_mode,
+                         views::MenuItemInterface* menu_item)
+    : menu_item_(menu_item),
+      delegate_(delegate),
       is_browser_mode_(is_browser_mode),
-      refreshing_menu_(false),
-      min_width_(kDefaultMinimumWidth) {
+      refreshing_menu_(false) {
   main_menu_model_.reset(new MainMenuModel(this));
-  menu_item_view_.reset(new views::MenuItemView(main_menu_model_.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();
+  menu_item_->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_item_view_->ChildrenChanged();
+  main_menu_model_->PopulateMenu(menu_item_.get());
+  menu_item_->ChildrenChanged();
   refreshing_menu_ = false;
 }
 
-void NetworkMenu::RunMenu(views::View* source) {
-  NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
-  cros->RequestNetworkScan();
-
-  UpdateMenu();
-
-  gfx::Point screen_location;
-  views::View::ConvertPointToScreen(source, &screen_location);
-  gfx::Rect bounds(screen_location, source->size());
-  menu_item_view_->GetSubmenu()->set_minimum_preferred_width(min_width_);
-  menu_item_view_->RunMenuAt(source->GetWidget()->GetTopLevelWidget(),
-                             delegate_->GetMenuButton(), bounds,
-                             views::MenuItemView::TOPRIGHT, true);
-}
-
 void NetworkMenu::ShowTabbedNetworkSettings(const Network* network) const {
   DCHECK(network);
   Browser* browser = BrowserList::GetLastActive();
   if (!browser)
     return;
   std::string network_name(network->name());
   if (network_name.empty() && network->type() == chromeos::TYPE_ETHERNET) {
     network_name = l10n_util::GetStringUTF8(
         IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET);
   }
   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);
 }
 
+views::MenuDelegate* NetworkMenu::GetMenuDelegate() {
+  return main_menu_model_.get();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NetworkMenuView
+
+NetworkMenuView::NetworkMenuView(Delegate* delegate, bool is_browser_mode)
+    : NetworkMenu(delegate, is_browser_mode, NULL),
+      min_width_(kDefaultMinimumWidth) {
+  menu_item_view_ = new views::MenuItemView(main_menu_model_.get());
+  menu_item_.reset(menu_item_view_);
+
+  menu_item_view_->set_has_icons(true);
+  menu_item_view_->set_menu_position(
+      views::MenuItemView::POSITION_BELOW_BOUNDS);
+}
+
+NetworkMenuView::~NetworkMenuView() {
+}
+
+void NetworkMenuView::RunMenu(views::View* source) {
+  NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
+  cros->RequestNetworkScan();
+
+  UpdateMenu();
+
+  gfx::Point screen_location;
+  views::View::ConvertPointToScreen(source, &screen_location);
+  gfx::Rect bounds(screen_location, source->size());
+  menu_item_view_->GetSubmenu()->set_minimum_preferred_width(min_width_);
+  menu_item_view_->RunMenuAt(source->GetWidget()->GetTopLevelWidget(),
+                             delegate()->GetMenuButton(), bounds,
+                             views::MenuItemView::TOPRIGHT, true);
+}
+
 }  // namespace chromeos