Cleanup network type matching.

chrome/browser/ui/webui/options/chromeos/internet_options_handler.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/ui/webui/options/chromeos/internet_options_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
@@ skipping 45 matching lines @@
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_ip_config.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_ui_data.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_constants.h"
+#include "chromeos/network/shill_property_util.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
@@ skipping 355 matching lines @@
     : service_path_(network->path()),
       name_(network->name()),
       connecting_(network->IsConnectingState()),
       connected_(network->IsConnectedState()),
       connectable_(network->connectable()),
       connection_type_(network->type()),
       remembered_(false),
       shared_(false),
       activation_state_(network->activation_state()),
       policy_managed_(network->IsManaged()) {
-  if (network->type() == flimflam::kTypeEthernet)
+  if (network->Matches(NetworkTypePattern::Ethernet()))
     name_ = l10n_util::GetStringUTF8(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET);
   gfx::ImageSkia icon = ash::network_icon::GetImageForNetwork(
       network, ash::network_icon::ICON_TYPE_LIST);
   SetIcon(icon, icon_scale_factor);
 }
 
 NetworkInfoDictionary::NetworkInfoDictionary(const FavoriteState* favorite,
                                              ui::ScaleFactor icon_scale_factor)
     : service_path_(favorite->path()),
       name_(favorite->name()),
       connecting_(false),
       connected_(false),
       connectable_(false),
       connection_type_(favorite->type()),
       remembered_(true),
       shared_(!favorite->IsPrivate()),
       policy_managed_(favorite->IsManaged()) {
-  if (favorite->type() == flimflam::kTypeEthernet)
+  if (favorite->Matches(NetworkTypePattern::Ethernet()))
     name_ = l10n_util::GetStringUTF8(IDS_STATUSBAR_NETWORK_DEVICE_ETHERNET);
   gfx::ImageSkia icon = ash::network_icon::GetImageForDisconnectedNetwork(
       ash::network_icon::ICON_TYPE_LIST, favorite->type());
   SetIcon(icon, icon_scale_factor);
 }
 
 base::DictionaryValue* NetworkInfoDictionary::BuildDictionary() {
   std::string status;
   if (remembered_) {
     if (shared_)
@@ skipping 193 matching lines @@
   std::string provider_host;
   provider_properties->GetStringWithoutPathExpansion(
       flimflam::kHostProperty, &provider_host);
   SetValueDictionary(dictionary, kTagServerHostname,
                      new base::StringValue(provider_host),
                      hostname_ui_data);
 
   // Disable 'Connect' for VPN unless connected to a non-VPN network.
   const NetworkState* connected_network =
       NetworkHandler::Get()->network_state_handler()->ConnectedNetworkByType(
-          NetworkStateHandler::kMatchTypeNonVirtual);
+          NetworkTypePattern::NonVirtual());
   dictionary->SetBoolean(kTagDisableConnectButton, !connected_network);
 }
 
 // Given a list of supported carrier's by the device, return the index of
 // the carrier the device is currently using.
 int FindCurrentCarrierIndex(const base::ListValue* carriers,
                             const DeviceState* device) {
   DCHECK(carriers);
   DCHECK(device);
   bool gsm = (device->technology_family() == flimflam::kTechnologyFamilyGsm);
@@ skipping 338 matching lines @@
   web_ui()->RegisterMessageCallback(kChangePinMessage,
       base::Bind(&InternetOptionsHandler::ChangePinCallback,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kSetServerHostname,
       base::Bind(&InternetOptionsHandler::SetServerHostnameCallback,
                  base::Unretained(this)));
 }
 
 void InternetOptionsHandler::EnableWifiCallback(const base::ListValue* args) {
   NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled(
-      flimflam::kTypeWifi, true,
+      NetworkTypePattern::WiFi(), true,
       base::Bind(&ShillError, "EnableWifiCallback"));
 }
 
 void InternetOptionsHandler::DisableWifiCallback(const base::ListValue* args) {
   NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled(
-      flimflam::kTypeWifi, false,
+      NetworkTypePattern::WiFi(), false,
       base::Bind(&ShillError, "DisableWifiCallback"));
 }
 
 void InternetOptionsHandler::EnableCellularCallback(
     const base::ListValue* args) {
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   const DeviceState* device =
-      handler->GetDeviceStateByType(flimflam::kTypeCellular);
+      handler->GetDeviceStateByType(NetworkTypePattern::Cellular());
   if (!device) {
     LOG(ERROR) << "Mobile device not found.";
     return;
   }
   if (!device->sim_lock_type().empty()) {
     SimDialogDelegate::ShowDialog(GetNativeWindow(),
                                   SimDialogDelegate::SIM_DIALOG_UNLOCK);
     return;
   }
-  if (!handler->IsTechnologyEnabled(flimflam::kTypeCellular)) {
+  if (!handler->IsTechnologyEnabled(NetworkTypePattern::Cellular())) {
     handler->SetTechnologyEnabled(
-        flimflam::kTypeCellular, true,
+        NetworkTypePattern::Cellular(), true,
         base::Bind(&ShillError, "EnableCellularCallback"));
     return;
   }
   if (device->IsSimAbsent()) {
     MobileConfig* config = MobileConfig::GetInstance();
     if (config->IsReady()) {
       const MobileConfig::LocaleConfig* locale_config =
           config->GetLocaleConfig();
       if (locale_config) {
         std::string setup_url = locale_config->setup_url();
         if (!setup_url.empty()) {
           chrome::ShowSingletonTab(GetAppropriateBrowser(), GURL(setup_url));
           return;
         }
       }
     }
     // TODO(nkostylev): Show generic error message. http://crosbug.com/15444
   }
   LOG(ERROR) << "EnableCellularCallback called for enabled mobile device";
 }
 
 void InternetOptionsHandler::DisableCellularCallback(
     const base::ListValue* args) {
   NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled(
-      NetworkStateHandler::kMatchTypeMobile, false,
+      NetworkTypePattern::Mobile(), false,
       base::Bind(&ShillError, "DisableCellularCallback"));
 }
 
 void InternetOptionsHandler::EnableWimaxCallback(const base::ListValue* args) {
   NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled(
-      flimflam::kTypeWimax, true,
+      NetworkTypePattern::Wimax(), true,
       base::Bind(&ShillError, "EnableWimaxCallback"));
 }
 
 void InternetOptionsHandler::DisableWimaxCallback(const base::ListValue* args) {
   NetworkHandler::Get()->network_state_handler()->SetTechnologyEnabled(
-      flimflam::kTypeWimax, false,
+      NetworkTypePattern::Wimax(), false,
       base::Bind(&ShillError, "DisableWimaxCallback"));
 }
 
 void InternetOptionsHandler::ShowMorePlanInfoCallback(
     const base::ListValue* args) {
   if (!web_ui())
     return;
   std::string service_path;
   if (args->GetSize() != 1 || !args->GetString(0, &service_path)) {
     NOTREACHED();
@@ skipping 68 matching lines @@
   properties.SetWithoutPathExpansion(flimflam::kCellularApnProperty, apn_dict);
   NetworkHandler::Get()->network_configuration_handler()->SetProperties(
       service_path, properties,
       base::Bind(&base::DoNothing),
       base::Bind(&ShillError, "SetApnProperties"));
 }
 
 void InternetOptionsHandler::CarrierStatusCallback() {
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   const DeviceState* device =
-      handler->GetDeviceStateByType(flimflam::kTypeCellular);
+      handler->GetDeviceStateByType(NetworkTypePattern::Cellular());
   if (device && (device->carrier() == shill::kCarrierSprint)) {
     const NetworkState* network =
-        handler->FirstNetworkByType(flimflam::kTypeCellular);
+        handler->FirstNetworkByType(NetworkTypePattern::Cellular());
     if (network) {
       ash::network_connect::ActivateCellular(network->path());
       UpdateConnectionData(network->path());
     }
   }
   UpdateCarrier();
 }
 
 void InternetOptionsHandler::SetCarrierCallback(const base::ListValue* args) {
   std::string service_path;
   std::string carrier;
   if (args->GetSize() != 2 ||
       !args->GetString(0, &service_path) ||
       !args->GetString(1, &carrier)) {
     NOTREACHED();
     return;
   }
   const DeviceState* device = NetworkHandler::Get()->network_state_handler()->
-      GetDeviceStateByType(flimflam::kTypeCellular);
+      GetDeviceStateByType(NetworkTypePattern::Cellular());
   if (!device) {
     LOG(WARNING) << "SetCarrierCallback with no cellular device.";
     return;
   }
   NetworkHandler::Get()->network_device_handler()->SetCarrier(
       device->path(),
       carrier,
       base::Bind(&InternetOptionsHandler::CarrierStatusCallback,
                  weak_factory_.GetWeakPtr()),
       base::Bind(&ShillError, "SetCarrierCallback"));
@@ skipping 329 matching lines @@
   std::string type = network->type();
   dictionary.SetString(kTagType, type);
   dictionary.SetString(kTagServicePath, network->path());
   dictionary.SetString(kTagNameServerType, name_server_type);
   dictionary.SetString(kTagNameServersGoogle, kGoogleNameServers);
 
   // Only show proxy for remembered networks.
   dictionary.SetBoolean(kTagShowProxy, !network->profile_path().empty());
 
   // Enable static ip config for ethernet. For wifi, enable if flag is set.
-  bool staticIPConfig = type == flimflam::kTypeEthernet ||
-      (type == flimflam::kTypeWifi &&
-       CommandLine::ForCurrentProcess()->HasSwitch(
-           chromeos::switches::kEnableStaticIPConfig));
+  bool staticIPConfig = network->Matches(NetworkTypePattern::Ethernet()) ||
+                        (type == flimflam::kTypeWifi &&
+                         CommandLine::ForCurrentProcess()->HasSwitch(
+                             chromeos::switches::kEnableStaticIPConfig));
   dictionary.SetBoolean(kTagShowStaticIPConfig, staticIPConfig);
 
   dictionary.SetBoolean(kTagShowPreferred, !network->profile_path().empty());
   bool preferred = network->priority() > 0;
   SetValueDictionary(&dictionary, kTagPreferred,
                      new base::FundamentalValue(preferred),
                      property_ui_data);
 
   NetworkPropertyUIData auto_connect_ui_data(onc_source);
   std::string onc_path_to_auto_connect;
@@ skipping 37 matching lines @@
   dictionary->SetString(kTagErrorState,
                         ash::network_connect::ErrorString(network->error()));
 
   dictionary->SetBoolean(kTagRemembered, !network->profile_path().empty());
   bool shared = !network->IsPrivate();
   dictionary->SetBoolean(kTagShared, shared);
 
   const std::string& type = network->type();
   const NetworkState* connected_network =
       NetworkHandler::Get()->network_state_handler()->ConnectedNetworkByType(
-          type);
+          NetworkTypePattern::Primitive(type));
 
   dictionary->SetBoolean(kTagDeviceConnected, connected_network != NULL);
 
   if (type == flimflam::kTypeWifi)
     PopulateWifiDetails(network, shill_properties, dictionary);
   else if (type == flimflam::kTypeWimax)
     PopulateWimaxDetails(network, shill_properties, dictionary);
   else if (type == flimflam::kTypeCellular)
     PopulateCellularDetails(network, shill_properties, dictionary);
   else if (type == flimflam::kTypeVPN)
@@ skipping 303 matching lines @@
     NetworkConfigView::ShowForType(flimflam::kTypeVPN, GetNativeWindow());
   else if (type == flimflam::kTypeCellular)
     ChooseMobileNetworkDialog::ShowDialog(GetNativeWindow());
   else
     NOTREACHED();
 }
 
 base::ListValue* InternetOptionsHandler::GetWiredList() {
   base::ListValue* list = new base::ListValue();
   const NetworkState* network = NetworkHandler::Get()->network_state_handler()->
-      FirstNetworkByType(flimflam::kTypeEthernet);
+      FirstNetworkByType(NetworkTypePattern::Ethernet());
   if (!network)
     return list;
   NetworkInfoDictionary network_dict(network, web_ui()->GetDeviceScaleFactor());
   list->Append(network_dict.BuildDictionary());
   return list;
 }
 
 base::ListValue* InternetOptionsHandler::GetWirelessList() {
   base::ListValue* list = new base::ListValue();
 
   NetworkStateHandler::NetworkStateList networks;
-  NetworkHandler::Get()->network_state_handler()->GetNetworkList(&networks);
+  NetworkHandler::Get()->network_state_handler()->GetNetworkListByType(
+      NetworkTypePattern::Wireless(), &networks);
   for (NetworkStateHandler::NetworkStateList::const_iterator iter =
            networks.begin(); iter != networks.end(); ++iter) {
-    const NetworkState* network = *iter;
-    if (network->type() != flimflam::kTypeWifi &&
-        network->type() != flimflam::kTypeWimax &&
-        network->type() != flimflam::kTypeCellular)
-      continue;
-    NetworkInfoDictionary network_dict(
-        network, web_ui()->GetDeviceScaleFactor());
+    NetworkInfoDictionary network_dict(*iter, web_ui()->GetDeviceScaleFactor());
     list->Append(network_dict.BuildDictionary());
   }
 
   return list;
 }
 
 base::ListValue* InternetOptionsHandler::GetVPNList() {
   base::ListValue* list = new base::ListValue();
 
   NetworkStateHandler::NetworkStateList networks;
-  NetworkHandler::Get()->network_state_handler()->GetNetworkList(&networks);
+  NetworkHandler::Get()->network_state_handler()->GetNetworkListByType(
+      NetworkTypePattern::VPN(), &networks);
   for (NetworkStateHandler::NetworkStateList::const_iterator iter =
            networks.begin(); iter != networks.end(); ++iter) {
-    const NetworkState* network = *iter;
-    if (network->type() != flimflam::kTypeVPN)
-      continue;
-    NetworkInfoDictionary network_dict(
-        network, web_ui()->GetDeviceScaleFactor());
+    NetworkInfoDictionary network_dict(*iter, web_ui()->GetDeviceScaleFactor());
     list->Append(network_dict.BuildDictionary());
   }
 
   return list;
 }
 
 base::ListValue* InternetOptionsHandler::GetRememberedList() {
   base::ListValue* list = new base::ListValue();
 
   NetworkStateHandler::FavoriteStateList favorites;
@@ skipping 13 matching lines @@
 }
 
 void InternetOptionsHandler::FillNetworkInfo(
     base::DictionaryValue* dictionary) {
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   dictionary->Set(kTagWiredList, GetWiredList());
   dictionary->Set(kTagWirelessList, GetWirelessList());
   dictionary->Set(kTagVpnList, GetVPNList());
   dictionary->Set(kTagRememberedList, GetRememberedList());
 
-  dictionary->SetBoolean(kTagWifiAvailable,
-                         handler->IsTechnologyAvailable(flimflam::kTypeWifi));
-  dictionary->SetBoolean(kTagWifiEnabled,
-                         handler->IsTechnologyEnabled(flimflam::kTypeWifi));
+  dictionary->SetBoolean(
+      kTagWifiAvailable,
+      handler->IsTechnologyAvailable(NetworkTypePattern::WiFi()));
+  dictionary->SetBoolean(
+      kTagWifiEnabled,
+      handler->IsTechnologyEnabled(NetworkTypePattern::WiFi()));
 
-  dictionary->SetBoolean(kTagCellularAvailable,
-                         handler->IsTechnologyAvailable(
-                             NetworkStateHandler::kMatchTypeMobile));
-  dictionary->SetBoolean(kTagCellularEnabled,
-                         handler->IsTechnologyEnabled(
-                             NetworkStateHandler::kMatchTypeMobile));
+  dictionary->SetBoolean(
+      kTagCellularAvailable,
+      handler->IsTechnologyAvailable(NetworkTypePattern::Mobile()));
+  dictionary->SetBoolean(
+      kTagCellularEnabled,
+      handler->IsTechnologyEnabled(NetworkTypePattern::Mobile()));
   const DeviceState* cellular =
-      handler->GetDeviceStateByType(NetworkStateHandler::kMatchTypeMobile);
+      handler->GetDeviceStateByType(NetworkTypePattern::Mobile());
   dictionary->SetBoolean(
       kTagCellularSupportsScan,
       cellular && cellular->support_network_scan());
 
-  dictionary->SetBoolean(kTagWimaxAvailable,
-                         handler->IsTechnologyAvailable(flimflam::kTypeWimax));
-  dictionary->SetBoolean(kTagWimaxEnabled,
-                         handler->IsTechnologyEnabled(flimflam::kTypeWimax));
+  dictionary->SetBoolean(
+      kTagWimaxAvailable,
+      handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
+  dictionary->SetBoolean(
+      kTagWimaxEnabled,
+      handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
 }
 
 }  // namespace options
 }  // namespace chromeos