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