Convert //components/data_reduction_proxy from scoped_ptr to std::unique_ptr

components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.cc

Index: components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.cc
diff --git a/components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.cc b/components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.cc
index fa03b6b2a83975a4f589f762463820ab47deaaee..1fe2e45e24fac90034c16bda71f684f6a39a02bf 100644
--- a/components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.cc
+++ b/components/data_reduction_proxy/core/browser/data_reduction_proxy_test_utils.cc
@@ -8,6 +8,7 @@
 #include <utility>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_compression_stats.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_config_service_client.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_config_test_utils.h"
@@ -93,7 +94,7 @@ MockDataReductionProxyRequestOptions::~MockDataReductionProxyRequestOptions() {
 
 TestDataReductionProxyConfigServiceClient::
     TestDataReductionProxyConfigServiceClient(
-        scoped_ptr<DataReductionProxyParams> params,
+        std::unique_ptr<DataReductionProxyParams> params,
         DataReductionProxyRequestOptions* request_options,
         DataReductionProxyMutableConfigValues* config_values,
         DataReductionProxyConfig* config,
@@ -197,7 +198,7 @@ MockDataReductionProxyService::MockDataReductionProxyService(
     : DataReductionProxyService(settings,
                                 prefs,
                                 request_context,
-                                make_scoped_ptr(new TestDataStore()),
+                                base::WrapUnique(new TestDataStore()),
                                 task_runner,
                                 task_runner,
                                 task_runner,
@@ -208,11 +209,11 @@ MockDataReductionProxyService::~MockDataReductionProxyService() {
 
 TestDataReductionProxyIOData::TestDataReductionProxyIOData(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    scoped_ptr<DataReductionProxyConfig> config,
-    scoped_ptr<DataReductionProxyEventCreator> event_creator,
-    scoped_ptr<DataReductionProxyRequestOptions> request_options,
-    scoped_ptr<DataReductionProxyConfigurator> configurator,
-    scoped_ptr<DataReductionProxyConfigServiceClient> config_client,
+    std::unique_ptr<DataReductionProxyConfig> config,
+    std::unique_ptr<DataReductionProxyEventCreator> event_creator,
+    std::unique_ptr<DataReductionProxyRequestOptions> request_options,
+    std::unique_ptr<DataReductionProxyConfigurator> configurator,
+    std::unique_ptr<DataReductionProxyConfigServiceClient> config_client,
     net::NetLog* net_log,
     bool enabled)
     : DataReductionProxyIOData(), service_set_(false) {
@@ -363,7 +364,7 @@ DataReductionProxyTestContext::Builder::SkipSettingsInitialization() {
   return *this;
 }
 
-scoped_ptr<DataReductionProxyTestContext>
+std::unique_ptr<DataReductionProxyTestContext>
 DataReductionProxyTestContext::Builder::Build() {
   // Check for invalid builder combinations.
   DCHECK(!(use_mock_config_ && use_config_client_));
@@ -372,16 +373,16 @@ DataReductionProxyTestContext::Builder::Build() {
   scoped_refptr<base::SingleThreadTaskRunner> task_runner =
       base::ThreadTaskRunnerHandle::Get();
   scoped_refptr<net::URLRequestContextGetter> request_context_getter;
-  scoped_ptr<TestingPrefServiceSimple> pref_service(
+  std::unique_ptr<TestingPrefServiceSimple> pref_service(
       new TestingPrefServiceSimple());
-  scoped_ptr<net::TestNetLog> net_log(new net::TestNetLog());
-  scoped_ptr<TestConfigStorer> config_storer(
+  std::unique_ptr<net::TestNetLog> net_log(new net::TestNetLog());
+  std::unique_ptr<TestConfigStorer> config_storer(
       new TestConfigStorer(pref_service.get()));
   if (request_context_) {
     request_context_getter = new net::TrivialURLRequestContextGetter(
         request_context_, task_runner);
   } else {
-    scoped_ptr<net::TestURLRequestContext> test_request_context(
+    std::unique_ptr<net::TestURLRequestContext> test_request_context(
         new net::TestURLRequestContext(true));
     if (mock_socket_factory_)
       test_request_context->set_client_socket_factory(mock_socket_factory_);
@@ -390,11 +391,11 @@ DataReductionProxyTestContext::Builder::Build() {
         task_runner, std::move(test_request_context));
   }
 
-  scoped_ptr<TestDataReductionProxyEventStorageDelegate> storage_delegate(
+  std::unique_ptr<TestDataReductionProxyEventStorageDelegate> storage_delegate(
       new TestDataReductionProxyEventStorageDelegate());
-  scoped_ptr<DataReductionProxyEventCreator> event_creator(
+  std::unique_ptr<DataReductionProxyEventCreator> event_creator(
       new DataReductionProxyEventCreator(storage_delegate.get()));
-  scoped_ptr<DataReductionProxyConfigurator> configurator;
+  std::unique_ptr<DataReductionProxyConfigurator> configurator;
   if (use_test_configurator_) {
     test_context_flags |= USE_TEST_CONFIGURATOR;
     configurator.reset(new TestDataReductionProxyConfigurator(
@@ -404,15 +405,15 @@ DataReductionProxyTestContext::Builder::Build() {
         new DataReductionProxyConfigurator(net_log.get(), event_creator.get()));
   }
 
-  scoped_ptr<TestDataReductionProxyConfig> config;
-  scoped_ptr<DataReductionProxyConfigServiceClient> config_client;
+  std::unique_ptr<TestDataReductionProxyConfig> config;
+  std::unique_ptr<DataReductionProxyConfigServiceClient> config_client;
   DataReductionProxyMutableConfigValues* raw_mutable_config = nullptr;
-  scoped_ptr<TestDataReductionProxyParams> params(
+  std::unique_ptr<TestDataReductionProxyParams> params(
       new TestDataReductionProxyParams(params_flags_, params_definitions_));
   TestDataReductionProxyParams* raw_params = params.get();
   if (use_config_client_) {
     test_context_flags |= USE_CONFIG_CLIENT;
-    scoped_ptr<DataReductionProxyMutableConfigValues> mutable_config =
+    std::unique_ptr<DataReductionProxyMutableConfigValues> mutable_config =
         DataReductionProxyMutableConfigValues::CreateFromParams(params.get());
     raw_mutable_config = mutable_config.get();
     config.reset(new TestDataReductionProxyConfig(
@@ -429,7 +430,7 @@ DataReductionProxyTestContext::Builder::Build() {
         event_creator.get()));
   }
 
-  scoped_ptr<DataReductionProxyRequestOptions> request_options;
+  std::unique_ptr<DataReductionProxyRequestOptions> request_options;
   if (use_mock_request_options_) {
     test_context_flags |= USE_MOCK_REQUEST_OPTIONS;
     request_options.reset(
@@ -454,7 +455,7 @@ DataReductionProxyTestContext::Builder::Build() {
                    base::Unretained(config_storer.get()))));
   }
 
-  scoped_ptr<DataReductionProxySettings> settings(
+  std::unique_ptr<DataReductionProxySettings> settings(
       new DataReductionProxySettings());
   if (skip_settings_initialization_) {
     settings->set_data_reduction_proxy_enabled_pref_name_for_test(
@@ -469,14 +470,14 @@ DataReductionProxyTestContext::Builder::Build() {
                                                 false);
   RegisterSimpleProfilePrefs(pref_service->registry());
 
-  scoped_ptr<TestDataReductionProxyIOData> io_data(
+  std::unique_ptr<TestDataReductionProxyIOData> io_data(
       new TestDataReductionProxyIOData(
           task_runner, std::move(config), std::move(event_creator),
           std::move(request_options), std::move(configurator),
           std::move(config_client), net_log.get(), true /* enabled */));
   io_data->SetSimpleURLRequestContextGetter(request_context_getter);
 
-  scoped_ptr<DataReductionProxyTestContext> test_context(
+  std::unique_ptr<DataReductionProxyTestContext> test_context(
       new DataReductionProxyTestContext(
           task_runner, std::move(pref_service), std::move(net_log),
           request_context_getter, mock_socket_factory_, std::move(io_data),
@@ -491,14 +492,15 @@ DataReductionProxyTestContext::Builder::Build() {
 
 DataReductionProxyTestContext::DataReductionProxyTestContext(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    scoped_ptr<TestingPrefServiceSimple> simple_pref_service,
-    scoped_ptr<net::TestNetLog> net_log,
+    std::unique_ptr<TestingPrefServiceSimple> simple_pref_service,
+    std::unique_ptr<net::TestNetLog> net_log,
     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     net::MockClientSocketFactory* mock_socket_factory,
-    scoped_ptr<TestDataReductionProxyIOData> io_data,
-    scoped_ptr<DataReductionProxySettings> settings,
-    scoped_ptr<TestDataReductionProxyEventStorageDelegate> storage_delegate,
-    scoped_ptr<TestConfigStorer> config_storer,
+    std::unique_ptr<TestDataReductionProxyIOData> io_data,
+    std::unique_ptr<DataReductionProxySettings> settings,
+    std::unique_ptr<TestDataReductionProxyEventStorageDelegate>
+        storage_delegate,
+    std::unique_ptr<TestConfigStorer> config_storer,
     TestDataReductionProxyParams* params,
     unsigned int test_context_flags)
     : test_context_flags_(test_context_flags),
@@ -568,7 +570,7 @@ void DataReductionProxyTestContext::InitSettingsWithoutCheck() {
   settings_->data_reduction_proxy_service()->SetIOData(io_data_->GetWeakPtr());
 }
 
-scoped_ptr<DataReductionProxyService>
+std::unique_ptr<DataReductionProxyService>
 DataReductionProxyTestContext::CreateDataReductionProxyService(
     DataReductionProxySettings* settings) {
   DCHECK(test_context_flags_ &
@@ -576,17 +578,17 @@ DataReductionProxyTestContext::CreateDataReductionProxyService(
   return CreateDataReductionProxyServiceInternal(settings);
 }
 
-scoped_ptr<DataReductionProxyService>
+std::unique_ptr<DataReductionProxyService>
 DataReductionProxyTestContext::CreateDataReductionProxyServiceInternal(
     DataReductionProxySettings* settings) {
   if (test_context_flags_ & DataReductionProxyTestContext::USE_MOCK_SERVICE) {
-    return make_scoped_ptr(new MockDataReductionProxyService(
+    return base::WrapUnique(new MockDataReductionProxyService(
         settings, simple_pref_service_.get(), request_context_getter_.get(),
         task_runner_));
   } else {
-    return make_scoped_ptr(new DataReductionProxyService(
+    return base::WrapUnique(new DataReductionProxyService(
         settings, simple_pref_service_.get(), request_context_getter_.get(),
-        make_scoped_ptr(new TestDataStore()), task_runner_, task_runner_,
+        base::WrapUnique(new TestDataStore()), task_runner_, task_runner_,
         task_runner_, base::TimeDelta()));
   }
 }
@@ -598,11 +600,11 @@ void DataReductionProxyTestContext::AttachToURLRequestContext(
   // |request_context_storage| takes ownership of the network delegate.
   request_context_storage->set_network_delegate(
       io_data()->CreateNetworkDelegate(
-          make_scoped_ptr(new net::TestNetworkDelegate()), true));
+          base::WrapUnique(new net::TestNetworkDelegate()), true));
 
   request_context_storage->set_job_factory(
-      make_scoped_ptr(new net::URLRequestInterceptingJobFactory(
-          scoped_ptr<net::URLRequestJobFactory>(
+      base::WrapUnique(new net::URLRequestInterceptingJobFactory(
+          std::unique_ptr<net::URLRequestJobFactory>(
               new net::URLRequestJobFactoryImpl()),
           io_data()->CreateInterceptor())));
 }