CrOS MD - use vectorized icons for ethernet and VPN.

ui/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 "ui/chromeos/network/network_icon.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"
@@ skipping 468 matching lines @@
 
   if (index < 0 || index >= kNumNetworkImages)
     return gfx::ImageSkia();
   gfx::ImageSkia* images = BaseImageForType(image_type, icon_type);
   int width = images->width();
   int height = images->height() / kNumNetworkImages;
   return gfx::ImageSkiaOperations::ExtractSubset(*images,
       gfx::Rect(0, index * height, width, height));
 }
 
-gfx::ImageSkia GetConnectedImage(IconType icon_type,
-                                 const std::string& network_type) {
-  if (network_type == shill::kTypeVPN) {
-    return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-        IDR_AURA_UBER_TRAY_NETWORK_VPN);
-  }
-  ImageType image_type = ImageTypeForNetworkType(network_type);
-  const int connected_index = kNumNetworkImages - 1;
-  return GetImageForIndex(image_type, icon_type, connected_index);
-}
-
 const gfx::ImageSkia GetDisconnectedImage(IconType icon_type,
                                           const std::string& network_type) {
-  if (network_type == shill::kTypeVPN) {
-    // Note: same as connected image, shouldn't normally be seen.
-    return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-        IDR_AURA_UBER_TRAY_NETWORK_VPN);
-  }
+  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);
 }
 
 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];
@@ skipping 25 matching lines @@
   if (!s_vpn_images[index]) {
     // Lazily cache images.
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     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) {
+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.
-    ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
-    gfx::ImageSkia* badge =
-        rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_VPN_BADGE);
+    gfx::ImageSkia badge =
+        UseMd() ? gfx::CreateVectorIcon(gfx::VectorIconId::NETWORK_BADGE_VPN,
+                                        GetBaseColorForIconType(icon_type))
+                : *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
+                      IDR_AURA_UBER_TRAY_NETWORK_VPN_BADGE);
     s_vpn_badges[index] = new gfx::ImageSkia(
-        gfx::ImageSkiaOperations::CreateTransparentImage(*badge, animation));
+        gfx::ImageSkiaOperations::CreateTransparentImage(badge, animation));
   }
   return *s_vpn_badges[index];
 }
 
 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);
@@ skipping 65 matching lines @@
     return gfx::ImageSkia();
   }
   return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(id);
 }
 
 gfx::ImageSkia GetIcon(const NetworkState* network,
                        IconType icon_type,
                        int strength_index) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   if (network->Matches(NetworkTypePattern::Ethernet())) {
-    return *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_WIRED);
+    DCHECK_NE(ICON_TYPE_TRAY, icon_type);
+    return UseMd()
+               ? gfx::CreateVectorIcon(gfx::VectorIconId::NETWORK_ETHERNET,
+                                       GetBaseColorForIconType(ICON_TYPE_LIST))
+               : *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_WIRED);
   } else if (network->Matches(NetworkTypePattern::Wireless())) {
     DCHECK(strength_index > 0);
     return GetImageForIndex(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: "
-                 << network->type();
-    return *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_WIRED);
+    DCHECK_NE(ICON_TYPE_TRAY, icon_type);
+    return GetVpnImage();
   }
+
+  NOTREACHED() << "Request for icon for unsupported type: " << network->type();
+  return gfx::ImageSkia();
 }
 
 //------------------------------------------------------------------------------
 // Get connecting images
 
 gfx::ImageSkia GetConnectingVpnImage(IconType icon_type) {
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
   const NetworkState* connected_network = nullptr;
   if (icon_type == ICON_TYPE_TRAY) {
     connected_network =
         handler->ConnectedNetworkByType(NetworkTypePattern::NonVirtual());
   }
   double animation = NetworkIconAnimation::GetInstance()->GetAnimation();
 
   gfx::ImageSkia icon;
   Badges badges;
   if (connected_network) {
     icon = GetImageForNetwork(connected_network, icon_type);
-    badges.bottom_left = ConnectingVpnBadge(animation);
+    badges.bottom_left = ConnectingVpnBadge(animation, icon_type);
   } else {
     icon = ConnectingVpnImage(animation);
   }
   return UseMd() ? NetworkIconImageSourceMd::CreateImage(icon, badges)
                  : gfx::ImageSkia(new NetworkIconImageSource(icon, badges),
                                   icon.size());
 }
 
 gfx::ImageSkia GetConnectingImage(IconType icon_type,
                                   const std::string& network_type) {
@@ skipping 214 matching lines @@
   if (!network->visible())
     return GetDisconnectedImage(icon_type, network->type());
 
   if (network->IsConnectingState())
     return GetConnectingImage(icon_type, network->type());
 
   NetworkIconImpl* icon = FindAndUpdateImageImpl(network, icon_type);
   return icon->image();
 }
 
-gfx::ImageSkia GetImageForConnectedNetwork(IconType icon_type,
-                                           const std::string& network_type) {
-  return GetConnectedImage(icon_type, network_type);
+gfx::ImageSkia GetImageForConnectedWifiNetwork() {
+  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 GetImageForConnectingNetwork(IconType icon_type,
-                                            const std::string& network_type) {
-  return GetConnectingImage(icon_type, network_type);
+gfx::ImageSkia GetImageForDisconnectedCellNetwork() {
+  return GetDisconnectedImage(ICON_TYPE_LIST, shill::kTypeCellular);
 }
 
-gfx::ImageSkia GetImageForDisconnectedNetwork(IconType icon_type,
-                                              const std::string& network_type) {
-  return GetDisconnectedImage(icon_type, network_type);
+gfx::ImageSkia GetVpnImage() {
+  return UseMd()
+             ? gfx::CreateVectorIcon(gfx::VectorIconId::NETWORK_VPN,
+                                     GetBaseColorForIconType(ICON_TYPE_LIST))
+             : *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
+                   IDR_AURA_UBER_TRAY_NETWORK_VPN);
 }
 
 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) {
     // Show "<network>: [Connecting|Activating|Reconnecting]..."
     if (network->IsReconnecting()) {
       return l10n_util::GetStringFUTF16(
@@ skipping 115 matching lines @@
         state_handler->FirstNetworkByType(NetworkTypePattern::Mobile());
     if (mobile_network && (mobile_network->activation_state() ==
                            shill::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, shill::kTypeCellular);
+      *image = GetConnectingImage(icon_type, shill::kTypeCellular);
       if (label)
         *label = l10n_util::GetStringUTF16(uninitialized_msg);
       *animating = true;
     } else {
       // Otherwise show the disconnected wifi icon.
-      *image = GetImageForDisconnectedNetwork(icon_type, shill::kTypeWifi);
+      *image = GetDisconnectedImage(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 11 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 ui