Render Ash material design battery image icon without PNGs

ash/system/chromeos/power/power_status.cc

 // Copyright (c) 2013 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 "ash/system/chromeos/power/power_status.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
 #include "grit/ash_resources.h"
 #include "grit/ash_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
+#include "ui/gfx/paint_vector_icon.h"
+#include "ui/gfx/vector_icons_public.h"
 
 namespace ash {
 namespace {
 
 // Updates |proto| to ensure that its fields are consistent.
 void SanitizeProto(power_manager::PowerSupplyProperties* proto) {
   DCHECK(proto);
 
   if (proto->battery_state() ==
       power_manager::PowerSupplyProperties_BatteryState_FULL)
@@ skipping 53 matching lines @@
       return IDS_ASH_POWER_SOURCE_PORT_RIGHT_BACK;
     case power_manager::PowerSupplyProperties_PowerSource_Port_BACK_LEFT:
       return IDS_ASH_POWER_SOURCE_PORT_BACK_LEFT;
     case power_manager::PowerSupplyProperties_PowerSource_Port_BACK_RIGHT:
       return IDS_ASH_POWER_SOURCE_PORT_BACK_RIGHT;
   }
   NOTREACHED();
   return 0;
 }
 
+gfx::VectorIconId VectorIconIdForIconBadge(PowerStatus::IconBadge icon_badge) {
+  // TODO(tdanderson): Create vector icons for remaining types. See
+  // crbug.com/617298.
+  switch (icon_badge) {
+    case PowerStatus::ICON_BADGE_NONE:
+      return gfx::VectorIconId::VECTOR_ICON_NONE;
+    case PowerStatus::ICON_BADGE_ALERT:
+    case PowerStatus::ICON_BADGE_X:
+    case PowerStatus::ICON_BADGE_BOLT:
+    case PowerStatus::ICON_BADGE_QUESTION:
+    case PowerStatus::ICON_BADGE_UNRELIABLE:
+      return gfx::VectorIconId::SYSTEM_TRAY_BATTERY_BOLT_TEST;
+  }
+  NOTREACHED();
+  return gfx::VectorIconId::VECTOR_ICON_NONE;
+}
+
 static PowerStatus* g_power_status = NULL;
 
 // Minimum battery percentage rendered in UI.
 const int kMinBatteryPercent = 1;
 
 // Width and height of battery images.
 const int kBatteryImageHeight = 25;
 const int kBatteryImageWidth = 25;
 
 // Number of different power states.
@@ skipping 147 matching lines @@
   return sources;
 }
 
 std::string PowerStatus::GetCurrentPowerSourceID() const {
   return proto_.external_power_source_id();
 }
 
 PowerStatus::BatteryImageInfo PowerStatus::GetBatteryImageInfo(
     IconSet icon_set) const {
   BatteryImageInfo info;
+  info.icon_set = icon_set;
+
+  if (!IsUsbChargerConnected() && !IsBatteryPresent()) {
+    info.icon_badge =
+        IsLinePowerConnected() ? ICON_BADGE_QUESTION : ICON_BADGE_X;
+    return info;
+  }
 
   if (IsUsbChargerConnected()) {
-    info.resource_id =
-        (icon_set == ICON_DARK)
-            ? IDR_AURA_UBER_TRAY_POWER_SMALL_CHARGING_UNRELIABLE_DARK
-            : IDR_AURA_UBER_TRAY_POWER_SMALL_CHARGING_UNRELIABLE;
+    info.icon_badge = ICON_BADGE_UNRELIABLE;
+  } else if (IsLinePowerConnected()) {
+    info.icon_badge = ICON_BADGE_BOLT;
   } else {
-    info.resource_id = (icon_set == ICON_DARK)
-                           ? IDR_AURA_UBER_TRAY_POWER_SMALL_DARK
-                           : IDR_AURA_UBER_TRAY_POWER_SMALL;
+    info.icon_badge = ICON_BADGE_NONE;
   }
 
-  info.offset = IsUsbChargerConnected() ? 0 : (IsLinePowerConnected() ? 1 : 0);
+  // Ensure fill level is between 0 and 14.
+  info.fill_level =
+      static_cast<int>(GetBatteryPercent() / 100.0 * (kNumPowerImages - 1));
+  info.fill_level = std::max(std::min(info.fill_level, kNumPowerImages - 1), 0);
 
-  if (GetBatteryPercent() >= 100.0) {
-    info.index = kNumPowerImages - 1;
-  } else if (!IsBatteryPresent()) {
-    info.index = kNumPowerImages;
-  } else {
-    info.index =
-        static_cast<int>(GetBatteryPercent() / 100.0 * (kNumPowerImages - 1));
-    info.index = std::max(std::min(info.index, kNumPowerImages - 2), 0);
+  if (info.fill_level == 0 && info.icon_badge == ICON_BADGE_NONE) {
+    info.icon_badge = ICON_BADGE_ALERT;
   }
 
   return info;
 }
 
-gfx::ImageSkia PowerStatus::GetBatteryImage(IconSet icon_set) const {
-  const BatteryImageInfo info = GetBatteryImageInfo(icon_set);
+PowerStatus::BatteryImageInfoNonMD PowerStatus::ConvertToBatteryImageInfoNonMD(
+    const BatteryImageInfo info) const {
+  BatteryImageInfoNonMD info_non_md;
+
+  if (info.icon_badge == ICON_BADGE_UNRELIABLE) {
+    info_non_md.resource_id = info.icon_set == ICON_DARK
+            ? IDR_AURA_UBER_TRAY_POWER_SMALL_CHARGING_UNRELIABLE_DARK
+            : IDR_AURA_UBER_TRAY_POWER_SMALL_CHARGING_UNRELIABLE;
+  } else {
+    info_non_md.resource_id = info.icon_set == ICON_DARK
+        ? IDR_AURA_UBER_TRAY_POWER_SMALL_DARK
+        : IDR_AURA_UBER_TRAY_POWER_SMALL;
+  }
+
+  info_non_md.offset =
+      (info.icon_badge == ICON_BADGE_BOLT ||
+       info.icon_badge == ICON_BADGE_QUESTION) ? 1 : 0;
+
+  if (info.icon_badge == ICON_BADGE_X ||
+      info.icon_badge == ICON_BADGE_QUESTION) {
+    info_non_md.index = kNumPowerImages;
+  } else {
+    CHECK_LE(info.fill_level, kNumPowerImages - 1);
+    info_non_md.index = info.fill_level;
+  }
+
+  return info_non_md;
+}
+
+gfx::ImageSkia PowerStatus::GetBatteryImage(const BatteryImageInfo info) const {
+  // Terry - use a flag here.
+  const bool use_md = true;
+  if (!use_md) {
+    return GetBatteryImageNonMD(ConvertToBatteryImageInfoNonMD(info));
+  }
+
+  // Terry - figure out what these should actually be, move them to const file.
+  const SkColor kBackgroundColor =
+      info.icon_set == ICON_LIGHT ? SK_ColorGRAY : SK_ColorLTGRAY;
+  const SkColor kFillColor =

[Evan Stade, 2016/06/13 17:37:20]

this is kind of confusing as a name, because to me "fill" is opposed to
"stroke", not "background".

[tdanderson, 2016/06/20 23:06:53]

I picked the terminology that is being used in the specs folder. Have a look at
the changes in the next patch set and see if there are still changes you'd like
me to make in the naming.

[Evan Stade, 2016/06/21 02:55:48]

yes, I still don't like "fill". I'm not surprised that it has a different
connotation in a design context compared to code. Perhaps instead of
fill/fill_height/fill_level we can use "charge"?

[tdanderson, 2016/06/21 22:42:28]

fill -> charge changed everywhere

+      info.icon_set == ICON_LIGHT ? SK_ColorWHITE : SK_ColorGRAY;
+  const SkColor kBadgeColor =

[Evan Stade, 2016/06/13 17:37:20]

is there just one badge color? It isn't one color above the fill and a different
one below the fill?

[tdanderson, 2016/06/20 23:06:53]

Clarified in next patch set.

+      info.icon_set == ICON_LIGHT ? SK_ColorDKGRAY : SK_ColorBLACK;
+
+  // |fill_height| represents the number of pixels that should be drawn as the
+  // fill color, upwards from the bottom of the 16x16 grid. Note that there is
+  // 2px of bottom padding baked into the battery icon, which means that no
+  // fill amount will be visible inside the battery for an |info.fill_level|
+  // of 0 or 1.
+  const int fill_height =
+      (info.icon_badge == ICON_BADGE_X ||
+       info.icon_badge == ICON_BADGE_QUESTION)
+          ? 0
+          : info.fill_level + 1;
+  const int kImageSize = 16;
+  gfx::Canvas canvas(gfx::Size(kImageSize, kImageSize), 1.0f, true);
+  canvas.FillRect(
+      gfx::Rect(0, kImageSize - fill_height, kImageSize, fill_height),
+      kFillColor);
+  canvas.FillRect(
+      gfx::Rect(0, 0, kImageSize, kImageSize - fill_height),
+      kBackgroundColor);
+
+  // Mask the drawing of the background fill level to the shape of the battery.

[Evan Stade, 2016/06/13 17:37:20]

this masking idea seems like a fine approach but I wonder if it's the simplest
or most straightforward?

In my head I had imagined something like:

PaintVectorIcon(canvas, BATTERY, size, bg_color);
canvas.Save();
canvas.ClipRect(fill_rect);
PaintVectorIcon(canvas, BATTERY, size, fg_color);
canvas.Restore();
if (badge)
  PaintVectorIcon(canvas, badge, size, badge_color);
return gfx::ImageSkia(canvas.ExtractImageRep());

Or if you need two different badge colors, something like:

PaintVectorIcon(canvas, BATTERY, size, bg_color);
if (badge)
  PaintVectorIcon(canvas, badge, size, badge_color1);
canvas.ClipRect(fill_rect);
PaintVectorIcon(canvas, BATTERY, size, fg_color);
if (badge)
  PaintVectorIcon(canvas, badge, size, badge_color2);
return gfx::ImageSkia(canvas.ExtractImageRep());

[tdanderson, 2016/06/20 23:06:53]

Yes, this is much better, thanks. Changed to this in the next patch set.

+  gfx::ImageSkia background(canvas.ExtractImageRep());
+  gfx::ImageSkia battery = CreateVectorIcon(
+      gfx::VectorIconId::SYSTEM_TRAY_BATTERY, kBackgroundColor);
+  gfx::ImageSkia filled_battery =
+      gfx::ImageSkiaOperations::CreateMaskedImage(background, battery);
+
+  // Draw a badge (exclamation mark, lightning bolt, etc) on top of the battery
+  // icon, if applicable.
+  if (info.icon_badge == ICON_BADGE_NONE)
+    return filled_battery;
+  gfx::ImageSkia overlay = CreateVectorIcon(
+      VectorIconIdForIconBadge(info.icon_badge), kBadgeColor);
+  return gfx::ImageSkiaOperations::CreateSuperimposedImage(filled_battery,
+                                                           overlay);
+}
+
+gfx::ImageSkia PowerStatus::GetBatteryImageNonMD(
+    const BatteryImageInfoNonMD info) const {
   gfx::Image all;
   all = ui::ResourceBundle::GetSharedInstance().GetImageNamed(info.resource_id);
   gfx::Rect region(info.offset * kBatteryImageWidth,
                    info.index * kBatteryImageHeight, kBatteryImageWidth,
                    kBatteryImageHeight);
   return gfx::ImageSkiaOperations::ExtractSubset(*all.ToImageSkia(), region);
 }
 
 base::string16 PowerStatus::GetAccessibleNameString(
     bool full_description) const {
@@ skipping 60 matching lines @@
 }
 
 void PowerStatus::PowerChanged(
     const power_manager::PowerSupplyProperties& proto) {
   proto_ = proto;
   SanitizeProto(&proto_);
   FOR_EACH_OBSERVER(Observer, observers_, OnPowerStatusChanged());
 }
 
 }  // namespace ash