Share tray constants in network icon code.

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.

[tdanderson, 2016/10/26 14:43:25]

Can you please add BUG=626786 in the CL description?

[Evan Stade, 2016/10/26 14:49:01]

Done.

 
 #include "ash/common/system/chromeos/network/network_icon.h"
 
 #include "ash/common/material_design/material_design_controller.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/vector_icons/vector_icons.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 "grit/ash_resources.h"
 #include "grit/ash_strings.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/base/resource/resource_bundle.h"
 #include "ui/base/webui/web_ui_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"
 #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/skia_util.h"
-#include "ui/gfx/vector_icons_public.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.
 // Only used for MD. 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;
 
-// TODO(estade): use kTrayIconSize. See crbug.com/623987
-const int kTrayIconSide = 16;
-
 bool UseMd() {
   return MaterialDesignController::UseMaterialDesignSystemIcons();
 }
 
 //------------------------------------------------------------------------------
 // Struct to pass icon badges to NetworkIconImageSource.
 struct Badges {
   gfx::ImageSkia top_left;
   gfx::ImageSkia top_right;
   gfx::ImageSkia bottom_left;
@@ skipping 114 matching lines @@
 const double kConnectingImageAlpha = 0.5;
 
 // Images for strength arcs for wireless networks or strength bars for cellular
 // networks.
 const int kNumNetworkImages = 5;
 
 // Number of discrete images to use for alpha fade animation
 const int kNumFadeImages = 10;
 
 SkColor GetDefaultColorForIconType(IconType icon_type) {
-  // TODO(estade): use kTrayIconColor and kMenuIconColor.
-  return icon_type == ICON_TYPE_TRAY ? SK_ColorWHITE : gfx::kChromeIconGrey;
+  return icon_type == ICON_TYPE_TRAY ? kTrayIconColor : kMenuIconColor;
 }
 
 bool IconTypeIsDark(IconType icon_type) {
   return (icon_type != ICON_TYPE_TRAY);
 }
 
 bool IconTypeHasVPNBadge(IconType icon_type) {
   return (icon_type != ICON_TYPE_LIST);
 }
 
@@ skipping 74 matching lines @@
 
  private:
   NetworkIconImageSourceMd(const gfx::ImageSkia& icon, const Badges& badges)
       : CanvasImageSource(GetSizeForBaseIconSize(icon.size()), false),
         icon_(icon),
         badges_(badges) {}
   ~NetworkIconImageSourceMd() override {}
 
   static gfx::Size GetSizeForBaseIconSize(const gfx::Size& base_icon_size) {
     gfx::Size size = base_icon_size;
-    const int badge_offset = base_icon_size.width() == kTrayIconSide
+    const int badge_offset = base_icon_size.width() == kTrayIconSize
                                  ? kTrayIconBadgeOffset
                                  : kMenuIconBadgeOffset;
     size.Enlarge(badge_offset * 2, badge_offset * 2);
     return size;
   }
 
   const gfx::ImageSkia icon_;
   const Badges badges_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkIconImageSourceMd);
@@ skipping 26 matching lines @@
     if (image_type_ == ARCS)
       DrawArcs(canvas);
     else
       DrawBars(canvas);
   }
 
   bool HasRepresentationAtAllScales() const override { return true; }
 
  private:
   static gfx::Size GetSizeForIconType(IconType icon_type) {
-    return icon_type == ICON_TYPE_TRAY
-               ? gfx::Size(kTrayIconSide, kTrayIconSide)
-               // TODO(estade): use kMenuIconSize instead of 20.
-               : gfx::Size(20, 20);
+    int side = icon_type == ICON_TYPE_TRAY ? kTrayIconSize : kMenuIconSize;
+    return gfx::Size(side, side);
   }
 
   void DrawArcs(gfx::Canvas* canvas) {
     gfx::RectF oval_bounds((gfx::Rect(size())));
     oval_bounds.Inset(gfx::Insets(kIconInset));
     // Double the width and height. The new midpoint should be the former
     // bottom center.
     oval_bounds.Inset(-oval_bounds.width() / 2, 0, -oval_bounds.width() / 2,
                       -oval_bounds.height());
 
@@ skipping 176 matching lines @@
   }
   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 =
