Remove Safebrowsing Rappor support

components/rappor/rappor_service_impl.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_impl.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
@@ skipping 41 matching lines @@
 
 RapporServiceImpl::RapporServiceImpl(
     PrefService* pref_service,
     const base::Callback<bool(void)> is_incognito_callback)
     : pref_service_(pref_service),
       is_incognito_callback_(is_incognito_callback),
       cohort_(-1),
       daily_event_(pref_service,
                    prefs::kRapporLastDailySample,
                    kRapporDailyEventHistogram),
-      recording_groups_(0) {}
+      recording_enabled_(false) {}
 
 RapporServiceImpl::~RapporServiceImpl() {}
 
 void RapporServiceImpl::AddDailyObserver(
     std::unique_ptr<metrics::DailyEvent::Observer> observer) {
   daily_event_.AddObserver(std::move(observer));
 }
 
 void RapporServiceImpl::Initialize(
     net::URLRequestContextGetter* request_context) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!IsInitialized());
   const GURL server_url = GetServerUrl();
   if (!server_url.is_valid()) {
     DVLOG(1) << server_url.spec() << " is invalid. "
              << "RapporServiceImpl not started.";
     return;
   }
   DVLOG(1) << "RapporServiceImpl reporting to " << server_url.spec();
   InitializeInternal(
       base::MakeUnique<LogUploader>(server_url, kMimeType, request_context),
       internal::LoadCohort(pref_service_), internal::LoadSecret(pref_service_));
 }
 
-void RapporServiceImpl::Update(int recording_groups, bool may_upload) {
+void RapporServiceImpl::Update(bool may_record, bool may_upload) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsInitialized());
-  if (recording_groups_ != recording_groups) {
-    if (recording_groups == 0) {
+  if (recording_enabled_ != may_record) {
+    recording_enabled_ = may_record;
+    if (!may_record) {
       DVLOG(1) << "Rappor service stopped because all groups were disabled.";
-      recording_groups_ = 0;
       CancelNextLogRotation();
-    } else if (recording_groups_ == 0) {
-      DVLOG(1) << "RapporServiceImpl started for groups: " << recording_groups;
-      recording_groups_ = recording_groups;
+    } else {
+      DVLOG(1) << "RapporServiceImpl started.";
       ScheduleNextLogRotation(
           base::TimeDelta::FromSeconds(kInitialLogIntervalSeconds));
-    } else {
-      DVLOG(1) << "RapporServiceImpl recording_groups changed:"
-               << recording_groups;
-      recording_groups_ = recording_groups;
     }
   }
 
-  DVLOG(1) << "RapporServiceImpl recording_groups=" << recording_groups_
+  DVLOG(1) << "RapporServiceImpl recording_groups=" << recording_enabled_
            << " may_upload=" << may_upload;
   if (may_upload) {
     uploader_->Start();
   } else {
     uploader_->Stop();
   }
 }
 
 // static
 void RapporServiceImpl::RegisterPrefs(PrefRegistrySimple* registry) {
@@ skipping 66 matching lines @@
   return cohort_ >= 0;
 }
 
 bool RapporServiceImpl::RecordingAllowed(const RapporParameters& parameters) {
   // Skip recording in incognito mode.
   if (is_incognito_callback_.Run()) {
     DVLOG(2) << "Metric not logged due to incognito mode.";
     return false;
   }
   // Skip this metric if its recording_group is not enabled.
-  if (!(recording_groups_ & parameters.recording_group)) {
-    DVLOG(2) << "Metric not logged due to recording_group " << recording_groups_
-             << " < " << parameters.recording_group;
+  if (!recording_enabled_) {
+    DVLOG(2) << "Metric not logged due to recording_enabled_ = false.";
     return false;
   }
   return true;
 }
 
 void RapporServiceImpl::RecordSampleString(const std::string& metric_name,
                                            RapporType type,
                                            const std::string& sample) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Ignore the sample if the service hasn't started yet.
@@ skipping 44 matching lines @@
 void RapporServiceImpl::RecordSample(const std::string& metric_name,
                                      std::unique_ptr<Sample> sample) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!RecordingAllowed(sample->parameters()))
     return;
   DVLOG(1) << "Recording sample of metric \"" << metric_name << "\"";
   sampler_.AddSample(metric_name, std::move(sample));
 }
 
 }  // namespace rappor