Create a mechanism for reporting rappor metrics from non-UMA

components/rappor/rappor_service.cc

Index: components/rappor/rappor_service.cc
diff --git a/components/rappor/rappor_service.cc b/components/rappor/rappor_service.cc
index 11419f5baaf583af9995ba352ec41b326d73a041..de814c42affd378c17d57024366ee86755fee831 100644
--- a/components/rappor/rappor_service.cc
+++ b/components/rappor/rappor_service.cc
@@ -37,18 +37,10 @@ const char kRapporRolloutFieldTrialName[] = "RapporRollout";
 // Constant for the finch parameter name for the server URL
 const char kRapporRolloutServerUrlParam[] = "ServerUrl";
 
-// Constant for the finch parameter name for the server URL
-const char kRapporRolloutRequireUmaParam[] = "RequireUma";
-
 // The rappor server's URL.
 const char kDefaultServerUrl[] = "https://clients4.google.com/rappor";
 
-GURL GetServerUrl(bool metrics_enabled) {
-  bool require_uma = variations::GetVariationParamValue(
-      kRapporRolloutFieldTrialName,
-      kRapporRolloutRequireUmaParam) != "False";
-  if (!metrics_enabled && require_uma)
-    return GURL();  // Invalid URL disables Rappor.
+GURL GetServerUrl() {
   std::string server_url = variations::GetVariationParamValue(
       kRapporRolloutFieldTrialName,
       kRapporRolloutServerUrlParam);
@@ -66,7 +58,17 @@ const RapporParameters kRapporParametersForType[NUM_RAPPOR_TYPES] = {
      rappor::PROBABILITY_50 /* Fake data probability */,
      rappor::PROBABILITY_50 /* Fake one probability */,
      rappor::PROBABILITY_75 /* One coin probability */,
-     rappor::PROBABILITY_25 /* Zero coin probability */},
+     rappor::PROBABILITY_25 /* Zero coin probability */,
+     FINE_LEVEL /* Reporting level */},
+    // COARSE_RAPPOR_TYPE
+    {128 /* Num cohorts */,
+     1 /* 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 */,
+     COARSE_LEVEL /* Reporting level */},
 };
 
 }  // namespace
@@ -75,8 +77,9 @@ RapporService::RapporService(PrefService* pref_service)
     : pref_service_(pref_service),
       cohort_(-1),
       daily_event_(pref_service,
-                      prefs::kRapporLastDailySample,
-                      kRapporDailyEventHistogram) {
+                   prefs::kRapporLastDailySample,
+                   kRapporDailyEventHistogram),
+      reporting_level_(REPORTING_DISABLED) {
 }
 
 RapporService::~RapporService() {
@@ -90,16 +93,22 @@ void RapporService::AddDailyObserver(
 
 void RapporService::Start(net::URLRequestContextGetter* request_context,
                           bool metrics_enabled) {
-  const GURL server_url = GetServerUrl(metrics_enabled);
+  const GURL server_url = GetServerUrl();
   if (!server_url.is_valid()) {
     DVLOG(1) << server_url.spec() << " is invalid. "
              << "RapporService not started.";
     return;
   }
+  // TODO(holte): Consider moving this logic once we've determined the
+  // conditions for COARSE metrics.
+  ReportingLevel reporting_level = metrics_enabled ?
+                                   FINE_LEVEL : REPORTING_DISABLED;
+  DVLOG(1) << "RapporService reporting_level_? " << reporting_level;
+  if (reporting_level <= REPORTING_DISABLED)
+    return;
   DVLOG(1) << "RapporService started. Reporting to " << server_url.spec();
   DCHECK(!uploader_);
-  LoadSecret();
-  LoadCohort();
+  Initialize(LoadCohort(), LoadSecret(), reporting_level_);
   uploader_.reset(new LogUploader(server_url, kMimeType, request_context));
   log_rotation_timer_.Start(
       FROM_HERE,
@@ -108,6 +117,16 @@ void RapporService::Start(net::URLRequestContextGetter* request_context,
       &RapporService::OnLogInterval);
 }
 
+void RapporService::Initialize(int32_t cohort,
+                               const std::string& secret,
+                               const ReportingLevel& reporting_level) {
+  DCHECK(!IsInitialized());
+  DCHECK(secret_.empty());
+  cohort_ = cohort;
+  secret_ = secret;
+  reporting_level_ = reporting_level;
+}
+
 void RapporService::OnLogInterval() {
   DCHECK(uploader_);
   DVLOG(2) << "RapporService::OnLogInterval";
@@ -136,39 +155,40 @@ void RapporService::RegisterPrefs(PrefRegistrySimple* registry) {
                                        prefs::kRapporLastDailySample);
 }
 
-void RapporService::LoadCohort() {
-  DCHECK(!IsInitialized());
+int32_t RapporService::LoadCohort() {
   // Ignore and delete old cohort parameter.
   pref_service_->ClearPref(prefs::kRapporCohortDeprecated);
 
-  cohort_ = pref_service_->GetInteger(prefs::kRapporCohortSeed);
+  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;
+  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_);
+  cohort = base::RandGenerator(RapporParameters::kMaxCohorts);
+  DVLOG(2) << "Selected a new Rappor cohort: " << cohort;
+  pref_service_->SetInteger(prefs::kRapporCohortSeed, cohort);
+  return cohort;
 }
 
-void RapporService::LoadSecret() {
-  DCHECK(secret_.empty());
+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_);
+    bool decoded = base::Base64Decode(secret_base64, &secret);
     if (decoded && secret_.size() == HmacByteVectorGenerator::kEntropyInputSize)
-      return;
+      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);
+  secret = HmacByteVectorGenerator::GenerateEntropyInput();
+  base::Base64Encode(secret, &secret_base64);
   pref_service_->SetString(prefs::kRapporSecret, secret_base64);
+  return secret;
 }
 
 bool RapporService::ExportMetrics(RapporReports* reports) {
@@ -203,16 +223,21 @@ void RapporService::RecordSample(const std::string& metric_name,
   if (!IsInitialized())
     return;
   DCHECK_LT(type, NUM_RAPPOR_TYPES);
+  const RapporParameters& parameters = kRapporParametersForType[type];
   DVLOG(2) << "Recording sample \"" << sample
            << "\" for metric \"" << metric_name
            << "\" of type: " << type;
-  RecordSampleInternal(metric_name, kRapporParametersForType[type], sample);
+  RecordSampleInternal(metric_name, parameters, sample);
 }
 
 void RapporService::RecordSampleInternal(const std::string& metric_name,
                                          const RapporParameters& parameters,
                                          const std::string& sample) {
   DCHECK(IsInitialized());
+  // Skip this metric if it's reporting level is less than the enabled
+  // reporting level.
+  if (reporting_level_ < parameters.reporting_level)
+    return;
   RapporMetric* metric = LookUpMetric(metric_name, parameters);
   metric->AddSample(sample);
 }