Propogate RAPPOR permission changes

chrome/browser/metrics/metrics_services_manager.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 "chrome/browser/metrics/metrics_services_manager.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 40 matching lines @@
 // Posts |GoogleUpdateSettings::StoreMetricsClientInfo| on blocking pool thread
 // because it needs access to IO and cannot work from UI thread.
 void PostStoreMetricsClientInfo(const metrics::ClientInfo& client_info) {
   content::BrowserThread::GetBlockingPool()->PostTask(FROM_HERE,
       base::Bind(&GoogleUpdateSettings::StoreMetricsClientInfo, client_info));
 }
 
 }  // namespace
 
 MetricsServicesManager::MetricsServicesManager(PrefService* local_state)
-    : local_state_(local_state) {
+    : local_state_(local_state),
+      may_upload_(false),
+      may_record_(false) {
   DCHECK(local_state);
+  pref_change_registrar_.Init(local_state);
+  pref_change_registrar_.Add(rappor::prefs::kRapporEnabled,
+      base::Bind(&MetricsServicesManager::UpdateRapporService,
+                 base::Unretained(this)));
 }
 
 MetricsServicesManager::~MetricsServicesManager() {
 }
 
 metrics::MetricsService* MetricsServicesManager::GetMetricsService() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return GetChromeMetricsServiceClient()->metrics_service();
 }
 
@@ skipping 64 matching lines @@
                         rappor::FINE_LEVEL :
                         rappor::COARSE_LEVEL;
     }
   } else if (metrics_enabled) {
     recording_level = rappor::FINE_LEVEL;
   }
 #endif  // defined(GOOGLE_CHROME_BUILD)
   return recording_level;
 }
 
+void MetricsServicesManager::UpdateRapporService() {
+  GetRapporService()->Update(GetRapporRecordingLevel(may_record_), may_upload_);
+}
+
 void MetricsServicesManager::UpdatePermissions(bool may_record,
                                                bool may_upload) {
+  // Stash the current permissions so that we can update the RapporService
+  // correctly when the Rappor preference changes.  The metrics recording
+  // preference partially determines the initial rappor setting, and also
+  // controls whether FINE metrics are sent.
+  may_record_ = may_record;
+  may_upload_ = may_upload;
+
   metrics::MetricsService* metrics = GetMetricsService();
 
   const base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
 
   const bool only_do_metrics_recording =
       cmdline->HasSwitch(switches::kMetricsRecordingOnly) ||
       cmdline->HasSwitch(switches::kEnableBenchmarking);
 
   if (only_do_metrics_recording) {
     metrics->StartRecordingForTests();
     GetRapporService()->Update(rappor::FINE_LEVEL, false);
     return;
   }
 
   if (may_record) {
     if (!metrics->recording_active())
       metrics->Start();
 
     if (may_upload)
       metrics->EnableReporting();
     else
       metrics->DisableReporting();
   } else if (metrics->recording_active() || metrics->reporting_active()) {
     metrics->Stop();
   }
 
-  GetRapporService()->Update(GetRapporRecordingLevel(may_record), may_upload);
+  UpdateRapporService();
 }
 
 void MetricsServicesManager::UpdateUploadPermissions(bool may_upload) {
   return UpdatePermissions(
       ChromeMetricsServiceAccessor::IsMetricsReportingEnabled(), may_upload);
 }