[Reland] Refactoring of SBER preference usage

chrome/browser/safe_browsing/incident_reporting/incident_reporting_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 "chrome/browser/safe_browsing/incident_reporting/incident_reporting_service.h"
 
 #include <math.h>
 #include <stddef.h>
 
 #include <algorithm>
@@ skipping 21 matching lines @@
 #include "chrome/browser/safe_browsing/incident_reporting/incident_receiver.h"
 #include "chrome/browser/safe_browsing/incident_reporting/incident_report_uploader_impl.h"
 #include "chrome/browser/safe_browsing/incident_reporting/preference_validation_delegate.h"
 #include "chrome/browser/safe_browsing/incident_reporting/state_store.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/chrome_features.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_browsing_db/database_manager.h"
+#include "components/safe_browsing_db/safe_browsing_prefs.h"
 #include "components/user_prefs/tracked/tracked_preference_validation_delegate.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace safe_browsing {
 
 #if !defined(GOOGLE_CHROME_BUILD)
 // Chromium-only flag to disable incident uploads.
 extern const base::Feature kIncidentReportingDisableUpload{
@@ skipping 76 matching lines @@
 
 bool ProfileCanAcceptIncident(Profile* profile, const Incident& incident) {
   if (profile->IsOffTheRecord())
     return false;
   if (!profile->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled))
     return false;
   switch (incident.GetMinimumProfileConsent()) {
     case MinimumProfileConsent::SAFE_BROWSING_ENABLED:
       return true;
     case MinimumProfileConsent::SAFE_BROWSING_EXTENDED_REPORTING_ENABLED:
-      return profile->GetPrefs()->GetBoolean(
-          prefs::kSafeBrowsingExtendedReportingEnabled);
+      return IsExtendedReportingEnabled(*profile->GetPrefs());
   }
   NOTREACHED();
   return false;
 }
 
 // Returns the shutdown behavior for the task runners of the incident reporting
 // service. Current metrics suggest that CONTINUE_ON_SHUTDOWN will reduce the
 // number of browser hangs on shutdown.
 base::SequencedWorkerPool::WorkerShutdown GetShutdownBehavior() {
   return base::FeatureList::IsEnabled(features::kBrowserHangFixesExperiment)
@@ skipping 171 matching lines @@
 }
 
 // static
 bool IncidentReportingService::IsEnabledForProfile(Profile* profile) {
   if (profile->IsOffTheRecord())
     return false;
   if (!profile->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled))
     return false;
   if (IsFieldTrialEnabled())
     return true;
-  return profile->GetPrefs()->GetBoolean(
-      prefs::kSafeBrowsingExtendedReportingEnabled);
+  return IsExtendedReportingEnabled(*profile->GetPrefs());
 }
 
 IncidentReportingService::IncidentReportingService(
     SafeBrowsingService* safe_browsing_service)
     : database_manager_(safe_browsing_service
                             ? safe_browsing_service->database_manager()
                             : nullptr),
       url_request_context_getter_(
           safe_browsing_service ? safe_browsing_service->url_request_context()
                                 : nullptr),
@@ skipping 91 matching lines @@
 
   // |callback| will be run on the blocking pool. The receiver will bounce back
   // to the origin thread if needed.
   extended_reporting_only_delayed_analysis_callbacks_.RegisterCallback(
       base::Bind(callback, base::Passed(GetIncidentReceiver())));
 
   // Start running the callbacks if any profiles have opted into Safebrowsing
   // extended reporting. If none are now, running will commence if/when such a
   // profile is added.
   Profile* profile = FindEligibleProfile();
-  if (profile &&
-      profile->GetPrefs()->GetBoolean(
-          prefs::kSafeBrowsingExtendedReportingEnabled)) {
+  if (profile && IsExtendedReportingEnabled(*profile->GetPrefs())) {
     extended_reporting_only_delayed_analysis_callbacks_.Start();
   }
 }
 
 void IncidentReportingService::AddDownloadManager(
     content::DownloadManager* download_manager) {
   download_metadata_manager_.AddDownloadManager(download_manager);
 }
 
 IncidentReportingService::IncidentReportingService(
@@ skipping 69 matching lines @@
       LogIncidentDataType(DROPPED, *incident);
     context->incidents.clear();
   }
 
   if (enabled_for_profile) {
     // Start processing delayed analysis callbacks if incident reporting is
     // enabled for this new profile. Start is idempotent, so this is safe even
     // if they're already running.
     delayed_analysis_callbacks_.Start();
 
-    if (profile->GetPrefs()->GetBoolean(
-            prefs::kSafeBrowsingExtendedReportingEnabled)) {
+    if (IsExtendedReportingEnabled(*profile->GetPrefs())) {
       extended_reporting_only_delayed_analysis_callbacks_.Start();
     }
 
     // Start a new report if there are process-wide incidents, or incidents for
     // this profile.
     if ((GetProfileContext(nullptr) &&
          GetProfileContext(nullptr)->HasIncidents()) ||
         context->HasIncidents()) {
       BeginReportProcessing();
     }
@@ skipping 85 matching lines @@
     // Skip over profiles that have yet to be added to the profile manager.
     // This will also skip over the NULL-profile context used to hold
     // process-wide incidents.
     if (!scan->second->added)
       continue;
     // Also skip over profiles for which IncidentReporting is not enabled.
     if (!IsEnabledForProfile(scan->first))
       continue;
     // If the current profile has Extended Reporting enabled, stop looking and
     // use that one.
-    if (scan->first->GetPrefs()->GetBoolean(
-            prefs::kSafeBrowsingExtendedReportingEnabled)) {
+    if (IsExtendedReportingEnabled(*scan->first->GetPrefs())) {
       return scan->first;
     }
     // Otherwise, store this one as a candidate and keep looking (in case we
     // find one with Extended Reporting enabled).
     candidate = scan->first;
   }
 
   return candidate;
 }
 
@@ skipping 252 matching lines @@
 
   ClientIncidentReport_EnvironmentData_Process* process =
       report->mutable_environment()->mutable_process();
 
   process->set_metrics_consent(
       ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled());
 
   // Find the profile that benefits from the strongest protections.
   Profile* eligible_profile = FindEligibleProfile();
   process->set_extended_consent(
-      eligible_profile ? eligible_profile->GetPrefs()->GetBoolean(
-                             prefs::kSafeBrowsingExtendedReportingEnabled) :
-                       false);
+      eligible_profile &&
+      IsExtendedReportingEnabled(*eligible_profile->GetPrefs()));
 
   process->set_field_trial_participant(enabled_by_field_trial_);
 
   // Associate process-wide incidents with the profile that benefits from the
   // strongest safe browsing protections. If there is no such profile, drop the
   // incidents.
   ProfileContext* null_context = GetProfileContext(nullptr);
   if (null_context && null_context->HasIncidents()) {
     if (eligible_profile) {
       ProfileContext* eligible_context = GetProfileContext(eligible_profile);
@@ skipping 211 matching lines @@
       if (!profile->IsOffTheRecord())
         OnProfileDestroyed(profile);
       break;
     }
     default:
       break;
   }
 }
 
 }  // namespace safe_browsing