[ash-md] Adds Wi-Fi header row to system tray network detailed view

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 298 matching lines @@
 // Depicts a given signal strength using arcs (e.g. for WiFi connections) or
 // bars (e.g. for cell connections).
 class SignalStrengthImageSource : public gfx::CanvasImageSource {
  public:
   SignalStrengthImageSource(ImageType image_type,
                             IconType icon_type,
                             int signal_strength)
       : CanvasImageSource(GetSizeForIconType(icon_type), false),
         image_type_(image_type),
         icon_type_(icon_type),
+        color_(GetBaseColorForIconType(icon_type_)),

[Evan Stade, 2016/09/23 01:22:34]

nit: maybe GetDefaultColorForIconType makes more sense now

[varkha, 2016/09/23 04:50:35]

Done.

         signal_strength_(signal_strength) {
     if (image_type_ == NONE)
       image_type_ = ARCS;
 
     DCHECK_GE(signal_strength, 0);
     DCHECK_LT(signal_strength, kNumNetworkImages);
   }
   ~SignalStrengthImageSource() override {}
 
+  void set_color(SkColor color) { color_ = color; }
+
   // gfx::CanvasImageSource:
   void Draw(gfx::Canvas* canvas) override {
     if (image_type_ == ARCS)
       DrawArcs(canvas);
     else
       DrawBars(canvas);
   }
 
   bool HasRepresentationAtAllScales() const override {
     return true;
@@ skipping 15 matching lines @@
     oval_bounds.Inset(-oval_bounds.width() / 2, 0, -oval_bounds.width() / 2,
                       -oval_bounds.height());
 
     const SkScalar kAngleAboveHorizontal = 51.f;
     const SkScalar kStartAngle = 180.f + kAngleAboveHorizontal;
     const SkScalar kSweepAngle = 180.f - 2 * kAngleAboveHorizontal;
 
     SkPaint paint;
     paint.setAntiAlias(true);
     paint.setStyle(SkPaint::kFill_Style);
-    const SkColor base_color = GetBaseColorForIconType(icon_type_);
     // Background. Skip drawing for full signal.
     if (signal_strength_ != kNumNetworkImages - 1) {
-      paint.setColor(SkColorSetA(base_color, kBgAlpha));
+      paint.setColor(SkColorSetA(color_, kBgAlpha));
       canvas->sk_canvas()->drawArc(gfx::RectFToSkRect(oval_bounds), kStartAngle,
                                    kSweepAngle, true, paint);
     }
     // Foreground (signal strength).
     if (signal_strength_ != 0) {
-      paint.setColor(base_color);
+      paint.setColor(color_);
       // Percent of the height of the background wedge that we draw the
       // foreground wedge, indexed by signal strength.
       static const float kWedgeHeightPercentages[] = {0.f, 0.375f, 0.5833f,
                                                       0.75f, 1.f};
       const float wedge_percent = kWedgeHeightPercentages[signal_strength_];
       oval_bounds.Inset(
           gfx::InsetsF((oval_bounds.height() / 2) * (1.f - wedge_percent)));
       canvas->sk_canvas()->drawArc(gfx::RectFToSkRect(oval_bounds), kStartAngle,
                                    kSweepAngle, true, paint);
     }
@@ skipping 16 matching lines @@
       triangle.moveTo(scale(kIconInset), scale(kIconInset + kFullTriangleSide));
       triangle.rLineTo(scale(side), 0);
       triangle.rLineTo(0, -scale(side));
       triangle.close();
       return triangle;
     };
 
     SkPaint paint;
     paint.setAntiAlias(true);
     paint.setStyle(SkPaint::kFill_Style);
-    const SkColor base_color = GetBaseColorForIconType(icon_type_);
     // Background. Skip drawing for full signal.
     if (signal_strength_ != kNumNetworkImages - 1) {
-      paint.setColor(SkColorSetA(base_color, kBgAlpha));
+      paint.setColor(SkColorSetA(color_, kBgAlpha));
       canvas->DrawPath(make_triangle(kFullTriangleSide), paint);
     }
     // Foreground (signal strength).
     if (signal_strength_ != 0) {
-      paint.setColor(base_color);
+      paint.setColor(color_);
       // As a percentage of the bg triangle, the length of one of the short
       // sides of the fg triangle, indexed by signal strength.
       static const float kTriangleSidePercents[] = {0.f, 0.5f, 0.625f, 0.75f,
                                                     1.f};
       canvas->DrawPath(make_triangle(kTriangleSidePercents[signal_strength_] *
                                      kFullTriangleSide),
                        paint);
     }
   }
 
   ImageType image_type_;
   IconType icon_type_;
