diff --git a/metrics/Makefile b/metrics/Makefile
index e0c3741..c8ba545 100644
--- a/metrics/Makefile
+++ b/metrics/Makefile
@@ -16,32 +16,42 @@
 LIB = libmetrics.a
 SHAREDLIB = libmetrics.so
 LIB_TEST = metrics_library_test
+COUNTER_TEST = counter_test
 
+TESTCOUNTER_OBJS = \
+	counter.o \
+	counter_test.o
 CLIENT_OBJS = \
 	metrics_client.o
+DAEMON_OBJS = \
+	counter.o \
+	metrics_daemon.o \
+	metrics_daemon_main.o
+TESTDAEMON_OBJS = \
+	counter.o \
+	metrics_daemon.o \
+	metrics_daemon_test.o
 LIB_OBJS = \
 	metrics_library.o
 TESTLIB_OBJS = \
 	metrics_library.o \
 	metrics_library_test.o
-DAEMON_OBJS = \
-	metrics_daemon.o \
-	metrics_daemon_main.o
-TESTDAEMON_OBJS = \
-	metrics_daemon.o \
-	metrics_daemon_test.o
 
+TESTCOUNTER_LIBS = -lgmock -lgtest -lbase -lrt -lpthread
 DAEMON_LDFLAGS = $(LDFLAGS) $(LDCONFIG) -lrt -lbase -lpthread -lgflags
 TESTDAEMON_LIBS = -lgmock -lgtest
 TESTLIB_LIBS = -lgtest -lbase -lrt -lpthread
 
 all: $(LIB) $(SHAREDLIB) $(CLIENT) $(DAEMON)
 
-tests: $(DAEMON_TEST) $(LIB_TEST)
+tests: $(COUNTER_TEST) $(DAEMON_TEST) $(LIB_TEST)
 
 $(CLIENT): $(CLIENT_OBJS) $(SHAREDLIB)
 	$(CXX) $(LDFLAGS) $^ -o $@
 
+$(COUNTER_TEST): $(TESTCOUNTER_OBJS)
+	$(CXX) -o $@ $^ $(TESTCOUNTER_LIBS)
+
 $(DAEMON): $(DAEMON_OBJS) $(SHAREDLIB)
 	$(CXX) -o $@ $^ $(DAEMON_LDFLAGS)
 
@@ -73,4 +83,4 @@
 
 clean:
 	rm -f $(CLIENT) $(DAEMON) $(LIB) $(SHAREDLIB) *.o
