Cleanup network type matching.

chromeos/network/network_state_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 "chromeos/network/network_state_handler.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/favorite_state.h"
 #include "chromeos/network/managed_state.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler_observer.h"
 #include "chromeos/network/shill_property_handler.h"
+#include "chromeos/network/shill_property_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
-// Returns true if |network->type()| == |match_type|, or it matches one of the
-// following special match types:
-// * kMatchTypeDefault matches any network (i.e. the first instance)
-// * kMatchTypeNonVirtual matches non virtual networks
-// * kMatchTypeWireless matches wireless networks
-// * kMatchTypeMobile matches cellular or wimax networks
-bool ManagedStateMatchesType(const ManagedState* managed,
-                             const std::string& match_type) {
-  const std::string& type = managed->type();
-  if (match_type == NetworkStateHandler::kMatchTypeDefault)
-    return true;
-  if (match_type == type)
-    return true;
-  if (match_type == NetworkStateHandler::kMatchTypeNonVirtual &&
-      type != flimflam::kTypeVPN) {
-    return true;
-  }
-  if (match_type == NetworkStateHandler::kMatchTypeWireless &&
-      type != flimflam::kTypeEthernet && type != flimflam::kTypeVPN) {
-    return true;
-  }
-  if (match_type == NetworkStateHandler::kMatchTypeMobile &&
-      (type == flimflam::kTypeCellular || type == flimflam::kTypeWimax)) {
-    return true;
-  }
-  return false;
-}
-
 bool ConnectionStateChanged(NetworkState* network,
                             const std::string& prev_connection_state) {
   return (network->connection_state() != prev_connection_state) &&
          (network->connection_state() != flimflam::kStateIdle ||
           !prev_connection_state.empty());
 }
 
 std::string GetManagedStateLogType(const ManagedState* state) {
   switch (state->managed_type()) {
     case ManagedState::MANAGED_TYPE_NETWORK:
       return "Network";
     case ManagedState::MANAGED_TYPE_FAVORITE:
       return "Favorite";
     case ManagedState::MANAGED_TYPE_DEVICE:
       return "Device";
   }
   NOTREACHED();
   return "";
 }
 
 std::string GetManagedStateLogName(const ManagedState* state) {
   if (!state)
     return "None";
   return base::StringPrintf("%s (%s)", state->name().c_str(),
                             state->path().c_str());
 }
 
 }  // namespace
 
-const char NetworkStateHandler::kMatchTypeDefault[] = "default";
-const char NetworkStateHandler::kMatchTypeWireless[] = "wireless";
-const char NetworkStateHandler::kMatchTypeMobile[] = "mobile";
-const char NetworkStateHandler::kMatchTypeNonVirtual[] = "non-virtual";
 const char NetworkStateHandler::kDefaultCheckPortalList[] =
     "ethernet,wifi,cellular";
 
 NetworkStateHandler::NetworkStateHandler() {
 }
 
 NetworkStateHandler::~NetworkStateHandler() {
   STLDeleteContainerPointers(network_list_.begin(), network_list_.end());
   STLDeleteContainerPointers(favorite_list_.begin(), favorite_list_.end());
   STLDeleteContainerPointers(device_list_.begin(), device_list_.end());
@@ skipping 30 matching lines @@
       network_event_log::LOG_LEVEL_DEBUG,
       "NetworkStateHandler::RemoveObserver", "");
 }
 
 void NetworkStateHandler::UpdateManagerProperties() {
   NET_LOG_USER("UpdateManagerProperties", "");
   shill_property_handler_->UpdateManagerProperties();
 }
 
 NetworkStateHandler::TechnologyState NetworkStateHandler::GetTechnologyState(
-    const std::string& type) const {
+    const NetworkTypePattern& type) const {
   std::string technology = GetTechnologyForType(type);
   TechnologyState state;
   if (shill_property_handler_->IsTechnologyEnabled(technology))
     state = TECHNOLOGY_ENABLED;
   else if (shill_property_handler_->IsTechnologyEnabling(technology))
     state = TECHNOLOGY_ENABLING;
   else if (shill_property_handler_->IsTechnologyUninitialized(technology))
     state = TECHNOLOGY_UNINITIALIZED;
   else if (shill_property_handler_->IsTechnologyAvailable(technology))
     state = TECHNOLOGY_AVAILABLE;
   else
     state = TECHNOLOGY_UNAVAILABLE;
-  VLOG(2) << "GetTechnologyState: " << type << " = " << state;
+  VLOG(2) << "GetTechnologyState: " << type.ToDebugString() << " = " << state;
   return state;
 }
 
 void NetworkStateHandler::SetTechnologyEnabled(
-    const std::string& type,
+    const NetworkTypePattern& type,
     bool enabled,
     const network_handler::ErrorCallback& error_callback) {
   std::string technology = GetTechnologyForType(type);
   NET_LOG_USER("SetTechnologyEnabled",
                base::StringPrintf("%s:%d", technology.c_str(), enabled));
   shill_property_handler_->SetTechnologyEnabled(
       technology, enabled, error_callback);
   // Signal Technology state changed -> ENABLING
   NotifyManagerPropertyChanged();
 }
 
 const DeviceState* NetworkStateHandler::GetDeviceState(
     const std::string& device_path) const {
   const DeviceState* device = GetModifiableDeviceState(device_path);
   DCHECK(!device || device->update_received());
   return device;
 }
 
 const DeviceState* NetworkStateHandler::GetDeviceStateByType(
-    const std::string& type) const {
+    const NetworkTypePattern& type) const {
   for (ManagedStateList::const_iterator iter = device_list_.begin();
        iter != device_list_.end(); ++iter) {
     ManagedState* device = *iter;
     if (!device->update_received())
       continue;
-    if (ManagedStateMatchesType(device, type))
+    if (device->Matches(type))
       return device->AsDeviceState();
   }
   return NULL;
 }
 
