Cros system menu - Use WiFi strike-through image for "No networks" row

ash/common/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/common/system/chromeos/network/network_icon.h"
 
 #include "ash/common/system/chromeos/network/network_icon_animation.h"
 #include "ash/common/system/chromeos/network/network_icon_animation_observer.h"
 #include "ash/common/system/tray/tray_constants.h"
 #include "ash/resources/grit/ash_resources.h"
@@ skipping 13 matching lines @@
 #include "ui/base/resource/resource_bundle.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"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/image/image_skia_source.h"
 #include "ui/gfx/paint_vector_icon.h"
+#include "ui/gfx/scoped_canvas.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/vector_icon_types.h"
 
 using chromeos::DeviceState;
 using chromeos::NetworkConnectionHandler;
 using chromeos::NetworkHandler;
 using chromeos::NetworkPortalDetector;
 using chromeos::NetworkState;
 using chromeos::NetworkStateHandler;
 using chromeos::NetworkTypePattern;
 
 namespace ash {
 namespace network_icon {
 
 namespace {
 
 // Constants for offseting the badge displayed on top of the signal strength
 // icon. The badge will extend outside of the base icon bounds by these amounts.
 // All values are in dp.
 
 // The badge offsets are different depending on whether the icon is in the tray
 // or menu.
 const int kTrayIconBadgeOffset = 3;
 const int kMenuIconBadgeOffset = 2;
 
-//------------------------------------------------------------------------------
-// Struct to pass icon badges to NetworkIconImageSource.
-struct Badges {
-  gfx::ImageSkia top_left;
-  gfx::ImageSkia top_right;
-  gfx::ImageSkia center;
-  gfx::ImageSkia bottom_left;
-  gfx::ImageSkia bottom_right;
+// Describes a single badge which is defined by a vector icon.
+struct Badge {
+  bool operator==(const Badge& other) const {
+    return other.icon == icon && other.color == color;
+  }
+  bool operator!=(const Badge& other) const { return !(other == *this); }
+
+  const gfx::VectorIcon* icon;
+  SkColor color;
 };
 
 //------------------------------------------------------------------------------
+// Struct to pass a collection of badges to NetworkIconImageSource.
+struct Badges {
+  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);
 
   // 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_; }
@@ skipping 23 matching lines @@
   // Defines color theme and VPN badging
   const IconType icon_type_;
 
   // Cached state of the network when the icon was last generated.
   std::string state_;
 
   // Cached strength index of the network when the icon was last generated.
   int strength_index_;
 
   // Cached technology badge for the network when the icon was last generated.
-  gfx::ImageSkia technology_badge_;
+  Badge technology_badge_ = {};
 
   // Cached vpn badge for the network when the icon was last generated.
-  gfx::ImageSkia vpn_badge_;
+  Badge vpn_badge_ = {};
 
   // Cached roaming state of the network when the icon was last generated.
   std::string roaming_state_;
 
   // Cached portal state of the network when the icon was last generated.
   bool behind_captive_portal_;
 
   // Generated icon image.
   gfx::ImageSkia image_;
 
@@ skipping 79 matching lines @@
     auto* source = new NetworkIconImageSource(icon, badges);
     return gfx::ImageSkia(source, source->size());
   }
 
   // gfx::CanvasImageSource:
   void Draw(gfx::Canvas* canvas) override {
     const int width = size().width();
     const int height = size().height();
 
     // The base icon is centered in both dimensions.
+    const int icon_x = (width - icon_.width()) / 2;
     const int icon_y = (height - icon_.height()) / 2;
-    canvas->DrawImageInt(icon_, (width - icon_.width()) / 2, icon_y);
+    canvas->DrawImageInt(icon_, icon_x, icon_y);
 
-    // The badges are flush against the edges of the canvas, except at the top,
-    // where the badge is only 1dp higher than the base image.
+    auto paint_badge = [&canvas](const Badge& badge, int x, int y,
+                                 int badge_size = 0) {
+      gfx::ScopedCanvas scoped(canvas);
+      canvas->Translate(gfx::Vector2d(x, y));
+      if (badge_size)
+        gfx::PaintVectorIcon(canvas, *badge.icon, badge_size, badge.color);
+      else
+        gfx::PaintVectorIcon(canvas, *badge.icon, badge.color);
+    };
+
+    // The center badge is scaled and centered over the icon.
+    if (badges_.center.icon)
+      paint_badge(badges_.center, icon_x, icon_y, icon_.width());
+
+    // The other badges are flush against the edges of the canvas, except at the
+    // top, where the badge is only 1dp higher than the base image.
     const int top_badge_y = icon_y - 1;
-    if (!badges_.top_left.isNull())
-      canvas->DrawImageInt(badges_.top_left, 0, top_badge_y);
-    if (!badges_.top_right.isNull()) {
-      canvas->DrawImageInt(badges_.top_right, width - badges_.top_right.width(),
-                           top_badge_y);
+    if (badges_.top_left.icon)
+      paint_badge(badges_.top_left, 0, top_badge_y);
+    if (badges_.bottom_left.icon) {
+      paint_badge(
+          badges_.bottom_left, 0,
+          height - gfx::GetDefaultSizeOfVectorIcon(*badges_.bottom_left.icon));
     }
-    if (!badges_.center.isNull()) {
-      canvas->DrawImageInt(badges_.center, (width - badges_.center.width()) / 2,
-                           (height - badges_.center.height()) / 2);
-    }
-    if (!badges_.bottom_left.isNull()) {
-      canvas->DrawImageInt(badges_.bottom_left, 0,
-                           height - badges_.bottom_left.height());
-    }
-    if (!badges_.bottom_right.isNull()) {
-      canvas->DrawImageInt(badges_.bottom_right,
-                           width - badges_.bottom_right.width(),
-                           height - badges_.bottom_right.height());
+    if (badges_.bottom_right.icon) {
+      const int badge_size =
+          gfx::GetDefaultSizeOfVectorIcon(*badges_.bottom_right.icon);
+      paint_badge(badges_.bottom_right, width - badge_size,
+                  height - badge_size);
     }
   }
 
   bool HasRepresentationAtAllScales() const override { return true; }
 
  private:
   NetworkIconImageSource(const gfx::ImageSkia& icon, const Badges& badges)
       : CanvasImageSource(GetSizeForBaseIconSize(icon.size()), false),
         icon_(icon),
         badges_(badges) {}
@@ skipping 161 matching lines @@
 }
 
 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());
 }
 
-const gfx::ImageSkia GetDisconnectedImage(IconType icon_type,
-                                          const std::string& network_type) {
+// Returns an image to represent either a fully connected/enabled network or a
+// disconnected/disabled network.
+const gfx::ImageSkia GetBasicImage(bool connected,
+                                   IconType icon_type,
+                                   const std::string& network_type) {
   DCHECK_NE(shill::kTypeVPN, network_type);
-  ImageType image_type = ImageTypeForNetworkType(network_type);
-  const int disconnected_index = 0;
-  return GetImageForIndex(image_type, icon_type, disconnected_index);
+  SignalStrengthImageSource* source = new SignalStrengthImageSource(
+      ImageTypeForNetworkType(network_type), icon_type, kNumNetworkImages - 1);
+  gfx::ImageSkia icon = gfx::ImageSkia(source, source->size());
+  Badges badges;
+  if (!connected) {
+    badges.center = {&kNetworkBadgeOffIcon,
+                     GetDefaultColorForIconType(icon_type)};
+  }
+  return NetworkIconImageSource::CreateImage(icon, badges);
 }
 
 gfx::ImageSkia* ConnectingWirelessImage(ImageType image_type,
                                         IconType icon_type,
                                         double animation) {
   static const int kImageCount = kNumNetworkImages - 1;
   static gfx::ImageSkia* s_bars_images_dark[kImageCount];
   static gfx::ImageSkia* s_bars_images_light[kImageCount];
   static gfx::ImageSkia* s_arcs_images_dark[kImageCount];
   static gfx::ImageSkia* s_arcs_images_light[kImageCount];
@@ skipping 23 matching lines @@
     // Lazily cache images.
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     // TODO(estade): update this icon to MD. See crbug.com/690176
     gfx::ImageSkia* icon = rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_VPN);
     s_vpn_images[index] = new gfx::ImageSkia(
         gfx::ImageSkiaOperations::CreateTransparentImage(*icon, animation));
   }
   return *s_vpn_images[index];
 }
 
-gfx::ImageSkia ConnectingVpnBadge(double animation, IconType icon_type) {
-  int index = animation * nextafter(static_cast<float>(kNumFadeImages), 0);
-  static gfx::ImageSkia* s_vpn_badges[kNumFadeImages];
-  if (!s_vpn_badges[index]) {
-    // Lazily cache images.
-    gfx::ImageSkia badge = gfx::CreateVectorIcon(
-        kNetworkBadgeVpnIcon, GetDefaultColorForIconType(icon_type));
-    s_vpn_badges[index] = new gfx::ImageSkia(
-        gfx::ImageSkiaOperations::CreateTransparentImage(badge, animation));
-  }
-  return *s_vpn_badges[index];
+Badge ConnectingVpnBadge(double animation, IconType icon_type) {
+  return {&kNetworkBadgeVpnIcon,
+          SkColorSetA(GetDefaultColorForIconType(icon_type), 0xFF * animation)};
 }
 
 int StrengthIndex(int strength) {
   // Return an index in the range [1, kNumNetworkImages - 1].
   const float findex = (static_cast<float>(strength) / 100.0f) *
                        nextafter(static_cast<float>(kNumNetworkImages - 1), 0);
   int index = 1 + static_cast<int>(findex);
   index = std::max(std::min(index, kNumNetworkImages - 1), 1);
   return index;
 }
 
-gfx::ImageSkia BadgeForNetworkTechnology(const NetworkState* network,
-                                         IconType icon_type) {
+Badge BadgeForNetworkTechnology(const NetworkState* network,
+                                IconType icon_type) {
+  Badge badge = {nullptr, GetDefaultColorForIconType(icon_type)};
   const std::string& technology = network->network_technology();
-  const gfx::VectorIcon* icon = &gfx::kNoneIcon;
   if (technology == shill::kNetworkTechnologyEvdo) {
-    icon = &kNetworkBadgeTechnologyEvdoIcon;
+    badge.icon = &kNetworkBadgeTechnologyEvdoIcon;
   } else if (technology == shill::kNetworkTechnology1Xrtt) {
-    icon = &kNetworkBadgeTechnology1xIcon;
+    badge.icon = &kNetworkBadgeTechnology1xIcon;
   } else if (technology == shill::kNetworkTechnologyGprs ||
              technology == shill::kNetworkTechnologyGsm) {
-    icon = &kNetworkBadgeTechnologyGprsIcon;
+    badge.icon = &kNetworkBadgeTechnologyGprsIcon;
   } else if (technology == shill::kNetworkTechnologyEdge) {
-    icon = &kNetworkBadgeTechnologyEdgeIcon;
+    badge.icon = &kNetworkBadgeTechnologyEdgeIcon;
   } else if (technology == shill::kNetworkTechnologyUmts) {
-    icon = &kNetworkBadgeTechnology3gIcon;
+    badge.icon = &kNetworkBadgeTechnology3gIcon;
   } else if (technology == shill::kNetworkTechnologyHspa) {
-    icon = &kNetworkBadgeTechnologyHspaIcon;
+    badge.icon = &kNetworkBadgeTechnologyHspaIcon;
   } else if (technology == shill::kNetworkTechnologyHspaPlus) {
-    icon = &kNetworkBadgeTechnologyHspaPlusIcon;
+    badge.icon = &kNetworkBadgeTechnologyHspaPlusIcon;
   } else if (technology == shill::kNetworkTechnologyLte) {
-    icon = &kNetworkBadgeTechnologyLteIcon;
+    badge.icon = &kNetworkBadgeTechnologyLteIcon;
   } else if (technology == shill::kNetworkTechnologyLteAdvanced) {
-    icon = &kNetworkBadgeTechnologyLteAdvancedIcon;
+    badge.icon = &kNetworkBadgeTechnologyLteAdvancedIcon;
   } else {
-    return gfx::ImageSkia();
+    return {};
   }
-  return gfx::CreateVectorIcon(*icon, GetDefaultColorForIconType(icon_type));
+  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())) {
@@ skipping 49 matching lines @@
 
 //------------------------------------------------------------------------------
 // NetworkIconImpl
 
 NetworkIconImpl::NetworkIconImpl(const std::string& path, IconType icon_type)
     : network_path_(path),
       icon_type_(icon_type),
       strength_index_(-1),
       behind_captive_portal_(false) {
   // Default image
-  image_ = GetDisconnectedImage(icon_type, shill::kTypeWifi);
+  image_ = GetBasicImage(false, icon_type, shill::kTypeWifi);
 }
 
 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();
@@ skipping 24 matching lines @@
   int index = StrengthIndex(network->signal_strength());
   if (index != strength_index_) {
     strength_index_ = index;
     return true;
   }
   return false;
 }
 
 bool NetworkIconImpl::UpdateCellularState(const NetworkState* network) {
   bool dirty = false;
-  const gfx::ImageSkia technology_badge =
-      BadgeForNetworkTechnology(network, icon_type_);
-  if (!technology_badge.BackedBySameObjectAs(technology_badge_)) {
+  const Badge technology_badge = BadgeForNetworkTechnology(network, icon_type_);
+  if (technology_badge == technology_badge_) {
     technology_badge_ = technology_badge;
     dirty = true;
   }
   std::string roaming_state = network->roaming();
   if (roaming_state != roaming_state_) {
     roaming_state_ = roaming_state;
     dirty = true;
   }
   return dirty;
 }
@@ skipping 11 matching lines @@
   if (behind_captive_portal == behind_captive_portal_)
     return false;
   behind_captive_portal_ = behind_captive_portal;
   return true;
 }
 
 bool NetworkIconImpl::UpdateVPNBadge() {
   const NetworkState* vpn =
       NetworkHandler::Get()->network_state_handler()->ConnectedNetworkByType(
           NetworkTypePattern::VPN());
-  if (vpn && vpn_badge_.isNull()) {
-    vpn_badge_ = gfx::CreateVectorIcon(kNetworkBadgeVpnIcon,
-                                       GetDefaultColorForIconType(icon_type_));
-    return true;
-  }
-  if (!vpn && !vpn_badge_.isNull()) {
-    vpn_badge_ = gfx::ImageSkia();
+  Badge vpn_badge = {};
+  if (vpn)
+    vpn_badge = {&kNetworkBadgeVpnIcon, GetDefaultColorForIconType(icon_type_)};
+  if (vpn_badge != vpn_badge_) {
+    vpn_badge_ = vpn_badge;
     return true;
   }
   return false;
 }
 
 void NetworkIconImpl::GetBadges(const NetworkState* network, Badges* badges) {
   DCHECK(network);
 
   const std::string& type = network->type();
   const SkColor icon_color = GetDefaultColorForIconType(icon_type_);
   if (type == shill::kTypeWifi) {
     if (network->security_class() != shill::kSecurityNone &&
         IconTypeIsDark(icon_type_)) {
-      badges->bottom_right =
-          gfx::CreateVectorIcon(kNetworkBadgeSecureIcon, icon_color);
+      badges->bottom_right = {&kNetworkBadgeSecureIcon, icon_color};
     }
   } else if (type == shill::kTypeWimax) {
-    technology_badge_ =
-        gfx::CreateVectorIcon(kNetworkBadgeTechnology4gIcon, icon_color);
+    technology_badge_ = {&kNetworkBadgeTechnology4gIcon, icon_color};
   } else if (type == shill::kTypeCellular) {
     if (network->roaming() == shill::kRoamingStateRoaming) {
       // For networks that are always in roaming don't show roaming badge.
       const DeviceState* device =
           NetworkHandler::Get()->network_state_handler()->GetDeviceState(
               network->device_path());
       LOG_IF(WARNING, !device) << "Could not find device state for "
                                << network->device_path();
       if (!device || !device->provider_requires_roaming()) {
-        badges->bottom_right =
-            gfx::CreateVectorIcon(kNetworkBadgeRoamingIcon, icon_color);
+        badges->bottom_right = {&kNetworkBadgeRoamingIcon, icon_color};
       }
     }
   }
   if (!network->IsConnectingState()) {
     badges->top_left = technology_badge_;
     badges->bottom_left = vpn_badge_;
   }
 
   if (behind_captive_portal_) {
-    badges->bottom_right =
-        gfx::CreateVectorIcon(kNetworkBadgeCaptivePortalIcon, icon_color);
+    badges->bottom_right = {&kNetworkBadgeCaptivePortalIcon, icon_color};
   }
 }
 
 void NetworkIconImpl::GenerateImage(const NetworkState* network) {
   DCHECK(network);
   gfx::ImageSkia icon = GetIcon(network, icon_type_, strength_index_);
   Badges badges;
   GetBadges(network, &badges);
   image_ = NetworkIconImageSource::CreateImage(icon, badges);
 }
@@ skipping 20 matching lines @@
 
 }  // namespace
 
 //------------------------------------------------------------------------------
 // Public interface
 
 gfx::ImageSkia GetImageForNetwork(const NetworkState* network,
                                   IconType icon_type) {
   DCHECK(network);
   if (!network->visible())
-    return GetDisconnectedImage(icon_type, network->type());
+    return GetBasicImage(false, icon_type, network->type());
 
   if (network->IsConnectingState())
     return GetConnectingImage(icon_type, network->type());
 
   NetworkIconImpl* icon = FindAndUpdateImageImpl(network, icon_type);
   return icon->image();
 }
 
-gfx::ImageSkia GetImageForConnectedMobileNetwork() {
-  ImageType image_type = ImageTypeForNetworkType(shill::kTypeWifi);
-  const IconType icon_type = ICON_TYPE_LIST;
-  const int connected_index = kNumNetworkImages - 1;
-  return GetImageForIndex(image_type, icon_type, connected_index);
+gfx::ImageSkia GetBasicImageForWiFiNetwork(bool connected) {
+  return GetBasicImage(connected, ICON_TYPE_LIST, shill::kTypeWifi);
 }
 
 gfx::ImageSkia GetImageForDisconnectedCellNetwork() {
-  return GetDisconnectedImage(ICON_TYPE_LIST, shill::kTypeCellular);
+  return GetBasicImage(false, ICON_TYPE_LIST, shill::kTypeCellular);
 }
 
 gfx::ImageSkia GetImageForNewWifiNetwork(SkColor icon_color,
                                          SkColor badge_color) {
   SignalStrengthImageSource* source =
       new SignalStrengthImageSource(ImageTypeForNetworkType(shill::kTypeWifi),
                                     ICON_TYPE_LIST, kNumNetworkImages - 1);
   source->set_color(icon_color);
   gfx::ImageSkia icon = gfx::ImageSkia(source, source->size());
   Badges badges;
-  badges.bottom_right =
-      gfx::CreateVectorIcon(kNetworkBadgeAddOtherIcon, badge_color);
+  badges.bottom_right = {&kNetworkBadgeAddOtherIcon, badge_color};
   return NetworkIconImageSource::CreateImage(icon, badges);
 }
 
-gfx::ImageSkia GetImageForWifiChipState(bool enabled) {
-  SignalStrengthImageSource* source =
-      new SignalStrengthImageSource(ImageTypeForNetworkType(shill::kTypeWifi),
-                                    ICON_TYPE_LIST, kNumNetworkImages - 1);
-  gfx::ImageSkia icon = gfx::ImageSkia(source, source->size());
-  Badges badges;
-  if (!enabled)
-    badges.center = gfx::CreateVectorIcon(kNetworkBadgeOffIcon, kMenuIconColor);
-  return NetworkIconImageSource::CreateImage(icon, badges);
-}
-
 base::string16 GetLabelForNetwork(const chromeos::NetworkState* network,
                                   IconType icon_type) {
   DCHECK(network);
   std::string activation_state = network->activation_state();
   if (icon_type == ICON_TYPE_LIST || icon_type == ICON_TYPE_MENU_LIST) {
     // Show "<network>: [Connecting|Activating|Reconnecting]..."
     // TODO(varkha): Remaining states should migrate to secondary status in the
     // network item and no longer be part of the label.
     // See http://crbug.com/676181 .
     if (network->IsReconnecting()) {
@@ skipping 122 matching lines @@
   if (!network) {
     // If no connecting network, check for cellular initializing.
     int uninitialized_msg = GetCellularUninitializedMsg();
     if (uninitialized_msg != 0) {
       *image = GetConnectingImage(icon_type, shill::kTypeCellular);
       if (label)
         *label = l10n_util::GetStringUTF16(uninitialized_msg);
       *animating = true;
     } else {
       // Otherwise show the disconnected wifi icon.
-      *image = GetDisconnectedImage(icon_type, shill::kTypeWifi);
+      *image = GetBasicImage(false, icon_type, shill::kTypeWifi);
       if (label) {
         *label = l10n_util::GetStringUTF16(
             IDS_ASH_STATUS_TRAY_NETWORK_NOT_CONNECTED);
       }
       *animating = false;
     }
     return;
   }
   *animating = network->IsConnectingState();
   // Get icon and label for connected or connecting network.
@@ skipping 12 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