Add a mechanism for collecting Rappor samples on a daily interval.

components/rappor/rappor_service.cc

 // Copyright 2014 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 "components/rappor/rappor_service.h"
 
 #include "base/base64.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
@@ skipping 51 matching lines @@
      16 /* Bloom filter size bytes */,
      2 /* Bloom filter hash count */,
      rappor::PROBABILITY_50 /* Fake data probability */,
      rappor::PROBABILITY_50 /* Fake one probability */,
      rappor::PROBABILITY_75 /* One coin probability */,
      rappor::PROBABILITY_25 /* Zero coin probability */},
 };
 
 }  // namespace
 
-RapporService::RapporService() : cohort_(-1) {}
+RapporService::RapporService(PrefService* pref_service)
+    : pref_service_(pref_service),
+      cohort_(-1),
+      daily_interval_(pref_service, prefs::kRapporLastDailySample) {
+}
 
 RapporService::~RapporService() {
   STLDeleteValues(&metrics_map_);
 }
 
-void RapporService::Start(PrefService* pref_service,
-                          net::URLRequestContextGetter* request_context,
+void RapporService::AddDailyMetric(metrics::DailyObserver* observer) {
+  daily_interval_.AddObserver(observer);
+}
+
+void RapporService::Start(net::URLRequestContextGetter* request_context,
                           bool metrics_enabled) {
   const GURL server_url = GetServerUrl(metrics_enabled);
   if (!server_url.is_valid()) {
     DVLOG(1) << server_url.spec() << " is invalid. "
              << "RapporService not started.";
     return;
   }
   DVLOG(1) << "RapporService started. Reporting to " << server_url.spec();
   DCHECK(!uploader_);
-  LoadSecret(pref_service);
-  LoadCohort(pref_service);
+  LoadSecret();
+  LoadCohort();
   uploader_.reset(new LogUploader(server_url, kMimeType, request_context));
   log_rotation_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromSeconds(kInitialLogIntervalSeconds),
       this,
       &RapporService::OnLogInterval);
 }
 
 void RapporService::OnLogInterval() {
   DCHECK(uploader_);
   DVLOG(2) << "RapporService::OnLogInterval";
+  daily_interval_.CheckInterval();
   RapporReports reports;
   if (ExportMetrics(&reports)) {
     std::string log_text;
     bool success = reports.SerializeToString(&log_text);
     DCHECK(success);
     DVLOG(1) << "RapporService sending a report of "
              << reports.report_size() << " value(s).";
     uploader_->QueueLog(log_text);
   }
   log_rotation_timer_.Start(FROM_HERE,
                             base::TimeDelta::FromSeconds(kLogIntervalSeconds),
                             this,
                             &RapporService::OnLogInterval);
 }
 
 // static
 void RapporService::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kRapporSecret, std::string());
   registry->RegisterIntegerPref(prefs::kRapporCohortDeprecated, -1);
   registry->RegisterIntegerPref(prefs::kRapporCohortSeed, -1);
+  metrics::DailyInterval::RegisterPref(registry,
+                                       prefs::kRapporLastDailySample);
 }
 
-void RapporService::LoadCohort(PrefService* pref_service) {
+void RapporService::LoadCohort() {
   DCHECK(!IsInitialized());
   // Ignore and delete old cohort parameter.
-  pref_service->ClearPref(prefs::kRapporCohortDeprecated);
+  pref_service_->ClearPref(prefs::kRapporCohortDeprecated);
 
-  cohort_ = pref_service->GetInteger(prefs::kRapporCohortSeed);
+  cohort_ = pref_service_->GetInteger(prefs::kRapporCohortSeed);
   // If the user is already assigned to a valid cohort, we're done.
   if (cohort_ >= 0 && cohort_ < RapporParameters::kMaxCohorts)
     return;
 
   // This is the first time the client has started the service (or their
   // preferences were corrupted).  Randomly assign them to a cohort.
   cohort_ = base::RandGenerator(RapporParameters::kMaxCohorts);
   DVLOG(2) << "Selected a new Rappor cohort: " << cohort_;
-  pref_service->SetInteger(prefs::kRapporCohortSeed, cohort_);
+  pref_service_->SetInteger(prefs::kRapporCohortSeed, cohort_);
 }
 
-void RapporService::LoadSecret(PrefService* pref_service) {
+void RapporService::LoadSecret() {
   DCHECK(secret_.empty());
-  std::string secret_base64 = pref_service->GetString(prefs::kRapporSecret);
+  std::string secret_base64 = pref_service_->GetString(prefs::kRapporSecret);
   if (!secret_base64.empty()) {
     bool decoded = base::Base64Decode(secret_base64, &secret_);
     if (decoded && secret_.size() == HmacByteVectorGenerator::kEntropyInputSize)
       return;
     // If the preference fails to decode, or is the wrong size, it must be
     // corrupt, so continue as though it didn't exist yet and generate a new
     // one.
   }
 
   DVLOG(2) << "Generated a new Rappor secret.";
   secret_ = HmacByteVectorGenerator::GenerateEntropyInput();
   base::Base64Encode(secret_, &secret_base64);
-  pref_service->SetString(prefs::kRapporSecret, secret_base64);
+  pref_service_->SetString(prefs::kRapporSecret, secret_base64);
 }
 
 bool RapporService::ExportMetrics(RapporReports* reports) {
   if (metrics_map_.empty())
     return false;
 
   DCHECK_GE(cohort_, 0);
   reports->set_cohort(cohort_);
 
   for (std::map<std::string, RapporMetric*>::const_iterator it =
@@ skipping 45 matching lines @@
     DCHECK_EQ(parameters.ToString(), metric->parameters().ToString());
     return metric;
   }
 
   RapporMetric* new_metric = new RapporMetric(metric_name, parameters, cohort_);
   metrics_map_[metric_name] = new_metric;
   return new_metric;
 }
 
 }  // namespace rappor