[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 178 matching lines @@
 // Amount to fade icons while connecting.
 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 GetBaseColorForIconType(IconType icon_type) {
+SkColor GetDefaultColorForIconType(IconType icon_type) {
   // TODO(estade): use kTrayIconColor and kMenuIconColor.
   return icon_type == ICON_TYPE_TRAY ? SK_ColorWHITE : gfx::kChromeIconGrey;
 }
 
 bool IconTypeIsDark(IconType icon_type) {
   return (icon_type != ICON_TYPE_TRAY);
 }
 
 bool IconTypeHasVPNBadge(IconType icon_type) {
   return (icon_type != ICON_TYPE_LIST);
@@ skipping 99 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_(GetDefaultColorForIconType(icon_type_)),
         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 94 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,
-                                        GetBaseColorForIconType(icon_type))
+                                        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].
@@ skipping 24 matching lines @@
       id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_HSPA;
     } else if (technology == shill::kNetworkTechnologyHspaPlus) {
       id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_HSPA_PLUS;
     } else if (technology == shill::kNetworkTechnologyLte) {
       id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_LTE;
     } else if (technology == shill::kNetworkTechnologyLteAdvanced) {
       id = gfx::VectorIconId::NETWORK_BADGE_TECHNOLOGY_LTE_ADVANCED;
     } else {
       return gfx::ImageSkia();
     }
-    return gfx::CreateVectorIcon(id, GetBaseColorForIconType(icon_type));
+    return gfx::CreateVectorIcon(id, 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 25 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,
-                                       GetBaseColorForIconType(ICON_TYPE_LIST))
-               : *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_WIRED);
+    return UseMd() ? gfx::CreateVectorIcon(
+                         gfx::VectorIconId::NETWORK_ETHERNET,
+                         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();
   }
 
   NOTREACHED() << "Request for icon for unsupported type: " << network->type();
@@ skipping 125 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,
-                                        GetBaseColorForIconType(icon_type_))
+                                        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 = GetBaseColorForIconType(icon_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)
               : *rb.GetImageSkiaNamed(IDR_AURA_UBER_TRAY_NETWORK_SECURE_DARK);
     }
   } else if (type == shill::kTypeWimax) {
@@ skipping 91 matching lines @@
   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 GetImageForDisconnectedCellNetwork() {
   return GetDisconnectedImage(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(
+      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))
+                                     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) {
     // Show "<network>: [Connecting|Activating|Reconnecting]..."
@@ skipping 155 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