chromeos: Remove PowerStateOverride.

chromeos/dbus/power_manager_client.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 "chromeos/dbus/power_manager_client.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/observer_list.h"
 #include "base/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "chromeos/dbus/power_manager/input_event.pb.h"
 #include "chromeos/dbus/power_manager/policy.pb.h"
 #include "chromeos/dbus/power_manager/suspend.pb.h"
-#include "chromeos/dbus/power_state_control.pb.h"
 #include "chromeos/dbus/power_supply_properties.pb.h"
 #include "chromeos/dbus/video_activity_update.pb.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
@@ skipping 267 matching lines @@
     if (!writer.AppendProtoAsArrayOfBytes(policy)) {
       LOG(ERROR) << "Error calling " << power_manager::kSetPolicyMethod;
       return;
     }
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
-  virtual void RequestPowerStateOverrides(
-      uint32 request_id,
-      base::TimeDelta duration,
-      int overrides,
-      const PowerStateRequestIdCallback& callback) OVERRIDE {
-    dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
-                                 power_manager::kStateOverrideRequest);
-    dbus::MessageWriter writer(&method_call);
-
-    PowerStateControl protobuf;
-    protobuf.set_request_id(request_id);
-    protobuf.set_duration(duration.InSeconds());
-    protobuf.set_disable_idle_dim(overrides & DISABLE_IDLE_DIM);
-    protobuf.set_disable_idle_blank(overrides & DISABLE_IDLE_BLANK);
-    protobuf.set_disable_idle_suspend(overrides & DISABLE_IDLE_SUSPEND);
-    protobuf.set_disable_lid_suspend(overrides & DISABLE_LID_SUSPEND);
-
-    if (!writer.AppendProtoAsArrayOfBytes(protobuf)) {
-      LOG(ERROR) << "Error calling "
-                 << power_manager::kStateOverrideRequest;
-      return;
-    }
-    power_manager_proxy_->CallMethod(
-        &method_call,
-        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&PowerManagerClientImpl::OnPowerStateOverride,
-                   weak_ptr_factory_.GetWeakPtr(), callback));
-  }
-
-  virtual void CancelPowerStateOverrides(uint32 request_id) OVERRIDE {
-    dbus::MethodCall method_call(power_manager::kPowerManagerInterface,
-                                 power_manager::kStateOverrideCancel);
-    dbus::MessageWriter writer(&method_call);
-    writer.AppendInt32(request_id);
-    power_manager_proxy_->CallMethod(
-        &method_call,
-        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        dbus::ObjectProxy::EmptyResponseCallback());
-  }
-
   virtual void SetIsProjecting(bool is_projecting) OVERRIDE {
     dbus::MethodCall method_call(
         power_manager::kPowerManagerInterface,
         power_manager::kSetIsProjectingMethod);
     dbus::MessageWriter writer(&method_call);
     writer.AppendBool(is_projecting);
     power_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
@@ skipping 101 matching lines @@
     status.battery_percentage = protobuf.battery_percentage();
     status.battery_is_present = protobuf.battery_is_present();
     status.battery_is_full = protobuf.battery_is_charged();
     status.is_calculating_battery_time = protobuf.is_calculating_battery_time();
     status.battery_energy_rate = protobuf.battery_energy_rate();
 
     VLOG(1) << "Power status: " << status.ToString();
     FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(status));
   }
 
-  void OnPowerStateOverride(const PowerStateRequestIdCallback& callback,
-                            dbus::Response* response) {
-    if (!response) {
-      LOG(ERROR) << "Error calling " << power_manager::kStateOverrideRequest;
-      return;
-    }
-
-    dbus::MessageReader reader(response);
-    int32 request_id = 0;
-    if (!reader.PopInt32(&request_id)) {
-      LOG(ERROR) << "Error reading response from powerd: "
-                 << response->ToString();
-      callback.Run(0);
-      return;
-    }
-
-    callback.Run(request_id);
-  }
-
   void OnGetScreenBrightnessPercent(
       const GetScreenBrightnessPercentCallback& callback,
       dbus::Response* response) {
     if (!response) {
       LOG(ERROR) << "Error calling "
                  << power_manager::kGetScreenBrightnessPercent;
       return;
     }
     dbus::MessageReader reader(response);
     double percent = 0.0;
@@ skipping 261 matching lines @@
 };
 
 // The PowerManagerClient implementation used on Linux desktop,
 // which does nothing.
 class PowerManagerClientStubImpl : public PowerManagerClient {
  public:
   PowerManagerClientStubImpl()
       : discharging_(true),
         battery_percentage_(40),
         brightness_(50.0),
-        pause_count_(2),
-        next_request_id_(1) {
+        pause_count_(2) {
   }
 
   virtual ~PowerManagerClientStubImpl() {}
 
   // PowerManagerClient overrides:
 
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
@@ skipping 63 matching lines @@
         base::TimeDelta::FromMilliseconds(threshold));
   }
 
   virtual void NotifyUserActivity(
       const base::TimeTicks& last_activity_time) OVERRIDE {}
   virtual void NotifyVideoActivity(
       const base::TimeTicks& last_activity_time,
       bool is_fullscreen) OVERRIDE {}
   virtual void SetPolicy(
       const power_manager::PowerManagementPolicy& policy) OVERRIDE {}
-  virtual void RequestPowerStateOverrides(
-      uint32 request_id,
-      base::TimeDelta duration,
-      int overrides,
-      const PowerStateRequestIdCallback& callback) OVERRIDE {
-    // Mimic the behavior of power manager w.r.t. the request_id.
-    if (request_id == 0) {
-      callback.Run(next_request_id_++);
-    } else {
-      callback.Run(request_id);
-    }
-  }
-  virtual void CancelPowerStateOverrides(uint32 request_id) OVERRIDE {}
   virtual void SetIsProjecting(bool is_projecting) OVERRIDE {}
   virtual base::Closure GetSuspendReadinessCallback() OVERRIDE {
     return base::Closure();
   }
 
  private:
   void Update() {
     if (pause_count_ > 0) {
       pause_count_--;
     } else {
@@ skipping 35 matching lines @@
     FOR_EACH_OBSERVER(Observer, observers_, IdleNotify(threshold));
   }
 
   bool discharging_;
   int battery_percentage_;
   double brightness_;
   int pause_count_;
   ObserverList<Observer> observers_;
   base::RepeatingTimer<PowerManagerClientStubImpl> timer_;
   PowerSupplyStatus status_;
-  uint32 next_request_id_;
 };
 
 PowerManagerClient::PowerManagerClient() {
 }
 
 PowerManagerClient::~PowerManagerClient() {
 }
 
+// static
 PowerManagerClient* PowerManagerClient::Create(
     DBusClientImplementationType type,
     dbus::Bus* bus) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new PowerManagerClientImpl(bus);
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new PowerManagerClientStubImpl();
 }
 
 }  // namespace chromeos