Add network_menu_ui.cc and network_menu.js

chrome/browser/chromeos/status/network_menu.cc

 // Copyright (c) 2010 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 "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/command_line.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
+#include "chrome/browser/chromeos/dom_ui/network_menu_ui.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/browser/views/window.h"
 #include "gfx/canvas_skia.h"
 #include "gfx/skbitmap_operations.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "net/base/escape.h"
+#include "views/controls/menu/menu_2.h"
 #include "views/window/window.h"
 
+namespace {
+// Constants passed to Javascript:
+static const char* kNetworkTypeEthernet = "ethernet";
+static const char* kNetworkTypeWifi = "wifi";
+static const char* kNetworkTypeCellular = "cellular";
+static const char* kNetworkTypeOther = "other";
+
+static const char* kNetworkStatusConnected = "connected";
+static const char* kNetworkStatusConnecting = "connecting";
+static const char* kNetworkStatusDisconnected = "disconnected";
+static const char* kNetworkStatusError = "error";
+}
+
 namespace chromeos {
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenu
 
 // static
 const int NetworkMenu::kNumWifiImages = 9;
 
 NetworkMenu::NetworkMenu()
-    : ALLOW_THIS_IN_INITIALIZER_LIST(network_menu_(this)),
-      min_width_(-1) {
+    : min_width_(-1) {
+  network_menu_.reset(NetworkMenuUI::CreateMenu2(this));
 }
 
 NetworkMenu::~NetworkMenu() {
 }
 
+bool NetworkMenu::GetNetworkAt(int index, NetworkInfo* info) const {
+  DCHECK(info);
+  bool res = true;  // True unless a network doesn't exist.
+  int flags = menu_items_[index].flags;
+  NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
+  if (flags & FLAG_ETHERNET) {
+    info->network_type = kNetworkTypeEthernet;
+    if (cros->ethernet_connected()) {
+      info->status = kNetworkStatusConnected;
+      info->ip_address = cros->ethernet_network().ip_address();
+    }
+    info->need_passphrase = false;
+    info->remembered = true;
+  } else if (flags & FLAG_WIFI) {
+    WifiNetwork wifi;
+    bool found = cros->FindWifiNetworkByPath(
+        menu_items_[index].wireless_path, &wifi);
+    if (found) {
+      info->network_type = kNetworkTypeWifi;
+      if (wifi.name() == cros->wifi_name()) {
+        if (cros->wifi_connected()) {
+          info->status = kNetworkStatusConnected;
+          info->message = l10n_util::GetStringUTF8(
+              IDS_STATUSBAR_NETWORK_DEVICE_CONNECTED);
+        } else if (cros->wifi_connecting()) {
+          info->status = kNetworkStatusConnecting;
+          // TODO(stevenjb): Eliminate status message, or localize properly.
+          info->message = l10n_util::GetStringUTF8(
+              IDS_STATUSBAR_NETWORK_DEVICE_CONNECTING)
+              + ": " + wifi.GetStateString();
+        } else if (wifi.state() == STATE_FAILURE) {
+          info->status = kNetworkStatusError;
+          info->message = wifi.GetErrorString();
+        } else {
+          info->status = kNetworkStatusDisconnected;
+          info->message = l10n_util::GetStringUTF8(
+              IDS_STATUSBAR_NETWORK_DEVICE_DISCONNECTED);
+        }
+      }
+      info->ip_address = wifi.ip_address();
+      info->need_passphrase = wifi.encrypted();
+      info->remembered = wifi.favorite();
+    } else {
+      res = false;  // Network not found, hide entry.
+    }
+  } else if (flags & FLAG_CELLULAR) {
+    CellularNetwork cellular;
+    bool found = cros->FindCellularNetworkByPath(
+        menu_items_[index].wireless_path, &cellular);
+    if (found) {
+      info->network_type = kNetworkTypeCellular;
+      if (cellular.name() == cros->cellular_name()) {
+        if (cros->cellular_connected()) {
+          info->status = kNetworkStatusConnected;
+          info->message = l10n_util::GetStringUTF8(
+              IDS_STATUSBAR_NETWORK_DEVICE_CONNECTED);
+        } else if (cros->cellular_connecting()) {
+          // TODO(stevenjb): Eliminate status message, or localize properly.
+          info->status = kNetworkStatusConnecting;
+          info->message = l10n_util::GetStringUTF8(
+              IDS_STATUSBAR_NETWORK_DEVICE_CONNECTING)
+              + ": " + cellular.GetStateString();
+        } else if (cellular.state() == STATE_FAILURE) {
+          info->status = kNetworkStatusError;
+          info->message = cellular.GetErrorString();
+        } else {
+          info->status = kNetworkStatusDisconnected;
+          info->message = l10n_util::GetStringUTF8(
+              IDS_STATUSBAR_NETWORK_DEVICE_DISCONNECTED);
+        }
+      }
+      info->ip_address = cellular.ip_address();
+      info->need_passphrase = false;
+      info->remembered = true;
+    } else {
+      res = false;  // Network not found, hide entry.
+    }
+  } else if (flags & FLAG_OTHER_NETWORK) {
+    info->network_type = kNetworkTypeOther;
+    info->need_passphrase = true;
+    info->remembered = true;
+  } else {
+    // Not a network, e.g options, separator.
+  }
+  return res;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenu, menus::MenuModel implementation:
 
 int NetworkMenu::GetItemCount() const {
   return static_cast<int>(menu_items_.size());
 }
 
 menus::MenuModel::ItemType NetworkMenu::GetTypeAt(int index) const {
   return menu_items_[index].type;
 }
@@ skipping 147 matching lines @@
       }
     } else {
       cros->ConnectToCellularNetwork(cellular);
     }
   }
 }
 
 void NetworkMenu::SetFirstLevelMenuWidth(int width) {
   min_width_ = width;
   // This actually has no effect since menu is rebuilt before showing.
-  network_menu_.SetMinimumWidth(width);
+  network_menu_->SetMinimumWidth(width);
 }
 
 void NetworkMenu::CancelMenu() {
-  network_menu_.CancelMenu();
+  network_menu_->CancelMenu();
 }
 
 // static
 SkBitmap NetworkMenu::IconForNetworkStrength(int strength, bool black) {
   // Compose wifi icon by superimposing various icons.
   // NOTE: Use an array rather than just calculating a resource number to avoid
   // creating implicit ordering dependencies on the resource values.
   static const int kBarsImages[kNumWifiImages] = {
     IDR_STATUSBAR_NETWORK_BARS1,
     IDR_STATUSBAR_NETWORK_BARS2,
@@ skipping 45 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // NetworkMenu, views::ViewMenuDelegate implementation:
 
 void NetworkMenu::RunMenu(views::View* source, const gfx::Point& pt) {
   refreshing_menu_ = true;
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   cros->RequestWifiScan();
   cros->UpdateSystemInfo();
   InitMenuItems();
-  network_menu_.Rebuild();
-  network_menu_.UpdateStates();
+  network_menu_->Rebuild();
+  network_menu_->UpdateStates();
   // 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_);
+    network_menu_->SetMinimumWidth(min_width_);
   refreshing_menu_ = false;
-  network_menu_.RunMenuAt(pt, views::Menu2::ALIGN_TOPRIGHT);
+  network_menu_->RunMenuAt(pt, views::Menu2::ALIGN_TOPRIGHT);
 }
 
 void NetworkMenu::InitMenuItems() {
   menu_items_.clear();
   // Populate our MenuItems with the current list of wifi networks.
   NetworkLibrary* cros = CrosLibrary::Get()->GetNetworkLibrary();
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 
   // Ethernet
   string16 label = l10n_util::GetStringUTF16(
@@ skipping 79 matching lines @@
   // Offline mode.
 //  menu_items_.push_back(MenuItem(cros->offline_mode() ?
 //      menus::MenuModel::TYPE_CHECK : menus::MenuModel::TYPE_COMMAND,
 //      l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_OFFLINE_MODE),
 //      SkBitmap(), std::string(), FLAG_TOGGLE_OFFLINE));
 
   if (cros->Connected() || ShouldOpenButtonOptions()) {
     // Separator.
     menu_items_.push_back(MenuItem());
 
-    // IP address
-    if (cros->Connected()) {
-      menu_items_.push_back(MenuItem(menus::MenuModel::TYPE_COMMAND,
-          ASCIIToUTF16(cros->IPAddress()), SkBitmap(),
-          std::string(), FLAG_DISABLED));
-    }
-
     // Network settings.
     if (ShouldOpenButtonOptions()) {
       label =
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_OPEN_OPTIONS_DIALOG);
       menu_items_.push_back(MenuItem(menus::MenuModel::TYPE_COMMAND, label,
           SkBitmap(), std::string(), FLAG_OPTIONS));
     }
   }
 }
 
 }  // namespace chromeos