Show hardware addresses for wifi and ethernet networks.

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 17 matching lines @@
 #include "views/controls/button/menu_button.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 {
 
-// Offset for VPN menu items.
+// Offsets for submenus items.
 const int kVPNCommandIndexOffset  = 10000;
+const int kMoreCommandIndexOffset  = 20000;
 
 }  // namespace
 
 namespace chromeos {
 
 class NetworkMenuModel : public views::MenuDelegate {
  public:
   struct NetworkInfo {
     NetworkInfo() :
         need_passphrase(false), remembered(true), auto_connect(true) {}
@@ skipping 12 matching lines @@
     // true if the network is currently remembered.
     bool remembered;
     // true if the network is auto connect (meaningful for Wifi only).
     bool auto_connect;
   };
 
   explicit NetworkMenuModel(NetworkMenu* owner) : owner_(owner) {}
   virtual ~NetworkMenuModel() {}
 
   // 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;
 
   // Connect or reconnect to the network at |index|.
   // If remember >= 0, set the favorite state of the network.
   // Returns true if a connect occurred (e.g. menu should be closed).
   bool 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) {}
 
   // PopulateMenu() clears and reinstalls the menu items defined in this
   // instance by calling PopulateMenuItem() on each one.  Subclasses with
   // submenus should override PopulateMenuItem(), deferring to the base
   // class implementation for non-submenu items and calling PopulateMenu()
   // for the submenu after adding it.
   virtual void PopulateMenu(views::MenuItemView* menu);
   virtual void PopulateMenuItem(
-      views::MenuItemView* menu,
-      int index,
-      int command_id);
+      views::MenuItemView* menu, int index, int command_id);
 
  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,
     FLAG_ETHERNET          = 1 << 6,
     FLAG_WIFI              = 1 << 7,
     FLAG_CELLULAR          = 1 << 8,
-    FLAG_PRIVATE_NETWORKS  = 1 << 9,
-    FLAG_OPTIONS           = 1 << 10,
-    FLAG_ADD_WIFI          = 1 << 11,
-    FLAG_ADD_CELLULAR      = 1 << 12,
-    FLAG_VPN               = 1 << 13,
-    FLAG_ADD_VPN           = 1 << 14,
-    FLAG_DISCONNECT_VPN    = 1 << 15,
+    FLAG_OPTIONS           = 1 << 9,
+    FLAG_ADD_WIFI          = 1 << 10,
+    FLAG_ADD_CELLULAR      = 1 << 11,
+    FLAG_VPN               = 1 << 12,
+    FLAG_ADD_VPN           = 1 << 13,
+    FLAG_DISCONNECT_VPN    = 1 << 14,
   };
 
   struct MenuItem {
     MenuItem()
         : type(ui::MenuModel::TYPE_SEPARATOR),
           sub_menu_model(NULL),
           flags(0) {}
     MenuItem(ui::MenuModel::ItemType type, string16 label, SkBitmap icon,
              const std::string& service_path, int flags)
         : type(type),
@@ skipping 31 matching lines @@
   // Show a NetworkConfigView modal dialog instance.
   void ShowNetworkConfigView(NetworkConfigView* view) const;
 
   void ActivateCellular(const CellularNetwork* cellular) const;
   void ShowOther(ConnectionType type) const;
   void ShowOtherCellular() const;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkMenuModel);
 };
 
