Changed wifi arcs to mobile bars for Tether network.

ash/system/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/network/network_icon.h"
 
 #include "ash/resources/vector_icons/vector_icons.h"
 #include "ash/strings/grit/ash_strings.h"
 #include "ash/system/network/network_icon_animation.h"
 #include "ash/system/network/network_icon_animation_observer.h"
 #include "ash/system/tray/tray_constants.h"
 #include "base/macros.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/portal_detector/network_portal_detector.h"
+#include "chromeos/network/tether_constants.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_palette.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/image/canvas_image_source.h"
@@ skipping 43 matching lines @@
   Badge top_left = {};
   Badge center = {};
   Badge bottom_left = {};
   Badge bottom_right = {};
 };
 
 //------------------------------------------------------------------------------
 // class used for maintaining a map of network state and images.
 class NetworkIconImpl {
  public:
-  NetworkIconImpl(const std::string& path, IconType icon_type);
+  NetworkIconImpl(const std::string& path,
+                  IconType icon_type,
+                  const std::string& network_type);
 
   // Determines whether or not the associated network might be dirty and if so
   // updates and generates the icon. Does nothing if network no longer exists.
   void Update(const chromeos::NetworkState* network);
 
   const gfx::ImageSkia& image() const { return image_; }
 
  private:
   // Updates |strength_index_| for wireless networks. Returns true if changed.
   bool UpdateWirelessStrengthIndex(const chromeos::NetworkState* network);
@@ skipping 323 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SignalStrengthImageSource);
 };
 
 //------------------------------------------------------------------------------
 // Utilities for extracting icon images.
 
 ImageType ImageTypeForNetworkType(const std::string& type) {
   if (type == shill::kTypeWifi)
     return ARCS;
-  else if (type == shill::kTypeCellular || type == shill::kTypeWimax)
+  else if (type == shill::kTypeCellular || type == shill::kTypeWimax ||
+           type == chromeos::kTypeTether)
     return BARS;
   return NONE;
 }
 
+// Returns the network type, performing a check to see if Wi-Fi networks
+// have an associated Tether network. Used to display the correct icon.
+std::string GetEffectiveNetworkType(const NetworkState* network) {
+  if (network->type() == shill::kTypeWifi && !network->tether_guid().empty())
+    return chromeos::kTypeTether;
+
+  return network->type();
+}
+
+ImageType ImageTypeForNetwork(const NetworkState* network) {
+  return ImageTypeForNetworkType(GetEffectiveNetworkType(network));
+}
+
 gfx::ImageSkia GetImageForIndex(ImageType image_type,
                                 IconType icon_type,
                                 int index) {
   gfx::CanvasImageSource* source =
       new SignalStrengthImageSource(image_type, icon_type, index);
   return gfx::ImageSkia(source, source->size());
 }
 
 // Returns an image to represent either a fully connected network or a
 // disconnected network.
@@ skipping 85 matching lines @@
   return badge;
 }
 
 gfx::ImageSkia GetIcon(const NetworkState* network,
                        IconType icon_type,
                        int strength_index) {
   if (network->Matches(NetworkTypePattern::Ethernet())) {
     DCHECK_NE(ICON_TYPE_TRAY, icon_type);
     return gfx::CreateVectorIcon(kNetworkEthernetIcon,
                                  GetDefaultColorForIconType(ICON_TYPE_LIST));
-  } else if (network->Matches(NetworkTypePattern::Wireless())) {
+  } else if (network->Matches(NetworkTypePattern::Wireless()) ||
+             network->Matches(NetworkTypePattern::Tether())) {
     DCHECK(strength_index > 0);
-    return GetImageForIndex(ImageTypeForNetworkType(network->type()), icon_type,
+    return GetImageForIndex(ImageTypeForNetwork(network), icon_type,
                             strength_index);
   } else if (network->Matches(NetworkTypePattern::VPN())) {
     DCHECK_NE(ICON_TYPE_TRAY, icon_type);
     return gfx::CreateVectorIcon(kNetworkVpnIcon,
                                  GetDefaultColorForIconType(ICON_TYPE_LIST));
   }
 
   NOTREACHED() << "Request for icon for unsupported type: " << network->type();
   return gfx::ImageSkia();
 }
@@ skipping 31 matching lines @@
 
   return NetworkIconImageSource::CreateImage(
       *ConnectingWirelessImage(image_type, icon_type, animation), Badges());
 }
 
 }  // namespace
 
 //------------------------------------------------------------------------------
 // NetworkIconImpl
 
