Render Ash material design battery image icon without PNGs

ash/common/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/common/system/chromeos/power/power_status.h"
 
 #include <algorithm>
 #include <cmath>
 
+#include "ash/common/material_design/material_design_controller.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/display/display.h"
+#include "ui/display/screen.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) {
+  switch (icon_badge) {
+    case PowerStatus::ICON_BADGE_NONE:
+      return gfx::VectorIconId::VECTOR_ICON_NONE;
+    case PowerStatus::ICON_BADGE_ALERT:
+      return gfx::VectorIconId::SYSTEM_TRAY_BATTERY_ALERT;
+    case PowerStatus::ICON_BADGE_BOLT:
+      return gfx::VectorIconId::SYSTEM_TRAY_BATTERY_BOLT;
+    case PowerStatus::ICON_BADGE_X:
+      return gfx::VectorIconId::SYSTEM_TRAY_BATTERY_X;
+    case PowerStatus::ICON_BADGE_UNRELIABLE:
+      return gfx::VectorIconId::SYSTEM_TRAY_BATTERY_UNRELIABLE;
+  }
+  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.
 const int kNumPowerImages = 15;
 
+// The height of the battery icon in material design (as measured from the
+// user-visible bottom of the icon to the user-visible top of the icon).
+const int kBatteryImageHeightMd = 12;
+
+// The dimensions of the canvas containing the material design battery icon.
+const int kBatteryCanvasSizeMd = 16;
+
+// The minimum height (in dp) of the charged region of the material design
+// battery icon when the battery is present and has a charge greater than 0.
+const int kMinVisualChargeLevelMd = 1;
+
+// The empty background color of the battery icon in the system tray. Used
+// for material design.
+// TODO(tdanderson): Move these constants to a shared location if they are
+// shared by more than one material design system icon.
+const SkColor kBatteryBaseColor = SkColorSetA(SK_ColorWHITE, 0x4C);
+
+// The background color of the charged region of the battery in the system
+// tray. Used for material design.
+const SkColor kBatteryChargeColor = SK_ColorWHITE;
+
+// The color of the battery's badge (bolt, unreliable, X).
+const SkColor kBatteryBadgeColor = SkColorSetA(SK_ColorBLACK, 0xB2);
+
+// The color used for the battery's badge and charged color when the battery
+// charge level is critically low.
+const SkColor kBatteryAlertColor = SkColorSetRGB(0xDA, 0x27, 0x12);
+
 }  // namespace
 
+bool PowerStatus::BatteryImageInfo::operator==(
+    const BatteryImageInfo& o) const {
+  if (ash::MaterialDesignController::UseMaterialDesignSystemIcons())
+    return icon_badge == o.icon_badge && charge_level == o.charge_level;
+
+  // TODO(tdanderson): |resource_id|, |offset|, and |index| are only used for
+  // non-MD. Remove these once MD is enabled by default. See crbug.com/614453.
+  return resource_id == o.resource_id && offset == o.offset && index == o.index;
+}
+
 const int PowerStatus::kMaxBatteryTimeToDisplaySec = 24 * 60 * 60;
 
+const double PowerStatus::kCriticalBatteryChargePercentageMd = 5;
+
 // static
 void PowerStatus::Initialize() {
   CHECK(!g_power_status);
   g_power_status = new PowerStatus();
 }
 
 // static
 void PowerStatus::Shutdown() {
   CHECK(g_power_status);
   delete g_power_status;
@@ skipping 131 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;
+  if (MaterialDesignController::UseMaterialDesignSystemIcons())
+    CalculateBatteryImageInfoMd(&info);
+  else
+    CalculateBatteryImageInfoNonMd(&info, icon_set);
+  return info;
+}
 