-	rm -f $(DAEMON_TEST) $(LIB_TEST)
+	rm -f $(COUNTER_TEST) $(DAEMON_TEST) $(LIB_TEST)
diff --git a/metrics/counter.cc b/metrics/counter.cc
new file mode 100644
index 0000000..34fcf71
--- /dev/null
+++ b/metrics/counter.cc
@@ -0,0 +1,176 @@
+// 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 "counter.h"
+
+#include <sys/file.h>
+
+#include <base/eintr_wrapper.h>
+#include <base/logging.h>
+
+namespace chromeos_metrics {
+
+// TaggedCounter::Record implementation.
+void TaggedCounter::Record::Init(int tag, int count) {
+  tag_ = tag;
+  count_ = (count > 0) ? count : 0;
+}
+
+void TaggedCounter::Record::Add(int count) {
+  if (count <= 0)
+    return;
+
+  count_ += count;
+
+  // Saturates on postive overflow.
+  if (count_ < 0) {
+    count_ = INT_MAX;
+  }
+}
+
+// TaggedCounter implementation.
+TaggedCounter::TaggedCounter()
+    : filename_(NULL), reporter_(NULL), reporter_handle_(NULL),
+      record_state_(kRecordInvalid) {}
+
+TaggedCounter::~TaggedCounter() {}
+
+void TaggedCounter::Init(const char* filename,
+                         Reporter reporter, void* reporter_handle) {
+  DCHECK(filename);
+  filename_ = filename;
+  reporter_ = reporter;
+  reporter_handle_ = reporter_handle;
+  record_state_ = kRecordInvalid;
+}
+
+void TaggedCounter::Update(int tag, int count) {
+  UpdateInternal(tag,
+                 count,
+                 false);  // No flush.
+}
+
+void TaggedCounter::Flush() {
+  UpdateInternal(0,  // tag
+                 0,  // count
+                 true);  // Do flush.
+}
+
+void TaggedCounter::UpdateInternal(int tag, int count, bool flush) {
+  // If there's no new data and the last record in the aggregation
+  // file is with the same tag, there's nothing to do.
+  if (!flush && count <= 0 &&
+      record_state_ == kRecordValid && record_.tag() == tag)
+    return;
+
+  DLOG(INFO) << "tag: " << tag << " count: " << count << " flush: " << flush;
+  DCHECK(filename_);
+
+  // NOTE: The assumption is that this TaggedCounter object is the
+  // sole owner of the persistent storage file so no locking is
+  // necessary.
+  int fd = HANDLE_EINTR(open(filename_, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR));
+  if (fd < 0) {
+    PLOG(WARNING) << "Unable to open the persistent counter file";
+    return;
+  }
+
+  ReadRecord(fd);
+  ReportRecord(tag, flush);
+  UpdateRecord(tag, count);
+  WriteRecord(fd);
+
+  HANDLE_EINTR(close(fd));
+}
+
+void TaggedCounter::ReadRecord(int fd) {
+  if (record_state_ != kRecordInvalid)
+    return;
+
+  if (HANDLE_EINTR(read(fd, &record_, sizeof(record_))) == sizeof(record_)) {
+    if (record_.count() > 0) {
+      record_state_ = kRecordValid;
+      return;
+    }
+    // This shouldn't happen normally unless somebody messed with the
+    // persistent storage file.
+    NOTREACHED();
+    record_state_ = kRecordNullDirty;
+    return;
+  }
+
+  record_state_ = kRecordNull;
+}
+
+void TaggedCounter::ReportRecord(int tag, bool flush) {
+  // If no valid record, there's nothing to report.
+  if (record_state_ != kRecordValid) {
+    DCHECK(record_state_ == kRecordNull);
+    return;
+  }
+
+  // If the current record has the same tag as the new tag, it's not
+  // ready to be reported yet.
+  if (!flush && record_.tag() == tag)
+    return;
+
+  if (reporter_) {
+    reporter_(reporter_handle_, record_.tag(), record_.count());
+  }
+  record_state_ = kRecordNullDirty;
+}
+
+void TaggedCounter::UpdateRecord(int tag, int count) {
+  if (count <= 0)
+    return;
+
+  switch (record_state_) {
+    case kRecordNull:
+    case kRecordNullDirty:
+      // Current record is null, starting a new record.
+      record_.Init(tag, count);
+      record_state_ = kRecordValidDirty;
+      break;
+
+    case kRecordValid:
+      // If there's an existing record for the current tag,
+      // accumulates the counts.
+      DCHECK_EQ(record_.tag(), tag);
+      record_.Add(count);
+      record_state_ = kRecordValidDirty;
+      break;
+
+    default:
+      NOTREACHED();
+  }
+}
+
+void TaggedCounter::WriteRecord(int fd) {
+  switch (record_state_) {
+    case kRecordNullDirty:
+      // Truncates the aggregation file to discard the record.
+      PLOG_IF(WARNING, HANDLE_EINTR(ftruncate(fd, 0)) != 0);
+      record_state_ = kRecordNull;
+      break;
+
+    case kRecordValidDirty:
+      // Updates the accumulator record in the file if there's new data.
+      PLOG_IF(WARNING, HANDLE_EINTR(lseek(fd, 0, SEEK_SET)) != 0);
+      PLOG_IF(WARNING,
+              HANDLE_EINTR(write(fd, &record_, sizeof(record_))) !=
+              sizeof(record_));
+      record_state_ = kRecordValid;
+      break;
+
+    case kRecordNull:
+    case kRecordValid:
+      // Nothing to do.
+      break;
+
+    default:
+      NOTREACHED();
+  }
+}
+
+}  // namespace chromeos_metrics
diff --git a/metrics/counter.h b/metrics/counter.h
new file mode 100644
index 0000000..aac00af
--- /dev/null
+++ b/metrics/counter.h
@@ -0,0 +1,151 @@
+// 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_COUNTER_H_
+#define METRICS_COUNTER_H_
+
+#include <gtest/gtest_prod.h>  // for FRIEND_TEST
+
+namespace chromeos_metrics {
+
+// TaggedCounter maintains a persistent storage (i.e., a file)
+// aggregation counter for a given tag (e.g., day, hour) that survives
+// system shutdowns, reboots and crashes, as well as daemon process
+// restarts. The counter object is initialized by pointing to the
+// persistent storage file and providing a callback used for reporting
+// aggregated data.  The counter can then be updated with additional
+// event counts.  The aggregated count is reported through the
+// callback when the counter is explicitly flushed or when data for a
+// new tag arrives.
+class TaggedCounterInterface {
+ public:
+  // Callback type used for reporting aggregated or flushed data.
+  // Once this callback is invoked by the counter, the reported
+  // aggregated data is discarded. Only aggregated data with positive
+  // counts is reported.
+  //
+  // |handle| is the |reporter_handle| pointer passed through Init.
+  // |tag| is the tag associated with the aggregated count.
+  // |count| is aggregated count.
+  typedef void (*Reporter)(void* handle, int tag, int count);
+
+  virtual ~TaggedCounterInterface() {}
+
+  // Initializes the counter by providing the persistent storage
+  // location |filename| and a |reporter| callback for reporting
+  // aggregated counts. |reporter_handle| is sent to the |reporter|
+  // along with the aggregated counts.
+  //
+  // NOTE: The assumption is that this object is the sole owner of the
+  // persistent storage file so no locking is currently implemented.
+  virtual void Init(const char* filename,
+                    Reporter reporter, void* reporter_handle) = 0;
+
+  // Adds |count| of events for the given |tag|. If there's an
+  // existing aggregated count for a different tag, it's reported
+  // through the reporter callback and discarded.
+  virtual void Update(int tag, int count) = 0;
+
+  // Reports the current aggregated count (if any) through the
+  // reporter callback and discards it.
+  virtual void Flush() = 0;
+};
+
+class TaggedCounter : public TaggedCounterInterface {
+ public:
+  TaggedCounter();
+  ~TaggedCounter();
+
+  // Implementation of interface methods.
+  void Init(const char* filename, Reporter reporter, void* reporter_handle);
+  void Update(int tag, int count);
+  void Flush();
+
+ private:
+  friend class RecordTest;
+  friend class TaggedCounterTest;
+  FRIEND_TEST(TaggedCounterTest, BadFileLocation);
+  FRIEND_TEST(TaggedCounterTest, Flush);
+  FRIEND_TEST(TaggedCounterTest, InitFromFile);
+  FRIEND_TEST(TaggedCounterTest, Update);
+
+  // The current tag/count record is cached by the counter object to
+  // avoid potentially unnecessary I/O. The cached record can be in
+  // one of the following states:
+  enum RecordState {
+    kRecordInvalid,    // Invalid record, sync from persistent storage needed.
+    kRecordNull,       // No current record, persistent storage synced.
+    kRecordNullDirty,  // No current record, persistent storage is invalid.
+    kRecordValid,      // Current record valid, persistent storage synced.
+    kRecordValidDirty  // Current record valid, persistent storage is invalid.
+  };
+
+  // Defines the tag/count record. Objects of this class are synced
+  // with the persistent storage through binary reads/writes.
+  class Record {
+   public:
+    // Creates a new Record with |tag_| and |count_| reset to 0.
+    Record() : tag_(0), count_(0) {}
+
+    // Initializes with |tag| and |count|. If |count| is negative,
+    // |count_| is set to 0.
+    void Init(int tag, int count);
+
+    // Adds |count| to the current |count_|. Negative |count| is
+    // ignored. In case of positive overflow, |count_| is saturated to
+    // INT_MAX.
+    void Add(int count);
+
+    int tag() const { return tag_; }
+    int count() const { return count_; }
+
+   private:
+    int tag_;
+    int count_;
+  };
+
+  // Implementation of the Update and Flush methods. Goes through the
+  // necessary steps to read, report, update, and sync the aggregated
+  // record.
+  void UpdateInternal(int tag, int count, bool flush);
+
+  // If the current cached record is invalid, reads it from persistent
+  // storage specified through file descriptor |fd| and updates the
+  // cached record state to either null, or valid depending on the
+  // persistent storage contents.
+  void ReadRecord(int fd);
+
+  // If there's an existing valid record and either |flush| is true,
+  // or the new |tag| is different than the old one, reports the
+  // aggregated data through the reporter callback and resets the
+  // cached record.
+  void ReportRecord(int tag, bool flush);
+
+  // Updates the cached record given the new |tag| and |count|. This
+  // method expects either a null cached record, or a valid cached
+  // record with the same tag as |tag|.
+  void UpdateRecord(int tag, int count);
+
+  // If the cached record state is dirty, updates the persistent
+  // storage specified through file descriptor |fd| and switches the
+  // record state to non-dirty.
+  void WriteRecord(int fd);
+
+  // Persistent storage file path.
+  const char* filename_;
+
+  // Aggregated data reporter callback and handle to pass-through.
+  Reporter reporter_;
+  void* reporter_handle_;
+
+  // Current cached aggregation record.
+  Record record_;
+
+  // Current cached aggregation record state.
+  RecordState record_state_;
+};
+
+}  // namespace chromeos_metrics
+
+#endif  // METRICS_COUNTER_H_
diff --git a/metrics/counter_mock.h b/metrics/counter_mock.h
new file mode 100644
index 0000000..22327ac
--- /dev/null
+++ b/metrics/counter_mock.h
@@ -0,0 +1,26 @@
+// 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_COUNTER_MOCK_H_
+#define METRICS_COUNTER_MOCK_H_
+
+#include <string>
+
+#include <gmock/gmock.h>
+
+#include "counter.h"
+
+namespace chromeos_metrics {
+
+class TaggedCounterMock : public TaggedCounterInterface {
+ public:
+  MOCK_METHOD3(Init, void(const char* filename,
+                          Reporter reporter, void* reporter_handle));
+  MOCK_METHOD2(Update, void(int tag, int count));
+  MOCK_METHOD0(Flush, void());
+};
+
+}  // namespace chromeos_metrics
+
+#endif  // METRICS_COUNTER_MOCK_H_
diff --git a/metrics/counter_test.cc b/metrics/counter_test.cc
new file mode 100644
index 0000000..f9a191f
--- /dev/null
+++ b/metrics/counter_test.cc
@@ -0,0 +1,262 @@
+// 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 <sys/file.h>
+
+#include <base/eintr_wrapper.h>
+#include <base/file_util.h>
+#include <base/logging.h>
+#include <base/string_util.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "counter.h"
+
+using ::testing::_;
+using ::testing::MockFunction;
+using ::testing::StrictMock;
+
+namespace chromeos_metrics {
+
+static const char kTestRecordFile[] = "record-file";
+static const char kDoesNotExistFile[] = "/does/not/exist";
+
+class RecordTest : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    EXPECT_EQ(0, record_.tag());
+    EXPECT_EQ(0, record_.count());
+  }
+
+  // The record under test.
+  TaggedCounter::Record record_;
+};
+
+class TaggedCounterTest : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    EXPECT_EQ(NULL, counter_.filename_);
+    EXPECT_TRUE(NULL == counter_.reporter_);
+    EXPECT_EQ(NULL, counter_.reporter_handle_);
+    EXPECT_EQ(TaggedCounter::kRecordInvalid, counter_.record_state_);
+
+    counter_.Init(kTestRecordFile, &Reporter, this);
+    EXPECT_TRUE(AssertNoOrEmptyRecordFile());
+    EXPECT_EQ(kTestRecordFile, counter_.filename_);
+    EXPECT_TRUE(Reporter == counter_.reporter_);
+    EXPECT_EQ(this, counter_.reporter_handle_);
+    EXPECT_EQ(TaggedCounter::kRecordInvalid, counter_.record_state_);
+
+    // The test fixture object will be used by the log message handler.
+    test_ = this;
+    logging::SetLogMessageHandler(HandleLogMessages);
+  }
+
+  virtual void TearDown() {
+    logging::SetLogMessageHandler(NULL);
+    test_ = NULL;
+    file_util::Delete(FilePath(kTestRecordFile), false);
+  }
+
+  // Asserts that the record file contains the specified contents.
+  testing::AssertionResult AssertRecord(const char* expr_tag,
+                                        const char* expr_count,
+                                        int expected_tag,
+                                        int expected_count) {
+    int fd = HANDLE_EINTR(open(kTestRecordFile, O_RDONLY));
+    if (fd < 0) {
+      testing::Message msg;
+      msg << "Unable to open " << kTestRecordFile;
+      return testing::AssertionFailure(msg);
+    }
+
+    TaggedCounter::Record record;
+    if (!file_util::ReadFromFD(fd, reinterpret_cast<char*>(&record),
+                               sizeof(record))) {
+      testing::Message msg;
+      msg << "Unable to read " << sizeof(record) << " bytes from "
+          << kTestRecordFile;
+      HANDLE_EINTR(close(fd));
+      return testing::AssertionFailure(msg);
+    }
+
+    if (record.tag() != expected_tag || record.count() != expected_count) {
+      testing::Message msg;
+      msg << "actual record (" << record.tag() << ", " << record.count()
+          << ") expected (" << expected_tag << ", " << expected_count << ")";
+      HANDLE_EINTR(close(fd));
+      return testing::AssertionFailure(msg);
+    }
+
+    HANDLE_EINTR(close(fd));
+    return testing::AssertionSuccess();
+  }
+
+  // Returns true if the persistent record file does not exist or is
+  // empty, false otherwise.
+  bool AssertNoOrEmptyRecordFile() {
+    FilePath record_file(counter_.filename_);
+    int64 record_file_size;
+    return !file_util::PathExists(record_file) ||
+        (file_util::GetFileSize(record_file, &record_file_size) &&
+         record_file_size == 0);
+  }
+
+  // Adds a reporter call expectation that the specified tag/count
+  // callback will be generated.
+  void ExpectReporterCall(int tag, int count) {
+    EXPECT_CALL(reporter_, Call(_, tag, count))
+        .Times(1)
+        .RetiresOnSaturation();
+  }
+
+  // The reporter callback forwards the call to the reporter mock so
+  // that we can set call expectations.
+  static void Reporter(void* handle, int tag, int count) {
+    TaggedCounterTest* test = static_cast<TaggedCounterTest*>(handle);
+    ASSERT_FALSE(NULL == test);
+    test->reporter_.Call(handle, tag, count);
+  }
+
+  // Collects log messages in the |log_| member string so that they
+  // can be analyzed for errors and expected behavior.
+  static bool HandleLogMessages(int severity, const std::string& str) {
+    test_->log_.append(str);
+    test_->log_.append("\n");
+
+    // Returning true would mute the log.
+    return false;
+  }
+
+  // Returns true if the counter log contains |pattern|, false otherwise.
+  bool LogContains(const std::string& pattern) {
+    return log_.find(pattern) != std::string::npos;
+  }
+
+  // The TaggedCounter object under test.
+  TaggedCounter counter_;
+
+  // The accumulated counter log.
+  std::string log_;
+
+  // Reporter mock to set callback expectations on.
+  StrictMock<MockFunction<void(void* handle, int tag, int count)> > reporter_;
+
+  // Pointer to the current test fixture.
+  static TaggedCounterTest* test_;
+};
+
+// static
+TaggedCounterTest* TaggedCounterTest::test_ = NULL;
+
+TEST_F(RecordTest, Init) {
+  record_.Init(/* tag */ 5, /* count */ -1);
+  EXPECT_EQ(5, record_.tag());
+  EXPECT_EQ(0, record_.count());
+
+  record_.Init(/* tag */ -2, /* count */ 10);
+  EXPECT_EQ(-2, record_.tag());
+  EXPECT_EQ(10, record_.count());
+}
+
+TEST_F(RecordTest, Add) {
+  record_.Add(/* count */ -1);
+  EXPECT_EQ(0, record_.count());
+
+  record_.Add(/* count */ 5);
+  EXPECT_EQ(5, record_.count());
+
+  record_.Add(/* count */ 10);
+  EXPECT_EQ(15, record_.count());
+
+  record_.Add(/* count */ -2);
+  EXPECT_EQ(15, record_.count());
+
+  record_.Add(/* count */ INT_MAX);
+  EXPECT_EQ(INT_MAX, record_.count());
+
+  record_.Add(/* count */ 1);
+  EXPECT_EQ(INT_MAX, record_.count());
+}
+
+TEST_F(TaggedCounterTest, BadFileLocation) {
+  // Checks that the counter doesn't die badly if the file can't be
+  // created.
+  counter_.Init(kDoesNotExistFile,
+                /* reporter */ NULL, /* reporter_handle */ NULL);
+  counter_.Update(/* tag */ 10, /* count */ 20);
+  EXPECT_TRUE(LogContains("Unable to open the persistent counter file: "
+                          "No such file or directory"));
+  EXPECT_EQ(TaggedCounter::kRecordInvalid, counter_.record_state_);
+  file_util::Delete(FilePath(kDoesNotExistFile), false);
+}
+
+TEST_F(TaggedCounterTest, Flush) {
+  counter_.Flush();
+  EXPECT_EQ(TaggedCounter::kRecordNull, counter_.record_state_);
+
+  counter_.Update(/* tag */ 40, /* count */ 60);
+  ExpectReporterCall(/* tag */ 40, /* count */ 60);
+  counter_.Flush();
+  EXPECT_TRUE(AssertNoOrEmptyRecordFile());
+  EXPECT_EQ(TaggedCounter::kRecordNull, counter_.record_state_);
+
+  counter_.Update(/* tag */ 41, /* count */ 70);
+  counter_.record_.Init(/* tag */ 0, /* count */ 0);
+  counter_.record_state_ = TaggedCounter::kRecordInvalid;
+  ExpectReporterCall(/* tag */ 41, /* count */ 70);
+  counter_.Flush();
+  EXPECT_TRUE(AssertNoOrEmptyRecordFile());
+  EXPECT_EQ(TaggedCounter::kRecordNull, counter_.record_state_);
+}
+
+TEST_F(TaggedCounterTest, InitFromFile) {
+  counter_.Update(/* tag */ 30, /* count */ 50);
+  EXPECT_PRED_FORMAT2(AssertRecord, /* day */ 30, /* seconds */ 50);
+  EXPECT_EQ(TaggedCounter::kRecordValid, counter_.record_state_);
+
+  counter_.Init(kTestRecordFile, &Reporter, this);
+  counter_.Update(/* tag */ 30, /* count */ 40);
+  EXPECT_PRED_FORMAT2(AssertRecord, /* day */ 30, /* seconds */ 90);
+  EXPECT_EQ(TaggedCounter::kRecordValid, counter_.record_state_);
+
+  counter_.Init(kTestRecordFile, &Reporter, this);
+  ExpectReporterCall(/* tag */ 30, /* count */ 90);
+  counter_.Update(/* tag */ 31, /* count */ 60);
+  EXPECT_PRED_FORMAT2(AssertRecord, /* day */ 31, /* seconds */ 60);
+  EXPECT_EQ(TaggedCounter::kRecordValid, counter_.record_state_);
+
+  ExpectReporterCall(/* tag */ 31, /* count */ 60);
+  counter_.Init(kTestRecordFile, &Reporter, this);
+  counter_.Update(/* tag */ 32, /* count */ 0);
+  EXPECT_TRUE(AssertNoOrEmptyRecordFile());
+  EXPECT_EQ(TaggedCounter::kRecordNull, counter_.record_state_);
+}
+
+TEST_F(TaggedCounterTest, Update) {
+  counter_.Update(/* tag */ 20, /* count */ 30);
+  EXPECT_PRED_FORMAT2(AssertRecord, /* day */ 20, /* seconds */ 30);
+  EXPECT_EQ(TaggedCounter::kRecordValid, counter_.record_state_);
+
+  counter_.Update(/* tag */ 20, /* count */ 40);
+  EXPECT_PRED_FORMAT2(AssertRecord, /* day */ 20, /* seconds */ 70);
+  EXPECT_EQ(TaggedCounter::kRecordValid, counter_.record_state_);
+
+  ExpectReporterCall(/* tag */ 20, /* count */ 70);
+  counter_.Update(/* tag */ 21, /* count */ 15);
+  EXPECT_PRED_FORMAT2(AssertRecord, /* day */ 21, /* seconds */ 15);
+  EXPECT_EQ(TaggedCounter::kRecordValid, counter_.record_state_);
+
+  ExpectReporterCall(/* tag */ 21, /* count */ 15);
+  counter_.Update(/* tag */ 22, /* count */ 0);
+  EXPECT_TRUE(AssertNoOrEmptyRecordFile());
+  EXPECT_EQ(TaggedCounter::kRecordNull, counter_.record_state_);
+}
+
+}  // namespace chromeos_metrics
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/metrics/metrics_daemon.cc b/metrics/metrics_daemon.cc
index 70c0748..e93c9a8 100644
--- a/metrics/metrics_daemon.cc
+++ b/metrics/metrics_daemon.cc
@@ -5,11 +5,11 @@
 #include "metrics_daemon.h"
 
 #include <dbus/dbus-glib-lowlevel.h>
