Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/proxy_config_service_impl_unittest.cc

 // Copyright (c) 2012 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/chromeos/proxy_config_service_impl.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 231 matching lines @@
     chromeos::proxy_config::RegisterPrefs(pref_service_.registry());
     PrefProxyConfigTrackerImpl::RegisterProfilePrefs(profile_prefs_.registry());
     chromeos::proxy_config::RegisterProfilePrefs(profile_prefs_.registry());
   }
 
   void SetUpProxyConfigService(PrefService* profile_prefs) {
     config_service_impl_.reset(
         new ProxyConfigServiceImpl(profile_prefs, &pref_service_));
     proxy_config_service_ =
         config_service_impl_->CreateTrackingProxyConfigService(
-            scoped_ptr<net::ProxyConfigService>());
+            std::unique_ptr<net::ProxyConfigService>());
 
     // CreateTrackingProxyConfigService triggers update of initial prefs proxy
     // config by tracker to chrome proxy config service, so flush all pending
     // tasks so that tests start fresh.
     loop_.RunUntilIdle();
   }
 
   void SetUpPrivateWiFi() {
     ShillProfileClient::TestInterface* profile_test =
         DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface();
@@ skipping 43 matching lines @@
     config_service_impl_->DetachFromPrefService();
     loop_.RunUntilIdle();
     config_service_impl_.reset();
     proxy_config_service_.reset();
     NetworkHandler::Shutdown();
     DBusThreadManager::Shutdown();
   }
 
   void InitConfigWithTestInput(const Input& input,
                                base::DictionaryValue* result) {
-    scoped_ptr<base::DictionaryValue> new_config;
+    std::unique_ptr<base::DictionaryValue> new_config;
     switch (input.mode) {
       case MK_MODE(DIRECT):
         new_config.reset(ProxyConfigDictionary::CreateDirect());
         break;
       case MK_MODE(AUTO_DETECT):
         new_config.reset(ProxyConfigDictionary::CreateAutoDetect());
         break;
       case MK_MODE(PAC_SCRIPT):
         new_config.reset(
             ProxyConfigDictionary::CreatePacScript(input.pac_url, false));
@@ skipping 29 matching lines @@
     // ChromeProxyConfigService::UpdateProxyConfig, which is posted on IO from
     // PrefProxyConfigTrackerImpl::OnProxyConfigChanged.
     loop_.RunUntilIdle();
     net::ProxyConfigService::ConfigAvailability availability =
         proxy_config_service_->GetLatestProxyConfig(config);
 
     EXPECT_EQ(net::ProxyConfigService::CONFIG_VALID, availability);
   }
 
   base::MessageLoop loop_;
-  scoped_ptr<net::ProxyConfigService> proxy_config_service_;
-  scoped_ptr<ProxyConfigServiceImpl> config_service_impl_;
+  std::unique_ptr<net::ProxyConfigService> proxy_config_service_;
+  std::unique_ptr<ProxyConfigServiceImpl> config_service_impl_;
   TestingPrefServiceSimple pref_service_;
   user_prefs::TestingPrefServiceSyncable profile_prefs_;
 
  private:
   ScopedTestDeviceSettingsService test_device_settings_service_;
   ScopedTestCrosSettings test_cros_settings_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
 };
 
@@ skipping 123 matching lines @@
   }
 }
 
 // Tests whether the proxy settings from user policy are used for ethernet even
 // if 'UseSharedProxies' is set to false.
 // See https://crbug.com/454966 .
 TEST_F(ProxyConfigServiceImplTest, SharedEthernetAndUserPolicy) {
   SetUpSharedEthernet();
   SetUpProxyConfigService(&profile_prefs_);
 
-  scoped_ptr<base::DictionaryValue> ethernet_policy(
+  std::unique_ptr<base::DictionaryValue> ethernet_policy(
       chromeos::onc::ReadDictionaryFromJson(kEthernetPolicy));
 
-  scoped_ptr<base::ListValue> network_configs(new base::ListValue);
+  std::unique_ptr<base::ListValue> network_configs(new base::ListValue);
   network_configs->Append(ethernet_policy.release());
 
   profile_prefs_.SetUserPref(prefs::kUseSharedProxies,
                              new base::FundamentalValue(false));
   profile_prefs_.SetManagedPref(prefs::kOpenNetworkConfiguration,
                                 network_configs.release());
 
   net::ProxyConfig actual_config;
   SyncGetLatestProxyConfig(&actual_config);
   net::ProxyConfig expected_config =
       net::ProxyConfig::CreateFromCustomPacURL(GURL("http://domain.com/x"));
   EXPECT_TRUE(expected_config.Equals(actual_config));
 }
 
 }  // namespace chromeos