Update metrics_daemon to use base/time.h instead of time_t directly.

metrics_daemon.cc

 // 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.
 
 #include "metrics_daemon.h"
 
 #include <dbus/dbus-glib-lowlevel.h>
 #include <sys/file.h>
 
 #include <base/eintr_wrapper.h>
 #include <base/logging.h>
 
+using base::Time;
+using base::TimeDelta;
+using base::TimeTicks;
+
 #define SAFE_MESSAGE(e) (e.message ? e.message : "unknown error")
 #define DBUS_IFACE_CONNMAN_MANAGER "org.moblin.connman.Manager"
 #define DBUS_IFACE_POWER_MANAGER "org.chromium.Power.Manager"
 #define DBUS_IFACE_SCREENSAVER_MANAGER "org.chromium.ScreenSaver.Manager"
 #define DBUS_IFACE_SESSION_MANAGER "org.chromium.SessionManagerInterface"
 
 // File to aggregate daily usage before sending to UMA.
 // TODO(petkov): This file should probably live in a user-specific stateful
 // location, e.g., /home/chronos/user.
 static const char kDailyUseRecordFile[] = "/var/log/metrics/daily-usage";
 
 static const int kSecondsPerMinute = 60;
 static const int kMinutesPerHour = 60;
 static const int kHoursPerDay = 24;
 static const int kMinutesPerDay = kHoursPerDay * kMinutesPerHour;
-static const int kSecondsPerDay = kMinutesPerDay * kSecondsPerMinute;
 
 // The daily use monitor is scheduled to a 1-minute interval after
 // initial user activity and then it's exponentially backed off to
 // 10-minute intervals. Although not required, the back off is
 // implemented because the histogram buckets are spaced exponentially
 // anyway and to avoid too frequent metrics daemon process wake-ups
 // and file I/O.
 static const int kUseMonitorIntervalInit = 1 * kSecondsPerMinute;
 static const int kUseMonitorIntervalMax = 10 * kSecondsPerMinute;
 
@@ skipping 106 matching lines @@
 
 void MetricsDaemon::Loop() {
   GMainLoop* loop = g_main_loop_new(NULL, false);
   g_main_loop_run(loop);
 }
 
 // static
 DBusHandlerResult MetricsDaemon::MessageFilter(DBusConnection* connection,
                                                DBusMessage* message,
                                                void* user_data) {
-  time_t now = time(NULL);
-  DLOG(INFO) << "message intercepted @ " << now;
+  Time now = Time::Now();
+  TimeTicks ticks = TimeTicks::Now();
+  DLOG(INFO) << "message intercepted @ " << now.ToInternalValue();
 
   int message_type = dbus_message_get_type(message);
   if (message_type != DBUS_MESSAGE_TYPE_SIGNAL) {
     DLOG(WARNING) << "unexpected message type " << message_type;
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   }
 
   // Signal messages always have interfaces.
   const char* interface = dbus_message_get_interface(message);
   CHECK(interface != NULL);
 
   MetricsDaemon* daemon = static_cast<MetricsDaemon*>(user_data);
 
   DBusMessageIter iter;
   dbus_message_iter_init(message, &iter);
   if (strcmp(interface, DBUS_IFACE_CONNMAN_MANAGER) == 0) {
     CHECK(strcmp(dbus_message_get_member(message),
                  "StateChanged") == 0);
 
     char *state_name;
     dbus_message_iter_get_basic(&iter, &state_name);
-    daemon->NetStateChanged(state_name, now);
+    daemon->NetStateChanged(state_name, ticks);
   } else if (strcmp(interface, DBUS_IFACE_POWER_MANAGER) == 0) {
     CHECK(strcmp(dbus_message_get_member(message),
                  "PowerStateChanged") == 0);
 
     char *state_name;
     dbus_message_iter_get_basic(&iter, &state_name);
     daemon->PowerStateChanged(state_name, now);
   } else if (strcmp(interface, DBUS_IFACE_SCREENSAVER_MANAGER) == 0) {
     CHECK(strcmp(dbus_message_get_member(message),
                  "LockStateChanged") == 0);
 
     char *state_name;
     dbus_message_iter_get_basic(&iter, &state_name);
     daemon->ScreenSaverStateChanged(state_name, now);
   } else if (strcmp(interface, DBUS_IFACE_SESSION_MANAGER) == 0) {
     CHECK(strcmp(dbus_message_get_member(message),
                  "SessionStateChanged") == 0);
 
     char *state_name;
     dbus_message_iter_get_basic(&iter, &state_name);
     daemon->SessionStateChanged(state_name, now);
   } else {
     DLOG(WARNING) << "unexpected interface: " << interface;
     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
   }
 
   return DBUS_HANDLER_RESULT_HANDLED;
 }
 
