Convert //components/[u-z]* from scoped_ptr to std::unique_ptr

components/wifi_sync/wifi_config_delegate_chromeos_unittest.cc

 // Copyright 2015 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/wifi_sync/wifi_config_delegate_chromeos.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_handler_callbacks.h"
 #include "components/wifi_sync/wifi_credential.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace wifi_sync {
 
 namespace {
 const char kSsid[] = "fake-ssid";
@@ skipping 122 matching lines @@
 
   // Wrapper for WifiConfigDelegateChromeOs::AddToLocalNetworks.
   void AddToLocalNetworks(const WifiCredential& network_credential) {
     config_delegate_->AddToLocalNetworks(network_credential);
   }
 
   // Returns a new WifiCredential constructed from the given parameters.
   WifiCredential MakeCredential(const std::string& ssid,
                                 WifiSecurityClass security_class,
                                 const std::string& passphrase) {
-    scoped_ptr<WifiCredential> credential =
-        WifiCredential::Create(
-            WifiCredential::MakeSsidBytesForTest(ssid),
-            security_class,
-            passphrase);
+    std::unique_ptr<WifiCredential> credential = WifiCredential::Create(

[danakj, 2016/04/25 18:32:58]

include memory

[dcheng, 2016/04/25 19:55:06]

DOne.

+        WifiCredential::MakeSsidBytesForTest(ssid), security_class, passphrase);
     CHECK(credential);
     return *credential;
   }
 
   // Runs the last |callback| passed to CreateConfiguration, unless
   // that |callback| is null.
   void RunCreateConfigurationSuccessCallback() {
     const char new_service_path[] = "/service/0";
     const ServiceResultCallback callback =
         fake_managed_network_configuration_handler_
@@ skipping 10 matching lines @@
   }
 
   // Returns the last |error_callback| passed to the CreateConfiguration
   // method of |fake_managed_network_configuration_handler_|.
   const ErrorCallback& create_configuration_error_callback() const {
     return fake_managed_network_configuration_handler_
         ->create_configuration_error_callback();
   }
 
  private:
-  scoped_ptr<WifiConfigDelegateChromeOs> config_delegate_;
-  scoped_ptr<FakeManagedNetworkConfigurationHandler>
-    fake_managed_network_configuration_handler_;
+  std::unique_ptr<WifiConfigDelegateChromeOs> config_delegate_;
+  std::unique_ptr<FakeManagedNetworkConfigurationHandler>
+      fake_managed_network_configuration_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(WifiConfigDelegateChromeOsTest);
 };
 
 TEST_F(WifiConfigDelegateChromeOsTest, AddToLocalNetworksOpen) {
   AddToLocalNetworks(MakeCredential(kSsid, SECURITY_CLASS_NONE, ""));
   ASSERT_TRUE(create_configuration_called());
   RunCreateConfigurationSuccessCallback();
 }
 
@@ skipping 16 matching lines @@
   EXPECT_FALSE(create_configuration_called());
 }
 
 TEST_F(WifiConfigDelegateChromeOsTest,
        AddToLocalNetworksCreateConfigurationFailure) {
   AddToLocalNetworks(MakeCredential(kSsid, SECURITY_CLASS_NONE, ""));
   EXPECT_TRUE(create_configuration_called());
   if (!create_configuration_error_callback().is_null()) {
     create_configuration_error_callback().Run(
         "Config.CreateConfiguration Failed",
-        make_scoped_ptr(new base::DictionaryValue()));
+        base::WrapUnique(new base::DictionaryValue()));
   }
 }
 
 }  // namespace wifi_sync