Cleanup network type matching.

ash/system/chromeos/network/network_icon.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 "ash/system/chromeos/network/network_icon.h"
 
 #include "ash/shell.h"
 #include "ash/system/chromeos/network/network_icon_animation.h"
 #include "ash/system/chromeos/network/network_icon_animation_observer.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_connection_handler.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 "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size_conversions.h"
 
 using chromeos::DeviceState;
 using chromeos::NetworkConnectionHandler;
 using chromeos::NetworkHandler;
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
+using chromeos::NetworkTypePattern;
 
 namespace ash {
 namespace network_icon {
 
 namespace {
 
 //------------------------------------------------------------------------------
 // Struct to pass icon badges to NetworkIconImageSource.
 struct Badges {
   Badges()
@@ skipping 415 matching lines @@
 
 const gfx::ImageSkia* BadgeForVPN(IconType icon_type) {
   return ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
       IDR_AURA_UBER_TRAY_NETWORK_VPN_BADGE);
 }
 
 gfx::ImageSkia GetIcon(const NetworkState* network,
                        IconType icon_type,
                        int strength_index) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-  const std::string& type = network->type();
-  if (type == flimflam::kTypeEthernet) {
+  if (network->Matches(NetworkTypePattern::Ethernet())) {
     return *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_WIRED);
-  } else if (type == flimflam::kTypeWifi ||
-             type == flimflam::kTypeWimax ||
-             type == flimflam::kTypeCellular) {
+  } else if (network->Matches(NetworkTypePattern::Wireless())) {
     DCHECK(strength_index > 0);
     return GetImageForIndex(
-        ImageTypeForNetworkType(type), icon_type, strength_index);
-  } else if (type == flimflam::kTypeVPN) {
+        ImageTypeForNetworkType(network->type()), icon_type, strength_index);
+  } else if (network->Matches(NetworkTypePattern::VPN())) {
     return *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_VPN);
   } else {
-    LOG(WARNING) << "Request for icon for unsupported type: " << type;
+    LOG(WARNING) << "Request for icon for unsupported type: "
+                 << network->type();
     return *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_WIRED);
   }
 }
 
 //------------------------------------------------------------------------------
 // Get connecting images
 
 gfx::ImageSkia GetConnectingVpnImage(IconType icon_type) {
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   const NetworkState* connected_network = NULL;
   if (icon_type == ICON_TYPE_TRAY) {
-    connected_network = handler->ConnectedNetworkByType(
-        NetworkStateHandler::kMatchTypeNonVirtual);
+    connected_network =
+        handler->ConnectedNetworkByType(NetworkTypePattern::NonVirtual());
   }
   double animation = NetworkIconAnimation::GetInstance()->GetAnimation();
 
   if (connected_network) {
     gfx::ImageSkia icon = GetImageForNetwork(connected_network, icon_type);
     Badges badges;
     badges.bottom_left = ConnectingVpnBadge(animation);
     return gfx::ImageSkia(
         new NetworkIconImageSource(icon, badges), icon.size());
   } else {
@@ skipping 35 matching lines @@
   DCHECK(network);
   // Determine whether or not we need to update the icon.
   bool dirty = image_.isNull();
 
   // If the network state has changed, the icon needs updating.
   if (state_ != network->connection_state()) {
     state_ = network->connection_state();
     dirty = true;
   }
 
-  const std::string& type = network->type();
-  if (type != flimflam::kTypeEthernet)
+  if (network->Matches(NetworkTypePattern::Wireless()))
     dirty |= UpdateWirelessStrengthIndex(network);
 
-  if (type == flimflam::kTypeCellular)
+  if (network->Matches(NetworkTypePattern::Cellular()))
     dirty |= UpdateCellularState(network);
 
-  if (IconTypeHasVPNBadge(icon_type_) && type != flimflam::kTypeVPN)
+  if (IconTypeHasVPNBadge(icon_type_) &&
+      network->Matches(NetworkTypePattern::NonVirtual())) {
     dirty |= UpdateVPNBadge();
+  }
 
   if (dirty) {
     // Set the icon and badges based on the network and generate the image.
     GenerateImage(network);
   }
 }
 
 bool NetworkIconImpl::UpdateWirelessStrengthIndex(const NetworkState* network) {
   int index = GetStrengthIndex(network);
   if (index != strength_index_) {
@@ skipping 14 matching lines @@
   std::string roaming_state = network->roaming();
   if (roaming_state != roaming_state_) {
     roaming_state_ = roaming_state;
     dirty = true;
   }
   return dirty;
 }
 
 bool NetworkIconImpl::UpdateVPNBadge() {
   const NetworkState* vpn = NetworkHandler::Get()->network_state_handler()->
-      ConnectedNetworkByType(flimflam::kTypeVPN);
+      ConnectedNetworkByType(NetworkTypePattern::VPN());
   if (vpn && vpn_badge_ == NULL) {
     vpn_badge_ = BadgeForVPN(icon_type_);
     return true;
   } else if (!vpn && vpn_badge_ != NULL) {
     vpn_badge_ = NULL;
     return true;
   }
   return false;
 }
 
@@ skipping 118 matching lines @@
       return l10n_util::GetStringFUTF16(
           IDS_ASH_STATUS_TRAY_NETWORK_CONNECTING, UTF8ToUTF16(network->name()));
     }
     if (activation_state == flimflam::kActivationStateActivating) {
       return l10n_util::GetStringFUTF16(
           IDS_ASH_STATUS_TRAY_NETWORK_ACTIVATING, UTF8ToUTF16(network->name()));
     }
   }
 
   // Otherwise just show the network name or 'Ethernet'.
