Add stricter tests for RapporService::LoadSecret

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"
-#include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
 #include "components/metrics/metrics_hashes.h"
 #include "components/rappor/log_uploader.h"
 #include "components/rappor/proto/rappor_metric.pb.h"
 #include "components/rappor/rappor_metric.h"
 #include "components/rappor/rappor_pref_names.h"
+#include "components/rappor/rappor_prefs.h"
 #include "components/variations/variations_associated_data.h"
 
 namespace rappor {
 
 namespace {
 
 // Seconds before the initial log is generated.
 const int kInitialLogIntervalSeconds = 15;
 // Interval between ongoing logs.
 const int kLogIntervalSeconds = 30 * 60;
@@ skipping 70 matching lines @@
   const GURL server_url = GetServerUrl();
   if (!server_url.is_valid()) {
     DVLOG(1) << server_url.spec() << " is invalid. "
              << "RapporService not started.";
     return;
   }
   DVLOG(1) << "RapporService reporting to " << server_url.spec();
   InitializeInternal(make_scoped_ptr(new LogUploader(server_url,
                                                      kMimeType,
                                                      request_context)),
-                     LoadCohort(),
-                     LoadSecret());
+                     internal::LoadCohort(pref_service_),
+                     internal::LoadSecret(pref_service_));
 }
 
 void RapporService::Update(RecordingLevel recording_level, bool may_upload) {
   DCHECK(IsInitialized());
   if (recording_level_ != recording_level) {
     if (recording_level == RECORDING_DISABLED) {
       DVLOG(1) << "Rappor service stopped due to RECORDING_DISABLED.";
       recording_level_ = RECORDING_DISABLED;
       CancelNextLogRotation();
     } else if (recording_level_ == RECORDING_DISABLED) {
       DVLOG(1) << "RapporService started at recording level: "
                << recording_level;
       recording_level_ = recording_level;
       ScheduleNextLogRotation(
           base::TimeDelta::FromSeconds(kInitialLogIntervalSeconds));
     } else {
       DVLOG(1) << "RapporService recording_level changed:" << recording_level;
       recording_level_ = recording_level;
     }
   }
 
   DVLOG(1) << "RapporService may_upload=" << may_upload;
   if (may_upload) {
     uploader_->Start();
   } else {
     uploader_->Stop();
   }
 }
 
+// static
+void RapporService::RegisterPrefs(PrefRegistrySimple* registry) {
+  internal::RegisterPrefs(registry);
+}
+
 void RapporService::InitializeInternal(
     scoped_ptr<LogUploaderInterface> uploader,
     int32_t cohort,
     const std::string& secret) {
   DCHECK(!IsInitialized());
   DCHECK(secret_.empty());
   uploader_.swap(uploader);
   cohort_ = cohort;
   secret_ = secret;
 }
@@ skipping 23 matching lines @@
     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);
   }
   ScheduleNextLogRotation(base::TimeDelta::FromSeconds(kLogIntervalSeconds));
 }
 
-// static
-void RapporService::RegisterPrefs(PrefRegistrySimple* registry) {
-  registry->RegisterStringPref(prefs::kRapporSecret, std::string());
-  registry->RegisterIntegerPref(prefs::kRapporCohortDeprecated, -1);
-  registry->RegisterIntegerPref(prefs::kRapporCohortSeed, -1);
-  metrics::DailyEvent::RegisterPref(registry, prefs::kRapporLastDailySample);
-}
-
-int32_t RapporService::LoadCohort() {
-  // Ignore and delete old cohort parameter.
-  pref_service_->ClearPref(prefs::kRapporCohortDeprecated);
-
-  int32_t 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 cohort;
-
-  // 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);
-  return cohort;
-}
-
-std::string RapporService::LoadSecret() {
-  std::string secret;
-  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 secret;
-    // 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);
-  return secret;
-}
-
 bool RapporService::ExportMetrics(RapporReports* reports) {
   if (metrics_map_.empty()) {
     DVLOG(2) << "metrics_map_ is empty.";
     return false;
   }
 
   DCHECK_GE(cohort_, 0);
   reports->set_cohort(cohort_);
 
   for (std::map<std::string, RapporMetric*>::const_iterator it =
@@ skipping 57 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