-NetworkIconImpl::NetworkIconImpl(const std::string& path, IconType icon_type)
+NetworkIconImpl::NetworkIconImpl(const std::string& path,
+                                 IconType icon_type,
+                                 const std::string& network_type)
     : network_path_(path),
       icon_type_(icon_type),
       strength_index_(-1),
       behind_captive_portal_(false) {
   // Default image
-  image_ = GetBasicImage(false, icon_type, shill::kTypeWifi);
+  image_ = GetBasicImage(false, icon_type, network_type);
 }
 
 void NetworkIconImpl::Update(const NetworkState* network) {
   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;
   }
 
   dirty |= UpdatePortalState(network);
 
-  if (network->Matches(NetworkTypePattern::Wireless())) {
+  if (network->Matches(NetworkTypePattern::Wireless()) ||
+      network->Matches(NetworkTypePattern::Tether())) {
     dirty |= UpdateWirelessStrengthIndex(network);
   }
 
   if (network->Matches(NetworkTypePattern::Cellular()))
     dirty |= UpdateCellularState(network);
 
   if (IconTypeHasVPNBadge(icon_type_) &&
       network->Matches(NetworkTypePattern::NonVirtual())) {
     dirty |= UpdateVPNBadge();
   }
@@ skipping 103 matching lines @@
 
 namespace {
 
 NetworkIconImpl* FindAndUpdateImageImpl(const NetworkState* network,
                                         IconType icon_type) {
   // Find or add the icon.
   NetworkIconMap* icon_map = GetIconMap(icon_type);
   NetworkIconImpl* icon;
   NetworkIconMap::iterator iter = icon_map->find(network->path());
   if (iter == icon_map->end()) {
-    icon = new NetworkIconImpl(network->path(), icon_type);
+    icon = new NetworkIconImpl(network->path(), icon_type, network->type());
     icon_map->insert(std::make_pair(network->path(), icon));
   } else {
     icon = iter->second;
   }
 
   // Update and return the icon's image.
   icon->Update(network);
   return icon;
 }
 
 }  // namespace
 
 //------------------------------------------------------------------------------
 // Public interface
 
 gfx::ImageSkia GetImageForNetwork(const NetworkState* network,
                                   IconType icon_type) {
   DCHECK(network);
+  const std::string network_type = GetEffectiveNetworkType(network);
+
   if (!network->visible())
-    return GetBasicImage(false, icon_type, network->type());
+    return GetBasicImage(false /* is_connected */, icon_type, network_type);
 
   if (network->IsConnectingState())
-    return GetConnectingImage(icon_type, network->type());
+    return GetConnectingImage(icon_type, network_type);
 
   NetworkIconImpl* icon = FindAndUpdateImageImpl(network, icon_type);
   return icon->image();
 }
 
 gfx::ImageSkia GetImageForWiFiEnabledState(bool enabled, IconType icon_type) {
   gfx::ImageSkia image =
       GetBasicImage(true /* connected */, icon_type, shill::kTypeWifi);
   Badges badges;
   if (!enabled) {
@@ skipping 196 matching lines @@
     network_paths.insert((*iter)->path());
   }
   PurgeIconMap(ICON_TYPE_TRAY, network_paths);
   PurgeIconMap(ICON_TYPE_DEFAULT_VIEW, network_paths);
   PurgeIconMap(ICON_TYPE_LIST, network_paths);
   PurgeIconMap(ICON_TYPE_MENU_LIST, network_paths);
 }
 
 }  // namespace network_icon
 }  // namespace ash