🚫Bind: components/data_reduction_proxy/

Migrates some directories off of deprecated base::Bind, base::Callback,
etc, and onto the newer APIs.

Specifically this covers components/data_reduction_proxy/

Fixed: 1007681
Change-Id: I9c137caef120d3a0d50b905456cdc13543029056
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1979140
Auto-Submit: Ken Rockot <rockot@google.com>
Commit-Queue: rajendrant <rajendrant@chromium.org>
Reviewed-by: rajendrant <rajendrant@chromium.org>
Cr-Commit-Position: refs/heads/master@{#727833}

components/data_reduction_proxy/core/browser/data_reduction_proxy_compression_stats.cc

@@ -333,13 +333,13 @@ void DataReductionProxyCompressionStats::Init() {
 
   data_usage_reporting_enabled_.Init(
       prefs::kDataUsageReportingEnabled, pref_service_,
-      base::Bind(
+      base::BindRepeating(
           &DataReductionProxyCompressionStats::OnDataUsageReportingPrefChanged,
           weak_factory_.GetWeakPtr()));
 
   if (data_usage_reporting_enabled_.GetValue()) {
     current_data_usage_load_status_ = LOADING;
-    service_->LoadCurrentDataUsageBucket(base::Bind(
+    service_->LoadCurrentDataUsageBucket(base::BindRepeating(
         &DataReductionProxyCompressionStats::OnCurrentDataUsageLoaded,
         weak_factory_.GetWeakPtr()));
   }
@@ -522,8 +522,9 @@ void DataReductionProxyCompressionStats::GetContentLengths(
 }
 
 void DataReductionProxyCompressionStats::GetHistoricalDataUsage(
-    const HistoricalDataUsageCallback& get_data_usage_callback) {
-  GetHistoricalDataUsageImpl(get_data_usage_callback, base::Time::Now());
+    HistoricalDataUsageCallback get_data_usage_callback) {
+  GetHistoricalDataUsageImpl(std::move(get_data_usage_callback),
+                             base::Time::Now());
 }
 
 void DataReductionProxyCompressionStats::DeleteBrowsingHistory(
@@ -751,7 +752,7 @@ void DataReductionProxyCompressionStats::DeleteHistoricalDataUsage() {
 }
 
 void DataReductionProxyCompressionStats::GetHistoricalDataUsageImpl(
-    const HistoricalDataUsageCallback& get_data_usage_callback,
+    HistoricalDataUsageCallback get_data_usage_callback,
     const base::Time& now) {
 #if !defined(OS_ANDROID)
   if (current_data_usage_load_status_ != LOADED) {
@@ -759,8 +760,8 @@ void DataReductionProxyCompressionStats::GetHistoricalDataUsageImpl(
     // extension can retry after a slight delay.
     // This use case is unlikely to occur in practice since current data usage
     // should have sufficient time to load before user tries to view data usage.
-    get_data_usage_callback.Run(
-        std::make_unique<std::vector<DataUsageBucket>>());
+    std::move(get_data_usage_callback)
+        .Run(std::make_unique<std::vector<DataUsageBucket>>());
     return;
   }
 #endif
@@ -779,14 +780,14 @@ void DataReductionProxyCompressionStats::GetHistoricalDataUsageImpl(
     service_->StoreCurrentDataUsageBucket(std::move(data_usage_bucket));
   }
 
-  service_->LoadHistoricalDataUsage(get_data_usage_callback);
+  service_->LoadHistoricalDataUsage(std::move(get_data_usage_callback));
 }
 
 void DataReductionProxyCompressionStats::OnDataUsageReportingPrefChanged() {
   if (data_usage_reporting_enabled_.GetValue()) {
     if (current_data_usage_load_status_ == NOT_LOADED) {
       current_data_usage_load_status_ = LOADING;
-      service_->LoadCurrentDataUsageBucket(base::Bind(
+      service_->LoadCurrentDataUsageBucket(base::BindOnce(
           &DataReductionProxyCompressionStats::OnCurrentDataUsageLoaded,
           weak_factory_.GetWeakPtr()));
     }

components/data_reduction_proxy/core/browser/data_reduction_proxy_compression_stats.h

@@ -135,7 +135,7 @@ class DataReductionProxyCompressionStats {
   // in-memory stats could be initialized from storage. Data usage is sorted
   // chronologically with the last entry corresponding to |base::Time::Now()|.
   void GetHistoricalDataUsage(
-      const HistoricalDataUsageCallback& get_data_usage_callback);
+      HistoricalDataUsageCallback get_data_usage_callback);
 
   // Deletes browsing history from storage and memory for the given time
   // range. Currently, this method deletes all data usage for the given range.
@@ -242,7 +242,7 @@ class DataReductionProxyCompressionStats {
   // Actual implementation of |GetHistoricalDataUsage|. This helper method
   // explicitly passes |base::Time::Now()| to make testing easier.
   void GetHistoricalDataUsageImpl(
-      const HistoricalDataUsageCallback& get_data_usage_callback,
+      HistoricalDataUsageCallback get_data_usage_callback,
       const base::Time& now);
 
   // Called when |prefs::kDataUsageReportingEnabled| pref values changes.

components/data_reduction_proxy/core/browser/data_reduction_proxy_compression_stats_unittest.cc

@@ -302,15 +302,15 @@ class DataReductionProxyCompressionStatsTest : public testing::Test {
                                             original_size, time);
   }
 
-  void GetHistoricalDataUsage(
-      const HistoricalDataUsageCallback& onLoadDataUsage,
-      const base::Time& now) {
-    compression_stats_->GetHistoricalDataUsageImpl(onLoadDataUsage, now);
+  void GetHistoricalDataUsage(HistoricalDataUsageCallback on_load_data_usage,
+                              const base::Time& now) {
+    compression_stats_->GetHistoricalDataUsageImpl(
+        std::move(on_load_data_usage), now);
   }
 
-  void LoadHistoricalDataUsage(
-      const HistoricalDataUsageCallback& onLoadDataUsage) {
-    compression_stats_->service_->LoadHistoricalDataUsage(onLoadDataUsage);
+  void LoadHistoricalDataUsage(HistoricalDataUsageCallback on_load_data_usage) {
+    compression_stats_->service_->LoadHistoricalDataUsage(
+        std::move(on_load_data_usage));
   }
 
   void DeleteHistoricalDataUsage() {
@@ -700,8 +700,8 @@ TEST_F(DataReductionProxyCompressionStatsTest, RecordDataUsageSingleSite) {
 
   DataUsageLoadVerifier verifier(std::move(expected_data_usage));
 
-  GetHistoricalDataUsage(base::Bind(&DataUsageLoadVerifier::OnLoadDataUsage,
-                                    base::Unretained(&verifier)),
+  GetHistoricalDataUsage(base::BindOnce(&DataUsageLoadVerifier::OnLoadDataUsage,
+                                        base::Unretained(&verifier)),
                          now);
   base::RunLoop().RunUntilIdle();
 }
@@ -722,15 +722,15 @@ TEST_F(DataReductionProxyCompressionStatsTest, DisableDataUsageRecording) {
       std::make_unique<std::vector<data_reduction_proxy::DataUsageBucket>>(
           kNumExpectedBuckets);
   DataUsageLoadVerifier verifier1(std::move(expected_data_usage1));
-  LoadHistoricalDataUsage(base::Bind(&DataUsageLoadVerifier::OnLoadDataUsage,
-                                     base::Unretained(&verifier1)));
+  LoadHistoricalDataUsage(base::BindOnce(
+      &DataUsageLoadVerifier::OnLoadDataUsage, base::Unretained(&verifier1)));
 
   // Public API must return an empty array.
   auto expected_data_usage2 =
       std::make_unique<std::vector<data_reduction_proxy::DataUsageBucket>>();
   DataUsageLoadVerifier verifier2(std::move(expected_data_usage2));
-  GetHistoricalDataUsage(base::Bind(&DataUsageLoadVerifier::OnLoadDataUsage,
-                                    base::Unretained(&verifier2)),
+  GetHistoricalDataUsage(base::BindOnce(&DataUsageLoadVerifier::OnLoadDataUsage,
+                                        base::Unretained(&verifier2)),
                          now);
 #else
   // For Android don't delete data usage.
@@ -747,8 +747,8 @@ TEST_F(DataReductionProxyCompressionStatsTest, DisableDataUsageRecording) {
 
   DataUsageLoadVerifier verifier(std::move(expected_data_usage));
 
-  GetHistoricalDataUsage(base::Bind(&DataUsageLoadVerifier::OnLoadDataUsage,
-                                    base::Unretained(&verifier)),
+  GetHistoricalDataUsage(base::BindOnce(&DataUsageLoadVerifier::OnLoadDataUsage,
+                                        base::Unretained(&verifier)),
                          now);
 #endif
 
@@ -787,8 +787,8 @@ TEST_F(DataReductionProxyCompressionStatsTest, RecordDataUsageMultipleSites) {
 
   DataUsageLoadVerifier verifier(std::move(expected_data_usage));
 
-  GetHistoricalDataUsage(base::Bind(&DataUsageLoadVerifier::OnLoadDataUsage,
-                                    base::Unretained(&verifier)),
+  GetHistoricalDataUsage(base::BindOnce(&DataUsageLoadVerifier::OnLoadDataUsage,
+                                        base::Unretained(&verifier)),
                          now);
   base::RunLoop().RunUntilIdle();
 }
@@ -825,8 +825,8 @@ TEST_F(DataReductionProxyCompressionStatsTest,
 
   DataUsageLoadVerifier verifier(std::move(expected_data_usage));
 
-  GetHistoricalDataUsage(base::Bind(&DataUsageLoadVerifier::OnLoadDataUsage,
-                                    base::Unretained(&verifier)),
+  GetHistoricalDataUsage(base::BindOnce(&DataUsageLoadVerifier::OnLoadDataUsage,
+                                        base::Unretained(&verifier)),
                          now);
   base::RunLoop().RunUntilIdle();
 }
@@ -856,8 +856,8 @@ TEST_F(DataReductionProxyCompressionStatsTest,
 
   DataUsageLoadVerifier verifier(std::move(expected_data_usage));
 
-  GetHistoricalDataUsage(base::Bind(&DataUsageLoadVerifier::OnLoadDataUsage,
-                                    base::Unretained(&verifier)),
+  GetHistoricalDataUsage(base::BindOnce(&DataUsageLoadVerifier::OnLoadDataUsage,
+                                        base::Unretained(&verifier)),
                          now);
   base::RunLoop().RunUntilIdle();
 }
@@ -881,8 +881,8 @@ TEST_F(DataReductionProxyCompressionStatsTest, DeleteHistoricalDataUsage) {
           kNumExpectedBuckets);
   DataUsageLoadVerifier verifier(std::move(expected_data_usage));
 
-  GetHistoricalDataUsage(base::Bind(&DataUsageLoadVerifier::OnLoadDataUsage,
-                                    base::Unretained(&verifier)),
+  GetHistoricalDataUsage(base::BindOnce(&DataUsageLoadVerifier::OnLoadDataUsage,
+                                        base::Unretained(&verifier)),
                          now);
   base::RunLoop().RunUntilIdle();
 }
@@ -918,8 +918,8 @@ TEST_F(DataReductionProxyCompressionStatsTest, DeleteBrowsingHistory) {
   site_usage->set_original_size(1100);
   DataUsageLoadVerifier verifier1(std::move(expected_data_usage));
 
-  LoadHistoricalDataUsage(base::Bind(&DataUsageLoadVerifier::OnLoadDataUsage,
-                                     base::Unretained(&verifier1)));
+  LoadHistoricalDataUsage(base::BindOnce(
+      &DataUsageLoadVerifier::OnLoadDataUsage, base::Unretained(&verifier1)));
   base::RunLoop().RunUntilIdle();
 
   // This should delete in-storage usage as well.
@@ -930,8 +930,8 @@ TEST_F(DataReductionProxyCompressionStatsTest, DeleteBrowsingHistory) {
       std::make_unique<std::vector<data_reduction_proxy::DataUsageBucket>>(
           kNumExpectedBuckets);
   DataUsageLoadVerifier verifier2(std::move(expected_data_usage));
-  LoadHistoricalDataUsage(base::Bind(&DataUsageLoadVerifier::OnLoadDataUsage,
-                                     base::Unretained(&verifier2)));
+  LoadHistoricalDataUsage(base::BindOnce(
+      &DataUsageLoadVerifier::OnLoadDataUsage, base::Unretained(&verifier2)));
   base::RunLoop().RunUntilIdle();
 }
 
@@ -965,8 +965,8 @@ TEST_F(DataReductionProxyCompressionStatsTest, ClearDataSavingStatistics) {
           kNumExpectedBuckets);
   DataUsageLoadVerifier verifier(std::move(expected_data_usage));
 
-  GetHistoricalDataUsage(base::Bind(&DataUsageLoadVerifier::OnLoadDataUsage,
-                                    base::Unretained(&verifier)),
+  GetHistoricalDataUsage(base::BindOnce(&DataUsageLoadVerifier::OnLoadDataUsage,
+                                        base::Unretained(&verifier)),
                          now);
   base::RunLoop().RunUntilIdle();
 

components/data_reduction_proxy/core/browser/data_reduction_proxy_config.cc

@@ -347,9 +347,9 @@ void DataReductionProxyConfig::SetProxyConfig(bool enabled, bool at_startup) {
     // It is safe to use base::Unretained here, since it gets executed
     // synchronously on the IO thread, and |this| outlives
     // |secure_proxy_checker_|.
-    SecureProxyCheck(
-        base::Bind(&DataReductionProxyConfig::HandleSecureProxyCheckResponse,
-                   base::Unretained(this)));
+    SecureProxyCheck(base::BindRepeating(
+        &DataReductionProxyConfig::HandleSecureProxyCheckResponse,
+        base::Unretained(this)));
   }
   network_properties_manager_->ResetWarmupURLFetchMetrics();
   FetchWarmupProbeURL();
@@ -601,9 +601,9 @@ void DataReductionProxyConfig::ContinueNetworkChanged(
     // It is safe to use base::Unretained here, since it gets executed
     // synchronously on the IO thread, and |this| outlives
     // |secure_proxy_checker_|.
-    SecureProxyCheck(
-        base::Bind(&DataReductionProxyConfig::HandleSecureProxyCheckResponse,
-                   base::Unretained(this)));
+    SecureProxyCheck(base::BindRepeating(
+        &DataReductionProxyConfig::HandleSecureProxyCheckResponse,
+        base::Unretained(this)));
   }
 }
 

components/data_reduction_proxy/core/browser/data_reduction_proxy_config_service_client.h

@@ -44,7 +44,7 @@ class DataReductionProxyService;
 class DataReductionProxyMutableConfigValues;
 class DataReductionProxyRequestOptions;
 
-typedef base::Callback<void(const std::string&)> ConfigStorer;
+using ConfigStorer = base::RepeatingCallback<void(const std::string&)>;
 
 // Retrieves the default net::BackoffEntry::Policy for the Data Reduction Proxy
 // configuration service client.

components/data_reduction_proxy/core/browser/data_reduction_proxy_service.cc

@@ -321,7 +321,7 @@ void DataReductionProxyService::AddCustomProxyConfigClient(
 }
 
 void DataReductionProxyService::LoadHistoricalDataUsage(
-    const HistoricalDataUsageCallback& load_data_usage_callback) {
+    HistoricalDataUsageCallback load_data_usage_callback) {
   std::unique_ptr<std::vector<DataUsageBucket>> data_usage(
       new std::vector<DataUsageBucket>());
   std::vector<DataUsageBucket>* data_usage_ptr = data_usage.get();
@@ -330,11 +330,12 @@ void DataReductionProxyService::LoadHistoricalDataUsage(
       base::BindOnce(&DBDataOwner::LoadHistoricalDataUsage,
                      db_data_owner_->GetWeakPtr(),
                      base::Unretained(data_usage_ptr)),
-      base::BindOnce(load_data_usage_callback, std::move(data_usage)));
+      base::BindOnce(std::move(load_data_usage_callback),
+                     std::move(data_usage)));
 }
 
 void DataReductionProxyService::LoadCurrentDataUsageBucket(
-    const LoadCurrentDataUsageCallback& load_current_data_usage_callback) {
+    LoadCurrentDataUsageCallback load_current_data_usage_callback) {
   std::unique_ptr<DataUsageBucket> bucket(new DataUsageBucket());
   DataUsageBucket* bucket_ptr = bucket.get();
   db_task_runner_->PostTaskAndReply(
@@ -342,7 +343,8 @@ void DataReductionProxyService::LoadCurrentDataUsageBucket(
       base::BindOnce(&DBDataOwner::LoadCurrentDataUsageBucket,
                      db_data_owner_->GetWeakPtr(),
                      base::Unretained(bucket_ptr)),
-      base::BindOnce(load_current_data_usage_callback, std::move(bucket)));
+      base::BindOnce(std::move(load_current_data_usage_callback),
+                     std::move(bucket)));
 }
 
 void DataReductionProxyService::StoreCurrentDataUsageBucket(

components/data_reduction_proxy/core/browser/data_reduction_proxy_service.h

@@ -119,9 +119,9 @@ class DataReductionProxyService
   virtual void SetProxyPrefs(bool enabled, bool at_startup);
 
   void LoadHistoricalDataUsage(
-      const HistoricalDataUsageCallback& load_data_usage_callback);
+      HistoricalDataUsageCallback load_data_usage_callback);
   void LoadCurrentDataUsageBucket(
-      const LoadCurrentDataUsageCallback& load_current_data_usage_callback);
+      LoadCurrentDataUsageCallback load_current_data_usage_callback);
   void StoreCurrentDataUsageBucket(std::unique_ptr<DataUsageBucket> current);
   void DeleteHistoricalDataUsage();
   void DeleteBrowsingHistory(const base::Time& start, const base::Time& end);

components/data_reduction_proxy/core/browser/data_reduction_proxy_settings.h

@@ -80,7 +80,7 @@ class DataReductionProxySettingsObserver {
 class DataReductionProxySettings {
  public:
   using SyntheticFieldTrialRegistrationCallback =
-      base::Callback<bool(base::StringPiece, base::StringPiece)>;
+      base::RepeatingCallback<bool(base::StringPiece, base::StringPiece)>;
 
   explicit DataReductionProxySettings(bool is_off_the_record_profile);
   virtual ~DataReductionProxySettings();

components/data_reduction_proxy/core/browser/data_reduction_proxy_settings_test_utils.cc

@@ -126,7 +126,7 @@ void DataReductionProxySettingsTestBase::InitDataReductionProxy(
   settings_->InitDataReductionProxySettings(
       test_context_->pref_service(),
       std::move(settings_->data_reduction_proxy_service_));
-  settings_->SetCallbackToRegisterSyntheticFieldTrial(base::Bind(
+  settings_->SetCallbackToRegisterSyntheticFieldTrial(base::BindRepeating(
       &DataReductionProxySettingsTestBase::OnSyntheticFieldTrialRegistration,
       base::Unretained(this)));
 

components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.cc

@@ -468,8 +468,8 @@ DataReductionProxyTestContext::Builder::Build() {
     config_client.reset(new DataReductionProxyConfigServiceClient(
         GetBackoffPolicy(), request_options.get(), raw_mutable_config,
         config.get(), service.get(), test_network_connection_tracker,
-        base::Bind(&TestConfigStorer::StoreSerializedConfig,
-                   base::Unretained(config_storer.get()))));
+        base::BindRepeating(&TestConfigStorer::StoreSerializedConfig,
+                            base::Unretained(config_storer.get()))));
   }
 
   service->SetDependenciesForTesting(

components/data_reduction_proxy/core/browser/db_data_owner.h

@@ -19,12 +19,12 @@ class DataUsageBucket;
 class DataUsageStore;
 
 // Callback for loading the historical data usage.
-typedef base::Callback<void(std::unique_ptr<std::vector<DataUsageBucket>>)>
-    HistoricalDataUsageCallback;
+using HistoricalDataUsageCallback =
+    base::OnceCallback<void(std::unique_ptr<std::vector<DataUsageBucket>>)>;
 
 // Callback for loading data usage for the current bucket.
-typedef base::Callback<void(std::unique_ptr<DataUsageBucket>)>
-    LoadCurrentDataUsageCallback;
+using LoadCurrentDataUsageCallback =
+    base::OnceCallback<void(std::unique_ptr<DataUsageBucket>)>;
 
 // Contains and initializes all Data Reduction Proxy objects that have a
 // lifetime based on the DB task runner.