-#include <sys/file.h>
 
-#include <base/eintr_wrapper.h>
 #include <base/logging.h>
 
+#include "counter.h"
+
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
@@ -89,6 +89,16 @@
 #include "session_states.h"
 };
 
+MetricsDaemon::MetricsDaemon()
+    : network_state_(kUnknownNetworkState),
+      power_state_(kUnknownPowerState),
+      session_state_(kUnknownSessionState),
+      user_active_(false),
+      usemon_interval_(0),
+      usemon_source_(NULL) {}
+
+MetricsDaemon::~MetricsDaemon() {}
+
 void MetricsDaemon::Run(bool run_as_daemon) {
   if (!run_as_daemon || daemon(0, 0) == 0) {
     Loop();
@@ -99,7 +109,8 @@
   testing_ = testing;
   DCHECK(metrics_lib != NULL);
   metrics_lib_ = metrics_lib;
-  daily_use_record_file_ = kDailyUseRecordFile;
+  daily_use_.reset(new chromeos_metrics::TaggedCounter());
+  daily_use_->Init(kDailyUseRecordFile, &DailyUseReporter, this);
 
   // Don't setup D-Bus and GLib in test mode.
   if (testing)
@@ -283,7 +294,7 @@
   }
   TimeDelta since_epoch = now - Time();
   int day = since_epoch.InDays();
-  LogDailyUseRecord(day, seconds);
+  daily_use_->Update(day, seconds);
 
   // Schedules a use monitor on inactive->active transitions and
   // unschedules it on active->inactive transitions.
@@ -298,70 +309,6 @@
   user_active_last_ = now;
 }
 
