Replace misc. network stub flags with more flexible ones

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/command_line.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/observer_list.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chromeos/chromeos_switches.h"
+#include "chromeos/dbus/dbus_command_line_helper.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager/input_event.pb.h"
 #include "chromeos/dbus/power_manager/peripheral_battery_status.pb.h"
 #include "chromeos/dbus/power_manager/policy.pb.h"
 #include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
 #include "chromeos/dbus/power_manager/suspend.pb.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 
@@ skipping 615 matching lines @@
   // Last state passed to SetIsProjecting().
   bool last_is_projecting_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
   base::WeakPtrFactory<PowerManagerClientImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PowerManagerClientImpl);
 };
 
-// The PowerManagerClient implementation used on Linux desktop,
-// which does nothing.
-class PowerManagerClientStubImpl : public PowerManagerClient {
+// The fake PowerManagerClient implementation used on Linux desktop. This
+// can simulate a battery draining/charging, etc, for testing UI.
+class FakePowerManagerClient : public PowerManagerClient {
  public:
-  PowerManagerClientStubImpl()
-      : discharging_(true),
+  FakePowerManagerClient()
+      : power_cycle_delay_(false),
+        discharging_(true),
         battery_percentage_(40),
         brightness_(50.0),
         pause_count_(2),
         cycle_count_(0),
         num_pending_suspend_readiness_callbacks_(0),
-        weak_ptr_factory_(this) {}
+        weak_ptr_factory_(this) {
+    ParseCommandLineSwitch();
+  }
 
-  virtual ~PowerManagerClientStubImpl() {}
+  virtual ~FakePowerManagerClient() {}
 
   int num_pending_suspend_readiness_callbacks() const {
     return num_pending_suspend_readiness_callbacks_;
   }
 
   // PowerManagerClient overrides:
   virtual void Init(dbus::Bus* bus) OVERRIDE {
-    if (CommandLine::ForCurrentProcess()->HasSwitch(
-        chromeos::switches::kEnableStubInteractive)) {
-      const int kStatusUpdateMs = 1000;
+    if (power_cycle_delay_) {
       update_timer_.Start(FROM_HERE,
-          base::TimeDelta::FromMilliseconds(kStatusUpdateMs), this,
-          &PowerManagerClientStubImpl::UpdateStatus);
+                          base::TimeDelta::FromSeconds(power_cycle_delay_),
+                          this,
+                          &FakePowerManagerClient::UpdateStatus);
     }
   }
 
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
@@ skipping 27 matching lines @@
   virtual void DecreaseKeyboardBrightness() OVERRIDE {
     VLOG(1) << "Requested to descrease keyboard brightness";
   }
 
   virtual void IncreaseKeyboardBrightness() OVERRIDE {
     VLOG(1) << "Requested to increase keyboard brightness";
   }
 
   virtual void RequestStatusUpdate() OVERRIDE {
     base::MessageLoop::current()->PostTask(FROM_HERE,
-        base::Bind(&PowerManagerClientStubImpl::UpdateStatus,
+        base::Bind(&FakePowerManagerClient::UpdateStatus,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual void RequestRestart() OVERRIDE {}
   virtual void RequestShutdown() OVERRIDE {}
 
   virtual void NotifyUserActivity(
       power_manager::UserActivityType type) OVERRIDE {}
   virtual void NotifyVideoActivity(bool is_fullscreen) OVERRIDE {}
   virtual void SetPolicy(
       const power_manager::PowerManagementPolicy& policy) OVERRIDE {}
   virtual void SetIsProjecting(bool is_projecting) OVERRIDE {}
   virtual base::Closure GetSuspendReadinessCallback() OVERRIDE {
     num_pending_suspend_readiness_callbacks_++;
-    return base::Bind(&PowerManagerClientStubImpl::HandleSuspendReadiness,
+    return base::Bind(&FakePowerManagerClient::HandleSuspendReadiness,
                       weak_ptr_factory_.GetWeakPtr());
   }
   virtual int GetNumPendingSuspendReadinessCallbacks() OVERRIDE {
     return num_pending_suspend_readiness_callbacks_;
   }
 
  private:
   void HandleSuspendReadiness() {
     num_pending_suspend_readiness_callbacks_--;
   }
@@ skipping 66 matching lines @@
     FOR_EACH_OBSERVER(Observer, observers_, PowerChanged(props_));
   }
 
   void SetBrightness(double percent, bool user_initiated) {
     brightness_ = std::min(std::max(0.0, percent), 100.0);
     int brightness_level = static_cast<int>(brightness_);
     FOR_EACH_OBSERVER(Observer, observers_,
                       BrightnessChanged(brightness_level, user_initiated));
   }
 
+  void ParseCommandLineSwitch() {
+    dbus_command_line_helper::ParseOptions(
+        switches::kPowerStub,
+          base::Bind(&FakePowerManagerClient::ParseOption,
+                     base::Unretained(this)));
+  }
+
+  bool ParseOption(const std::string& arg0, const std::string& arg1) {
+    if (arg0 == "cycle" || arg0 == "interactive") {
+      int seconds = 1;
+      if (!arg1.empty())
+        base::StringToInt(arg1, &seconds);
+      power_cycle_delay_ = seconds;
+      return true;
+    }
+    return false;
+  }
+
+  int power_cycle_delay_;  // Seconds over which to cycle power state
   bool discharging_;
   int battery_percentage_;
   double brightness_;
   int pause_count_;
   int cycle_count_;
   ObserverList<Observer> observers_;
-  base::RepeatingTimer<PowerManagerClientStubImpl> update_timer_;
+  base::RepeatingTimer<FakePowerManagerClient> update_timer_;
   power_manager::PowerSupplyProperties props_;
 
   // Number of callbacks returned by GetSuspendReadinessCallback() but not yet
   // invoked.
   int num_pending_suspend_readiness_callbacks_;
 
   // Note: This should remain the last member so it'll be destroyed and
   // invalidate its weak pointers before any other members are destroyed.
-  base::WeakPtrFactory<PowerManagerClientStubImpl> weak_ptr_factory_;
+  base::WeakPtrFactory<FakePowerManagerClient> weak_ptr_factory_;
 };
 
 PowerManagerClient::PowerManagerClient() {
 }
 
 PowerManagerClient::~PowerManagerClient() {
 }
 
 // static
 PowerManagerClient* PowerManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new PowerManagerClientImpl();
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
-  return new PowerManagerClientStubImpl();
+  return new FakePowerManagerClient();
 }
 
 }  // namespace chromeos