Log active use time between kernel crashes.

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>
 
@@ skipping 13 matching lines @@
 
   // Initializes.
   void Init(bool testing, MetricsLibraryInterface* metrics_lib);
 
   // Does all the work. If |run_as_daemon| is true, daemonizes by
   // forking.
   void Run(bool run_as_daemon);
 
  private:
   friend class MetricsDaemonTest;
+  FRIEND_TEST(MetricsDaemonTest, CheckKernelCrash);
   FRIEND_TEST(MetricsDaemonTest, DailyUseReporter);
+  FRIEND_TEST(MetricsDaemonTest, KernelCrashIntervalReporter);
   FRIEND_TEST(MetricsDaemonTest, LookupNetworkState);
   FRIEND_TEST(MetricsDaemonTest, LookupPowerState);
   FRIEND_TEST(MetricsDaemonTest, LookupScreenSaverState);
   FRIEND_TEST(MetricsDaemonTest, LookupSessionState);
   FRIEND_TEST(MetricsDaemonTest, MessageFilter);
   FRIEND_TEST(MetricsDaemonTest, NetStateChangedSimpleDrop);
   FRIEND_TEST(MetricsDaemonTest, NetStateChangedSuspend);
   FRIEND_TEST(MetricsDaemonTest, PowerStateChanged);
+  FRIEND_TEST(MetricsDaemonTest, ProcessKernelCrash);
   FRIEND_TEST(MetricsDaemonTest, ProcessUserCrash);
   FRIEND_TEST(MetricsDaemonTest, ScreenSaverStateChanged);
   FRIEND_TEST(MetricsDaemonTest, SendMetric);
   FRIEND_TEST(MetricsDaemonTest, SessionStateChanged);
   FRIEND_TEST(MetricsDaemonTest, SetUserActiveState);
   FRIEND_TEST(MetricsDaemonTest, SetUserActiveStateTimeJump);
   FRIEND_TEST(MetricsDaemonTest, UserCrashIntervalReporter);
 
   // The network states (see network_states.h).
   enum NetworkState {
@@ skipping 25 matching lines @@
     UseRecord() : day_(0), seconds_(0) {}
     int day_;
     int seconds_;
   };
 
   // Metric parameters.
   static const char kMetricDailyUseTimeName[];
   static const int kMetricDailyUseTimeMin;
   static const int kMetricDailyUseTimeMax;
   static const int kMetricDailyUseTimeBuckets;
+  static const char kMetricKernelCrashIntervalName[];
+  static const int kMetricKernelCrashIntervalMin;
+  static const int kMetricKernelCrashIntervalMax;
+  static const int kMetricKernelCrashIntervalBuckets;
   static const char kMetricTimeToNetworkDropName[];
   static const int kMetricTimeToNetworkDropMin;
   static const int kMetricTimeToNetworkDropMax;
   static const int kMetricTimeToNetworkDropBuckets;
   static const char kMetricUserCrashIntervalName[];
   static const int kMetricUserCrashIntervalMin;
   static const int kMetricUserCrashIntervalMax;
   static const int kMetricUserCrashIntervalBuckets;
 
   // D-Bus message match strings.
@@ skipping 47 matching lines @@
   // of active use to the |day| since Epoch. If there's usage data for
   // day in the past in the usage file, that data is sent to UMA and
   // removed from the file. If there's already usage data for |day| in
   // the usage file, the |seconds| are accumulated.
   void LogDailyUseRecord(int day, int seconds);
 
   // Updates the active use time and logs time between user-space
   // process crashes.
   void ProcessUserCrash();
 
+  // Updates the active use time and logs time between kernel crashes.
+  void ProcessKernelCrash();
+
+  // Checks if a kernel crash has been detected and processes if so.
+  // The method assumes that a kernel crash has happened if
+  // |crash_file| exists.
+  void CheckKernelCrash(const std::string& crash_file);
+
   // Callbacks for the daily use monitor. The daily use monitor uses
   // LogDailyUseRecord to aggregate current usage data and send it to
   // UMA, if necessary. It also reschedules itself using an
   // exponentially bigger interval (up to a certain maximum) -- so
   // usage is monitored less frequently with longer active use.
   static gboolean UseMonitorStatic(gpointer data);
   bool UseMonitor();
 
   // Schedules or reschedules a daily use monitor for |interval|
   // seconds from now. |backoff| mode is used by the use monitor to
@@ skipping 15 matching lines @@
                   int min, int max, int nbuckets);
 
   // TaggedCounter callback to process aggregated daily usage data and
   // send to UMA.
   static void DailyUseReporter(void* data, int tag, int count);
 
   // TaggedCounter callback to process time between user-space process
   // crashes and send to UMA.
   static void UserCrashIntervalReporter(void* data, int tag, int count);
 
+  // TaggedCounter callback to process time between kernel crashes and
+  // send to UMA.
+  static void KernelCrashIntervalReporter(void* data, int tag, int count);
+
   // Test mode.
   bool testing_;
 
   // The metrics library handle.
   MetricsLibraryInterface* metrics_lib_;
 
   // Current network state.
   NetworkState network_state_;
 
   // Timestamps last network state update.  This timestamp is used to
@@ skipping 15 matching lines @@
   // each day before sending to UMA so using time since the epoch as
   // the timestamp.
   base::Time user_active_last_;
 
   // Daily active use time in seconds.
   scoped_ptr<chromeos_metrics::TaggedCounterInterface> daily_use_;
 
   // Active use time between user-space process crashes.
   scoped_ptr<chromeos_metrics::TaggedCounterInterface> user_crash_interval_;
 
+  // Active use time between kernel crashes.
+  scoped_ptr<chromeos_metrics::TaggedCounterInterface> kernel_crash_interval_;
+
   // 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_