-void MetricsDaemon::LogDailyUseRecord(int day, int seconds) {
-  // If there's no new active use today and the last record in the
-  // usage aggregation file is today, there's nothing to do.
-  if (seconds == 0 && day == daily_use_day_last_)
-    return;
-
-  DLOG(INFO) << "day: " << day << " usage: " << seconds << " seconds";
-  int fd = HANDLE_EINTR(open(daily_use_record_file_,
-                             O_RDWR | O_CREAT,
-                             S_IRUSR | S_IWUSR));
-  if (fd < 0) {
-    PLOG(WARNING) << "Unable to open the daily use file";
-    return;
-  }
-
-  bool same_day = false;
-  UseRecord record;
-  if (HANDLE_EINTR(read(fd, &record, sizeof(record))) == sizeof(record)) {
-    if (record.day_ == day) {
-      // If there's an existing record for today, aggregates the usage
-      // time.
-      same_day = true;
-      record.seconds_ += seconds;
-    } else {
-      // If there's an existing record for a day in the past, rounds
-      // the usage to the nearest minute and sends it to UMA.
-      int minutes =
-          (record.seconds_ + kSecondsPerMinute / 2) / kSecondsPerMinute;
-      SendMetric(kMetricDailyUseTimeName, minutes,
-                 kMetricDailyUseTimeMin,
-                 kMetricDailyUseTimeMax,
-                 kMetricDailyUseTimeBuckets);
-
-      // Truncates the usage file to ensure that no duplicate usage is
-      // sent to UMA.
-      PLOG_IF(WARNING, HANDLE_EINTR(ftruncate(fd, 0)) != 0);
-    }
-  }
-
-  // Updates the use record in the daily usage file if there's new
-  // usage today.
-  if (seconds > 0) {
-    if (!same_day) {
-      record.day_ = day;
-      record.seconds_ = seconds;
-    }
-    // else an already existing record for the same day will be
-    // overwritten with updated usage below.
-
-    PLOG_IF(WARNING, HANDLE_EINTR(lseek(fd, 0, SEEK_SET)) != 0);
-    PLOG_IF(WARNING,
-            HANDLE_EINTR(write(fd, &record, sizeof(record))) !=
-            sizeof(record));
-  }
-
-  HANDLE_EINTR(close(fd));
-
-  // Remembers the day of the use record in the usage aggregation file
-  // to reduce file I/O. This is not really useful now but potentially
-  // allows frequent LogDailyUseRecord calls with no unnecessary I/O
-  // overhead.
-  daily_use_day_last_ = day;
-}
-
 // static
 gboolean MetricsDaemon::UseMonitorStatic(gpointer data) {
   return static_cast<MetricsDaemon*>(data)->UseMonitor() ? TRUE : FALSE;
@@ -422,6 +369,16 @@
   usemon_interval_ = 0;
 }
 
