Cleanup network type matching.

chrome/browser/chromeos/status/network_menu.cc

 // Copyright (c) 2012 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 "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/system/chromeos/network/network_connect.h"
 #include "ash/system/chromeos/network/network_icon.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chromeos/choose_mobile_network_dialog.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/mobile_config.h"
 #include "chrome/browser/chromeos/options/network_config_view.h"
 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
+#include "chromeos/network/shill_property_util.h"
 #include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
 #include "grit/generated_resources.h"
 #include "third_party/cros_system_api/dbus/service_constants.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/image/image_skia.h"
 
 namespace chromeos {
@@ skipping 14 matching lines @@
     found = str.find('&', found + 2);
   }
   return str;
 }
 
 // Highlight any connected or connecting networks in the UI.
 bool ShouldHighlightNetwork(const NetworkState* network) {
   return network->IsConnectedState() || network->IsConnectingState();
 }
 
-void ToggleTechnology(const std::string& technology) {
+void ToggleTechnology(const NetworkTypePattern& technology) {
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   bool is_enabled = handler->IsTechnologyEnabled(technology);
   ash::network_connect::SetTechnologyEnabled(technology, !is_enabled);
 }
 
 }  // namespace
 
 class NetworkMenuModel : public ui::MenuModel {
  public:
   struct MenuItem {
@@ skipping 225 matching lines @@
 
 void NetworkMenuModel::ActivatedAt(int index) {
   // When we are refreshing the menu, ignore menu item activation.
   if (owner_->refreshing_menu_)
     return;
 
   int flags = menu_items_[index].flags;
   if (flags & FLAG_OPTIONS) {
     owner_->delegate()->OpenButtonOptions();
   } else if (flags & FLAG_TOGGLE_WIFI) {
-    ToggleTechnology(flimflam::kTypeWifi);
+    ToggleTechnology(NetworkTypePattern::WiFi());
   } else if (flags & FLAG_TOGGLE_MOBILE) {
-    ToggleTechnology(NetworkStateHandler::kMatchTypeMobile);
+    ToggleTechnology(NetworkTypePattern::Mobile());
   } else if (flags & FLAG_ETHERNET) {
     owner_->delegate()->OnConnectToNetworkRequested(
         menu_items_[index].service_path);
   } else if (flags & (FLAG_WIFI | FLAG_WIMAX | FLAG_CELLULAR)) {
     ConnectToNetworkAt(index);
     owner_->delegate()->OnConnectToNetworkRequested(
         menu_items_[index].service_path);
   } else if (flags & FLAG_ADD_WIFI) {
     ShowOther(flimflam::kTypeWifi);
   } else if (flags & FLAG_ADD_CELLULAR) {
@@ skipping 59 matching lines @@
 void MainMenuModel::InitMenuItems(bool should_open_button_options) {
   menu_items_.clear();
 
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
 
   // Populate our MenuItems with the current list of networks.
   string16 label;
 
   // Ethernet
   // Only display an ethernet icon if enabled, and an ethernet network exists.
-  bool ethernet_enabled = handler->IsTechnologyEnabled(flimflam::kTypeEthernet);
+  bool ethernet_enabled =
+      handler->IsTechnologyEnabled(NetworkTypePattern::Ethernet());
   const NetworkState* ethernet_network =
-      handler->FirstNetworkByType(flimflam::kTypeEthernet);
+      handler->FirstNetworkByType(NetworkTypePattern::Ethernet());
   if (ethernet_enabled && ethernet_network) {
     bool ethernet_connecting = ethernet_network->IsConnectingState();
     if (ethernet_connecting) {
       label = l10n_util::GetStringFUTF16(
           IDS_STATUSBAR_NETWORK_DEVICE_STATUS,
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET),
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_CONNECTING));
     } else {
       label = l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET);
     }
     int flag = FLAG_ETHERNET;
     if (ShouldHighlightNetwork(ethernet_network))
       flag |= FLAG_ASSOCIATED;
     const gfx::ImageSkia icon = ash::network_icon::GetImageForNetwork(
         ethernet_network, ash::network_icon::ICON_TYPE_LIST);
     menu_items_.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND,
                                    label, icon, std::string(), flag));
   }
 
   // Get the list of all networks.
   NetworkStateHandler::NetworkStateList network_list;
   handler->GetNetworkList(&network_list);
 
   // Cellular Networks
