src/chromeos/dbus/power_manager_client.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromeos/dbus/power_manager_client.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/bind.h"
  10 #include "base/callback.h"
  11 #include "base/command_line.h"
  12 #include "base/format_macros.h"
  13 #include "base/logging.h"
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/observer_list.h"
  17 #include "base/strings/string_number_conversions.h"
  18 #include "base/strings/string_split.h"
  19 #include "base/strings/stringprintf.h"
  20 #include "base/threading/platform_thread.h"
  21 #include "base/time/time.h"
  22 #include "base/timer/timer.h"
  23 #include "chromeos/chromeos_switches.h"
  24 #include "chromeos/dbus/power_manager/input_event.pb.h"
  25 #include "chromeos/dbus/power_manager/peripheral_battery_status.pb.h"
  26 #include "chromeos/dbus/power_manager/policy.pb.h"
  27 #include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
  28 #include "chromeos/dbus/power_manager/suspend.pb.h"
  29 #include "dbus/bus.h"
  30 #include "dbus/message.h"
  31 #include "dbus/object_path.h"
  32 #include "dbus/object_proxy.h"
  33
  34 namespace chromeos {
  35
  36 // Maximum amount of time that the power manager will wait for Chrome to
  37 // say that it's ready for the system to be suspended, in milliseconds.
  38 const int kSuspendDelayTimeoutMs = 5000;
  39
  40 // Human-readable description of Chrome's suspend delay.
  41 const char kSuspendDelayDescription[] = "chrome";
  42
  43 // The PowerManagerClient implementation used in production.
  44 class PowerManagerClientImpl : public PowerManagerClient {
  45  public:
  46   PowerManagerClientImpl()
  47       : origin_thread_id_(base::PlatformThread::CurrentId()),
  48         power_manager_proxy_(NULL),
  49         suspend_delay_id_(-1),
  50         has_suspend_delay_id_(false),
  51         dark_suspend_delay_id_(-1),
  52         has_dark_suspend_delay_id_(false),
  53         pending_suspend_id_(-1),
  54         suspend_is_pending_(false),
  55         suspending_from_dark_resume_(false),
  56         num_pending_suspend_readiness_callbacks_(0),
  57         last_is_projecting_(false),
  58         weak_ptr_factory_(this) {}
  59
  60   virtual ~PowerManagerClientImpl() {
  61     // Here we should unregister suspend notifications from powerd,
  62     // however:
  63     // - The lifetime of the PowerManagerClientImpl can extend past that of
  64     //   the objectproxy,
  65     // - power_manager can already detect that the client is gone and
  66     //   unregister our suspend delay.
  67   }
  68
  69   // PowerManagerClient overrides:
  70
  71   virtual void AddObserver(Observer* observer) OVERRIDE {
  72     CHECK(observer);  // http://crbug.com/119976
  73     observers_.AddObserver(observer);
  74   }
  75
  76   virtual void RemoveObserver(Observer* observer) OVERRIDE {
  77     observers_.RemoveObserver(observer);
  78   }
  79
  80   virtual bool HasObserver(Observer* observer) OVERRIDE {
  81     return observers_.HasObserver(observer);
  82   }
  83
  84   virtual void DecreaseScreenBrightness(bool allow_off) OVERRIDE {
  85     dbus::MethodCall method_call(
  86         power_manager::kPowerManagerInterface,
  87         power_manager::kDecreaseScreenBrightnessMethod);
  88     dbus::MessageWriter writer(&method_call);
  89     writer.AppendBool(allow_off);
  90     power_manager_proxy_->CallMethod(
  91         &method_call,
  92         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
  93         dbus::ObjectProxy::EmptyResponseCallback());
  94   }
  95
  96   virtual void IncreaseScreenBrightness() OVERRIDE {
  97     SimpleMethodCallToPowerManager(
  98         power_manager::kIncreaseScreenBrightnessMethod);
  99   }
 100
 101   virtual void DecreaseKeyboardBrightness() OVERRIDE {
 102     SimpleMethodCallToPowerManager(
 103         power_manager::kDecreaseKeyboardBrightnessMethod);
 104   }
 105
 106   virtual void IncreaseKeyboardBrightness() OVERRIDE {
 107     SimpleMethodCallToPowerManager(
 108         power_manager::kIncreaseKeyboardBrightnessMethod);
 109   }
 110
 111   virtual void SetScreenBrightnessPercent(double percent,
 112                                           bool gradual) OVERRIDE {
 113     dbus::MethodCall method_call(
 114         power_manager::kPowerManagerInterface,
 115         power_manager::kSetScreenBrightnessPercentMethod);
 116     dbus::MessageWriter writer(&method_call);
 117     writer.AppendDouble(percent);
 118     writer.AppendInt32(
 119         gradual ?
 120         power_manager::kBrightnessTransitionGradual :
 121         power_manager::kBrightnessTransitionInstant);
 122     power_manager_proxy_->CallMethod(
 123         &method_call,
 124         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 125         dbus::ObjectProxy::EmptyResponseCallback());
 126   }
 127
 128   virtual void GetScreenBrightnessPercent(
 129       const GetScreenBrightnessPercentCallback& callback) OVERRIDE {
 130     dbus::MethodCall method_call(
 131         power_manager::kPowerManagerInterface,
 132         power_manager::kGetScreenBrightnessPercentMethod);
 133     power_manager_proxy_->CallMethod(
 134         &method_call,
 135         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 136         base::Bind(&PowerManagerClientImpl::OnGetScreenBrightnessPercent,
 137                    weak_ptr_factory_.GetWeakPtr(), callback));
 138   }
 139
 140   virtual void RequestStatusUpdate() OVERRIDE {
 141     dbus::MethodCall method_call(
 142         power_manager::kPowerManagerInterface,
 143         power_manager::kGetPowerSupplyPropertiesMethod);
 144     power_manager_proxy_->CallMethod(
 145         &method_call,
 146         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 147         base::Bind(&PowerManagerClientImpl::OnGetPowerSupplyPropertiesMethod,
 148                    weak_ptr_factory_.GetWeakPtr()));
 149   }
 150
 151   virtual void RequestSuspend() OVERRIDE {
 152     SimpleMethodCallToPowerManager(power_manager::kRequestSuspendMethod);
 153   }
 154
 155   virtual void RequestRestart() OVERRIDE {
 156     SimpleMethodCallToPowerManager(power_manager::kRequestRestartMethod);
 157   }
 158
 159   virtual void RequestShutdown() OVERRIDE {
 160     SimpleMethodCallToPowerManager(power_manager::kRequestShutdownMethod);
 161   }
 162
 163   virtual void NotifyUserActivity(
 164       power_manager::UserActivityType type) OVERRIDE {
 165     dbus::MethodCall method_call(
 166         power_manager::kPowerManagerInterface,
 167         power_manager::kHandleUserActivityMethod);
 168     dbus::MessageWriter writer(&method_call);
 169     writer.AppendInt32(type);
 170
 171     power_manager_proxy_->CallMethod(
 172         &method_call,
 173         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 174         dbus::ObjectProxy::EmptyResponseCallback());
 175   }
 176
 177   virtual void NotifyVideoActivity(bool is_fullscreen) OVERRIDE {
 178     dbus::MethodCall method_call(
 179         power_manager::kPowerManagerInterface,
 180         power_manager::kHandleVideoActivityMethod);
 181     dbus::MessageWriter writer(&method_call);
 182     writer.AppendBool(is_fullscreen);
 183
 184     power_manager_proxy_->CallMethod(
 185         &method_call,
 186         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 187         dbus::ObjectProxy::EmptyResponseCallback());
 188   }
 189
 190   virtual void SetPolicy(
 191       const power_manager::PowerManagementPolicy& policy) OVERRIDE {
 192     dbus::MethodCall method_call(
 193         power_manager::kPowerManagerInterface,
 194         power_manager::kSetPolicyMethod);
 195     dbus::MessageWriter writer(&method_call);
 196     if (!writer.AppendProtoAsArrayOfBytes(policy)) {
 197       LOG(ERROR) << "Error calling " << power_manager::kSetPolicyMethod;
 198       return;
 199     }
 200     power_manager_proxy_->CallMethod(
 201         &method_call,
 202         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 203         dbus::ObjectProxy::EmptyResponseCallback());
 204   }
 205
 206   virtual void SetIsProjecting(bool is_projecting) OVERRIDE {
 207     dbus::MethodCall method_call(
 208         power_manager::kPowerManagerInterface,
 209         power_manager::kSetIsProjectingMethod);
 210     dbus::MessageWriter writer(&method_call);
 211     writer.AppendBool(is_projecting);
 212     power_manager_proxy_->CallMethod(
 213         &method_call,
 214         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 215         dbus::ObjectProxy::EmptyResponseCallback());
 216     last_is_projecting_ = is_projecting;
 217   }
 218
 219   virtual base::Closure GetSuspendReadinessCallback() OVERRIDE {
 220     DCHECK(OnOriginThread());
 221     DCHECK(suspend_is_pending_);
 222     num_pending_suspend_readiness_callbacks_++;
 223     return base::Bind(&PowerManagerClientImpl::HandleObserverSuspendReadiness,
 224                       weak_ptr_factory_.GetWeakPtr(), pending_suspend_id_,
 225                       suspending_from_dark_resume_);
 226   }
 227
 228   virtual int GetNumPendingSuspendReadinessCallbacks() OVERRIDE {
 229     return num_pending_suspend_readiness_callbacks_;
 230   }
 231
 232  protected:
 233   virtual void Init(dbus::Bus* bus) OVERRIDE {
 234     power_manager_proxy_ = bus->GetObjectProxy(
 235         power_manager::kPowerManagerServiceName,
 236         dbus::ObjectPath(power_manager::kPowerManagerServicePath));
 237
 238     power_manager_proxy_->SetNameOwnerChangedCallback(
 239         base::Bind(&PowerManagerClientImpl::NameOwnerChangedReceived,
 240                    weak_ptr_factory_.GetWeakPtr()));
 241
 242     // Monitor the D-Bus signal for brightness changes. Only the power
 243     // manager knows the actual brightness level. We don't cache the
 244     // brightness level in Chrome as it'll make things less reliable.
 245     power_manager_proxy_->ConnectToSignal(
 246         power_manager::kPowerManagerInterface,
 247         power_manager::kBrightnessChangedSignal,
 248         base::Bind(&PowerManagerClientImpl::BrightnessChangedReceived,
 249                    weak_ptr_factory_.GetWeakPtr()),
 250         base::Bind(&PowerManagerClientImpl::SignalConnected,
 251                    weak_ptr_factory_.GetWeakPtr()));
 252
 253     power_manager_proxy_->ConnectToSignal(
 254         power_manager::kPowerManagerInterface,
 255         power_manager::kPeripheralBatteryStatusSignal,
 256         base::Bind(&PowerManagerClientImpl::PeripheralBatteryStatusReceived,
 257                    weak_ptr_factory_.GetWeakPtr()),
 258         base::Bind(&PowerManagerClientImpl::SignalConnected,
 259                    weak_ptr_factory_.GetWeakPtr()));
 260
 261     power_manager_proxy_->ConnectToSignal(
 262         power_manager::kPowerManagerInterface,
 263         power_manager::kPowerSupplyPollSignal,
 264         base::Bind(&PowerManagerClientImpl::PowerSupplyPollReceived,
 265                    weak_ptr_factory_.GetWeakPtr()),
 266         base::Bind(&PowerManagerClientImpl::SignalConnected,
 267                    weak_ptr_factory_.GetWeakPtr()));
 268
 269     power_manager_proxy_->ConnectToSignal(
 270         power_manager::kPowerManagerInterface,
 271         power_manager::kInputEventSignal,
 272         base::Bind(&PowerManagerClientImpl::InputEventReceived,
 273                    weak_ptr_factory_.GetWeakPtr()),
 274         base::Bind(&PowerManagerClientImpl::SignalConnected,
 275                    weak_ptr_factory_.GetWeakPtr()));
 276
 277     power_manager_proxy_->ConnectToSignal(
 278         power_manager::kPowerManagerInterface,
 279         power_manager::kSuspendImminentSignal,
 280         base::Bind(
 281             &PowerManagerClientImpl::HandleSuspendImminent,
 282             weak_ptr_factory_.GetWeakPtr(), false),
 283         base::Bind(&PowerManagerClientImpl::SignalConnected,
 284                    weak_ptr_factory_.GetWeakPtr()));
 285
 286     power_manager_proxy_->ConnectToSignal(
 287         power_manager::kPowerManagerInterface,
 288         power_manager::kSuspendDoneSignal,
 289         base::Bind(&PowerManagerClientImpl::SuspendDoneReceived,
 290                    weak_ptr_factory_.GetWeakPtr()),
 291         base::Bind(&PowerManagerClientImpl::SignalConnected,
 292                    weak_ptr_factory_.GetWeakPtr()));
 293
 294     power_manager_proxy_->ConnectToSignal(
 295         power_manager::kPowerManagerInterface,
 296         power_manager::kDarkSuspendImminentSignal,
 297         base::Bind(
 298             &PowerManagerClientImpl::HandleSuspendImminent,
 299             weak_ptr_factory_.GetWeakPtr(), true),
 300         base::Bind(&PowerManagerClientImpl::SignalConnected,
 301                    weak_ptr_factory_.GetWeakPtr()));
 302
 303     power_manager_proxy_->ConnectToSignal(
 304         power_manager::kPowerManagerInterface,
 305         power_manager::kIdleActionImminentSignal,
 306         base::Bind(
 307             &PowerManagerClientImpl::IdleActionImminentReceived,
 308             weak_ptr_factory_.GetWeakPtr()),
 309         base::Bind(&PowerManagerClientImpl::SignalConnected,
 310                    weak_ptr_factory_.GetWeakPtr()));
 311
 312     power_manager_proxy_->ConnectToSignal(
 313         power_manager::kPowerManagerInterface,
 314         power_manager::kIdleActionDeferredSignal,
 315         base::Bind(
 316             &PowerManagerClientImpl::IdleActionDeferredReceived,
 317             weak_ptr_factory_.GetWeakPtr()),
 318         base::Bind(&PowerManagerClientImpl::SignalConnected,
 319                    weak_ptr_factory_.GetWeakPtr()));
 320
 321     RegisterSuspendDelays();
 322   }
 323
 324  private:
 325   // Returns true if the current thread is the origin thread.
 326   bool OnOriginThread() {
 327     return base::PlatformThread::CurrentId() == origin_thread_id_;
 328   }
 329
 330   // Called when a dbus signal is initially connected.
 331   void SignalConnected(const std::string& interface_name,
 332                        const std::string& signal_name,
 333                        bool success) {
 334     LOG_IF(WARNING, !success) << "Failed to connect to signal "
 335                               << signal_name << ".";
 336   }
 337
 338   // Makes a method call to power manager with no arguments and no response.
 339   void SimpleMethodCallToPowerManager(const std::string& method_name) {
 340     dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
 341                                  method_name);
 342     power_manager_proxy_->CallMethod(
 343         &method_call,
 344         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 345         dbus::ObjectProxy::EmptyResponseCallback());
 346   }
 347
 348   void NameOwnerChangedReceived(const std::string& old_owner,
 349                                 const std::string& new_owner) {
 350     VLOG(1) << "Power manager restarted (old owner was "
 351             << (old_owner.empty() ? "[none]" : old_owner.c_str())
 352             << ", new owner is "
 353             << (new_owner.empty() ? "[none]" : new_owner.c_str()) << ")";
 354     suspend_is_pending_ = false;
 355     pending_suspend_id_ = -1;
 356     suspending_from_dark_resume_ = false;
 357     if (!new_owner.empty()) {
 358       VLOG(1) << "Sending initial state to power manager";
 359       RegisterSuspendDelays();
 360       SetIsProjecting(last_is_projecting_);
 361       FOR_EACH_OBSERVER(Observer, observers_, PowerManagerRestarted());
 362     }
 363   }
 364
 365   void BrightnessChangedReceived(dbus::Signal* signal) {
 366     dbus::MessageReader reader(signal);
 367     int32_t brightness_level = 0;
 368     bool user_initiated = 0;
 369     if (!(reader.PopInt32(&brightness_level) &&
 370           reader.PopBool(&user_initiated))) {
 371       LOG(ERROR) << "Brightness changed signal had incorrect parameters: "
 372                  << signal->ToString();
 373       return;
 374     }
 375     VLOG(1) << "Brightness changed to " << brightness_level
 376             << ": user initiated " << user_initiated;
 377     FOR_EACH_OBSERVER(Observer, observers_,
 378                       BrightnessChanged(brightness_level, user_initiated));
 379   }
 380
 381   void PeripheralBatteryStatusReceived(dbus::Signal* signal) {
 382     dbus::MessageReader reader(signal);
 383     power_manager::PeripheralBatteryStatus protobuf_status;
 384     if (!reader.PopArrayOfBytesAsProto(&protobuf_status)) {
 385       LOG(ERROR) << "Unable to decode protocol buffer from "
 386                  << power_manager::kPeripheralBatteryStatusSignal << " signal";
 387       return;
 388     }
 389
 390     std::string path = protobuf_status.path();
 391     std::string name = protobuf_status.name();
 392     int level = protobuf_status.has_level() ? protobuf_status.level() : -1;
 393
 394     VLOG(1) << "Device battery status received " << level
 395             << " for " << name << " at " << path;
 396
 397     FOR_EACH_OBSERVER(Observer, observers_,
 398                       PeripheralBatteryStatusReceived(path, name, level));
 399   }
 400
 401   void PowerSupplyPollReceived(dbus::Signal* signal) {
 402     VLOG(1) << "Received power supply poll signal.";
 403     dbus::MessageReader reader(signal);
 404     power_manager::PowerSupplyProperties protobuf;
 405     if (reader.PopArrayOfBytesAsProto(&protobuf)) {
 406       FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(protobuf));
 407     } else {
 408       LOG(ERROR) << "Unable to decode "
 409                  << power_manager::kPowerSupplyPollSignal << "signal";
 410     }
 411   }
 412
 413   void OnGetPowerSupplyPropertiesMethod(dbus::Response* response) {
 414     if (!response) {
 415       LOG(ERROR) << "Error calling "
 416                  << power_manager::kGetPowerSupplyPropertiesMethod;
 417       return;
 418     }
 419
 420     dbus::MessageReader reader(response);
 421     power_manager::PowerSupplyProperties protobuf;
 422     if (reader.PopArrayOfBytesAsProto(&protobuf)) {
 423       FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(protobuf));
 424     } else {
 425       LOG(ERROR) << "Unable to decode "
 426                  << power_manager::kGetPowerSupplyPropertiesMethod
 427                  << " response";
 428     }
 429   }
 430
 431   void OnGetScreenBrightnessPercent(
 432       const GetScreenBrightnessPercentCallback& callback,
 433       dbus::Response* response) {
 434     if (!response) {
 435       LOG(ERROR) << "Error calling "
 436                  << power_manager::kGetScreenBrightnessPercentMethod;
 437       return;
 438     }
 439     dbus::MessageReader reader(response);
 440     double percent = 0.0;
 441     if (!reader.PopDouble(&percent))
 442       LOG(ERROR) << "Error reading response from powerd: "
 443                  << response->ToString();
 444     callback.Run(percent);
 445   }
 446
 447   void HandleRegisterSuspendDelayReply(bool dark_suspend,
 448                                        const std::string& method_name,
 449                                        dbus::Response* response) {
 450     if (!response) {
 451       LOG(ERROR) << "Error calling " << method_name;
 452       return;
 453     }
 454
 455     dbus::MessageReader reader(response);
 456     power_manager::RegisterSuspendDelayReply protobuf;
 457     if (!reader.PopArrayOfBytesAsProto(&protobuf)) {
 458       LOG(ERROR) << "Unable to parse reply from " << method_name;
 459       return;
 460     }
 461
 462     if (dark_suspend) {
 463       dark_suspend_delay_id_ = protobuf.delay_id();
 464       has_dark_suspend_delay_id_ = true;
 465       VLOG(1) << "Registered dark suspend delay " << dark_suspend_delay_id_;
 466     } else {
 467       suspend_delay_id_ = protobuf.delay_id();
 468       has_suspend_delay_id_ = true;
 469       VLOG(1) << "Registered suspend delay " << suspend_delay_id_;
 470     }
 471   }
 472
 473   void HandleSuspendImminent(bool in_dark_resume, dbus::Signal* signal) {
 474     std::string signal_name = signal->GetMember();
 475     if ((in_dark_resume && !has_dark_suspend_delay_id_) ||
 476         (!in_dark_resume && !has_suspend_delay_id_)) {
 477       LOG(ERROR) << "Received unrequested " << signal_name << " signal";
 478       return;
 479     }
 480
 481     dbus::MessageReader reader(signal);
 482     power_manager::SuspendImminent proto;
 483     if (!reader.PopArrayOfBytesAsProto(&proto)) {
 484       LOG(ERROR) << "Unable to decode protocol buffer from " << signal_name
 485                  << " signal";
 486       return;
 487     }
 488
 489     VLOG(1) << "Got " << signal_name << " signal announcing suspend attempt "
 490             << proto.suspend_id();
 491
 492     // If a previous suspend is pending from the same state we are currently in
 493     // (fully powered on or in dark resume), then something's gone a little
 494     // wonky.
 495     if (suspend_is_pending_ &&
 496         suspending_from_dark_resume_ == in_dark_resume) {
 497       LOG(WARNING) << "Got " << signal_name << " signal about pending suspend "
 498                    << "attempt " << proto.suspend_id() << " while still "
 499                    << "waiting on attempt " << pending_suspend_id_;
 500     }
 501
 502     pending_suspend_id_ = proto.suspend_id();
 503     suspend_is_pending_ = true;
 504     suspending_from_dark_resume_ = in_dark_resume;
 505     num_pending_suspend_readiness_callbacks_ = 0;
 506     if (suspending_from_dark_resume_)
 507       FOR_EACH_OBSERVER(Observer, observers_, DarkSuspendImminent());
 508     else
 509       FOR_EACH_OBSERVER(Observer, observers_, SuspendImminent());
 510     MaybeReportSuspendReadiness();
 511   }
 512
 513   void SuspendDoneReceived(dbus::Signal* signal) {
 514     dbus::MessageReader reader(signal);
 515     power_manager::SuspendDone proto;
 516     if (!reader.PopArrayOfBytesAsProto(&proto)) {
 517       LOG(ERROR) << "Unable to decode protocol buffer from "
 518                  << power_manager::kSuspendDoneSignal << " signal";
 519       return;
 520     }
 521
 522     const base::TimeDelta duration =
 523         base::TimeDelta::FromInternalValue(proto.suspend_duration());
 524     VLOG(1) << "Got " << power_manager::kSuspendDoneSignal << " signal:"
 525             << " suspend_id=" << proto.suspend_id()
 526             << " duration=" << duration.InSeconds() << " sec";
 527     FOR_EACH_OBSERVER(
 528         PowerManagerClient::Observer, observers_, SuspendDone(duration));
 529   }
 530
 531   void IdleActionImminentReceived(dbus::Signal* signal) {
 532     dbus::MessageReader reader(signal);
 533     power_manager::IdleActionImminent proto;
 534     if (!reader.PopArrayOfBytesAsProto(&proto)) {
 535       LOG(ERROR) << "Unable to decode protocol buffer from "
 536                  << power_manager::kIdleActionImminentSignal << " signal";
 537       return;
 538     }
 539     FOR_EACH_OBSERVER(Observer, observers_,
 540         IdleActionImminent(base::TimeDelta::FromInternalValue(
 541             proto.time_until_idle_action())));
 542   }
 543
 544   void IdleActionDeferredReceived(dbus::Signal* signal) {
 545     FOR_EACH_OBSERVER(Observer, observers_, IdleActionDeferred());
 546   }
 547
 548   void InputEventReceived(dbus::Signal* signal) {
 549     dbus::MessageReader reader(signal);
 550     power_manager::InputEvent proto;
 551     if (!reader.PopArrayOfBytesAsProto(&proto)) {
 552       LOG(ERROR) << "Unable to decode protocol buffer from "
 553                  << power_manager::kInputEventSignal << " signal";
 554       return;
 555     }
 556
 557     base::TimeTicks timestamp =
 558         base::TimeTicks::FromInternalValue(proto.timestamp());
 559     VLOG(1) << "Got " << power_manager::kInputEventSignal << " signal:"
 560             << " type=" << proto.type() << " timestamp=" << proto.timestamp();
 561     switch (proto.type()) {
 562       case power_manager::InputEvent_Type_POWER_BUTTON_DOWN:
 563       case power_manager::InputEvent_Type_POWER_BUTTON_UP: {
 564         const bool down =
 565             (proto.type() == power_manager::InputEvent_Type_POWER_BUTTON_DOWN);
 566         FOR_EACH_OBSERVER(PowerManagerClient::Observer, observers_,
 567                           PowerButtonEventReceived(down, timestamp));
 568
 569         // Tell powerd that Chrome has handled power button presses.
 570         if (down) {
 571           dbus::MethodCall method_call(
 572               power_manager::kPowerManagerInterface,
 573               power_manager::kHandlePowerButtonAcknowledgmentMethod);
 574           dbus::MessageWriter writer(&method_call);
 575           writer.AppendInt64(proto.timestamp());
 576           power_manager_proxy_->CallMethod(
 577               &method_call,
 578               dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 579               dbus::ObjectProxy::EmptyResponseCallback());
 580         }
 581         break;
 582       }
 583       case power_manager::InputEvent_Type_LID_OPEN:
 584       case power_manager::InputEvent_Type_LID_CLOSED: {
 585         bool open =
 586             (proto.type() == power_manager::InputEvent_Type_LID_OPEN);
 587         FOR_EACH_OBSERVER(PowerManagerClient::Observer, observers_,
 588                           LidEventReceived(open, timestamp));
 589         break;
 590       }
 591     }
 592   }
 593
 594   void RegisterSuspendDelayImpl(
 595       const std::string& method_name,
 596       const power_manager::RegisterSuspendDelayRequest& protobuf_request,
 597       dbus::ObjectProxy::ResponseCallback callback) {
 598     dbus::MethodCall method_call(
 599         power_manager::kPowerManagerInterface, method_name);
 600     dbus::MessageWriter writer(&method_call);
 601
 602     if (!writer.AppendProtoAsArrayOfBytes(protobuf_request)) {
 603       LOG(ERROR) << "Error constructing message for " << method_name;
 604       return;
 605     }
 606
 607     power_manager_proxy_->CallMethod(
 608         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT, callback);
 609   }
 610
 611   // Registers suspend delays with the power manager.  This is usually only
 612   // called at startup, but if the power manager restarts, we need to create new
 613   // delays.
 614   void RegisterSuspendDelays() {
 615     // Throw out any old delay that was registered.
 616     suspend_delay_id_ = -1;
 617     has_suspend_delay_id_ = false;
 618     dark_suspend_delay_id_ = -1;
 619     has_dark_suspend_delay_id_ = false;
 620
 621     power_manager::RegisterSuspendDelayRequest protobuf_request;
 622     base::TimeDelta timeout =
 623         base::TimeDelta::FromMilliseconds(kSuspendDelayTimeoutMs);
 624     protobuf_request.set_timeout(timeout.ToInternalValue());
 625     protobuf_request.set_description(kSuspendDelayDescription);
 626
 627     RegisterSuspendDelayImpl(
 628         power_manager::kRegisterSuspendDelayMethod,
 629         protobuf_request,
 630         base::Bind(&PowerManagerClientImpl::HandleRegisterSuspendDelayReply,
 631                    weak_ptr_factory_.GetWeakPtr(), false,
 632                    power_manager::kRegisterSuspendDelayMethod));
 633     RegisterSuspendDelayImpl(
 634         power_manager::kRegisterDarkSuspendDelayMethod,
 635         protobuf_request,
 636         base::Bind(&PowerManagerClientImpl::HandleRegisterSuspendDelayReply,
 637                    weak_ptr_factory_.GetWeakPtr(), true,
 638                    power_manager::kRegisterDarkSuspendDelayMethod));
 639   }
 640
 641   // Records the fact that an observer has finished doing asynchronous work
 642   // that was blocking a pending suspend attempt and possibly reports
 643   // suspend readiness to powerd.  Called by callbacks returned via
 644   // GetSuspendReadinessCallback().
 645   void HandleObserverSuspendReadiness(int32_t suspend_id, bool in_dark_resume) {
 646     DCHECK(OnOriginThread());
 647     if (!suspend_is_pending_ || suspend_id != pending_suspend_id_ ||
 648         in_dark_resume != suspending_from_dark_resume_)
 649       return;
 650
 651     num_pending_suspend_readiness_callbacks_--;
 652     MaybeReportSuspendReadiness();
 653   }
 654
 655   // Reports suspend readiness to powerd if no observers are still holding
 656   // suspend readiness callbacks.
 657   void MaybeReportSuspendReadiness() {
 658     if (!suspend_is_pending_ || num_pending_suspend_readiness_callbacks_ > 0)
 659       return;
 660
 661     std::string method_name;
 662     int32_t delay_id = -1;
 663     if (suspending_from_dark_resume_) {
 664       method_name = power_manager::kHandleDarkSuspendReadinessMethod;
 665       delay_id = dark_suspend_delay_id_;
 666     } else {
 667       method_name = power_manager::kHandleSuspendReadinessMethod;
 668       delay_id = suspend_delay_id_;
 669     }
 670
 671     dbus::MethodCall method_call(
 672         power_manager::kPowerManagerInterface, method_name);
 673     dbus::MessageWriter writer(&method_call);
 674
 675     VLOG(1) << "Announcing readiness of suspend delay " << delay_id
 676             << " for suspend attempt " << pending_suspend_id_;
 677     power_manager::SuspendReadinessInfo protobuf_request;
 678     protobuf_request.set_delay_id(delay_id);
 679     protobuf_request.set_suspend_id(pending_suspend_id_);
 680
 681     pending_suspend_id_ = -1;
 682     suspend_is_pending_ = false;
 683
 684     if (!writer.AppendProtoAsArrayOfBytes(protobuf_request)) {
 685       LOG(ERROR) << "Error constructing message for " << method_name;
 686       return;
 687     }
 688     power_manager_proxy_->CallMethod(
 689         &method_call,
 690         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 691         dbus::ObjectProxy::EmptyResponseCallback());
 692   }
 693
 694   // Origin thread (i.e. the UI thread in production).
 695   base::PlatformThreadId origin_thread_id_;
 696
 697   dbus::ObjectProxy* power_manager_proxy_;
 698   ObserverList<Observer> observers_;
 699
 700   // The delay_id_ obtained from the RegisterSuspendDelay request.
 701   int32_t suspend_delay_id_;
 702   bool has_suspend_delay_id_;
 703
 704   // The delay_id_ obtained from the RegisterDarkSuspendDelay request.
 705   int32_t dark_suspend_delay_id_;
 706   bool has_dark_suspend_delay_id_;
 707
 708   // powerd-supplied ID corresponding to an imminent suspend attempt that is
 709   // currently being delayed.
 710   int32_t pending_suspend_id_;
 711   bool suspend_is_pending_;
 712
 713   // Set to true when the suspend currently being delayed was triggered during a
 714   // dark resume.  Since |pending_suspend_id_| and |suspend_is_pending_| are
 715   // both shared by normal and dark suspends, |suspending_from_dark_resume_|
 716   // helps distinguish the context within which these variables are being used.
 717   bool suspending_from_dark_resume_;
 718
 719   // Number of callbacks that have been returned by
 720   // GetSuspendReadinessCallback() during the currently-pending suspend
 721   // attempt but have not yet been called.
 722   int num_pending_suspend_readiness_callbacks_;
 723
 724   // Last state passed to SetIsProjecting().
 725   bool last_is_projecting_;
 726
 727   // Note: This should remain the last member so it'll be destroyed and
 728   // invalidate its weak pointers before any other members are destroyed.
 729   base::WeakPtrFactory<PowerManagerClientImpl> weak_ptr_factory_;
 730
 731   DISALLOW_COPY_AND_ASSIGN(PowerManagerClientImpl);
 732 };
 733
 734 // The PowerManagerClient implementation used on Linux desktop,
 735 // which does nothing.
 736 class PowerManagerClientStubImpl : public PowerManagerClient {
 737  public:
 738   PowerManagerClientStubImpl()
 739       : discharging_(true),
 740         battery_percentage_(40),
 741         brightness_(50.0),
 742         pause_count_(2),
 743         cycle_count_(0),
 744         num_pending_suspend_readiness_callbacks_(0),
 745         weak_ptr_factory_(this) {}
 746
 747   virtual ~PowerManagerClientStubImpl() {}
 748
 749   int num_pending_suspend_readiness_callbacks() const {
 750     return num_pending_suspend_readiness_callbacks_;
 751   }
 752
 753   // PowerManagerClient overrides:
 754   virtual void Init(dbus::Bus* bus) OVERRIDE {
 755     ParseCommandLineSwitch();
 756     if (power_cycle_delay_ != base::TimeDelta()) {
 757       update_timer_.Start(FROM_HERE,
 758                           power_cycle_delay_,
 759                           this,
 760                           &PowerManagerClientStubImpl::UpdateStatus);
 761     }
 762   }
 763
 764   virtual void AddObserver(Observer* observer) OVERRIDE {
 765     observers_.AddObserver(observer);
 766   }
 767
 768   virtual void RemoveObserver(Observer* observer) OVERRIDE {
 769     observers_.RemoveObserver(observer);
 770   }
 771
 772   virtual bool HasObserver(Observer* observer) OVERRIDE {
 773     return observers_.HasObserver(observer);
 774   }
 775
 776   virtual void DecreaseScreenBrightness(bool allow_off) OVERRIDE {
 777     VLOG(1) << "Requested to descrease screen brightness";
 778     SetBrightness(brightness_ - 5.0, true);
 779   }
 780
 781   virtual void IncreaseScreenBrightness() OVERRIDE {
 782     VLOG(1) << "Requested to increase screen brightness";
 783     SetBrightness(brightness_ + 5.0, true);
 784   }
 785
 786   virtual void SetScreenBrightnessPercent(double percent,
 787                                           bool gradual) OVERRIDE {
 788     VLOG(1) << "Requested to set screen brightness to " << percent << "% "
 789             << (gradual ? "gradually" : "instantaneously");
 790     SetBrightness(percent, false);
 791   }
 792
 793   virtual void GetScreenBrightnessPercent(
 794       const GetScreenBrightnessPercentCallback& callback) OVERRIDE {
 795     callback.Run(brightness_);
 796   }
 797
 798   virtual void DecreaseKeyboardBrightness() OVERRIDE {
 799     VLOG(1) << "Requested to descrease keyboard brightness";
 800   }
 801
 802   virtual void IncreaseKeyboardBrightness() OVERRIDE {
 803     VLOG(1) << "Requested to increase keyboard brightness";
 804   }
 805
 806   virtual void RequestStatusUpdate() OVERRIDE {
 807     base::MessageLoop::current()->PostTask(FROM_HERE,
 808         base::Bind(&PowerManagerClientStubImpl::UpdateStatus,
 809                    weak_ptr_factory_.GetWeakPtr()));
 810   }
 811
 812   virtual void RequestSuspend() OVERRIDE {}
 813   virtual void RequestRestart() OVERRIDE {}
 814   virtual void RequestShutdown() OVERRIDE {}
 815
 816   virtual void NotifyUserActivity(
 817       power_manager::UserActivityType type) OVERRIDE {}
 818   virtual void NotifyVideoActivity(bool is_fullscreen) OVERRIDE {}
 819   virtual void SetPolicy(
 820       const power_manager::PowerManagementPolicy& policy) OVERRIDE {}
 821   virtual void SetIsProjecting(bool is_projecting) OVERRIDE {}
 822   virtual base::Closure GetSuspendReadinessCallback() OVERRIDE {
 823     num_pending_suspend_readiness_callbacks_++;
 824     return base::Bind(&PowerManagerClientStubImpl::HandleSuspendReadiness,
 825                       weak_ptr_factory_.GetWeakPtr());
 826   }
 827   virtual int GetNumPendingSuspendReadinessCallbacks() OVERRIDE {
 828     return num_pending_suspend_readiness_callbacks_;
 829   }
 830
 831  private:
 832   void HandleSuspendReadiness() {
 833     num_pending_suspend_readiness_callbacks_--;
 834   }
 835
 836   void UpdateStatus() {
 837     if (pause_count_ > 0) {
 838       pause_count_--;
 839       if (pause_count_ == 2)
 840         discharging_ = !discharging_;
 841     } else {
 842       if (discharging_)
 843         battery_percentage_ -= (battery_percentage_ <= 10 ? 1 : 10);
 844       else
 845         battery_percentage_ += (battery_percentage_ >= 10 ? 10 : 1);
 846       battery_percentage_ = std::min(std::max(battery_percentage_, 0), 100);
 847       // We pause at 0 and 100% so that it's easier to check those conditions.
 848       if (battery_percentage_ == 0 || battery_percentage_ == 100) {
 849         pause_count_ = 4;
 850         if (battery_percentage_ == 100)
 851           cycle_count_ = (cycle_count_ + 1) % 3;
 852       }
 853     }
 854
 855     const int kSecondsToEmptyFullBattery = 3 * 60 * 60;  // 3 hours.
 856     int64 remaining_battery_time =
 857         std::max(1, battery_percentage_ * kSecondsToEmptyFullBattery / 100);
 858
 859     props_.Clear();
 860
 861     switch (cycle_count_) {
 862       case 0:
 863         // Say that the system is charging with AC connected and
 864         // discharging without any charger connected.
 865         props_.set_external_power(discharging_ ?
 866             power_manager::PowerSupplyProperties_ExternalPower_DISCONNECTED :
 867             power_manager::PowerSupplyProperties_ExternalPower_AC);
 868         break;
 869       case 1:
 870         // Say that the system is both charging and discharging on USB
 871         // (i.e. a low-power charger).
 872         props_.set_external_power(
 873             power_manager::PowerSupplyProperties_ExternalPower_USB);
 874         break;
 875       case 2:
 876         // Say that the system is both charging and discharging on AC.
 877         props_.set_external_power(
 878             power_manager::PowerSupplyProperties_ExternalPower_AC);
 879         break;
 880       default:
 881         NOTREACHED() << "Unhandled cycle " << cycle_count_;
 882     }
 883
 884     if (battery_percentage_ == 100 && !discharging_) {
 885       props_.set_battery_state(
 886           power_manager::PowerSupplyProperties_BatteryState_FULL);
 887     } else if (!discharging_) {
 888       props_.set_battery_state(
 889           power_manager::PowerSupplyProperties_BatteryState_CHARGING);
 890       props_.set_battery_time_to_full_sec(std::max(static_cast<int64>(1),
 891           kSecondsToEmptyFullBattery - remaining_battery_time));
 892     } else {
 893       props_.set_battery_state(
 894           power_manager::PowerSupplyProperties_BatteryState_DISCHARGING);
 895       props_.set_battery_time_to_empty_sec(remaining_battery_time);
 896     }
 897
 898     props_.set_battery_percent(battery_percentage_);
 899     props_.set_is_calculating_battery_time(pause_count_ > 1);
 900
 901     FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(props_));
 902   }
 903
 904   void SetBrightness(double percent, bool user_initiated) {
 905     brightness_ = std::min(std::max(0.0, percent), 100.0);
 906     int brightness_level = static_cast<int>(brightness_);
 907     FOR_EACH_OBSERVER(Observer, observers_,
 908                       BrightnessChanged(brightness_level, user_initiated));
 909   }
 910
 911   void ParseCommandLineSwitch() {
 912     CommandLine* command_line = CommandLine::ForCurrentProcess();
 913     if (!command_line || !command_line->HasSwitch(switches::kPowerStub))
 914       return;
 915     std::string option_str =
 916         command_line->GetSwitchValueASCII(switches::kPowerStub);
 917     base::StringPairs string_pairs;
 918     base::SplitStringIntoKeyValuePairs(option_str, '=', ',', &string_pairs);
 919     for (base::StringPairs::iterator iter = string_pairs.begin();
 920          iter != string_pairs.end(); ++iter) {
 921       ParseOption((*iter).first, (*iter).second);
 922     }
 923   }
 924
 925   void ParseOption(const std::string& arg0, const std::string& arg1) {
 926     if (arg0 == "cycle" || arg0 == "interactive") {
 927       int seconds = 1;
 928       if (!arg1.empty())
 929         base::StringToInt(arg1, &seconds);
 930       power_cycle_delay_ = base::TimeDelta::FromSeconds(seconds);
 931     }
 932   }
 933
 934   base::TimeDelta power_cycle_delay_;  // Time over which to cycle power state
 935   bool discharging_;
 936   int battery_percentage_;
 937   double brightness_;
 938   int pause_count_;
 939   int cycle_count_;
 940   ObserverList<Observer> observers_;
 941   base::RepeatingTimer<PowerManagerClientStubImpl> update_timer_;
 942   power_manager::PowerSupplyProperties props_;
 943
 944   // Number of callbacks returned by GetSuspendReadinessCallback() but not yet
 945   // invoked.
 946   int num_pending_suspend_readiness_callbacks_;
 947
 948   // Note: This should remain the last member so it'll be destroyed and
 949   // invalidate its weak pointers before any other members are destroyed.
 950   base::WeakPtrFactory<PowerManagerClientStubImpl> weak_ptr_factory_;
 951 };
 952
 953 PowerManagerClient::PowerManagerClient() {
 954 }
 955
 956 PowerManagerClient::~PowerManagerClient() {
 957 }
 958
 959 // static
 960 PowerManagerClient* PowerManagerClient::Create(
 961     DBusClientImplementationType type) {
 962   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
 963     return new PowerManagerClientImpl();
 964   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
 965   return new PowerManagerClientStubImpl();
 966 }
 967
 968 }  // namespace chromeos