+// static
+void MetricsDaemon::DailyUseReporter(void* handle, int tag, int count) {
+  MetricsDaemon* daemon = static_cast<MetricsDaemon*>(handle);
+  int minutes = (count + kSecondsPerMinute / 2) / kSecondsPerMinute;
+  daemon->SendMetric(kMetricDailyUseTimeName, minutes,
+                     kMetricDailyUseTimeMin,
+                     kMetricDailyUseTimeMax,
+                     kMetricDailyUseTimeBuckets);
+}
+
 void MetricsDaemon::SendMetric(const std::string& name, int sample,
                                int min, int max, int nbuckets) {
   DLOG(INFO) << "received metric: " << name << " " << sample << " "
diff --git a/metrics/metrics_daemon.h b/metrics/metrics_daemon.h
index ea4771f..ee80596 100644
--- a/metrics/metrics_daemon.h
+++ b/metrics/metrics_daemon.h
@@ -8,24 +8,19 @@
 #include <dbus/dbus.h>
 #include <glib.h>
 
+#include <base/scoped_ptr.h>
+#include <base/time.h>
+#include <gtest/gtest_prod.h>  // for FRIEND_TEST
+
 #include "metrics_library.h"
 
-#include <gtest/gtest_prod.h>  // for FRIEND_TEST
-#include <base/time.h>
+namespace chromeos_metrics { class TaggedCounterInterface; }
 
 class MetricsDaemon {
 
  public:
-  MetricsDaemon()
-      : daily_use_record_file_(NULL),
-        network_state_(kUnknownNetworkState),
-        power_state_(kUnknownPowerState),
-        session_state_(kUnknownSessionState),
-        user_active_(false),
-        daily_use_day_last_(0),
-        usemon_interval_(0),
-        usemon_source_(NULL) {}
-  ~MetricsDaemon() {}
+  MetricsDaemon();
+  ~MetricsDaemon();
 
   // Initializes.
   void Init(bool testing, MetricsLibraryInterface* metrics_lib);
@@ -36,10 +31,7 @@
 
  private:
   friend class MetricsDaemonTest;
-  FRIEND_TEST(MetricsDaemonTest, LogDailyUseRecordBadFileLocation);
-  FRIEND_TEST(MetricsDaemonTest, LogDailyUseRecordOnLogin);
-  FRIEND_TEST(MetricsDaemonTest, LogDailyUseRecordRoundDown);
-  FRIEND_TEST(MetricsDaemonTest, LogDailyUseRecordRoundUp);
+  FRIEND_TEST(MetricsDaemonTest, DailyUseReporter);
   FRIEND_TEST(MetricsDaemonTest, LookupNetworkState);
   FRIEND_TEST(MetricsDaemonTest, LookupPowerState);
   FRIEND_TEST(MetricsDaemonTest, LookupScreenSaverState);
@@ -51,8 +43,7 @@
   FRIEND_TEST(MetricsDaemonTest, ScreenSaverStateChanged);
   FRIEND_TEST(MetricsDaemonTest, SendMetric);
   FRIEND_TEST(MetricsDaemonTest, SessionStateChanged);
-  FRIEND_TEST(MetricsDaemonTest, SetUserActiveStateSendOnLogin);
-  FRIEND_TEST(MetricsDaemonTest, SetUserActiveStateSendOnMonitor);
+  FRIEND_TEST(MetricsDaemonTest, SetUserActiveState);
   FRIEND_TEST(MetricsDaemonTest, SetUserActiveStateTimeJump);
 
   // The network states (see network_states.h).
@@ -178,14 +169,14 @@
   void SendMetric(const std::string& name, int sample,
                   int min, int max, int nbuckets);
 
+  static void DailyUseReporter(void* data, int tag, int count);
+
   // Test mode.
   bool testing_;
 
   // The metrics library handle.
   MetricsLibraryInterface* metrics_lib_;
 
-  const char* daily_use_record_file_;
-
   // Current network state.
   NetworkState network_state_;
 
@@ -209,8 +200,7 @@
   // epoch as the timestamp.
   base::Time user_active_last_;
 
-  // Last stored daily use day (since the epoch).
-  int daily_use_day_last_;
+  scoped_ptr<chromeos_metrics::TaggedCounterInterface> daily_use_;
 
   // Sleep period until the next daily usage aggregation performed by
   // the daily use monitor (see ScheduleUseMonitor).
diff --git a/metrics/metrics_daemon_test.cc b/metrics/metrics_daemon_test.cc
index 49acd31..7119c85 100644
--- a/metrics/metrics_daemon_test.cc
+++ b/metrics/metrics_daemon_test.cc
@@ -2,26 +2,19 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <gtest/gtest.h>
+
+#include "counter_mock.h"
 #include "metrics_daemon.h"
 #include "metrics_library_mock.h"
 
-#include <sys/file.h>
-
-#include <base/eintr_wrapper.h>
-#include <base/file_util.h>
-#include <base/logging.h>
-#include <base/string_util.h>
-#include <gtest/gtest.h>
-
 using base::Time;
 using base::TimeTicks;
-using ::testing::Mock;
+using chromeos_metrics::TaggedCounterMock;
+using ::testing::_;
 using ::testing::Return;
 using ::testing::StrictMock;
 
-static const char kTestDailyUseRecordFile[] = "daily-usage-test";
-static const char kDoesNotExistFile[] = "/does/not/exist";
-
 static const int kSecondsPerDay = 24 * 60 * 60;
 
 // This class allows a TimeTicks object to be initialized with seconds
@@ -48,46 +41,29 @@
 class MetricsDaemonTest : public testing::Test {
  protected:
   virtual void SetUp() {
-    EXPECT_EQ(NULL, daemon_.daily_use_record_file_);
+    EXPECT_EQ(NULL, daemon_.daily_use_.get());
     daemon_.Init(true, &metrics_lib_);
 
-    // Tests constructor initialization. Switches to a test daily use
-    // record file.
-    EXPECT_TRUE(NULL != daemon_.daily_use_record_file_);
-    daemon_.daily_use_record_file_ = kTestDailyUseRecordFile;
-    EXPECT_TRUE(AssertNoOrEmptyUseRecordFile());
-    EXPECT_EQ(0, daemon_.daily_use_day_last_);
+    // Tests constructor initialization. Switches to mock counters.
+    EXPECT_TRUE(NULL != daemon_.daily_use_.get());
+    daily_use_ = new StrictMock<TaggedCounterMock>();
+    daemon_.daily_use_.reset(daily_use_);  // Transfers ownership.
     EXPECT_FALSE(daemon_.user_active_);
     EXPECT_TRUE(daemon_.user_active_last_.is_null());
     EXPECT_EQ(MetricsDaemon::kUnknownNetworkState, daemon_.network_state_);
     EXPECT_TRUE(daemon_.network_state_last_.is_null());
     EXPECT_EQ(MetricsDaemon::kUnknownPowerState, daemon_.power_state_);
     EXPECT_EQ(MetricsDaemon::kUnknownSessionState, daemon_.session_state_);
-
-    // The test fixture object will be used by the log message handler.
-    daemon_test_ = this;
-    logging::SetLogMessageHandler(HandleLogMessages);
   }
 
-  virtual void TearDown() {
-    logging::SetLogMessageHandler(NULL);
-    daemon_test_ = NULL;
-    file_util::Delete(FilePath(kTestDailyUseRecordFile), false);
-  }
+  virtual void TearDown() {}
 
-  // Collects log messages in the |daemon_log_| member string so that
-  // they can be analyzed for errors and expected behavior.
-  static bool HandleLogMessages(int severity, const std::string& str) {
-    daemon_test_->daemon_log_.append(str);
-    daemon_test_->daemon_log_.append("\n");
-
-    // Returning true would mute the log.
-    return false;
-  }
-
-  // Returns true if the daemon log contains |pattern|, false otherwise.
-  bool LogContains(const std::string& pattern) {
-    return daemon_log_.find(pattern) != std::string::npos;
+  // Adds a daily use aggregation counter expectation that the
+  // specified tag/count update will be generated.
+  void ExpectDailyUseUpdate(int tag, int count) {
+    EXPECT_CALL(*daily_use_, Update(tag, count))
+        .Times(1)
+        .RetiresOnSaturation();
   }
 
   // Adds a metrics library mock expectation that the specified metric
@@ -118,55 +94,11 @@
                  MetricsDaemon::kMetricTimeToNetworkDropBuckets);
   }
 
+  // Converts from seconds to a Time object.
   Time TestTime(int64 seconds) {
     return Time::FromInternalValue(seconds * Time::kMicrosecondsPerSecond);
   }
 
-  // Asserts that the daily use record file contains the specified
-  // contents.
-  testing::AssertionResult AssertDailyUseRecord(const char* expr_day,
-                                                const char* expr_seconds,
-                                                int expected_day,
-                                                int expected_seconds) {
-    int fd = HANDLE_EINTR(open(daemon_.daily_use_record_file_, O_RDONLY));
-    if (fd < 0) {
-      testing::Message msg;
-      msg << "Unable to open " << daemon_.daily_use_record_file_;
-      return testing::AssertionFailure(msg);
-    }
-
-    MetricsDaemon::UseRecord record;
-    if (!file_util::ReadFromFD(fd, reinterpret_cast<char*>(&record),
-                               sizeof(record))) {
-      testing::Message msg;
-      msg << "Unable to read " << sizeof(record) << " bytes from "
-          << daemon_.daily_use_record_file_;
-      HANDLE_EINTR(close(fd));
-      return testing::AssertionFailure(msg);
-    }
-
-    if (record.day_ != expected_day || record.seconds_ != expected_seconds) {
-      testing::Message msg;
-      msg << "actual use record (" << record.day_ << ", " << record.seconds_
-          << ") expected (" << expected_day << ", " << expected_seconds << ")";
-      HANDLE_EINTR(close(fd));
-      return testing::AssertionFailure(msg);
-    }
-
-    HANDLE_EINTR(close(fd));
-    return testing::AssertionSuccess();
-  }
-
-  // Returns true if the daily use record file does not exist or is
-  // empty, false otherwise.
-  bool AssertNoOrEmptyUseRecordFile() {
-    FilePath record_file(daemon_.daily_use_record_file_);
-    int64 record_file_size;
-    return !file_util::PathExists(record_file) ||
-        (file_util::GetFileSize(record_file, &record_file_size) &&
-         record_file_size == 0);
-  }
-
   // Creates a new DBus signal message with a single string
   // argument. The message can be deallocated through
   // DeleteDBusMessage.
@@ -195,9 +127,6 @@
     dbus_message_unref(msg);
   }
 
-  // Pointer to the current test fixture.
-  static MetricsDaemonTest* daemon_test_;
-
   // The MetricsDaemon under test.
   MetricsDaemon daemon_;
 
@@ -205,67 +134,19 @@
   // metric generation calls are marked as failures.
   StrictMock<MetricsLibraryMock> metrics_lib_;
 
-  // The accumulated metrics daemon log.
-  std::string daemon_log_;
+  // Daily use time aggregation counter mock. It's a strict mock so
+  // that all unexpected update calls are marked as failures. It's a
+  // pointer so that it can replace the scoped_ptr allocated by the
+  // daemon.
+  StrictMock<TaggedCounterMock>* daily_use_;
 };
 