-bool NetworkStateHandler::GetScanningByType(const std::string& type) const {
+bool NetworkStateHandler::GetScanningByType(
+    const NetworkTypePattern& type) const {
   for (ManagedStateList::const_iterator iter = device_list_.begin();
        iter != device_list_.end(); ++iter) {
     const DeviceState* device = (*iter)->AsDeviceState();
     DCHECK(device);
     if (!device->update_received())
       continue;
-    if (ManagedStateMatchesType(device, type) && device->scanning())
+    if (device->Matches(type) && device->scanning())
       return true;
   }
   return false;
 }
 
 const NetworkState* NetworkStateHandler::GetNetworkState(
     const std::string& service_path) const {
   const NetworkState* network = GetModifiableNetworkState(service_path);
   DCHECK(!network || network->update_received());
   return network;
 }
 
 const NetworkState* NetworkStateHandler::DefaultNetwork() const {
   if (network_list_.empty())
     return NULL;
   const NetworkState* network = network_list_.front()->AsNetworkState();
   DCHECK(network);
   if (!network->update_received() || !network->IsConnectedState())
     return NULL;
   return network;
 }
 
 const NetworkState* NetworkStateHandler::ConnectedNetworkByType(
-    const std::string& type) const {
+    const NetworkTypePattern& type) const {
   for (ManagedStateList::const_iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
     if (!network->update_received())
       continue;
     if (!network->IsConnectedState())
       break;  // Connected networks are listed first.
-    if (ManagedStateMatchesType(network, type))
+    if (network->Matches(type))
       return network;
   }
   return NULL;
 }
 
 const NetworkState* NetworkStateHandler::ConnectingNetworkByType(
-    const std::string& type) const {
+    const NetworkTypePattern& type) const {
   for (ManagedStateList::const_iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
     if (!network->update_received() || network->IsConnectedState())
       continue;
     if (!network->IsConnectingState())
       break;  // Connected and connecting networks are listed first.
-    if (ManagedStateMatchesType(network, type))
+    if (network->Matches(type))
       return network;
   }
   return NULL;
 }
 
 const NetworkState* NetworkStateHandler::FirstNetworkByType(
-    const std::string& type) const {
+    const NetworkTypePattern& type) const {
   for (ManagedStateList::const_iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
     if (!network->update_received())
       continue;
-    if (ManagedStateMatchesType(network, type))
+    if (network->Matches(type))
       return network;
   }
   return NULL;
 }
 
 std::string NetworkStateHandler::HardwareAddressForType(
-    const std::string& type) const {
+    const NetworkTypePattern& type) const {
   const NetworkState* network = ConnectedNetworkByType(type);
   if (!network)
     return std::string();
   const DeviceState* device = GetDeviceState(network->device_path());
   if (!device)
     return std::string();
   std::string result = device->mac_address();
   StringToUpperASCII(&result);
   return result;
 }
 
 std::string NetworkStateHandler::FormattedHardwareAddressForType(
-    const std::string& type) const {
+    const NetworkTypePattern& type) const {
   std::string address = HardwareAddressForType(type);
   if (address.size() % 2 != 0)
     return address;
   std::string result;
   for (size_t i = 0; i < address.size(); ++i) {
     if ((i != 0) && (i % 2 == 0))
       result.push_back(':');
     result.push_back(address[i]);
   }
   return result;
 }
 
 void NetworkStateHandler::GetNetworkList(NetworkStateList* list) const {
-  GetNetworkListByType(kMatchTypeDefault, list);
+  GetNetworkListByType(NetworkTypePattern::Default(), list);
 }
 
-void NetworkStateHandler::GetNetworkListByType(const std::string& type,
+void NetworkStateHandler::GetNetworkListByType(const NetworkTypePattern& type,
                                                NetworkStateList* list) const {
   DCHECK(list);
   list->clear();
   for (ManagedStateList::const_iterator iter = network_list_.begin();
        iter != network_list_.end(); ++iter) {
     const NetworkState* network = (*iter)->AsNetworkState();
     DCHECK(network);
     if (!network->update_received())
       continue;
-    if (ManagedStateMatchesType(network, type))
+    if (network->Matches(type))
       list->push_back(network);
   }
 }
 
 void NetworkStateHandler::GetDeviceList(DeviceStateList* list) const {
   DCHECK(list);
   list->clear();
   for (ManagedStateList::const_iterator iter = device_list_.begin();
        iter != device_list_.end(); ++iter) {
     const DeviceState* device = (*iter)->AsDeviceState();
@@ skipping 30 matching lines @@
 }
 
 void NetworkStateHandler::RequestScan() const {
   NET_LOG_USER("RequestScan", "");
   shill_property_handler_->RequestScan();
 }
 
 void NetworkStateHandler::WaitForScan(const std::string& type,
                                       const base::Closure& callback) {
   scan_complete_callbacks_[type].push_back(callback);
-  if (!GetScanningByType(type))
+  if (!GetScanningByType(NetworkTypePattern::Primitive(type)))
     RequestScan();
 }
 
 void NetworkStateHandler::ConnectToBestWifiNetwork() {
   NET_LOG_USER("ConnectToBestWifiNetwork", "");
   WaitForScan(flimflam::kTypeWifi,
               base::Bind(&internal::ShillPropertyHandler::ConnectToBestServices,
                          shill_property_handler_->AsWeakPtr()));
 }
 
@@ skipping 371 matching lines @@
     return;
   ScanCallbackList& callback_list = scan_complete_callbacks_[type];
   for (ScanCallbackList::iterator iter = callback_list.begin();
        iter != callback_list.end(); ++iter) {
     (*iter).Run();
   }
   scan_complete_callbacks_.erase(type);
 }
 
 std::string NetworkStateHandler::GetTechnologyForType(
-    const std::string& type) const {
-  if (type == kMatchTypeMobile) {
-    if (shill_property_handler_->IsTechnologyAvailable(flimflam::kTypeWimax))
+    const NetworkTypePattern& type) const {
+  if (type.MatchesType(flimflam::kTypeEthernet))
+    return flimflam::kTypeEthernet;
+
+  if (type.MatchesType(flimflam::kTypeWifi))
+    return flimflam::kTypeWifi;
+
+  if (type.Equals(NetworkTypePattern::Wimax()))
       return flimflam::kTypeWimax;
-    else
+
+  // Prefer Wimax over Cellular only if it's available.
+  if (type.MatchesType(flimflam::kTypeWimax) &&
+      shill_property_handler_->IsTechnologyAvailable(flimflam::kTypeWimax)) {
+      return flimflam::kTypeWimax;
+  }
+
+  if (type.MatchesType(flimflam::kTypeCellular))
       return flimflam::kTypeCellular;
-  }
-  if (type == kMatchTypeDefault || type == kMatchTypeNonVirtual ||
-      type == kMatchTypeWireless) {
-    NOTREACHED();
-    return flimflam::kTypeWifi;
-  }
-  return type;
+
+  NOTREACHED();
+  return std::string();
 }
 
 }  // namespace chromeos