-void MetricsDaemon::NetStateChanged(const char* state_name, time_t now) {
+void MetricsDaemon::NetStateChanged(const char* state_name, TimeTicks ticks) {
   DLOG(INFO) << "network state: " << state_name;
 
   NetworkState state = LookupNetworkState(state_name);
 
   // Logs the time in seconds between the network going online to
   // going offline (or, more precisely, going not online) in order to
   // measure the mean time to network dropping. Going offline as part
   // of suspend-to-RAM is not logged as network drop -- the assumption
   // is that the message for suspend-to-RAM comes before the network
   // offline message which seems to and should be the case.
   if (state != kNetworkStateOnline &&
       network_state_ == kNetworkStateOnline &&
       power_state_ != kPowerStateMem) {
-    int online_time = static_cast<int>(now - network_state_last_);
+    TimeDelta since_online = ticks - network_state_last_;
+    int online_time = static_cast<int>(since_online.InSeconds());
     SendMetric(kMetricTimeToNetworkDropName, online_time,
                kMetricTimeToNetworkDropMin,
                kMetricTimeToNetworkDropMax,
                kMetricTimeToNetworkDropBuckets);
   }
 
   network_state_ = state;
-  network_state_last_ = now;
+  network_state_last_ = ticks;
 }
 
 MetricsDaemon::NetworkState
 MetricsDaemon::LookupNetworkState(const char* state_name) {
   for (int i = 0; i < kNumberNetworkStates; i++) {
     if (strcmp(state_name, kNetworkStates_[i]) == 0) {
       return static_cast<NetworkState>(i);
     }
   }
   DLOG(WARNING) << "unknown network connection state: " << state_name;
   return kUnknownNetworkState;
 }
 
-void MetricsDaemon::PowerStateChanged(const char* state_name, time_t now) {
+void MetricsDaemon::PowerStateChanged(const char* state_name, Time now) {
   DLOG(INFO) << "power state: " << state_name;
   power_state_ = LookupPowerState(state_name);
 
   if (power_state_ != kPowerStateOn)
     SetUserActiveState(false, now);
 }
 
 MetricsDaemon::PowerState
 MetricsDaemon::LookupPowerState(const char* state_name) {
   for (int i = 0; i < kNumberPowerStates; i++) {
     if (strcmp(state_name, kPowerStates_[i]) == 0) {
       return static_cast<PowerState>(i);
     }
   }
   DLOG(WARNING) << "unknown power state: " << state_name;
   return kUnknownPowerState;
 }
 
-void MetricsDaemon::ScreenSaverStateChanged(const char* state_name,
-                                            time_t now) {
+void MetricsDaemon::ScreenSaverStateChanged(const char* state_name, Time now) {
   DLOG(INFO) << "screen-saver state: " << state_name;
   screensaver_state_ = LookupScreenSaverState(state_name);
   SetUserActiveState(screensaver_state_ == kScreenSaverStateUnlocked, now);
 }
 
 MetricsDaemon::ScreenSaverState
 MetricsDaemon::LookupScreenSaverState(const char* state_name) {
   for (int i = 0; i < kNumberScreenSaverStates; i++) {
     if (strcmp(state_name, kScreenSaverStates_[i]) == 0) {
       return static_cast<ScreenSaverState>(i);
     }
   }
   DLOG(WARNING) << "unknown screen-saver state: " << state_name;
   return kUnknownScreenSaverState;
 }
 
-void MetricsDaemon::SessionStateChanged(const char* state_name,
-                                        time_t now) {
+void MetricsDaemon::SessionStateChanged(const char* state_name, Time now) {
   DLOG(INFO) << "user session state: " << state_name;
   session_state_ = LookupSessionState(state_name);
   SetUserActiveState(session_state_ == kSessionStateStarted, now);
 }
 
 MetricsDaemon::SessionState
 MetricsDaemon::LookupSessionState(const char* state_name) {
   for (int i = 0; i < kNumberSessionStates; i++) {
     if (strcmp(state_name, kSessionStates_[i]) == 0) {
       return static_cast<SessionState>(i);
     }
   }
   DLOG(WARNING) << "unknown user session state: " << state_name;
   return kUnknownSessionState;
 }
 
-void MetricsDaemon::SetUserActiveState(bool active, time_t now) {
+void MetricsDaemon::SetUserActiveState(bool active, Time now) {
   DLOG(INFO) << "user: " << (active ? "active" : "inactive");
 
   // Calculates the seconds of active use since the last update and
-  // the day since Epoch, and logs the usage data.
-  int seconds = user_active_ ? (now - user_active_last_) : 0;
-  int day = now / kSecondsPerDay;
+  // the day since Epoch, and logs the usage data.  Guards against the
+  // time jumping back and forth due to the user changing it by
+  // discarding the new use time.
+  int seconds = 0;
+  if (user_active_ && now > user_active_last_) {
+    TimeDelta since_active = now - user_active_last_;
+    if (since_active < TimeDelta::FromSeconds(
+            kUseMonitorIntervalMax + kSecondsPerMinute)) {
+      seconds = static_cast<int>(since_active.InSeconds());
+    }
+  }
+  TimeDelta since_epoch = now - Time();
+  int day = since_epoch.InDays();
   LogDailyUseRecord(day, seconds);
 
   // Schedules a use monitor on inactive->active transitions and
   // unschedules it on active->inactive transitions.
   if (!user_active_ && active)
     ScheduleUseMonitor(kUseMonitorIntervalInit, /* backoff */ false);
   else if (user_active_ && !active)
     UnscheduleUseMonitor();
 
   // Remembers the current active state and the time of the last
@@ skipping 65 matching lines @@
   // overhead.
   daily_use_day_last_ = day;
 }
 
 // static
 gboolean MetricsDaemon::UseMonitorStatic(gpointer data) {
   return static_cast<MetricsDaemon*>(data)->UseMonitor() ? TRUE : FALSE;
 }
 
 bool MetricsDaemon::UseMonitor() {
-  SetUserActiveState(user_active_, time(NULL));
+  SetUserActiveState(user_active_, Time::Now());
 
   // If a new monitor source/instance is scheduled, returns false to
   // tell GLib to destroy this monitor source/instance. Returns true
   // otherwise to keep calling back this monitor.
   return !ScheduleUseMonitor(usemon_interval_ * 2, /* backoff */ true);
 }
 
 bool MetricsDaemon::ScheduleUseMonitor(int interval, bool backoff)
 {
   if (testing_)
@@ skipping 39 matching lines @@
   usemon_source_ = NULL;
   usemon_interval_ = 0;
 }
 
 void MetricsDaemon::SendMetric(const std::string& name, int sample,
                                int min, int max, int nbuckets) {
   DLOG(INFO) << "received metric: " << name << " " << sample << " "
              << min << " " << max << " " << nbuckets;
   metrics_lib_->SendToUMA(name, sample, min, max, nbuckets);
 }