+class MoreMenuModel : public NetworkMenuModel {
+ public:
+  explicit MoreMenuModel(NetworkMenu* 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;
+
+ private:
+  friend class MainMenuModel;
+  DISALLOW_COPY_AND_ASSIGN(MoreMenuModel);
+};
+
+class VPNMenuModel : public NetworkMenuModel {
+ public:
+  explicit VPNMenuModel(NetworkMenu* 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;
+
+  static SkBitmap IconForDisplay(const Network* network);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(VPNMenuModel);
+};
+
 class MainMenuModel : public NetworkMenuModel {
  public:
   explicit MainMenuModel(NetworkMenu* owner);
   virtual ~MainMenuModel() {}
 
-  // NetworkMenuModel implementation -------------------------------------------
+  // NetworkMenuModel implementation.
   virtual void InitMenuItems(bool is_browser_mode,
-                             bool should_open_button_options) OVERRIDE;
+                             bool should_open_button_options);
   virtual void PopulateMenuItem(views::MenuItemView* menu,
                                 int index,
                                 int command_id) OVERRIDE;
 
   // MenuDelegate implementaion ------------------------------------------------
   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:
   scoped_ptr<NetworkMenuModel> vpn_menu_model_;
+  scoped_ptr<MoreMenuModel> more_menu_model_;
 
   DISALLOW_COPY_AND_ASSIGN(MainMenuModel);
 };
 
-class VPNMenuModel : public NetworkMenuModel {
- public:
-  explicit VPNMenuModel(NetworkMenu* owner);
-  virtual ~VPNMenuModel() {}
-
-  // NetworkMenuModel implementation.
-  virtual void InitMenuItems(bool is_browser_mode,
-                             bool should_open_button_options);
-  virtual void PopulateMenuItem(
-      views::MenuItemView* menu,
-      int index,
-      int command_id) OVERRIDE;
-
-  static SkBitmap IconForDisplay(const Network* network);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(VPNMenuModel);
-};
-
 // NetworkMenuModel, public methods: -------------------------------------------
 
 bool 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) {
@@ skipping 145 matching lines @@
     ConnectToNetworkAt(id, std::string(), std::string(), -1);
   } else if (flags & FLAG_DISCONNECT_VPN) {
     const VirtualNetwork* active_vpn = cros->virtual_network();
     if (active_vpn)
       cros->DisconnectFromNetwork(active_vpn);
   }
 }
 
 void NetworkMenuModel::PopulateMenu(views::MenuItemView* menu) {
   menu->CreateSubmenu()->RemoveAllChildViews(true);
-  const int menu_items_count = static_cast<int>(menu_items_.size());
-  for (int i = 0; i < menu_items_count; ++i)
+  for (size_t i = 0; i < menu_items_.size(); ++i)
     PopulateMenuItem(menu, i, i);
-
   menu->ChildrenChanged();
 }
 
 void NetworkMenuModel::PopulateMenuItem(
-    views::MenuItemView* menu,
-    int index,
-    int command_id) {
+    views::MenuItemView* menu, int index, int command_id) {
   DCHECK_GT(static_cast<int>(menu_items_.size()), index);
   const MenuItem& item = menu_items_[index];
   switch (item.type) {
     case ui::MenuModel::TYPE_SEPARATOR:
       menu->AppendSeparator();
       break;
     case ui::MenuModel::TYPE_COMMAND:
       if (item.icon.empty()) {
         menu->AppendMenuItemWithLabel(command_id, UTF16ToWide(item.label));
       } else {
         menu->AppendMenuItemWithIcon(
-            command_id,
-            UTF16ToWide(item.label),
-            item.icon);
+            command_id, UTF16ToWide(item.label), item.icon);
       }
       break;
     default:
       // Submenus should be handled by subclasses.
       NOTREACHED();
   }
 }
 
 // NetworkMenuModel, private methods: ------------------------------------------
 
@@ skipping 32 matching lines @@
   ShowNetworkConfigView(new NetworkConfigView(type));
 }
 
 void NetworkMenuModel::ShowOtherCellular() const {
   ChooseMobileNetworkDialog::ShowDialog(owner_->GetNativeWindow());
 }
 
 // MainMenuModel ---------------------------------------------------------------
 
 MainMenuModel::MainMenuModel(NetworkMenu* owner)
