Update metrics daemon to use new power manager signals for locking (4 of 7).

metrics_daemon.h

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef METRICS_DAEMON_H_
 #define METRICS_DAEMON_H_
 
 #include <dbus/dbus.h>
 #include <glib.h>
 
 #include "metrics_library.h"
 
 #include <gtest/gtest_prod.h>  // for FRIEND_TEST
 #include <base/time.h>
 
 class MetricsDaemon {
 
  public:
   MetricsDaemon()
       : daily_use_record_file_(NULL),
         network_state_(kUnknownNetworkState),
         power_state_(kUnknownPowerState),
-        screensaver_state_(kUnknownScreenSaverState),
         session_state_(kUnknownSessionState),
         user_active_(false),
         daily_use_day_last_(0),
         usemon_interval_(0),
         usemon_source_(NULL) {}
   ~MetricsDaemon() {}
 
   // Initializes.
   void Init(bool testing, MetricsLibraryInterface* metrics_lib);
 
@@ skipping 31 matching lines @@
   };
 
   // The power states (see power_states.h).
   enum PowerState {
     kUnknownPowerState = -1, // Initial/unknown power state.
 #define STATE(name, capname) kPowerState ## capname,
 #include "power_states.h"
     kNumberPowerStates
   };
 
-  // The screen-saver states (see screensaver_states.h).
-  enum ScreenSaverState {
-    kUnknownScreenSaverState = -1, // Initial/unknown screen-saver state.
-#define STATE(name, capname) kScreenSaverState ## capname,
-#include "screensaver_states.h"
-    kNumberScreenSaverStates
-  };
-
   // The user session states (see session_states.h).
   enum SessionState {
     kUnknownSessionState = -1, // Initial/unknown user session state.
 #define STATE(name, capname) kSessionState ## capname,
 #include "session_states.h"
     kNumberSessionStates
   };
 
   // Data record for aggregating daily usage.
   class UseRecord {
@@ skipping 15 matching lines @@
 
   // D-Bus message match strings.
   static const char* kDBusMatches_[];
 
   // Array of network states.
   static const char* kNetworkStates_[kNumberNetworkStates];
 
   // Array of power states.
   static const char* kPowerStates_[kNumberPowerStates];
 
-  // Array of screen-saver states.
-  static const char* kScreenSaverStates_[kNumberScreenSaverStates];
-
   // Array of user session states.
   static const char* kSessionStates_[kNumberSessionStates];
 
   // Creates the event loop and enters it.
   void Loop();
 
   // D-Bus filter callback.
   static DBusHandlerResult MessageFilter(DBusConnection* connection,
                                          DBusMessage* message,
                                          void* user_data);
 
   // Processes network state change.
   void NetStateChanged(const char* state_name, base::TimeTicks ticks);
 
   // Given the state name, returns the state id.
   NetworkState LookupNetworkState(const char* state_name);
 
   // Processes power state change.
   void PowerStateChanged(const char* state_name, base::Time now);
 
   // Given the state name, returns the state id.
   PowerState LookupPowerState(const char* state_name);
 
-  // Processes screen-saver state change.
-  void ScreenSaverStateChanged(const char* state_name, base::Time now);
-
-  // Given the state name, returns the state id.
-  ScreenSaverState LookupScreenSaverState(const char* state_name);
-
   // Processes user session state change.
   void SessionStateChanged(const char* state_name, base::Time now);
 
   // Given the state name, returns the state id.
   SessionState LookupSessionState(const char* state_name);
 
   // Updates the user-active state to |active| and logs the usage data
   // since the last update. If the user has just become active,
   // reschedule the daily use monitor for more frequent updates --
   // this is followed by an exponential back-off (see UseMonitor).
@@ skipping 48 matching lines @@
   NetworkState network_state_;
 
   // Timestamps last network state update.  This timestamp is used to
   // sample the time from the network going online to going offline so
   // TimeTicks ensures a monotonically increasing TimeDelta.
   base::TimeTicks network_state_last_;
 
   // Current power state.
   PowerState power_state_;
 
-  // Current screen-saver state.
-  ScreenSaverState screensaver_state_;
-
   // Current user session state.
   SessionState session_state_;
 
   // Is the user currently active: power is on, user session has
   // started, screen is not locked.
   bool user_active_;
 
   // Timestamps last user active update.  Active use time is
   // aggregated each day before sending to UMA so using time since the
   // epoch as the timestamp.
   base::Time user_active_last_;
 
   // Last stored daily use day (since the epoch).
   int daily_use_day_last_;
 
   // Sleep period until the next daily usage aggregation performed by
   // the daily use monitor (see ScheduleUseMonitor).
   int usemon_interval_;
 
   // Scheduled daily use monitor source (see ScheduleUseMonitor).
   GSource* usemon_source_;
 };
 
 #endif  // METRICS_DAEMON_H_