-// static
-MetricsDaemonTest* MetricsDaemonTest::daemon_test_ = NULL;
-
-TEST_F(MetricsDaemonTest, LogDailyUseRecordBadFileLocation) {
-  // Checks that the daemon doesn't die badly if the file can't be
-  // created.
-  daemon_.daily_use_record_file_ = kDoesNotExistFile;
-  daemon_.LogDailyUseRecord(10, 20);
-  EXPECT_TRUE(LogContains("Unable to open the daily use file: "
-                          "No such file or directory"));
-  EXPECT_EQ(0, daemon_.daily_use_day_last_);
-  file_util::Delete(FilePath(kDoesNotExistFile), false);
-}
-
-TEST_F(MetricsDaemonTest, LogDailyUseRecordOnLogin) {
-  daemon_.LogDailyUseRecord(/* day */ 5, /* seconds */ 120);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 5, /* seconds */ 120);
-  EXPECT_EQ(5, daemon_.daily_use_day_last_);
-
-  daemon_.LogDailyUseRecord(/* day */ 5, /* seconds */ 0);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 5, /* seconds */ 120);
-  EXPECT_EQ(5, daemon_.daily_use_day_last_);
-
-  daemon_.LogDailyUseRecord(/* day */ 5, /* seconds */ 240);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 5, /* seconds */ 360);
-  EXPECT_EQ(5, daemon_.daily_use_day_last_);
-
-  ExpectDailyUseTimeMetric(/* sample */ 6);
-  daemon_.LogDailyUseRecord(/* day */ 6, /* seconds */ 0);
-  EXPECT_TRUE(AssertNoOrEmptyUseRecordFile());
-  EXPECT_EQ(6, daemon_.daily_use_day_last_);
-}
-
-TEST_F(MetricsDaemonTest, LogDailyUseRecordRoundDown) {
-  daemon_.LogDailyUseRecord(/* day */ 7, /* seconds */ 89);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 7, /* seconds */ 89);
-  EXPECT_EQ(7, daemon_.daily_use_day_last_);
+TEST_F(MetricsDaemonTest, DailyUseReporter) {
+  ExpectDailyUseTimeMetric(/* sample */ 2);
+  MetricsDaemon::DailyUseReporter(&daemon_, /* tag */ 20, /* count */ 90);
 
   ExpectDailyUseTimeMetric(/* sample */ 1);
-  daemon_.LogDailyUseRecord(/* day */ 6, /* seconds */ 15);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 6, /* seconds */ 15);
-  EXPECT_EQ(6, daemon_.daily_use_day_last_);
-}
-
-TEST_F(MetricsDaemonTest, LogDailyUseRecordRoundUp) {
-  daemon_.LogDailyUseRecord(/* day */ 6, /* seconds */ 0);
-  EXPECT_EQ(6, daemon_.daily_use_day_last_);
-
-  // Tests rounding use time to the closest minute.
-  daemon_.LogDailyUseRecord(/* day */ 6, /* seconds */ 90);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 6, /* seconds */ 90);
-  EXPECT_EQ(6, daemon_.daily_use_day_last_);
-
-  ExpectDailyUseTimeMetric(/* sample */ 2);
-  daemon_.LogDailyUseRecord(/* day */ 7, /* seconds */ 89);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 7, /* seconds */ 89);
-  EXPECT_EQ(7, daemon_.daily_use_day_last_);
+  MetricsDaemon::DailyUseReporter(&daemon_, /* tag */ 23, /* count */ 89);
 }
 
 TEST_F(MetricsDaemonTest, LookupNetworkState) {
@@ -322,6 +203,9 @@
   EXPECT_EQ(DBUS_HANDLER_RESULT_HANDLED, res);
   DeleteDBusMessage(msg);
 
+  EXPECT_CALL(*daily_use_, Update(_, 0))
+      .Times(1)
+      .RetiresOnSaturation();
   msg = NewDBusSignalString("/",
                             "org.chromium.PowerManager",
                             "ScreenIsUnlocked",
@@ -332,6 +216,9 @@
   EXPECT_EQ(DBUS_HANDLER_RESULT_HANDLED, res);
   DeleteDBusMessage(msg);
 
+  EXPECT_CALL(*daily_use_, Update(_, 0))
+      .Times(1)
+      .RetiresOnSaturation();
   msg = NewDBusSignalString("/org/chromium/SessionManager",
                             "org.chromium.SessionManagerInterface",
                             "SessionStateChanged",
@@ -396,30 +283,28 @@
 }
 
 TEST_F(MetricsDaemonTest, PowerStateChanged) {
+  ExpectDailyUseUpdate(7, 0);
   daemon_.SetUserActiveState(/* active */ true,
                              TestTime(7 * kSecondsPerDay + 15));
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(TestTime(7 * kSecondsPerDay + 15), daemon_.user_active_last_);
-  EXPECT_EQ(7, daemon_.daily_use_day_last_);
-  EXPECT_TRUE(AssertNoOrEmptyUseRecordFile());
 
+  ExpectDailyUseUpdate(7, 30);
   daemon_.PowerStateChanged("mem", TestTime(7 * kSecondsPerDay + 45));
   EXPECT_EQ(MetricsDaemon::kPowerStateMem, daemon_.power_state_);
   EXPECT_FALSE(daemon_.user_active_);
   EXPECT_EQ(TestTime(7 * kSecondsPerDay + 45), daemon_.user_active_last_);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 7, /* seconds */ 30);
 
   daemon_.PowerStateChanged("on", TestTime(7 * kSecondsPerDay + 85));
   EXPECT_EQ(MetricsDaemon::kPowerStateOn, daemon_.power_state_);
   EXPECT_FALSE(daemon_.user_active_);
   EXPECT_EQ(TestTime(7 * kSecondsPerDay + 45), daemon_.user_active_last_);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 7, /* seconds */ 30);
 
+  ExpectDailyUseUpdate(7, 0);
   daemon_.PowerStateChanged("otherstate", TestTime(7 * kSecondsPerDay + 185));
   EXPECT_EQ(MetricsDaemon::kUnknownPowerState, daemon_.power_state_);
   EXPECT_FALSE(daemon_.user_active_);
   EXPECT_EQ(TestTime(7 * kSecondsPerDay + 185), daemon_.user_active_last_);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 7, /* seconds */ 30);
 }
 
 TEST_F(MetricsDaemonTest, SendMetric) {
@@ -429,117 +314,76 @@
 }
 
 TEST_F(MetricsDaemonTest, SessionStateChanged) {
+  ExpectDailyUseUpdate(15, 0);
   daemon_.SessionStateChanged("started", TestTime(15 * kSecondsPerDay + 20));
   EXPECT_EQ(MetricsDaemon::kSessionStateStarted, daemon_.session_state_);
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(TestTime(15 * kSecondsPerDay + 20), daemon_.user_active_last_);
-  EXPECT_EQ(15, daemon_.daily_use_day_last_);
-  EXPECT_TRUE(AssertNoOrEmptyUseRecordFile());
 
+  ExpectDailyUseUpdate(15, 130);
   daemon_.SessionStateChanged("stopped", TestTime(15 * kSecondsPerDay + 150));
   EXPECT_EQ(MetricsDaemon::kSessionStateStopped, daemon_.session_state_);
   EXPECT_FALSE(daemon_.user_active_);
   EXPECT_EQ(TestTime(15 * kSecondsPerDay + 150), daemon_.user_active_last_);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 15, /* seconds */ 130);
 