-    : NetworkMenuModel(owner) {
-  vpn_menu_model_.reset(new VPNMenuModel(owner));
+    : NetworkMenuModel(owner),
+      vpn_menu_model_(new VPNMenuModel(owner)),
+      more_menu_model_(new MoreMenuModel(owner)) {
 }
 
 // MainMenuModel, NetworkMenuModel implementation: -----------------------------
 
 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();
@@ skipping 199 matching lines @@
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableVPN)) {
     // If there's a connected network, add submenu for Private Networks.
     const Network* connected_network = cros->connected_network();
     if (connected_network) {
       menu_items_.push_back(MenuItem());  // Separator
       menu_items_.push_back(MenuItem(
           ui::MenuModel::TYPE_SUBMENU,
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_PRIVATE_NETWORKS),
           VPNMenuModel::IconForDisplay(connected_network),
-          vpn_menu_model_.get(), FLAG_PRIVATE_NETWORKS));
+          vpn_menu_model_.get(), FLAG_NONE));
     }
   }
 
   // Enable / disable wireless.
   if (wifi_available || cellular_available) {
     menu_items_.push_back(MenuItem());  // Separator
 
     if (wifi_available) {
       // Add 'Scanning...'
       if (cros->wifi_scanning()) {
@@ skipping 32 matching lines @@
     }
   }
 
   // Offline mode.
   // TODO(chocobo): Uncomment once we figure out how to do offline mode.
   // menu_items_.push_back(MenuItem(cros->offline_mode() ?
   //     ui::MenuModel::TYPE_CHECK : ui::MenuModel::TYPE_COMMAND,
   //     l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_OFFLINE_MODE),
   //     SkBitmap(), std::string(), FLAG_TOGGLE_OFFLINE));
 
-  bool connected = cros->Connected();  // always call for test expectations.
-  bool oobe = !should_open_button_options;  // we don't show options for OOBE.
-  // Network settings. (And IP Address)
-  if (!oobe) {
-    menu_items_.push_back(MenuItem());  // Separator
-
-    if (connected) {
-      std::string ip_address = cros->IPAddress();
-      if (!ip_address.empty()) {
-        menu_items_.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND,
-            ASCIIToUTF16(cros->IPAddress()), SkBitmap(), std::string(),
-                         FLAG_DISABLED));
-      }
+  // Additional links like:
+  // * Network settings;
+  // * IP Address on active interface;
+  // * Hardware addresses for wifi and ethernet.
+  menu_items_.push_back(MenuItem());  // Separator
+  more_menu_model_->InitMenuItems(
+      is_browser_mode, should_open_button_options);
+  if (is_browser_mode) {
+    menu_items_.insert(
+        menu_items_.end(),
+        more_menu_model_->menu_items_.begin(),
+        more_menu_model_->menu_items_.end());
+  } 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));
     }
