Reland: cros: Show notification when low-power charger connected

ash/system/chromeos/power/tray_power.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 "ash/system/chromeos/power/tray_power.h"
 
 #include "ash/ash_switches.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/system/chromeos/power/power_status_view.h"
@@ skipping 11 matching lines @@
 #include "third_party/icu/public/i18n/unicode/fieldpos.h"
 #include "third_party/icu/public/i18n/unicode/fmtable.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/size.h"
+#include "ui/message_center/message_center.h"
+#include "ui/message_center/notification.h"
 #include "ui/views/controls/button/button.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/layout/fill_layout.h"
 #include "ui/views/layout/grid_layout.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 using chromeos::PowerManagerHandler;
 using chromeos::PowerSupplyStatus;
+using message_center::MessageCenter;
+using message_center::Notification;
 
 namespace ash {
 namespace internal {
 
 namespace {
 // Width and height of battery images.
 const int kBatteryImageHeight = 25;
 const int kBatteryImageWidth = 25;
 // Number of different power states.
 const int kNumPowerImages = 15;
@@ skipping 141 matching lines @@
   int battery_icon_offset_;
   bool battery_charging_unreliable_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerNotificationView);
 };
 
 }  // namespace tray
 
 using tray::PowerNotificationView;
 
-TrayPower::TrayPower(SystemTray* system_tray)
+TrayPower::TrayPower(SystemTray* system_tray, MessageCenter* message_center)
     : SystemTrayItem(system_tray),
+      message_center_(message_center),
       power_tray_(NULL),
       notification_view_(NULL),
       notification_state_(NOTIFICATION_NONE) {
-  PowerManagerHandler::Get()->AddObserver(this);
+  // Tests may not have a PowerManagerHandler.
+  if (PowerManagerHandler::IsInitialized())
+    PowerManagerHandler::Get()->AddObserver(this);
 }
 
 TrayPower::~TrayPower() {
   if (PowerManagerHandler::IsInitialized())
     PowerManagerHandler::Get()->RemoveObserver(this);
 }
 
 // static
 bool TrayPower::IsBatteryChargingUnreliable(
     const chromeos::PowerSupplyStatus& supply_status) {
@@ skipping 47 matching lines @@
         IDR_AURA_UBER_TRAY_POWER_SMALL_DARK : IDR_AURA_UBER_TRAY_POWER_SMALL);
   }
   gfx::Rect region(
       image_offset * kBatteryImageWidth,
       image_index * kBatteryImageHeight,
       kBatteryImageWidth, kBatteryImageHeight);
   return gfx::ImageSkiaOperations::ExtractSubset(*all.ToImageSkia(), region);
 }
 
 // static
+gfx::Image TrayPower::GetUsbChargerNotificationImage() {
+  // TODO(jamescook): Use a specialized art asset here.
+  gfx::ImageSkia icon =
+      GetBatteryImage(kNumPowerImages - 1, 0, true, ICON_LIGHT);
+  return gfx::Image(icon);
+}
+
+// static
 base::string16 TrayPower::GetAccessibleNameString(
     const chromeos::PowerSupplyStatus& supply_status) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   if (supply_status.line_power_on && supply_status.battery_is_full) {
     return rb.GetLocalizedString(
         IDS_ASH_STATUS_TRAY_BATTERY_FULL_CHARGE_ACCESSIBLE);
   }
   bool charging_unreliable =
       IsBatteryChargingUnreliable(supply_status);
   if (supply_status.battery_percentage < 0.0f) {
@@ skipping 106 matching lines @@
   if (power_tray_)
     power_tray_->UpdatePowerStatus(status, battery_alert);
   if (notification_view_)
     notification_view_->UpdatePowerStatus(status);
 
   // Factory testing may place the battery into unusual states.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           ash::switches::kAshHideNotificationsForFactory))
     return;
 
+  if (ash::switches::UseUsbChargerNotification())
+    MaybeShowUsbChargerNotification(last_power_supply_status_, status);
+
   if (battery_alert)
     ShowNotificationView();
   else if (notification_state_ == NOTIFICATION_NONE)
     HideNotificationView();
+
+  last_power_supply_status_ = status;
 }
 
 void TrayPower::RequestStatusUpdate() const {
   PowerManagerHandler::Get()->RequestStatusUpdate();
 }
 
+bool TrayPower::MaybeShowUsbChargerNotification(
+    const PowerSupplyStatus& old_status,
+    const PowerSupplyStatus& new_status) {
+  ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
+  const char kNotificationId[] = "usb-charger";
+  // Check for a USB charger being connected.
+  if (new_status.battery_state == PowerSupplyStatus::CONNECTED_TO_USB &&
+      old_status.battery_state != PowerSupplyStatus::CONNECTED_TO_USB) {
+    scoped_ptr<Notification> notification(new Notification(
+        message_center::NOTIFICATION_TYPE_SIMPLE,
+        kNotificationId,
+        rb.GetLocalizedString(IDS_ASH_STATUS_TRAY_LOW_POWER_CHARGER_TITLE),
+        rb.GetLocalizedString(IDS_ASH_STATUS_TRAY_LOW_POWER_CHARGER_MESSAGE),
+        GetUsbChargerNotificationImage(),
+        base::string16(),
+        std::string(),
+        message_center::RichNotificationData(),
+        NULL));
+    message_center_->AddNotification(notification.Pass());
+    return true;
+  }
+
+  // Check for unplug of a USB charger while the USB charger notification is
+  // showing.
+  if (new_status.battery_state != PowerSupplyStatus::CONNECTED_TO_USB &&
+      old_status.battery_state == PowerSupplyStatus::CONNECTED_TO_USB) {
+    message_center_->RemoveNotification(kNotificationId, false);
+    return true;
+  }
+  return false;
+}
+
 bool TrayPower::UpdateNotificationState(
     const chromeos::PowerSupplyStatus& status) {
   if (!status.battery_is_present ||
       status.is_calculating_battery_time ||
       status.battery_state == PowerSupplyStatus::CHARGING) {
     notification_state_ = NOTIFICATION_NONE;
     return false;
   }
 
   if (TrayPower::IsBatteryChargingUnreliable(status)) {
     return UpdateNotificationStateForRemainingPercentage(
         status.battery_percentage);
   } else {
     return UpdateNotificationStateForRemainingTime(
         status.battery_seconds_to_empty);
   }
 }
 
 bool TrayPower::UpdateNotificationStateForRemainingTime(int remaining_seconds) {
   if (remaining_seconds >= kNoWarningSeconds) {
     notification_state_ = NOTIFICATION_NONE;
     return false;
   }
 
   switch (notification_state_) {
     case NOTIFICATION_NONE:
       if (remaining_seconds <= kCriticalSeconds) {
         notification_state_ = NOTIFICATION_CRITICAL;
         return true;
-      } else if (remaining_seconds <= kLowPowerSeconds) {
+      }
+      if (remaining_seconds <= kLowPowerSeconds) {
         notification_state_ = NOTIFICATION_LOW_POWER;
         return true;
       }
       return false;
     case NOTIFICATION_LOW_POWER:
       if (remaining_seconds <= kCriticalSeconds) {
         notification_state_ = NOTIFICATION_CRITICAL;
         return true;
       }
       return false;
@@ skipping 30 matching lines @@
       return false;
     case NOTIFICATION_CRITICAL:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace internal
 }  // namespace ash