diff --git a/metrics/metrics_daemon.cc b/metrics/metrics_daemon.cc
index d1eb25e..97c099c 100644
--- a/metrics/metrics_daemon.cc
+++ b/metrics/metrics_daemon.cc
@@ -170,6 +170,7 @@
   if (version_cycle_->Get() != version) {
     version_cycle_->Set(version);
     kernel_crashes_version_count_->Set(0);
+    version_cumulative_active_use_->Set(0);
     version_cumulative_cpu_use_->Set(0);
   }
 
@@ -206,8 +207,10 @@
   // Sysconf cannot fail, so no sanity checks are needed.
   ticks_per_second_ = sysconf(_SC_CLK_TCK);
 
-  daily_use_.reset(
+  daily_active_use_.reset(
       new PersistentInteger("Logging.DailyUseTime"));
+  version_cumulative_active_use_.reset(
+      new PersistentInteger("Logging.CumulativeDailyUseTime"));
   version_cumulative_cpu_use_.reset(
       new PersistentInteger("Logging.CumulativeCpuTime"));
 
@@ -931,8 +934,7 @@
   metrics_lib_->SendToUMA(name, sample, min, max, nbuckets);
 }
 
-void MetricsDaemon::SendKernelCrashesCumulativeCountStats(
-    int64 active_use_seconds) {
+void MetricsDaemon::SendKernelCrashesCumulativeCountStats() {
   // Report the number of crashes for this OS version, but don't clear the
   // counter.  It is cleared elsewhere on version change.
   int64 crashes_count = kernel_crashes_version_count_->Get();
@@ -961,7 +963,13 @@
                100);
   }
 
+  int64 active_use_seconds = version_cumulative_active_use_->Get();
   if (active_use_seconds > 0) {
+    SendSample(version_cumulative_active_use_->Name(),
+               active_use_seconds / 1000,  // stat is in seconds
+               1,                          // device may be used very little...
+               8 * 1000 * 1000,            // ... or a lot (about 90 days)
+               100);
     // Same as above, but per year of active time.
     SendSample("Logging.KernelCrashesPerActiveYear",
                crashes_count * kSecondsPerDay * 365 / active_use_seconds,
@@ -971,6 +979,15 @@
   }
 }
 