+  ExpectDailyUseUpdate(15, 0);
   daemon_.SessionStateChanged("otherstate",
                               TestTime(15 * kSecondsPerDay + 300));
   EXPECT_EQ(MetricsDaemon::kUnknownSessionState, daemon_.session_state_);
   EXPECT_FALSE(daemon_.user_active_);
   EXPECT_EQ(TestTime(15 * kSecondsPerDay + 300), daemon_.user_active_last_);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 15, /* seconds */ 130);
 }
 
-TEST_F(MetricsDaemonTest, SetUserActiveStateSendOnLogin) {
+TEST_F(MetricsDaemonTest, SetUserActiveState) {
+  ExpectDailyUseUpdate(5, 0);
   daemon_.SetUserActiveState(/* active */ false,
                              TestTime(5 * kSecondsPerDay + 10));
   EXPECT_FALSE(daemon_.user_active_);
   EXPECT_EQ(TestTime(5 * kSecondsPerDay + 10), daemon_.user_active_last_);
-  EXPECT_EQ(5, daemon_.daily_use_day_last_);
-  EXPECT_TRUE(AssertNoOrEmptyUseRecordFile());
 
+  ExpectDailyUseUpdate(6, 0);
   daemon_.SetUserActiveState(/* active */ true,
                              TestTime(6 * kSecondsPerDay + 20));
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(TestTime(6 * kSecondsPerDay + 20), daemon_.user_active_last_);
-  EXPECT_EQ(6, daemon_.daily_use_day_last_);
-  EXPECT_TRUE(AssertNoOrEmptyUseRecordFile());
 
+  ExpectDailyUseUpdate(6, 100);
   daemon_.SetUserActiveState(/* active */ true,
                              TestTime(6 * kSecondsPerDay + 120));
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(TestTime(6 * kSecondsPerDay + 120), daemon_.user_active_last_);
-  EXPECT_EQ(6, daemon_.daily_use_day_last_);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 6, /* seconds */ 100);
 
+  ExpectDailyUseUpdate(6, 110);
   daemon_.SetUserActiveState(/* active */ false,
-                             TestTime(6 * kSecondsPerDay + 220));
+                             TestTime(6 * kSecondsPerDay + 230));
   EXPECT_FALSE(daemon_.user_active_);
