Readability review.

counter.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 "counter.h"
 
-#include <sys/file.h>
+#include <fcntl.h>
 
 #include <base/eintr_wrapper.h>
 #include <base/logging.h>
 
 namespace chromeos_metrics {
 
 // TaggedCounter::Record implementation.
-void TaggedCounter::Record::Init(int tag, int count) {
+void TaggedCounter::Record::Init(int32 tag, int32 count) {
   tag_ = tag;
   count_ = (count > 0) ? count : 0;
 }
 
-void TaggedCounter::Record::Add(int count) {
+void TaggedCounter::Record::Add(int32 count) {
   if (count <= 0)
     return;
 
-  count_ += count;
-
-  // Saturates on postive overflow.
-  if (count_ < 0) {
-    count_ = INT_MAX;
-  }
+  // Saturates on positive overflow.
+  int64 new_count = static_cast<int64>(count_) + static_cast<int64>(count);
+  if (new_count > kint32max)
+    count_ = kint32max;
+  else
+    count_ = static_cast<int32>(new_count);
 }
 
 // TaggedCounter implementation.
 TaggedCounter::TaggedCounter()
-    : filename_(NULL), reporter_(NULL), reporter_handle_(NULL),
+    : 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) {
+void TaggedCounter::Update(int32 tag, int32 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) {
+void TaggedCounter::UpdateInternal(int32 tag, int32 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
@@ skipping 21 matching lines @@
     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) {
+void TaggedCounter::ReportRecord(int32 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) {
+void TaggedCounter::UpdateRecord(int32 tag, int32 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;
@@ skipping 32 matching lines @@
     case kRecordValid:
       // Nothing to do.
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace chromeos_metrics