-  if (handler->IsTechnologyEnabled(flimflam::kTypeCellular)) {
+  if (handler->IsTechnologyEnabled(NetworkTypePattern::Cellular())) {
     // List Cellular networks.
     for (NetworkStateHandler::NetworkStateList::const_iterator iter =
              network_list.begin(); iter != network_list.end(); ++iter) {
       const NetworkState* network = *iter;
       if (network->type() != flimflam::kTypeCellular)
         continue;
       std::string activation_state = network->activation_state();
 
       // This is only used in the login screen; do not show unactivated
       // networks.
@@ skipping 18 matching lines @@
         flag |= FLAG_ASSOCIATED;
       const gfx::ImageSkia icon = ash::network_icon::GetImageForNetwork(
           network, ash::network_icon::ICON_TYPE_LIST);
       menu_items_.push_back(
           MenuItem(ui::MenuModel::TYPE_COMMAND,
                    label, icon, network->path(), flag));
     }
 
     // For GSM add cellular network scan.
     const DeviceState* cellular_device =
-        handler->GetDeviceStateByType(flimflam::kTypeCellular);
+        handler->GetDeviceStateByType(NetworkTypePattern::Cellular());
     if (cellular_device && cellular_device->support_network_scan()) {
       const gfx::ImageSkia icon =
           ash::network_icon::GetImageForDisconnectedNetwork(
               ash::network_icon::ICON_TYPE_LIST, flimflam::kTypeCellular);
       menu_items_.push_back(MenuItem(
           ui::MenuModel::TYPE_COMMAND,
           l10n_util::GetStringUTF16(
               IDS_OPTIONS_SETTINGS_OTHER_CELLULAR_NETWORKS),
           icon, std::string(), FLAG_ADD_CELLULAR));
     }
   } else {
     int initializing_message_id =
         ash::network_icon::GetCellularUninitializedMsg();
     if (initializing_message_id) {
       // Initializing cellular modem...
       AddMessageItem(l10n_util::GetStringUTF16(initializing_message_id));
     }
   }
 
   // Wimax Networks
-  if (handler->IsTechnologyEnabled(flimflam::kTypeWimax)) {
+  if (handler->IsTechnologyEnabled(NetworkTypePattern::Wimax())) {
     // List Wimax networks.
     for (NetworkStateHandler::NetworkStateList::const_iterator iter =
              network_list.begin(); iter != network_list.end(); ++iter) {
       const NetworkState* network = *iter;
       if (network->type() != flimflam::kTypeWimax)
         continue;
       AddWirelessNetworkMenuItem(network, FLAG_WIMAX);
     }
   }
 
   // Wifi Networks
-  if (handler->IsTechnologyEnabled(flimflam::kTypeWifi)) {
+  if (handler->IsTechnologyEnabled(NetworkTypePattern::WiFi())) {
     // List Wifi networks.
-    int scanning_msg = handler->GetScanningByType(flimflam::kTypeWifi) ?
-        IDS_ASH_STATUS_TRAY_WIFI_SCANNING_MESSAGE : 0;
+    int scanning_msg = handler->GetScanningByType(NetworkTypePattern::WiFi())
+                           ? IDS_ASH_STATUS_TRAY_WIFI_SCANNING_MESSAGE
+                           : 0;
     for (NetworkStateHandler::NetworkStateList::const_iterator iter =
              network_list.begin(); iter != network_list.end(); ++iter) {
       const NetworkState* network = *iter;
       if (network->type() != flimflam::kTypeWifi)
         continue;
       // Add 'Searching for Wi-Fi networks...' after connected networks.
       if (scanning_msg && !network->IsConnectedState()) {
         AddMessageItem(l10n_util::GetStringUTF16(scanning_msg));
         scanning_msg = 0;
       }
@@ skipping 12 matching lines @@
 
   if (menu_items_.empty()) {
     // No networks available (and not initializing cellular or wifi scanning)
     AddMessageItem(l10n_util::GetStringFUTF16(
         IDS_STATUSBAR_NETWORK_MENU_ITEM_INDENT,
         l10n_util::GetStringUTF16(IDS_STATUSBAR_NO_NETWORKS_MESSAGE)));
   }
 
   // Enable / Disable Technology
   NetworkStateHandler::TechnologyState wifi_state =
-      handler->GetTechnologyState(flimflam::kTypeWifi);
+      handler->GetTechnologyState(NetworkTypePattern::WiFi());
   bool wifi_available =
       wifi_state != NetworkStateHandler::TECHNOLOGY_UNAVAILABLE;
   bool wifi_enabled = wifi_state == NetworkStateHandler::TECHNOLOGY_ENABLED;
 
   NetworkStateHandler::TechnologyState mobile_state =
-      handler->GetTechnologyState(NetworkStateHandler::kMatchTypeMobile);
+      handler->GetTechnologyState(NetworkTypePattern::Mobile());
   bool mobile_available =
       mobile_state != NetworkStateHandler::TECHNOLOGY_UNAVAILABLE;
   bool mobile_enabled = mobile_state == NetworkStateHandler::TECHNOLOGY_ENABLED;
 
   // Do not show disable wifi or cellular during oobe.
   bool show_toggle_wifi = wifi_available &&
       (should_open_button_options || !wifi_enabled);
   bool show_toggle_mobile = mobile_available &&
       (should_open_button_options || !mobile_enabled);
 
   if (show_toggle_wifi || show_toggle_mobile) {
     menu_items_.push_back(MenuItem());  // Separator
 
     if (show_toggle_wifi) {
       int id = wifi_enabled ? IDS_STATUSBAR_NETWORK_DEVICE_DISABLE :
                               IDS_STATUSBAR_NETWORK_DEVICE_ENABLE;
       label = l10n_util::GetStringFUTF16(id,
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_WIFI));
       int flag = FLAG_TOGGLE_WIFI;
       if (wifi_state == NetworkStateHandler::TECHNOLOGY_ENABLING)
         flag |= FLAG_DISABLED;
       menu_items_.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND, label,
           gfx::ImageSkia(), std::string(), flag));
     }
 
     if (show_toggle_mobile) {
       const DeviceState* mobile_device =
-          handler->GetDeviceStateByType(NetworkStateHandler::kMatchTypeMobile);
+          handler->GetDeviceStateByType(NetworkTypePattern::Mobile());
       bool is_locked = mobile_device && !mobile_device->sim_lock_type().empty();
       int id = (mobile_enabled && !is_locked)
           ? IDS_STATUSBAR_NETWORK_DEVICE_DISABLE
           : IDS_STATUSBAR_NETWORK_DEVICE_ENABLE;
       label = l10n_util::GetStringFUTF16(id,
           l10n_util::GetStringUTF16(IDS_STATUSBAR_NETWORK_DEVICE_CELLULAR));
       gfx::ImageSkia icon;
       int flag = FLAG_TOGGLE_MOBILE;
       if (mobile_state == NetworkStateHandler::TECHNOLOGY_ENABLING)
         flag |= FLAG_DISABLED;
@@ skipping 44 matching lines @@
   if (default_network) {
     std::string ip_address = default_network->ip_address();
     if (!ip_address.empty()) {
       address_items.push_back(MenuItem(ui::MenuModel::TYPE_COMMAND,
           ASCIIToUTF16(ip_address), gfx::ImageSkia(), std::string(),
                        FLAG_DISABLED));
     }
   }
 
   std::string ethernet_address =
-      handler->FormattedHardwareAddressForType(flimflam::kTypeEthernet);
+      handler->FormattedHardwareAddressForType(NetworkTypePattern::Ethernet());
   if (!ethernet_address.empty()) {
     std::string label = l10n_util::GetStringUTF8(
         IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET) + " " + ethernet_address;
     address_items.push_back(MenuItem(
         ui::MenuModel::TYPE_COMMAND,
         UTF8ToUTF16(label), gfx::ImageSkia(), std::string(), FLAG_DISABLED));
   }
 
   std::string wifi_address =
-      handler->FormattedHardwareAddressForType(flimflam::kTypeWifi);
+      handler->FormattedHardwareAddressForType(NetworkTypePattern::WiFi());
   if (!wifi_address.empty()) {
     std::string label = l10n_util::GetStringUTF8(
         IDS_STATUSBAR_NETWORK_DEVICE_WIFI) + " " + wifi_address;
     address_items.push_back(MenuItem(
         ui::MenuModel::TYPE_COMMAND,
         UTF8ToUTF16(label), gfx::ImageSkia(), std::string(), FLAG_DISABLED));
   }
 
   menu_items_ = link_items;
   if (!menu_items_.empty() && address_items.size() > 1)
@@ skipping 26 matching lines @@
   return main_menu_model_.get();
 }
 
 void NetworkMenu::UpdateMenu() {
   refreshing_menu_ = true;
   main_menu_model_->InitMenuItems(delegate_->ShouldOpenButtonOptions());
   refreshing_menu_ = false;
 }
 
 }  // namespace chromeos