-  EXPECT_EQ(TestTime(6 * kSecondsPerDay + 220), daemon_.user_active_last_);
-  EXPECT_EQ(6, daemon_.daily_use_day_last_);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 6, /* seconds */ 200);
+  EXPECT_EQ(TestTime(6 * kSecondsPerDay + 230), daemon_.user_active_last_);
 
-  ExpectDailyUseTimeMetric(/* sample */ 3);
-  daemon_.SetUserActiveState(/* active */ true,
-                             TestTime(8 * kSecondsPerDay - 300));
-  EXPECT_TRUE(daemon_.user_active_);
-  EXPECT_EQ(TestTime(8 * kSecondsPerDay - 300), daemon_.user_active_last_);
-  EXPECT_EQ(7, daemon_.daily_use_day_last_);
-  EXPECT_TRUE(AssertNoOrEmptyUseRecordFile());
-}
-
-TEST_F(MetricsDaemonTest, SetUserActiveStateSendOnMonitor) {
-  daemon_.SetUserActiveState(/* active */ true,
-                             TestTime(8 * kSecondsPerDay - 300));
-  EXPECT_TRUE(daemon_.user_active_);
-  EXPECT_EQ(TestTime(8 * kSecondsPerDay - 300), daemon_.user_active_last_);
-  EXPECT_EQ(7, daemon_.daily_use_day_last_);
-  EXPECT_TRUE(AssertNoOrEmptyUseRecordFile());
-
+  ExpectDailyUseUpdate(6, 0);
   daemon_.SetUserActiveState(/* active */ false,
-                             TestTime(8 * kSecondsPerDay + 300));
+                             TestTime(6 * kSecondsPerDay + 260));
   EXPECT_FALSE(daemon_.user_active_);
-  EXPECT_EQ(TestTime(8 * kSecondsPerDay + 300), daemon_.user_active_last_);
-  EXPECT_EQ(8, daemon_.daily_use_day_last_);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 8, /* seconds */ 600);
-
-  daemon_.SetUserActiveState(/* active */ true,
-                             TestTime(9 * kSecondsPerDay - 200));
-  EXPECT_TRUE(daemon_.user_active_);
-  EXPECT_EQ(TestTime(9 * kSecondsPerDay - 200), daemon_.user_active_last_);
-  EXPECT_EQ(8, daemon_.daily_use_day_last_);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 8, /* seconds */ 600);
-
-  ExpectDailyUseTimeMetric(/* sample */ 10);
-  daemon_.SetUserActiveState(/* active */ true,
-                             TestTime(9 * kSecondsPerDay + 200));
-  EXPECT_TRUE(daemon_.user_active_);
-  EXPECT_EQ(TestTime(9 * kSecondsPerDay + 200), daemon_.user_active_last_);
-  EXPECT_EQ(9, daemon_.daily_use_day_last_);
-  EXPECT_PRED_FORMAT2(AssertDailyUseRecord, /* day */ 9, /* seconds */ 400);
+  EXPECT_EQ(TestTime(6 * kSecondsPerDay + 260), daemon_.user_active_last_);
 }
 
 TEST_F(MetricsDaemonTest, SetUserActiveStateTimeJump) {
+  ExpectDailyUseUpdate(10, 0);
   daemon_.SetUserActiveState(/* active */ true,
                              TestTime(10 * kSecondsPerDay + 500));
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(TestTime(10 * kSecondsPerDay + 500), daemon_.user_active_last_);
-  EXPECT_EQ(10, daemon_.daily_use_day_last_);
-  EXPECT_TRUE(AssertNoOrEmptyUseRecordFile());
 
+  ExpectDailyUseUpdate(10, 0);
   daemon_.SetUserActiveState(/* active */ true,
                              TestTime(10 * kSecondsPerDay + 300));
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(TestTime(10 * kSecondsPerDay + 300), daemon_.user_active_last_);
-  EXPECT_EQ(10, daemon_.daily_use_day_last_);
-  EXPECT_TRUE(AssertNoOrEmptyUseRecordFile());
 
+  ExpectDailyUseUpdate(10, 0);
   daemon_.SetUserActiveState(/* active */ true,
                              TestTime(10 * kSecondsPerDay + 1000));
   EXPECT_TRUE(daemon_.user_active_);
   EXPECT_EQ(TestTime(10 * kSecondsPerDay + 1000), daemon_.user_active_last_);
-  EXPECT_EQ(10, daemon_.daily_use_day_last_);
-  EXPECT_TRUE(AssertNoOrEmptyUseRecordFile());
 }
 
 int main(int argc, char** argv) {
diff --git a/metrics/metrics_library_mock.h b/metrics/metrics_library_mock.h
index ffc9342..ba59c8f 100644
--- a/metrics/metrics_library_mock.h
+++ b/metrics/metrics_library_mock.h
@@ -20,4 +20,4 @@
                                    int max));
 };
 
-#endif /* METRICS_LIBRARY_MOCK_H_ */
+#endif  // METRICS_LIBRARY_MOCK_H_