Create a mechanism for reporting rappor metrics from non-UMA

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 19 matching lines @@
 const char kMimeType[] = "application/vnd.chrome.rappor";
 
 const char kRapporDailyEventHistogram[] = "Rappor.DailyEvent.IntervalType";
 
 // Constants for the RAPPOR rollout field trial.
 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);
   if (!server_url.empty())
     return GURL(server_url);
   else
     return GURL(kDefaultServerUrl);
 }
 
 const RapporParameters kRapporParametersForType[NUM_RAPPOR_TYPES] = {
     // ETLD_PLUS_ONE_RAPPOR_TYPE
     {128 /* Num cohorts */,
      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 */},
+     rappor::PROBABILITY_25 /* Zero coin probability */,
+     false /* Require UMA */},
+    // FULL_POPULATION_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 */,
+     true /* Don't require UMA */},
 };
 
 }  // namespace
 
 RapporService::RapporService(PrefService* pref_service)
     : pref_service_(pref_service),
       cohort_(-1),
       daily_event_(pref_service,
-                      prefs::kRapporLastDailySample,
-                      kRapporDailyEventHistogram) {
+                   prefs::kRapporLastDailySample,
+                   kRapporDailyEventHistogram),
+      all_metrics_enabled_(false) {
 }
 
 RapporService::~RapporService() {
   STLDeleteValues(&metrics_map_);
 }
 
 void RapporService::AddDailyObserver(
     scoped_ptr<metrics::DailyEvent::Observer> observer) {
   daily_event_.AddObserver(observer.Pass());
 }
 
 void RapporService::Start(net::URLRequestContextGetter* request_context,
                           bool metrics_enabled) {

[Alexei Svitkine (slow), 2014/11/03 21:48:21]

Can you document the 2nd param better in the header file?

[Steven Holte, 2014/11/04 02:44:19]

Done.

-  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;
   }
+  all_metrics_enabled_ = metrics_enabled;
+  DVLOG(1) << "RapporService all_metrics_enabled_? " << all_metrics_enabled_;
   DVLOG(1) << "RapporService started. Reporting to " << server_url.spec();
   DCHECK(!uploader_);
   LoadSecret();
   LoadCohort();
   uploader_.reset(new LogUploader(server_url, kMimeType, request_context));
   log_rotation_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromSeconds(kInitialLogIntervalSeconds),
       this,
       &RapporService::OnLogInterval);
@@ skipping 87 matching lines @@
   return cohort_ >= 0;
 }
 
 void RapporService::RecordSample(const std::string& metric_name,
                                  RapporType type,
                                  const std::string& sample) {
   // Ignore the sample if the service hasn't started yet.
   if (!IsInitialized())
     return;
   DCHECK_LT(type, NUM_RAPPOR_TYPES);
+  const RapporParameters& parameters = kRapporParametersForType[type];
+  // Skip this metric if all metrics aren't enabled and this isn't a
+  // whitelisted metric.
+  if (!all_metrics_enabled_ && !parameters.always_enabled)

[Alexei Svitkine (slow), 2014/11/03 21:48:21]

Can you add a test for this?

[Steven Holte, 2014/11/04 02:44:20]

Done.

+    return;
   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());
   RapporMetric* metric = LookUpMetric(metric_name, parameters);
   metric->AddSample(sample);
 }
 
 RapporMetric* RapporService::LookUpMetric(const std::string& metric_name,
                                           const RapporParameters& parameters) {
   DCHECK(IsInitialized());
   std::map<std::string, RapporMetric*>::const_iterator it =
       metrics_map_.find(metric_name);
   if (it != metrics_map_.end()) {
     RapporMetric* metric = it->second;
     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