[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 255 matching lines @@
     // 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_.bottom_left.isNull()) {
       canvas->DrawImageInt(badges_.bottom_left, 0,
-                           height - badges_.bottom_left.height());
+                           height - badges_.bottom_left.height() - 1);

[varkha, 2016/09/19 20:19:23]

Not sure why this is necessary but without it the bottom row of a badge is
clipped. Interestingly the rightmost column of a badge is not clipped.

[Evan Stade, 2016/09/19 20:40:47]

I don't think this is correct.

Note that the size of the icon you're getting back here is 24x24dp (see
GetSizeForBaseIconSize). Are you sure you have enough space in your layout to
display that?

[varkha, 2016/09/23 00:35:53]

Acknowledged.

     }
     if (!badges_.bottom_right.isNull()) {
       canvas->DrawImageInt(badges_.bottom_right,
                            width - badges_.bottom_right.width(),
-                           height - badges_.bottom_right.height());
+                           height - badges_.bottom_right.height() - 1);
     }
   }
 
   bool HasRepresentationAtAllScales() const override { return true; }
 
  private:
   NetworkIconImageSourceMd(const gfx::ImageSkia& icon, const Badges& badges)
       : CanvasImageSource(GetSizeForBaseIconSize(icon.size()), false),
         icon_(icon),
         badges_(badges) {}
@@ skipping 17 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_)),

[varkha, 2016/09/19 20:19:23]

[self review] Need to add a color or alpha for the badge to allow themeing both
colors.

[varkha, 2016/09/23 00:35:53]

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)

[varkha, 2016/09/19 20:19:23]

[self review] This seems hacky. Maybe provide a more explicit way to specify
that the color is set by a client.

+      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 color) {
+  ImageType image_type = ImageTypeForNetworkType(shill::kTypeWifi);
+  const int connected_index = kNumNetworkImages - 1;
+  gfx::ImageSkia icon =
+      GetImageForIndex(image_type, ICON_TYPE_LIST, color, connected_index);
+  Badges badges;
+  badges.bottom_right =
+      gfx::CreateVectorIcon(gfx::VectorIconId::NETWORK_BADGE_ADD_OTHER, 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