Home | History | Annotate | Download | only in dbus 
      1 // Copyright (c) 2013 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 #ifndef CHROMEOS_DBUS_POWER_POLICY_CONTROLLER_H_
      6 #define CHROMEOS_DBUS_POWER_POLICY_CONTROLLER_H_
      7 
      8 #include <map>
      9 #include <string>
     10 
     11 #include "base/basictypes.h"
     12 #include "base/compiler_specific.h"
     13 #include "chromeos/chromeos_export.h"
     14 #include "chromeos/dbus/dbus_thread_manager_observer.h"
     15 #include "chromeos/dbus/power_manager/policy.pb.h"
     16 #include "chromeos/dbus/power_manager_client.h"
     17 
     18 namespace chromeos {
     19 
     20 class DBusThreadManager;
     21 
     22 // PowerPolicyController is responsible for sending Chrome's assorted power
     23 // management preferences to the Chrome OS power manager.
     24 class CHROMEOS_EXPORT PowerPolicyController
     25     : public DBusThreadManagerObserver,
     26       public PowerManagerClient::Observer {
     27  public:
     28   // Note: Do not change these values; they are used by preferences.
     29   enum Action {
     30     ACTION_SUSPEND      = 0,
     31     ACTION_STOP_SESSION = 1,
     32     ACTION_SHUT_DOWN    = 2,
     33     ACTION_DO_NOTHING   = 3,
     34   };
     35 
     36   // Values of various power-management-related preferences.
     37   struct PrefValues {
     38     PrefValues();
     39 
     40     int ac_screen_dim_delay_ms;
     41     int ac_screen_off_delay_ms;
     42     int ac_screen_lock_delay_ms;
     43     int ac_idle_warning_delay_ms;
     44     int ac_idle_delay_ms;
     45     int battery_screen_dim_delay_ms;
     46     int battery_screen_off_delay_ms;
     47     int battery_screen_lock_delay_ms;
     48     int battery_idle_warning_delay_ms;
     49     int battery_idle_delay_ms;
     50     Action ac_idle_action;
     51     Action battery_idle_action;
     52     Action lid_closed_action;
     53     bool use_audio_activity;
     54     bool use_video_activity;
     55     bool allow_screen_wake_locks;
     56     bool enable_screen_lock;
     57     double presentation_screen_dim_delay_factor;
     58     double user_activity_screen_dim_delay_factor;
     59   };
     60 
     61   // Returns a string describing |policy|.  Useful for tests.
     62   static std::string GetPolicyDebugString(
     63       const power_manager::PowerManagementPolicy& policy);
     64 
     65   // Delay in milliseconds between the screen being turned off and the
     66   // screen being locked. Used if the |enable_screen_lock| pref is set but
     67   // |*_screen_lock_delay_ms| are unset or set to higher values than what
     68   // this constant would imply.
     69   static const int kScreenLockAfterOffDelayMs;
     70 
     71   PowerPolicyController(DBusThreadManager* manager, PowerManagerClient* client);
     72   virtual ~PowerPolicyController();
     73 
     74   // Updates |prefs_policy_| with |values| and sends an updated policy.
     75   void ApplyPrefs(const PrefValues& values);
     76 
     77   // Resets |prefs_policy_| to its defaults and sends an updated policy.
     78   void ClearPrefs();
     79 
     80   // Registers a request to temporarily prevent the screen from getting
     81   // dimmed or turned off or the system from suspending in response to user
     82   // inactivity and sends an updated policy.  |reason| is a human-readable
     83   // description of the reason the lock was created.  Returns a unique ID
     84   // that can be passed to RemoveWakeLock() later.
     85   int AddScreenWakeLock(const std::string& reason);
     86   int AddSystemWakeLock(const std::string& reason);
     87 
     88   // Unregisters a request previously created via AddScreenWakeLock() or
     89   // AddSystemWakeLock() and sends an updated policy.
     90   void RemoveWakeLock(int id);
     91 
     92   // DBusThreadManagerObserver implementation:
     93   virtual void OnDBusThreadManagerDestroying(DBusThreadManager* manager)
     94       OVERRIDE;
     95 
     96   // PowerManagerClient::Observer implementation:
     97   virtual void PowerManagerRestarted() OVERRIDE;
     98 
     99  private:
    100   friend class PowerPrefsTest;
    101 
    102   typedef std::map<int, std::string> WakeLockMap;
    103 
    104   // Sends a policy based on |prefs_policy_| to the power manager.
    105   void SendCurrentPolicy();
    106 
    107   // Sends an empty policy to the power manager to reset its configuration.
    108   void SendEmptyPolicy();
    109 
    110   DBusThreadManager* manager_;  // not owned
    111   PowerManagerClient* client_;  // not owned
    112 
    113   // Policy derived from values passed to ApplyPrefs().
    114   power_manager::PowerManagementPolicy prefs_policy_;
    115 
    116   // Was ApplyPrefs() called?
    117   bool prefs_were_set_;
    118 
    119   // Maps from an ID representing a request to prevent the screen from
    120   // getting dimmed or turned off or to prevent the system from suspending
    121   // to the reason for the request.
    122   WakeLockMap screen_wake_locks_;
    123   WakeLockMap system_wake_locks_;
    124 
    125   // Should entries in |screen_wake_locks_| be honored?  If false, screen
    126   // wake locks are just treated as system wake locks instead.
    127   bool honor_screen_wake_locks_;
    128 
    129   // Next ID to be used by AddScreenWakeLock() or AddSystemWakeLock().
    130   int next_wake_lock_id_;
    131 
    132   DISALLOW_COPY_AND_ASSIGN(PowerPolicyController);
    133 };
    134 
    135 }  // namespace chromeos
    136 
    137 #endif  // CHROMEOS_DBUS_POWER_POLICY_CONTROLLER_H_
    138