+  SkColor color_;
 
   // On a scale of 0 to kNum{Arcs,Bars}Images - 1, how connected we are.
   int signal_strength_;
 
   // Padding between outside of icon and edge of the canvas, in dp. This value
   // stays the same regardless of the canvas size (which depends on
   // |icon_type_|).
   static constexpr int kIconInset = 2;
 
   // TODO(estade): share this alpha with other things in ash (battery, etc.).
@@ skipping 23 matching lines @@
 ImageType ImageTypeForNetworkType(const std::string& type) {
   if (type == shill::kTypeWifi)
     return ARCS;
   else if (type == shill::kTypeCellular || type == shill::kTypeWimax)
     return BARS;
   return NONE;
 }
 
 gfx::ImageSkia GetImageForIndex(ImageType image_type,
                                 IconType icon_type,
+                                SkColor color,
                                 int index) {
   if (UseMd()) {
-    gfx::CanvasImageSource* source =
+    SignalStrengthImageSource* source =
         new SignalStrengthImageSource(image_type, icon_type, index);
+    if (color != SK_ColorTRANSPARENT)
+      source->set_color(color);
     return gfx::ImageSkia(source, source->size());
   }
 
   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));
 }
 
 const gfx::ImageSkia GetDisconnectedImage(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);
+  return GetImageForIndex(image_type, icon_type, SK_ColorTRANSPARENT,
+                          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];
   static gfx::ImageSkia* s_bars_images_light[kImageCount];
   static gfx::ImageSkia* s_arcs_images_dark[kImageCount];
   static gfx::ImageSkia* s_arcs_images_light[kImageCount];
   int index = animation * nextafter(static_cast<float>(kImageCount), 0);
   index = std::max(std::min(index, kImageCount - 1), 0);
   gfx::ImageSkia** images;
   bool dark = IconTypeIsDark(icon_type);
   if (image_type == BARS)
     images = dark ? s_bars_images_dark : s_bars_images_light;
   else
     images = dark ? s_arcs_images_dark : s_arcs_images_light;
   if (!images[index]) {
     // Lazily cache images.
     // TODO(estade): should the alpha be applied in SignalStrengthImageSource?
-    gfx::ImageSkia source = GetImageForIndex(image_type, icon_type, index + 1);
+    gfx::ImageSkia source =
+        GetImageForIndex(image_type, icon_type, SK_ColorTRANSPARENT, index + 1);
     images[index] =
         new gfx::ImageSkia(gfx::ImageSkiaOperations::CreateTransparentImage(
             source, kConnectingImageAlpha));
   }
   return images[index];
 }
 
 gfx::ImageSkia ConnectingVpnImage(double animation) {
   int index = animation * nextafter(static_cast<float>(kNumFadeImages), 0);
   static gfx::ImageSkia* s_vpn_images[kNumFadeImages];
@@ skipping 105 matching lines @@
   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,
                                        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);
+                            SK_ColorTRANSPARENT, strength_index);
   } else if (network->Matches(NetworkTypePattern::VPN())) {
     DCHECK_NE(ICON_TYPE_TRAY, icon_type);
     return GetVpnImage();
   }
 
   NOTREACHED() << "Request for icon for unsupported type: " << network->type();
   return gfx::ImageSkia();
 }
 
 //------------------------------------------------------------------------------
@@ skipping 244 matching lines @@
     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);
+  return GetImageForIndex(image_type, icon_type, SK_ColorTRANSPARENT,
+                          connected_index);
 }
 
 gfx::ImageSkia GetImageForDisconnectedCellNetwork() {
   return GetDisconnectedImage(ICON_TYPE_LIST, shill::kTypeCellular);
 }
 
+gfx::ImageSkia GetImageForHeaderWifiNetwork(SkColor icon_color,

[Evan Stade, 2016/09/23 01:22:34]

nit: name suggestion - GetImageForNewWifiNetwork

[varkha, 2016/09/23 04:50:35]

Done.

+                                            SkColor badge_color) {
+  ImageType image_type = ImageTypeForNetworkType(shill::kTypeWifi);
+  const int connected_index = kNumNetworkImages - 1;
+  gfx::ImageSkia icon =
+      GetImageForIndex(image_type, ICON_TYPE_LIST, icon_color, connected_index);

[Evan Stade, 2016/09/23 01:22:34]

I think we should just use SignalStrengthImageSource so we don't have to add a
generally unused parameter to GetImageForIndex

[varkha, 2016/09/23 04:50:35]

Done.

+  Badges badges;
+  badges.bottom_right = gfx::CreateVectorIcon(
+      gfx::VectorIconId::NETWORK_BADGE_ADD_OTHER, badge_color);
+  return NetworkIconImageSourceMd::CreateImage(icon, badges);
+}
+
 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) {
@@ skipping 159 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