Move a bunch of ash-only vector icons to ash/.

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 "ash/resources/vector_icons/vector_icons.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 54 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) {
+const gfx::VectorIcon& VectorIconForIconBadge(
+    PowerStatus::IconBadge icon_badge) {
   switch (icon_badge) {
     case PowerStatus::ICON_BADGE_NONE:
-      return gfx::VectorIconId::VECTOR_ICON_NONE;
+      return gfx::kNoneIcon;
     case PowerStatus::ICON_BADGE_ALERT:
-      return gfx::VectorIconId::SYSTEM_TRAY_BATTERY_ALERT;
+      return kSystemTrayBatteryAlertIcon;
     case PowerStatus::ICON_BADGE_BOLT:
-      return gfx::VectorIconId::SYSTEM_TRAY_BATTERY_BOLT;
+      return kSystemTrayBatteryBoltIcon;
     case PowerStatus::ICON_BADGE_X:
-      return gfx::VectorIconId::SYSTEM_TRAY_BATTERY_X;
+      return kSystemTrayBatteryXIcon;
     case PowerStatus::ICON_BADGE_UNRELIABLE:
-      return gfx::VectorIconId::SYSTEM_TRAY_BATTERY_UNRELIABLE;
+      return kSystemTrayBatteryUnreliableIcon;
   }
   NOTREACHED();
-  return gfx::VectorIconId::VECTOR_ICON_NONE;
+  return gfx::kNoneIcon;
 }
 
 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;
@@ skipping 273 matching lines @@
   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(),
       false);
 
   // Paint the battery's base (background) color.
-  PaintVectorIcon(&canvas, gfx::VectorIconId::SYSTEM_TRAY_BATTERY,
-                  kBatteryCanvasSizeMd, kBatteryBaseColor);
+  PaintVectorIcon(&canvas, kSystemTrayBatteryIcon, 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);
+  PaintVectorIcon(&canvas, kSystemTrayBatteryIcon, 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),
+    PaintVectorIcon(&canvas, VectorIconForIconBadge(info.icon_badge),
                     kBatteryCanvasSizeMd, badge_color);
   }
 
   return gfx::ImageSkia(canvas.ExtractImageRep());
 }
 
 gfx::ImageSkia PowerStatus::GetBatteryImageNonMd(
     const BatteryImageInfo& info) const {
   gfx::Image all;
   all = ui::ResourceBundle::GetSharedInstance().GetImageNamed(info.resource_id);
@@ skipping 68 matching lines @@
 }
 
 void PowerStatus::PowerChanged(
     const power_manager::PowerSupplyProperties& proto) {
   proto_ = proto;
   SanitizeProto(&proto_);
   FOR_EACH_OBSERVER(Observer, observers_, OnPowerStatusChanged());
 }
 
 }  // namespace ash