-
-    label = l10n_util::GetStringUTF16(is_browser_mode ?
-        IDS_STATUSBAR_NETWORK_OPEN_OPTIONS_DIALOG :
-        IDS_STATUSBAR_NETWORK_OPEN_PROXY_SETTINGS_DIALOG);
-    menu_items_.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND, label,
-                                   SkBitmap(), std::string(), FLAG_OPTIONS));
   }
 
   // Recursively call each submenu to populate its own menu items.
   for (size_t i = 0; i < menu_items_.size(); ++i) {
-    if (menu_items_[i].type == ui::MenuModel::TYPE_SUBMENU &&
-        menu_items_[i].sub_menu_model) {
+    if (menu_items_[i].type == ui::MenuModel::TYPE_SUBMENU) {
+      NetworkMenuModel* model = menu_items_[i].sub_menu_model;
+      if (model == NULL)
+        continue;
+      if (model == more_menu_model_.get()) {
+        // This submenu is already initialized.
+        continue;
+      }
       menu_items_[i].sub_menu_model->InitMenuItems(is_browser_mode,
                                                    should_open_button_options);
     }
   }
 }
 
 // MainMenuModel, views::MenuDelegate implementation ---------------------------
 
 const gfx::Font& MainMenuModel::GetLabelFont(int id) const {
-  if (id >= kVPNCommandIndexOffset)
+  DCHECK(kMoreCommandIndexOffset > kVPNCommandIndexOffset);
+  if (id >= kMoreCommandIndexOffset)
+    return more_menu_model_->GetLabelFont(id - kMoreCommandIndexOffset);
+  else if (id >= kVPNCommandIndexOffset)
     return vpn_menu_model_->GetLabelFont(id - kVPNCommandIndexOffset);
   else
     return NetworkMenuModel::GetLabelFont(id);
 }
 
 bool MainMenuModel::IsItemChecked(int id) const {
-  if (id >= kVPNCommandIndexOffset)
+  DCHECK(kMoreCommandIndexOffset > kVPNCommandIndexOffset);
+  if (id >= kMoreCommandIndexOffset)
+    return more_menu_model_->IsItemChecked(id - kMoreCommandIndexOffset);
+  else if (id >= kVPNCommandIndexOffset)
     return vpn_menu_model_->IsItemChecked(id - kVPNCommandIndexOffset);
   else
     return NetworkMenuModel::IsItemChecked(id);
 }
 
 bool MainMenuModel::IsCommandEnabled(int id) const {
-  if (id >= kVPNCommandIndexOffset)
+  DCHECK(kMoreCommandIndexOffset > kVPNCommandIndexOffset);
+  if (id >= kMoreCommandIndexOffset)
+    return more_menu_model_->IsCommandEnabled(id - kMoreCommandIndexOffset);
+  else if (id >= kVPNCommandIndexOffset)
     return vpn_menu_model_->IsCommandEnabled(id - kVPNCommandIndexOffset);
   else
     return NetworkMenuModel::IsCommandEnabled(id);
 }
 
 void MainMenuModel::ExecuteCommand(int id) {
-  if (id >= kVPNCommandIndexOffset)
+  DCHECK(kMoreCommandIndexOffset > kVPNCommandIndexOffset);
+  if (id >= kMoreCommandIndexOffset)
+    more_menu_model_->ExecuteCommand(id - kMoreCommandIndexOffset);
+  else if (id >= kVPNCommandIndexOffset)
     vpn_menu_model_->ExecuteCommand(id - kVPNCommandIndexOffset);
   else
     NetworkMenuModel::ExecuteCommand(id);
 }
 
 // MainMenuModel, NetworkMenuModel implementation: -----------------------------
 
 void MainMenuModel::PopulateMenuItem(
-    views::MenuItemView* menu,
-    int index,
-    int command_id) {
+    views::MenuItemView* menu, int index, int command_id) {
   DCHECK_GT(static_cast<int>(menu_items_.size()), index);
   const MenuItem& item = menu_items_[index];
   if (item.type == ui::MenuModel::TYPE_SUBMENU) {
-    views::MenuItemView* vpn_menu = NULL;
+    views::MenuItemView* sub_menu = NULL;
     if (item.icon.empty()) {
-      vpn_menu = menu->AppendSubMenu(command_id, UTF16ToWide(item.label));
+      sub_menu = menu->AppendSubMenu(command_id, UTF16ToWide(item.label));
     } else {
-      vpn_menu = menu->AppendSubMenuWithIcon(
-          command_id,
-          UTF16ToWide(item.label),
-          item.icon);
+      sub_menu = menu->AppendSubMenuWithIcon(
+          command_id, UTF16ToWide(item.label), item.icon);
     }
-    vpn_menu_model_->PopulateMenu(vpn_menu);
+    item.sub_menu_model->PopulateMenu(sub_menu);
   } else {
     NetworkMenuModel::PopulateMenuItem(menu, index, command_id);
   }
 }
 
 // VPNMenuModel ----------------------------------------------------------------
 
 VPNMenuModel::VPNMenuModel(NetworkMenu* owner)
     : NetworkMenuModel(owner) {
 }
@@ skipping 59 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::MenuItemView* menu, int index, int command_id) {
   NetworkMenuModel::PopulateMenuItem(
-      menu,
-      index,
-      command_id + kVPNCommandIndexOffset);
+      menu, index, command_id + kVPNCommandIndexOffset);
 }
 
 // static
 SkBitmap VPNMenuModel::IconForDisplay(const Network* network) {
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   const SkBitmap* icon = NULL;
   const SkBitmap* bottom_right_badge = NULL;
   const SkBitmap* top_left_badge = NULL;
   // We know for sure |network| is the active network, so no more checking
   // is needed by BadgeForPrivateNetworkStatus, hence pass in NULL.
@@ skipping 19 matching lines @@
     default:
       LOG(WARNING) << "VPN not handled for connection type " << network->type();
       return SkBitmap();
   }
 
   return NetworkMenu::IconForDisplay(icon, bottom_right_badge, top_left_badge,
                                      bottom_left_badge);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// MoreMenuModel
+
+MoreMenuModel::MoreMenuModel(NetworkMenu* owner)
+    : NetworkMenuModel(owner) {
+}
+
+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().
+
+  menu_items_.clear();
+  MenuItemVector link_items_;

[stevenjb, 2011/04/25 17:54:27]

'link_items' for local variable name

[Denis Lagno, 2011/04/26 15:54:58]

Done.

+  MenuItemVector address_items_;

[stevenjb, 2011/04/25 17:54:27]

'address_items' for local variable name

[Denis Lagno, 2011/04/26 15:54:58]

Done.