-  if (network->type() == flimflam::kTypeEthernet) {
+  if (network->Matches(NetworkTypePattern::Ethernet())) {
     return l10n_util::GetStringUTF16(IDS_ASH_STATUS_TRAY_ETHERNET);
   } else {
     return UTF8ToUTF16(network->name());
   }
 }
 
 int GetCellularUninitializedMsg() {
   static base::Time s_uninitialized_state_time;
   static int s_uninitialized_msg(0);
 
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
-  if (handler->GetTechnologyState(NetworkStateHandler::kMatchTypeMobile)
+  if (handler->GetTechnologyState(NetworkTypePattern::Mobile())
       == NetworkStateHandler::TECHNOLOGY_UNINITIALIZED) {
     s_uninitialized_msg = IDS_ASH_STATUS_TRAY_INITIALIZING_CELLULAR;
     s_uninitialized_state_time = base::Time::Now();
     return s_uninitialized_msg;
-  } else if (handler->GetScanningByType(
-      NetworkStateHandler::kMatchTypeMobile)) {
+  } else if (handler->GetScanningByType(NetworkTypePattern::Mobile())) {
     s_uninitialized_msg = IDS_ASH_STATUS_TRAY_CELLULAR_SCANNING;
     s_uninitialized_state_time = base::Time::Now();
     return s_uninitialized_msg;
   }
   // There can be a delay between leaving the Initializing state and when
   // a Cellular device shows up, so keep showing the initializing
   // animation for a bit to avoid flashing the disconnect icon.
   const int kInitializingDelaySeconds = 1;
   base::TimeDelta dtime = base::Time::Now() - s_uninitialized_state_time;
   if (dtime.InSeconds() < kInitializingDelaySeconds)
     return s_uninitialized_msg;
   return 0;
 }
 
 void GetDefaultNetworkImageAndLabel(IconType icon_type,
                                     gfx::ImageSkia* image,
                                     base::string16* label,
                                     bool* animating) {
   NetworkStateHandler* state_handler =
       NetworkHandler::Get()->network_state_handler();
   NetworkConnectionHandler* connect_handler =
       NetworkHandler::Get()->network_connection_handler();
   const NetworkState* connected_network =
-      state_handler->ConnectedNetworkByType(
-          NetworkStateHandler::kMatchTypeNonVirtual);
+      state_handler->ConnectedNetworkByType(NetworkTypePattern::NonVirtual());
   const NetworkState* connecting_network =
-      state_handler->ConnectingNetworkByType(
-          NetworkStateHandler::kMatchTypeWireless);
+      state_handler->ConnectingNetworkByType(NetworkTypePattern::Wireless());
   if (!connecting_network && icon_type == ICON_TYPE_TRAY) {
     connecting_network =
-        state_handler->ConnectingNetworkByType(flimflam::kTypeVPN);
+        state_handler->ConnectingNetworkByType(NetworkTypePattern::VPN());
   }
 
   const NetworkState* network;
   // If we are connecting to a network, and there is either no connected
   // network, or the connection was user requested, use the connecting
   // network.
   if (connecting_network &&
       (!connected_network ||
        connect_handler->HasConnectingNetwork(connecting_network->path()))) {
     network = connecting_network;
   } else {
     network = connected_network;
   }
 
   // Don't show ethernet in the tray
-  if (icon_type == ICON_TYPE_TRAY &&
-      network && network->type() == flimflam::kTypeEthernet) {
+  if (icon_type == ICON_TYPE_TRAY && network &&
+      network->Matches(NetworkTypePattern::Ethernet())) {
     *image = gfx::ImageSkia();
     *animating = false;
     return;
   }
 
   if (!network) {
     // If no connecting network, check if we are activating a network.
-    const NetworkState* mobile_network = state_handler->FirstNetworkByType(
-        NetworkStateHandler::kMatchTypeMobile);
+    const NetworkState* mobile_network =
+        state_handler->FirstNetworkByType(NetworkTypePattern::Mobile());
     if (mobile_network && (mobile_network->activation_state() ==
                            flimflam::kActivationStateActivating)) {
       network = mobile_network;
     }
   }
   if (!network) {
     // If no connecting network, check for cellular initializing.
     int uninitialized_msg = GetCellularUninitializedMsg();
     if (uninitialized_msg != 0) {
       *image = GetImageForConnectingNetwork(icon_type, flimflam::kTypeCellular);
@@ skipping 26 matching lines @@
        iter != networks.end(); ++iter) {
     network_paths.insert((*iter)->path());
   }
   PurgeIconMap(ICON_TYPE_TRAY, network_paths);
   PurgeIconMap(ICON_TYPE_DEFAULT_VIEW, network_paths);
   PurgeIconMap(ICON_TYPE_LIST, network_paths);
 }
 
 }  // namespace network_icon
 }  // namespace ash