clang-format all of //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"
@@ skipping 21 matching lines @@
 
 // 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)
     proto->set_battery_percent(100.0);
 
   if (!proto->is_calculating_battery_time()) {
-    const bool on_line_power = proto->external_power() !=
+    const bool on_line_power =
+        proto->external_power() !=
         power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED;
     if ((on_line_power && proto->battery_time_to_full_sec() < 0) ||
         (!on_line_power && proto->battery_time_to_empty_sec() < 0))
       proto->set_is_calculating_battery_time(true);
   }
 }
 
 base::string16 GetBatteryTimeAccessibilityString(int hour, int min) {
   DCHECK(hour || min);
   if (hour && !min) {
@@ skipping 139 matching lines @@
 
 // static
 PowerStatus* PowerStatus::Get() {
   CHECK(g_power_status) << "PowerStatus::Get() called before Initialize().";
   return g_power_status;
 }
 
 // static
 bool PowerStatus::ShouldDisplayBatteryTime(const base::TimeDelta& time) {
   return time >= base::TimeDelta::FromMinutes(1) &&
-      time.InSeconds() <= kMaxBatteryTimeToDisplaySec;
+         time.InSeconds() <= kMaxBatteryTimeToDisplaySec;
 }
 
 // static
 void PowerStatus::SplitTimeIntoHoursAndMinutes(const base::TimeDelta& time,
                                                int* hours,
                                                int* minutes) {
   DCHECK(hours);
   DCHECK(minutes);
   const int total_minutes = static_cast<int>(time.InSecondsF() / 60 + 0.5);
   *hours = total_minutes / 60;
   *minutes = total_minutes % 60;
 }
 
 void PowerStatus::AddObserver(Observer* observer) {
   DCHECK(observer);
   observers_.AddObserver(observer);
 }
 
 void PowerStatus::RemoveObserver(Observer* observer) {
   DCHECK(observer);
   observers_.RemoveObserver(observer);
 }
 
 void PowerStatus::RequestStatusUpdate() {
-  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
-      RequestStatusUpdate();
+  chromeos::DBusThreadManager::Get()
+      ->GetPowerManagerClient()
+      ->RequestStatusUpdate();
 }
 
 void PowerStatus::SetPowerSource(const std::string& id) {
   chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->SetPowerSource(
       id);
 }
 
 bool PowerStatus::IsBatteryPresent() const {
   return proto_.battery_state() !=
-      power_manager::PowerSupplyProperties_BatteryState_NOT_PRESENT;
+         power_manager::PowerSupplyProperties_BatteryState_NOT_PRESENT;
 }
 
 bool PowerStatus::IsBatteryFull() const {
   return proto_.battery_state() ==
-      power_manager::PowerSupplyProperties_BatteryState_FULL;
+         power_manager::PowerSupplyProperties_BatteryState_FULL;
 }
 
 bool PowerStatus::IsBatteryCharging() const {
   return proto_.battery_state() ==
-      power_manager::PowerSupplyProperties_BatteryState_CHARGING;
+         power_manager::PowerSupplyProperties_BatteryState_CHARGING;
 }
 
 bool PowerStatus::IsBatteryDischargingOnLinePower() const {
-  return IsLinePowerConnected() && proto_.battery_state() ==
-      power_manager::PowerSupplyProperties_BatteryState_DISCHARGING;
+  return IsLinePowerConnected() &&
+         proto_.battery_state() ==
+             power_manager::PowerSupplyProperties_BatteryState_DISCHARGING;
 }
 
 double PowerStatus::GetBatteryPercent() const {
   return proto_.battery_percent();
 }
 
 int PowerStatus::GetRoundedBatteryPercent() const {
   return std::max(kMinBatteryPercent,
-      static_cast<int>(GetBatteryPercent() + 0.5));
+                  static_cast<int>(GetBatteryPercent() + 0.5));
 }
 
 bool PowerStatus::IsBatteryTimeBeingCalculated() const {
   return proto_.is_calculating_battery_time();
 }
 
 base::TimeDelta PowerStatus::GetBatteryTimeToEmpty() const {
   return base::TimeDelta::FromSeconds(proto_.battery_time_to_empty_sec());
 }
 
 base::TimeDelta PowerStatus::GetBatteryTimeToFull() const {
   return base::TimeDelta::FromSeconds(proto_.battery_time_to_full_sec());
 }
 
 bool PowerStatus::IsLinePowerConnected() const {
   return proto_.external_power() !=
-      power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED;
+         power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED;
 }
 
 bool PowerStatus::IsMainsChargerConnected() const {
   return proto_.external_power() ==
-      power_manager::PowerSupplyProperties_ExternalPower_AC;
+         power_manager::PowerSupplyProperties_ExternalPower_AC;
 }
 
 bool PowerStatus::IsUsbChargerConnected() const {
   return proto_.external_power() ==
-      power_manager::PowerSupplyProperties_ExternalPower_USB;
+         power_manager::PowerSupplyProperties_ExternalPower_USB;
 }
 
 bool PowerStatus::SupportsDualRoleDevices() const {
   return proto_.supports_dual_role_devices();
 }
 
 bool PowerStatus::HasDualRoleDevices() const {
   if (!SupportsDualRoleDevices())
     return false;
 
@@ skipping 141 matching lines @@
 
 base::string16 PowerStatus::GetAccessibleNameString(
     bool full_description) const {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   if (IsBatteryFull()) {
     return rb.GetLocalizedString(
         IDS_ASH_STATUS_TRAY_BATTERY_FULL_CHARGE_ACCESSIBLE);
   }
 
   base::string16 battery_percentage_accessible = l10n_util::GetStringFUTF16(
-      IsBatteryCharging() ?
-      IDS_ASH_STATUS_TRAY_BATTERY_PERCENT_CHARGING_ACCESSIBLE :
-      IDS_ASH_STATUS_TRAY_BATTERY_PERCENT_ACCESSIBLE,
+      IsBatteryCharging()
+          ? IDS_ASH_STATUS_TRAY_BATTERY_PERCENT_CHARGING_ACCESSIBLE
+          : IDS_ASH_STATUS_TRAY_BATTERY_PERCENT_ACCESSIBLE,
       base::IntToString16(GetRoundedBatteryPercent()));
   if (!full_description)
     return battery_percentage_accessible;
 
   base::string16 battery_time_accessible = base::string16();
-  const base::TimeDelta time = IsBatteryCharging() ? GetBatteryTimeToFull() :
-      GetBatteryTimeToEmpty();
+  const base::TimeDelta time =
+      IsBatteryCharging() ? GetBatteryTimeToFull() : GetBatteryTimeToEmpty();
 
   if (IsUsbChargerConnected()) {
     battery_time_accessible = rb.GetLocalizedString(
         IDS_ASH_STATUS_TRAY_BATTERY_CHARGING_UNRELIABLE_ACCESSIBLE);
   } else if (IsBatteryTimeBeingCalculated()) {
     battery_time_accessible = rb.GetLocalizedString(
         IDS_ASH_STATUS_TRAY_BATTERY_CALCULATING_ACCESSIBLE);
   } else if (ShouldDisplayBatteryTime(time) &&
              !IsBatteryDischargingOnLinePower()) {
     int hour = 0, min = 0;
     PowerStatus::SplitTimeIntoHoursAndMinutes(time, &hour, &min);
-    base::string16 minute = min < 10 ?
-        base::ASCIIToUTF16("0") + base::IntToString16(min) :
-        base::IntToString16(min);
-    battery_time_accessible =
-        l10n_util::GetStringFUTF16(
-            IsBatteryCharging() ?
-            IDS_ASH_STATUS_TRAY_BATTERY_TIME_UNTIL_FULL_ACCESSIBLE :
-            IDS_ASH_STATUS_TRAY_BATTERY_TIME_LEFT_ACCESSIBLE,
-            GetBatteryTimeAccessibilityString(hour, min));
+    base::string16 minute =
+        min < 10 ? base::ASCIIToUTF16("0") + base::IntToString16(min)
+                 : base::IntToString16(min);
+    battery_time_accessible = l10n_util::GetStringFUTF16(
+        IsBatteryCharging()
+            ? IDS_ASH_STATUS_TRAY_BATTERY_TIME_UNTIL_FULL_ACCESSIBLE
+            : IDS_ASH_STATUS_TRAY_BATTERY_TIME_LEFT_ACCESSIBLE,
+        GetBatteryTimeAccessibilityString(hour, min));
   }
-  return battery_time_accessible.empty() ?
-      battery_percentage_accessible :
-      battery_percentage_accessible + base::ASCIIToUTF16(". ") +
-      battery_time_accessible;
+  return battery_time_accessible.empty()
+             ? battery_percentage_accessible
+             : battery_percentage_accessible + base::ASCIIToUTF16(". ") +
+                   battery_time_accessible;
 }
 
 PowerStatus::PowerStatus() {
-  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
-      AddObserver(this);
-  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
-      RequestStatusUpdate();
+  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(
+      this);
+  chromeos::DBusThreadManager::Get()
+      ->GetPowerManagerClient()
+      ->RequestStatusUpdate();
 }
 
 PowerStatus::~PowerStatus() {
-  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->
-      RemoveObserver(this);
+  chromeos::DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(
+      this);
 }
 
 void PowerStatus::SetProtoForTesting(
     const power_manager::PowerSupplyProperties& proto) {
   proto_ = proto;
   SanitizeProto(&proto_);
 }
 
 void PowerStatus::PowerChanged(
     const power_manager::PowerSupplyProperties& proto) {
   proto_ = proto;
   SanitizeProto(&proto_);
   FOR_EACH_OBSERVER(Observer, observers_, OnPowerStatusChanged());
 }
 
 }  // namespace ash