Fix reporting_level_ initialization

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 90 matching lines @@
   }
   // 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_);
-  Initialize(LoadCohort(), LoadSecret(), reporting_level_);
+  Initialize(LoadCohort(), LoadSecret(), reporting_level);
   uploader_.reset(new LogUploader(server_url, kMimeType, request_context));
   log_rotation_timer_.Start(
       FROM_HERE,
       base::TimeDelta::FromSeconds(kInitialLogIntervalSeconds),
       this,
       &RapporService::OnLogInterval);
 }
 
 void RapporService::Initialize(int32_t cohort,
                                const std::string& secret,
@@ skipping 63 matching lines @@
   }
 
   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())
+  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 =
            metrics_map_.begin();
        it != metrics_map_.end();
        ++it) {
     const RapporMetric* metric = it->second;
     RapporReports::Report* report = reports->add_report();
@@ skipping 22 matching lines @@
            << "\" of type: " << type;
   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)
+  if (reporting_level_ < parameters.reporting_level) {
+    DVLOG(2) << "Metric not logged due to reporting_level "
+             << reporting_level_ << " < " << parameters.reporting_level;
     return;
+  }
   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