+void MetricsDaemon::SendDailyUseSample(
+    const scoped_ptr<PersistentInteger>& use) {
+  SendSample(use->Name(),
+             use->GetAndClear(),
+             1,                        // value of first bucket
+             kSecondsPerDay,           // value of last bucket
+             50);                      // number of buckets
+}
+
 void MetricsDaemon::SendCrashIntervalSample(
     const scoped_ptr<PersistentInteger>& interval) {
   SendSample(interval->Name(),
@@ -1000,7 +1017,8 @@
 void MetricsDaemon::UpdateStats(TimeTicks now_ticks,
                                 Time now_wall_time) {
   const int elapsed_seconds = (now_ticks - last_update_stats_time_).InSeconds();
-  daily_use_->Add(elapsed_seconds);
+  daily_active_use_->Add(elapsed_seconds);
+  version_cumulative_active_use_->Add(elapsed_seconds);
   user_crash_interval_->Add(elapsed_seconds);
   kernel_crash_interval_->Add(elapsed_seconds);
   version_cumulative_cpu_use_->Add(GetIncrementalCpuUse().InMilliseconds());
@@ -1012,11 +1030,13 @@
 
   if (daily_cycle_->Get() != day) {
     daily_cycle_->Set(day);
+    SendDailyUseSample(daily_active_use_);
+    SendDailyUseSample(version_cumulative_active_use_);
     SendCrashFrequencySample(any_crashes_daily_count_);
     SendCrashFrequencySample(user_crashes_daily_count_);
     SendCrashFrequencySample(kernel_crashes_daily_count_);
     SendCrashFrequencySample(unclean_shutdowns_daily_count_);
-    SendKernelCrashesCumulativeCountStats(daily_use_->Get());
+    SendKernelCrashesCumulativeCountStats();
   }
 
   if (weekly_cycle_->Get() != week) {
diff --git a/metrics/metrics_daemon.h b/metrics/metrics_daemon.h
index 929706a..81e5386 100644
--- a/metrics/metrics_daemon.h
+++ b/metrics/metrics_daemon.h
@@ -175,12 +175,16 @@
 
   // Sends various cumulative kernel crash-related stats, for instance the
   // total number of kernel crashes since the last version update.
-  void SendKernelCrashesCumulativeCountStats(int64 active_time_seconds);
+  void SendKernelCrashesCumulativeCountStats();
 
   // Returns the total (system-wide) CPU usage between the time of the most
   // recent call to this function and now.
   base::TimeDelta GetIncrementalCpuUse();
 
+  // Sends a sample representing the number of seconds of active use
+  // for a 24-hour period.
+  void SendDailyUseSample(const scoped_ptr<PersistentInteger>& use);
+
   // Sends a sample representing a time interval between two crashes of the
   // same type.
   void SendCrashIntervalSample(const scoped_ptr<PersistentInteger>& interval);
@@ -316,7 +320,10 @@
   scoped_ptr<PersistentInteger> weekly_cycle_;
   scoped_ptr<PersistentInteger> version_cycle_;
 
-  scoped_ptr<PersistentInteger> daily_use_;
+  // Active use accumulated in a day.
+  scoped_ptr<PersistentInteger> daily_active_use_;
+  // Active use accumulated since the latest version update.
+  scoped_ptr<PersistentInteger> version_cumulative_active_use_;
 
   // The CPU time accumulator.  This contains the CPU time, in milliseconds,
   // used by the system since the most recent OS version update.
diff --git a/metrics/metrics_daemon_test.cc b/metrics/metrics_daemon_test.cc
index 4217d51..264d5cd 100644
--- a/metrics/metrics_daemon_test.cc
+++ b/metrics/metrics_daemon_test.cc
@@ -65,9 +65,9 @@
     base::CreateDirectory(FilePath(kTestDir));
 
     // Replace original persistent values with mock ones.
-    daily_use_mock_ =
+    daily_active_use_mock_ =
         new StrictMock<PersistentIntegerMock>("1.mock");
-    daemon_.daily_use_.reset(daily_use_mock_);
+    daemon_.daily_active_use_.reset(daily_active_use_mock_);
 
     kernel_crash_interval_mock_ =
         new StrictMock<PersistentIntegerMock>("2.mock");
@@ -92,7 +92,7 @@
   // Adds active use aggregation counters update expectations that the
   // specified count will be added.
   void ExpectActiveUseUpdate(int count) {
-    EXPECT_CALL(*daily_use_mock_, Add(count))
+    EXPECT_CALL(*daily_active_use_mock_, Add(count))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*kernel_crash_interval_mock_, Add(count))
@@ -105,7 +105,7 @@
 
   // As above, but ignore values of counter updates.
   void IgnoreActiveUseUpdate() {
-    EXPECT_CALL(*daily_use_mock_, Add(_))
+    EXPECT_CALL(*daily_active_use_mock_, Add(_))
         .Times(1)
         .RetiresOnSaturation();
     EXPECT_CALL(*kernel_crash_interval_mock_, Add(_))
@@ -182,7 +182,7 @@
   // Mocks. They are strict mock so that all unexpected
   // calls are marked as failures.
   StrictMock<MetricsLibraryMock> metrics_lib_;
-  StrictMock<PersistentIntegerMock>* daily_use_mock_;
+  StrictMock<PersistentIntegerMock>* daily_active_use_mock_;
   StrictMock<PersistentIntegerMock>* kernel_crash_interval_mock_;
   StrictMock<PersistentIntegerMock>* user_crash_interval_mock_;
   StrictMock<PersistentIntegerMock>* unclean_shutdown_interval_mock_;