+void PowerStatus::CalculateBatteryImageInfoMd(BatteryImageInfo* info) const {
+  if (!IsUsbChargerConnected() && !IsBatteryPresent()) {
+    info->icon_badge = ICON_BADGE_X;
+    info->charge_level = 0;
+    return;
+  }
+
+  if (IsUsbChargerConnected())
+    info->icon_badge = ICON_BADGE_UNRELIABLE;
+  else if (IsLinePowerConnected())
+    info->icon_badge = ICON_BADGE_BOLT;
+  else
+    info->icon_badge = ICON_BADGE_NONE;
+
+  // |charge_state| is a value between 0 and kBatteryImageHeightMd representing
+  // the number of device pixels the battery image should be shown charged. The
+  // exception is when |charge_state| is 0 (a critically-low battery); in this
+  // case, still draw 1dp of charge.
+  int charge_state =
+      static_cast<int>(GetBatteryPercent() / 100.0 * kBatteryImageHeightMd);
+  charge_state = std::max(std::min(charge_state, kBatteryImageHeightMd), 0);
+  info->charge_level = std::max(charge_state, kMinVisualChargeLevelMd);
+
+  // Use ICON_BADGE_ALERT if the battery is critically low and does not already
+  // have a badge assigned.
+  if (GetBatteryPercent() < kCriticalBatteryChargePercentageMd &&
+      info->icon_badge == ICON_BADGE_NONE) {
+    info->icon_badge = ICON_BADGE_ALERT;
+  }
+}
+
+void PowerStatus::CalculateBatteryImageInfoNonMd(
+    BatteryImageInfo* info,
+    const IconSet& icon_set) const {
   if (IsUsbChargerConnected()) {
-    info.resource_id =
+    info->resource_id =
         (icon_set == ICON_DARK)
             ? IDR_AURA_UBER_TRAY_POWER_SMALL_CHARGING_UNRELIABLE_DARK
             : IDR_AURA_UBER_TRAY_POWER_SMALL_CHARGING_UNRELIABLE;
   } else {
-    info.resource_id = (icon_set == ICON_DARK)
-                           ? IDR_AURA_UBER_TRAY_POWER_SMALL_DARK
-                           : IDR_AURA_UBER_TRAY_POWER_SMALL;
+    info->resource_id = (icon_set == ICON_DARK)
+                            ? IDR_AURA_UBER_TRAY_POWER_SMALL_DARK
+                            : IDR_AURA_UBER_TRAY_POWER_SMALL;
   }
 
-  info.offset = IsUsbChargerConnected() ? 0 : (IsLinePowerConnected() ? 1 : 0);
+  info->offset = IsUsbChargerConnected() ? 0 : (IsLinePowerConnected() ? 1 : 0);
 
   if (GetBatteryPercent() >= 100.0) {
-    info.index = kNumPowerImages - 1;
+    info->index = kNumPowerImages - 1;
   } else if (!IsBatteryPresent()) {
-    info.index = kNumPowerImages;
+    info->index = kNumPowerImages;
   } else {
-    info.index =
+    info->index =
         static_cast<int>(GetBatteryPercent() / 100.0 * (kNumPowerImages - 1));
-    info.index = std::max(std::min(info.index, kNumPowerImages - 2), 0);
+    info->index = std::max(std::min(info->index, kNumPowerImages - 2), 0);
+  }
+}
+
+gfx::ImageSkia PowerStatus::GetBatteryImage(
+    const BatteryImageInfo& info) const {
+  if (!MaterialDesignController::UseMaterialDesignSystemIcons())
+    return GetBatteryImageNonMd(info);
+
+  const bool use_alert_color =
+      (info.charge_level == kMinVisualChargeLevelMd && !IsLinePowerConnected());
+  const SkColor badge_color =
+      use_alert_color ? kBatteryAlertColor : kBatteryBadgeColor;
+  const SkColor charge_color =
+      use_alert_color ? kBatteryAlertColor : kBatteryChargeColor;
+  gfx::Canvas canvas(
+      gfx::Size(kBatteryCanvasSizeMd, kBatteryCanvasSizeMd),
+      display::Screen::GetScreen()->GetPrimaryDisplay().device_scale_factor(),
+      true);
+
+  // Paint the battery's base (background) color.
+  PaintVectorIcon(&canvas, gfx::VectorIconId::SYSTEM_TRAY_BATTERY,
+                  kBatteryCanvasSizeMd, kBatteryBaseColor);
+
+  // Paint the charged portion of the battery. Note that |charge_height| adjusts
+  // for the 2dp of padding between the bottom of the battery icon and the
+  // bottom edge of |canvas|.
+  const int charge_height = info.charge_level + 2;
+  gfx::Rect clip_rect(0, kBatteryCanvasSizeMd - charge_height,
+                      kBatteryCanvasSizeMd, charge_height);
+  canvas.Save();
+  canvas.ClipRect(clip_rect);
+  PaintVectorIcon(&canvas, gfx::VectorIconId::SYSTEM_TRAY_BATTERY,
+                  kBatteryCanvasSizeMd, charge_color);
+  canvas.Restore();
+
+  // Paint the badge over top of the battery, if applicable.
+  if (info.icon_badge != ICON_BADGE_NONE) {
+    PaintVectorIcon(&canvas, VectorIconIdForIconBadge(info.icon_badge),
+                    kBatteryCanvasSizeMd, badge_color);
   }
 
-  return info;
+  return gfx::ImageSkia(canvas.ExtractImageRep());
 }
 
-gfx::ImageSkia PowerStatus::GetBatteryImage(IconSet icon_set) const {
-  const BatteryImageInfo info = GetBatteryImageInfo(icon_set);
+gfx::ImageSkia PowerStatus::GetBatteryImageNonMd(
+    const BatteryImageInfo& 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