-        UseMd() ? gfx::CreateVectorIcon(gfx::VectorIconId::NETWORK_BADGE_VPN,
+        UseMd() ? gfx::CreateVectorIcon(kNetworkBadgeVpnIcon,
                                         GetDefaultColorForIconType(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));
   }
   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);
   return index;
 }
 
 gfx::ImageSkia BadgeForNetworkTechnology(const NetworkState* network,
                                          IconType icon_type) {
   const std::string& technology = network->network_technology();
   if (UseMd()) {
-    gfx::VectorIconId id = gfx::VectorIconId::VECTOR_ICON_NONE;
+    const gfx::VectorIcon* icon = &gfx::kNoneIcon;
     if (technology == shill::kNetworkTechnologyEvdo) {
-      id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_EVDO;
+      icon = &kNetworkBadgeTechnologyEvdoIcon;
     } else if (technology == shill::kNetworkTechnology1Xrtt) {
-      id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_1X;
+      icon = &kNetworkBadgeTechnology1xIcon;
     } else if (technology == shill::kNetworkTechnologyGprs ||
                technology == shill::kNetworkTechnologyGsm) {
-      id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_GPRS;
+      icon = &kNetworkBadgeTechnologyGprsIcon;
     } else if (technology == shill::kNetworkTechnologyEdge) {
-      id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_EDGE;
+      icon = &kNetworkBadgeTechnologyEdgeIcon;
     } else if (technology == shill::kNetworkTechnologyUmts) {
-      id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_3G;
+      icon = &kNetworkBadgeTechnology3gIcon;
     } else if (technology == shill::kNetworkTechnologyHspa) {
-      id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_HSPA;
+      icon = &kNetworkBadgeTechnologyHspaIcon;
     } else if (technology == shill::kNetworkTechnologyHspaPlus) {
-      id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_HSPA_PLUS;
+      icon = &kNetworkBadgeTechnologyHspaPlusIcon;
     } else if (technology == shill::kNetworkTechnologyLte) {
-      id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_LTE;
+      icon = &kNetworkBadgeTechnologyLteIcon;
     } else if (technology == shill::kNetworkTechnologyLteAdvanced) {
-      id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_LTE_ADVANCED;
+      icon = &kNetworkBadgeTechnologyLteAdvancedIcon;
     } else {
       return gfx::ImageSkia();
     }
-    return gfx::CreateVectorIcon(id, GetDefaultColorForIconType(icon_type));
+    return gfx::CreateVectorIcon(*icon, GetDefaultColorForIconType(icon_type));
   }
 
   int id = -1;
   if (technology == shill::kNetworkTechnologyEvdo) {
     id = IconTypeIsDark(icon_type) ? IDR_AURA_UBER_TRAY_NETWORK_EVDO_DARK
                                    : IDR_AURA_UBER_TRAY_NETWORK_EVDO_LIGHT;
   } else if (technology == shill::kNetworkTechnology1Xrtt) {
     id = IDR_AURA_UBER_TRAY_NETWORK_1X;
   } else if (technology == shill::kNetworkTechnologyGprs) {
     id = IconTypeIsDark(icon_type) ? IDR_AURA_UBER_TRAY_NETWORK_GPRS_DARK
@@ skipping 26 matching lines @@
   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())) {
     DCHECK_NE(ICON_TYPE_TRAY, icon_type);
     return UseMd() ? gfx::CreateVectorIcon(
-                         gfx::VectorIconId::NETWORK_ETHERNET,
+                         kNetworkEthernetIcon,
                          GetDefaultColorForIconType(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())) {
     DCHECK_NE(ICON_TYPE_TRAY, icon_type);
     return GetVpnImage();
   }
@@ skipping 127 matching lines @@
   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_ =
-        UseMd() ? gfx::CreateVectorIcon(gfx::VectorIconId::NETWORK_BADGE_VPN,
+        UseMd() ? gfx::CreateVectorIcon(kNetworkBadgeVpnIcon,
                                         GetDefaultColorForIconType(icon_type_))
                 : *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
                       IDR_AURA_UBER_TRAY_NETWORK_VPN_BADGE);
     return true;
   }
   if (!vpn && !vpn_badge_.isNull()) {
     vpn_badge_ = gfx::ImageSkia();
     return true;
   }
   return false;
 }
 
 void NetworkIconImpl::GetBadges(const NetworkState* network, Badges* badges) {
   DCHECK(network);
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
 
   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 =
           UseMd()
-              ? gfx::CreateVectorIcon(gfx::VectorIconId::NETWORK_BADGE_SECURE,
-                                      icon_color)
+              ? gfx::CreateVectorIcon(kNetworkBadgeSecureIcon, icon_color)
               : *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_SECURE_DARK);
     }
   } else if (type == shill::kTypeWimax) {
     technology_badge_ =
         UseMd()
-            ? gfx::CreateVectorIcon(
-                  gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_4G, icon_color)
+            ? gfx::CreateVectorIcon(kNetworkBadgeTechnology4gIcon, icon_color)
             : *rb.GetImageSkiaNamed(IconTypeIsDark(icon_type_)
                                         ? IDR_AURA_UBER_TRAY_NETWORK_4G_DARK
                                         : IDR_AURA_UBER_TRAY_NETWORK_4G_LIGHT);
   } 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 =
           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 =