+
+  NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
+  bool oobe = !should_open_button_options;  // we don't show options for OOBE.
+  if (!oobe) {
+    string16 label = l10n_util::GetStringUTF16(is_browser_mode ?
+        IDS_STATUSBAR_NETWORK_OPEN_OPTIONS_DIALOG :
+        IDS_STATUSBAR_NETWORK_OPEN_PROXY_SETTINGS_DIALOG);
+    link_items_.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND, label,
+                                   SkBitmap(), std::string(), FLAG_OPTIONS));
+  }
+
+  bool connected = cros->Connected();  // always call for test expectations.
+  if (connected) {
+    std::string ip_address = cros->IPAddress();
+    if (!ip_address.empty()) {
+      address_items_.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND,
+          ASCIIToUTF16(cros->IPAddress()), SkBitmap(), std::string(),
+                       FLAG_DISABLED));
+    }
+  }
+
+  if (!is_browser_mode) {
+    if (cros->wifi_enabled()) {
+      NetworkDeviceVector wifi = cros->FindWifiDevices();
+      for (size_t i = 0; i < wifi.size(); ++i) {
+        std::string hardware_address;
+        cros->GetIPConfigs(wifi[i]->device_path(),
+            &hardware_address, NetworkLibrary::FORMAT_COLON_SEPARATED_HEX);
+        if (!hardware_address.empty()) {
+          std::string label = l10n_util::GetStringUTF8(
+              IDS_STATUSBAR_NETWORK_DEVICE_WIFI) + " " + hardware_address;
+          address_items_.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND,
+              UTF8ToUTF16(label), SkBitmap(), std::string(), FLAG_DISABLED));
+        }
+      }
+    }
+
+    NetworkDeviceVector ether = cros->FindEthernetDevices();
+    for (size_t i = 0; i < ether.size(); ++i) {
+      std::string hardware_address;
+      cros->GetIPConfigs(ether[i]->device_path(), &hardware_address,
+          NetworkLibrary::FORMAT_COLON_SEPARATED_HEX);
+      if (!hardware_address.empty()) {
+        std::string label = l10n_util::GetStringUTF8(
+            IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET) + " " + hardware_address;
+        address_items_.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND,
+            UTF8ToUTF16(label), SkBitmap(), std::string(), FLAG_DISABLED));
+      }
+    }

[stevenjb, 2011/04/25 17:54:27]

Since we list ethernet networks first, shouldn't we list ethernet hardware
addresses first?
Also, any reason not to show cellular device hardware address?

[Denis Lagno, 2011/04/26 15:54:58]

Done.
We do not see why it may be needed.
Would add it if the need will arise.

+  }
+
+  menu_items_.swap(link_items_);

[stevenjb, 2011/04/25 17:54:27]

manu_items_ = link_items;  (no need for swap)

[Denis Lagno, 2011/04/26 15:54:58]

Done.

+  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) {
+  NetworkMenuModel::PopulateMenuItem(
+      menu, index, command_id + kMoreCommandIndexOffset);
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // 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.
 // static
 const int NetworkMenu::kBarsImages[kNumBarsImages] = {
   IDR_STATUSBAR_NETWORK_BARS1,
@@ skipping 27 matching lines @@
 
 // static
 const int NetworkMenu::kNumAnimatingImages = 10;
 
 // static
 SkBitmap NetworkMenu::kAnimatingImages[kNumAnimatingImages];
 
 // static
 SkBitmap NetworkMenu::kAnimatingImagesBlack[kNumAnimatingImages];
 
-NetworkMenu::NetworkMenu()
-    : min_width_(-1) {
+NetworkMenu::NetworkMenu() : min_width_(-1) {
   main_menu_model_.reset(new MainMenuModel(this));
   network_menu_.reset(new views::MenuItemView(main_menu_model_.get()));
   network_menu_->set_has_icons(true);
 }
 
 NetworkMenu::~NetworkMenu() {
 }
 
 void NetworkMenu::SetFirstLevelMenuWidth(int width) {
   min_width_ = width;
@@ skipping 228 matching lines @@
   gfx::Rect bounds(screen_loc, source->size());
   network_menu_->RunMenuAt(
       window,
       GetMenuButton(),
       bounds,
       base::i18n::IsRTL() ? MenuItemView::TOPLEFT : MenuItemView::TOPRIGHT,
       true);
 }
 
 }  // namespace chromeos
+
+