Change status button menu implementation from Menu2 to MenuItemView.

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/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/choose_mobile_network_dialog.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/sim_unlock_dialog_delegate.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/views/window.h"
 #include "chrome/common/url_constants.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.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_2.h"
+#include "views/controls/menu/menu_item_view.h"
+#include "views/controls/menu/submenu_view.h"
+#include "views/widget/widget.h"
 #include "views/window/window.h"
 
+using views::MenuItemView;
+
 namespace chromeos {
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenu
 
 // static
 const int NetworkMenu::kNumBarsImages = 4;
 
 // NOTE: Use an array rather than just calculating a resource number to avoid
 // creating implicit ordering dependencies on the resource values.
@@ skipping 32 matching lines @@
 const int NetworkMenu::kNumAnimatingImages = 10;
 
 // static
 SkBitmap NetworkMenu::kAnimatingImages[kNumAnimatingImages];
 
 // static
 SkBitmap NetworkMenu::kAnimatingImagesBlack[kNumAnimatingImages];
 
 NetworkMenu::NetworkMenu()
     : min_width_(-1) {
-  network_menu_.reset(new views::Menu2(this));
+  network_menu_.reset(new views::MenuItemView(this));
+  network_menu_->set_has_icons(true);
 }
 
 NetworkMenu::~NetworkMenu() {
 }
 
 bool NetworkMenu::ConnectToNetworkAt(int index,
                                      const std::string& passphrase,
                                      const std::string& ssid,
                                      int auto_connect) const {
   int flags = menu_items_[index].flags;
@@ skipping 49 matching lines @@
     }
   } else if (flags & FLAG_OTHER_WIFI_NETWORK) {
     ShowOtherWifi();
   } else if (flags & FLAG_OTHER_CELLULAR_NETWORK) {
     ShowOtherCellular();
   }
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// NetworkMenu, ui::MenuModel implementation:
-
-int NetworkMenu::GetItemCount() const {
-  return static_cast<int>(menu_items_.size());
+// NetworkMenu, views::MenuItemView implementation:
+std::wstring NetworkMenu::GetLabel(int id) const {
+  DCHECK_LE(0, id);
+  DCHECK_GT(static_cast<int>(menu_items_.size()), id);
+  return UTF16ToWide(menu_items_[id].label);
 }
 
-ui::MenuModel::ItemType NetworkMenu::GetTypeAt(int index) const {
-  return menu_items_[index].type;
+const gfx::Font* NetworkMenu::GetLabelFont(int id) const {
+  return (menu_items_[id].flags & FLAG_ASSOCIATED) ?
+      &ResourceBundle::GetSharedInstance().GetFont(ResourceBundle::BoldFont) :
+      &ResourceBundle::GetSharedInstance().GetFont(ResourceBundle::BaseFont);
 }
 
-string16 NetworkMenu::GetLabelAt(int index) const {
-  return menu_items_[index].label;
+bool NetworkMenu::IsCommandEnabled(int id) const {
+  if (id < static_cast<int>(menu_items_.size()))
+    return !(menu_items_[id].flags & FLAG_DISABLED);
+  else
+    return false;
 }
 
-const gfx::Font* NetworkMenu::GetLabelFontAt(int index) const {
-  return (menu_items_[index].flags & FLAG_ASSOCIATED) ?
-      &ResourceBundle::GetSharedInstance().GetFont(ResourceBundle::BoldFont) :
-      NULL;
+bool NetworkMenu::IsItemChecked(int id) const {
+  DCHECK_LE(0, id);
+  DCHECK_GT(static_cast<int>(menu_items_.size()), id);
+  return menu_items_[id].type == ui::MenuModel::TYPE_CHECK;
 }
 
-bool NetworkMenu::IsItemCheckedAt(int index) const {
-  // All ui::MenuModel::TYPE_CHECK menu items are checked.
-  return true;
-}
+void NetworkMenu::ExecuteCommand(int id) {
+  DCHECK_LE(0, id);
+  DCHECK_GT(static_cast<int>(menu_items_.size()), id);
 
-bool NetworkMenu::GetIconAt(int index, SkBitmap* icon) {
-  if (!menu_items_[index].icon.empty()) {
-    *icon = menu_items_[index].icon;
-    return true;
-  }
-  return false;
-}
-
-bool NetworkMenu::IsEnabledAt(int index) const {
-  return !(menu_items_[index].flags & FLAG_DISABLED);
-}
-
-void NetworkMenu::ActivatedAt(int index) {
   // When we are refreshing the menu, ignore menu item activation.
   if (refreshing_menu_)
     return;
 
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
-  int flags = menu_items_[index].flags;
+  int flags = menu_items_[id].flags;
   if (flags & FLAG_OPTIONS) {
     OpenButtonOptions();
   } else if (flags & FLAG_TOGGLE_ETHERNET) {
     cros->EnableEthernetNetworkDevice(!cros->ethernet_enabled());
   } else if (flags & FLAG_TOGGLE_WIFI) {
     cros->EnableWifiNetworkDevice(!cros->wifi_enabled());
   } else if (flags & FLAG_TOGGLE_CELLULAR) {
     const NetworkDevice* cellular = cros->FindCellularDevice();
     if (!cellular) {
       LOG(ERROR) << "Not found cellular device, it should be available.";
       cros->EnableCellularNetworkDevice(!cros->cellular_enabled());
     } else {
       if (cellular->sim_lock_state() == SIM_UNLOCKED ||
           cellular->sim_lock_state() == SIM_UNKNOWN) {
         cros->EnableCellularNetworkDevice(!cros->cellular_enabled());
       } else {
         SimUnlockDialogDelegate::ShowDialog(GetNativeWindow());
       }
     }
   } else if (flags & FLAG_TOGGLE_OFFLINE) {
     cros->EnableOfflineMode(!cros->offline_mode());
   } else if (flags & FLAG_ETHERNET) {
     if (cros->ethernet_connected()) {
       ShowTabbedNetworkSettings(cros->ethernet_network());
     }
   } else if (flags & FLAG_WIFI) {
-    ConnectToNetworkAt(index, std::string(), std::string(), -1);
+    ConnectToNetworkAt(id, std::string(), std::string(), -1);
   } else if (flags & FLAG_OTHER_WIFI_NETWORK) {
-    ConnectToNetworkAt(index, std::string(), std::string(), -1);
+    ConnectToNetworkAt(id, std::string(), std::string(), -1);
   } else if (flags & FLAG_CELLULAR) {
-    ConnectToNetworkAt(index, std::string(), std::string(), -1);
+    ConnectToNetworkAt(id, std::string(), std::string(), -1);
   } else if (flags & FLAG_OTHER_CELLULAR_NETWORK) {
-    ConnectToNetworkAt(index, std::string(), std::string(), -1);
+    ConnectToNetworkAt(id, std::string(), std::string(), -1);
   }
 }
 
 void NetworkMenu::SetFirstLevelMenuWidth(int width) {
   min_width_ = width;
   // This actually has no effect since menu is rebuilt before showing.
-  network_menu_->SetMinimumWidth(width);
 }
 
 void NetworkMenu::CancelMenu() {
-  network_menu_->CancelMenu();
+  network_menu_->Cancel();
 }
 
 void NetworkMenu::UpdateMenu() {
   refreshing_menu_ = true;
+
+  // Rebuild list of available networks.
   InitMenuItems();
-  network_menu_->Rebuild();
+
+  // Clear and repopulate MenuItemView.
+  network_menu_->CreateSubmenu()->RemoveAllChildViews(true);
+  for (int i = 0, n = menu_items_.size(); i < n; ++i) {
+    if (menu_items_[i].type == ui::MenuModel::TYPE_SEPARATOR)
+      network_menu_->AppendSeparator();
+    else
+      network_menu_->AppendMenuItemWithIcon(
+          i,
+          UTF16ToWide(menu_items_[i].label),
+          menu_items_[i].icon);
+  }
+
+  network_menu_->ChildrenChanged();
   refreshing_menu_ = false;
 }
 
 // static
 const SkBitmap* NetworkMenu::IconForNetworkStrength(const WifiNetwork* wifi,
                                                     bool black) {
   DCHECK(wifi);
   if (wifi->strength() == 0) {
     return ResourceBundle::GetSharedInstance().GetBitmapNamed(
         black ? IDR_STATUSBAR_NETWORK_BARS0_BLACK :
@@ skipping 162 matching lines @@
                          kBottomRightBadgeY);
   if (top_left_badge != NULL)
     canvas.DrawBitmapInt(*top_left_badge, kTopLeftBadgeX, kTopLeftBadgeY);
   return canvas.ExtractBitmap();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenu, views::ViewMenuDelegate implementation:
 
 void NetworkMenu::RunMenu(views::View* source, const gfx::Point& pt) {
-  refreshing_menu_ = true;
+  DCHECK_EQ(GetMenuButton(), source);
+
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   cros->RequestNetworkScan();
 
-  // Build initial menu items. They will be updated when UpdateMenu is
-  // called from NetworkChanged.
-  InitMenuItems();
-  network_menu_->Rebuild();
+  UpdateMenu();
 
-  // Restore menu width, if it was set up.
-  // NOTE: width isn't checked for correctness here since all width-related
-  // logic implemented inside |network_menu_|.
-  if (min_width_ != -1)
-    network_menu_->SetMinimumWidth(min_width_);
-  refreshing_menu_ = false;
-  network_menu_->RunMenuAt(pt, views::Menu2::ALIGN_TOPRIGHT);
+  // TODO(rhashimoto): Remove this workaround when WebUI provides a
+  // top-level widget on the ChromeOS login screen that is a window.
+  // The current BackgroundView class for the ChromeOS login screen
+  // creates a owning Widget that has a native GtkWindow but is not a
+  // Window.  This makes it impossible to get the NativeWindow via
+  // the views API.  This workaround casts the top-level NativeWidget
+  // to a NativeWindow that we can pass to MenuItemView::RunMenuAt().
+  gfx::NativeWindow window;
+  if (source->GetWindow())
+    window = source->GetWindow()->GetNativeWindow();
+  else
+    window = GTK_WINDOW(source->GetWidget()->GetNativeView());
+
+  gfx::Point screen_loc;
+  views::View::ConvertPointToScreen(source, &screen_loc);
+  gfx::Rect bounds(screen_loc, source->size());
+  network_menu_->RunMenuAt(
+      window,
+      GetMenuButton(),
+      bounds,
+      base::i18n::IsRTL() ? MenuItemView::TOPLEFT : MenuItemView::TOPRIGHT,
+      true);
 }
 
 void NetworkMenu::InitMenuItems() {
   // This gets called on initialization, so any changes should be reflected
   // in CrosMock::SetNetworkLibraryStatusAreaExpectations().
 
   menu_items_.clear();
   // Populate our MenuItems with the current list of wifi networks.
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
@@ skipping 295 matching lines @@
 
 void NetworkMenu::ShowOtherWifi() const {
   ShowNetworkConfigView(new NetworkConfigView());
 }
 
 void NetworkMenu::ShowOtherCellular() const {
   ChooseMobileNetworkDialog::ShowDialog(GetNativeWindow());
 }
 
 }  // namespace chromeos