-            UseMd() ? gfx::CreateVectorIcon(
-                          gfx::VectorIconId::NETWORK_BADGE_ROAMING, icon_color)
-                    : *rb.GetImageSkiaNamed(
-                          IconTypeIsDark(icon_type_)
-                              ? IDR_AURA_UBER_TRAY_NETWORK_ROAMING_DARK
-                              : IDR_AURA_UBER_TRAY_NETWORK_ROAMING_LIGHT);
+            UseMd()
+                ? gfx::CreateVectorIcon(kNetworkBadgeRoamingIcon, icon_color)
+                : *rb.GetImageSkiaNamed(
+                      IconTypeIsDark(icon_type_)
+                          ? IDR_AURA_UBER_TRAY_NETWORK_ROAMING_DARK
+                          : IDR_AURA_UBER_TRAY_NETWORK_ROAMING_LIGHT);
       }
     }
   }
   if (!network->IsConnectingState()) {
     badges->top_left = technology_badge_;
     badges->bottom_left = vpn_badge_;
   }
 
   if (behind_captive_portal_) {
     badges->bottom_right =
         UseMd()
-            ? gfx::CreateVectorIcon(
-                  gfx::VectorIconId::NETWORK_BADGE_CAPTIVE_PORTAL, icon_color)
+            ? gfx::CreateVectorIcon(kNetworkBadgeCaptivePortalIcon, icon_color)
             : *rb.GetImageSkiaNamed(
                   IconTypeIsDark(icon_type_)
                       ? IDR_AURA_UBER_TRAY_NETWORK_PORTAL_DARK
                       : IDR_AURA_UBER_TRAY_NETWORK_PORTAL_LIGHT);
   }
 }
 
 void NetworkIconImpl::GenerateImage(const NetworkState* network) {
   DCHECK(network);
   gfx::ImageSkia icon = GetIcon(network, icon_type_, strength_index_);
@@ skipping 54 matching lines @@
 }
 
 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(
-      gfx::VectorIconId::NETWORK_BADGE_ADD_OTHER, badge_color);
+  badges.bottom_right =
+      gfx::CreateVectorIcon(kNetworkBadgeAddOtherIcon, badge_color);
   return NetworkIconImageSourceMd::CreateImage(icon, badges);
 }
 
 gfx::ImageSkia GetVpnImage() {
   return UseMd()
-             ? gfx::CreateVectorIcon(gfx::VectorIconId::NETWORK_VPN,
+             ? gfx::CreateVectorIcon(kNetworkVpnIcon,
                                      GetDefaultColorForIconType(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) {
@@ skipping 156 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