Minor style cleanup in metrics_reporting_scheduler.*

chrome/browser/metrics/metrics_reporting_scheduler.cc

 // Copyright (c) 2012 The Chromium 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 "chrome/browser/metrics/metrics_reporting_scheduler.h"
 
 #include "base/compiler_specific.h"
 #include "chrome/browser/metrics/metrics_service.h"
 
-using base::Time;
 using base::TimeDelta;
 
 // The delay, in seconds, after startup before sending the first log message.
-static const int kInitialUploadIntervalSeconds = 60;

[jar (doing other things), 2012/06/08 00:20:02]

I'm surprised you pulled the static qualifier. Won't that cause the vars to have
extern linkage (i.e., be visible at the linker level)?

Usually, we either use an anonymous namespace, or static, to preclude that.

[Ilya Sherman, 2012/06/08 00:52:14]

Numeric constants don't seem to require either, but I've gone ahead and wrapped
these in an anonymous namespace to be extra sure.  (I know, I could probably
just leave the "static"... but that doesn't match the style I've seen in other
files, and so I find it surprising when reading through the code.)

[jar (doing other things), 2012/06/11 18:54:28]

If I had my druthers.... I'd suggest that Chromium use the static qualifier, as
it makes it easier to grep the code etc. ...but no one asked me ;-).

The only restriction is that static doesn't work for classes <sigh>, so for them
you need the anonymous namespace.

On 2012/06/08 00:52:14, Ilya Sherman wrote:

+const int kInitialUploadIntervalSeconds = 60;
 
 // The delay, in seconds, between uploading when there are queued logs from
 // previous sessions to send.
-static const int kUnsentLogsIntervalSeconds = 15;
+const int kUnsentLogsIntervalSeconds = 15;
 
 // Standard interval between log uploads, in seconds.
-static const int kStandardUploadIntervalSeconds = 30 * 60;  // Thirty minutes.
+const int kStandardUploadIntervalSeconds = 30 * 60;  // Thirty minutes.
 
 // When uploading metrics to the server fails, we progressively wait longer and
 // longer before sending the next log. This backoff process helps reduce load
 // on a server that is having issues.
 // The following is the multiplier we use to expand that inter-log duration.
-static const double kBackoffMultiplier = 1.1;
+const double kBackoffMultiplier = 1.1;
 
 // The maximum backoff multiplier.
-static const int kMaxBackoffMultiplier = 10;
+const int kMaxBackoffMultiplier = 10;
 
 
 MetricsReportingScheduler::MetricsReportingScheduler(
     const base::Closure& upload_callback)
     : upload_callback_(upload_callback),
       upload_interval_(TimeDelta::FromSeconds(kInitialUploadIntervalSeconds)),
       running_(false),
       callback_pending_(false) {
 }
 
 MetricsReportingScheduler::~MetricsReportingScheduler() {}
 
 void MetricsReportingScheduler::Start() {
   running_ = true;
-  ScheduleNextCallback();
+  ScheduleNextUpload();
 }
 
 void MetricsReportingScheduler::Stop() {
   running_ = false;
   if (upload_timer_.IsRunning())
     upload_timer_.Stop();
 }
 
 void MetricsReportingScheduler::UploadFinished(bool server_is_healthy,
                                                bool more_logs_remaining) {
   DCHECK(callback_pending_);
   callback_pending_ = false;
   // If the server is having issues, back off. Otherwise, reset to default
   // (unless there are more logs to send, in which case the next upload should
   // happen sooner).
   if (!server_is_healthy) {
     BackOffUploadInterval();
   } else if (more_logs_remaining) {
     upload_interval_ = TimeDelta::FromSeconds(kUnsentLogsIntervalSeconds);
   } else {
     upload_interval_ = TimeDelta::FromSeconds(kStandardUploadIntervalSeconds);
   }
 
   if (running_)
-    ScheduleNextCallback();
+    ScheduleNextUpload();
 }
 
 void MetricsReportingScheduler::UploadCancelled() {
   DCHECK(callback_pending_);
   callback_pending_ = false;
   if (running_)
-    ScheduleNextCallback();
+    ScheduleNextUpload();
 }
 
 void MetricsReportingScheduler::TriggerUpload() {
   callback_pending_ = true;
   upload_callback_.Run();
 }
 
-void MetricsReportingScheduler::ScheduleNextCallback() {
+void MetricsReportingScheduler::ScheduleNextUpload() {
   DCHECK(running_);
   if (upload_timer_.IsRunning() || callback_pending_)
     return;
 
   upload_timer_.Start(FROM_HERE, upload_interval_, this,
                       &MetricsReportingScheduler::TriggerUpload);
 }
 
 void MetricsReportingScheduler::BackOffUploadInterval() {
-  DCHECK(kBackoffMultiplier > 1.0);
+  DCHECK_GT(kBackoffMultiplier, 1.0);
   upload_interval_ = TimeDelta::FromMicroseconds(
       static_cast<int64>(kBackoffMultiplier *
                          upload_interval_.InMicroseconds()));
 
   TimeDelta max_interval = kMaxBackoffMultiplier *
       TimeDelta::FromSeconds(kStandardUploadIntervalSeconds);
   if (upload_interval_ > max_interval || upload_interval_.InSeconds() < 0) {
     upload_interval_ = max_interval;
   }
 }