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

chrome/browser/extensions/api/signed_in_devices/signed_in_devices_api_unittest.cc

 // Copyright (c) 2013 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/extensions/api/signed_in_devices/signed_in_devices_api.h"
+
+#include <memory>
 #include <string>
-
 #include <vector>
 
 #include "base/guid.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
-#include "chrome/browser/extensions/api/signed_in_devices/signed_in_devices_api.h"
 #include "chrome/browser/extensions/extension_api_unittest.h"
 #include "chrome/browser/extensions/test_extension_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/sync/profile_sync_test_util.h"
 #include "components/browser_sync/browser/profile_sync_service_mock.h"
 #include "components/prefs/pref_service.h"
 #include "components/sync_driver/device_info.h"
 #include "components/sync_driver/device_info_tracker.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/common/extension.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using sync_driver::DeviceInfo;
 using sync_driver::DeviceInfoTracker;
 using testing::Return;
 
 namespace extensions {
 
 class MockDeviceInfoTracker : public DeviceInfoTracker {
  public:
   ~MockDeviceInfoTracker() override {}
 
   bool IsSyncing() const override { return !devices_.empty(); }
 
-  scoped_ptr<DeviceInfo> GetDeviceInfo(
+  std::unique_ptr<DeviceInfo> GetDeviceInfo(
       const std::string& client_id) const override {
     NOTREACHED();
-    return scoped_ptr<DeviceInfo>();
+    return std::unique_ptr<DeviceInfo>();
   }
 
   static DeviceInfo* CloneDeviceInfo(const DeviceInfo* device_info) {
     return new DeviceInfo(device_info->guid(),
                           device_info->client_name(),
                           device_info->chrome_version(),
                           device_info->sync_user_agent(),
                           device_info->device_type(),
                           device_info->signin_scoped_device_id());
   }
@@ skipping 91 matching lines @@
     public ProfileSyncServiceMock {
  public:
   explicit ProfileSyncServiceMockForExtensionTests(Profile* p)
       : ProfileSyncServiceMock(CreateProfileSyncServiceParamsForTest(p)) {}
   ~ProfileSyncServiceMockForExtensionTests() {}
 
   MOCK_METHOD0(Shutdown, void());
   MOCK_CONST_METHOD0(GetDeviceInfoTracker, DeviceInfoTracker*());
 };
 
-scoped_ptr<KeyedService> CreateProfileSyncServiceMock(
+std::unique_ptr<KeyedService> CreateProfileSyncServiceMock(
     content::BrowserContext* context) {
-  return make_scoped_ptr(new ProfileSyncServiceMockForExtensionTests(
+  return base::WrapUnique(new ProfileSyncServiceMockForExtensionTests(
       Profile::FromBrowserContext(context)));
 }
 
 class ExtensionSignedInDevicesTest : public ExtensionApiUnittest {
  public:
   void SetUp() override {
     ExtensionApiUnittest::SetUp();
 
     ProfileSyncServiceFactory::GetInstance()->SetTestingFactory(
         profile(), CreateProfileSyncServiceMock);
   }
 };
 
 std::string GetPublicId(const base::DictionaryValue* dictionary) {
   std::string public_id;
   if (!dictionary->GetString("id", &public_id)) {
     ADD_FAILURE() << "Not able to find public id in the dictionary";
   }
 
   return public_id;
 }
 
 void VerifyDictionaryWithDeviceInfo(const base::DictionaryValue* actual_value,
                                     DeviceInfo* device_info) {
   std::string public_id = GetPublicId(actual_value);
   device_info->set_public_id(public_id);
 
-  scoped_ptr<base::DictionaryValue> expected_value(device_info->ToValue());
+  std::unique_ptr<base::DictionaryValue> expected_value(device_info->ToValue());
   EXPECT_TRUE(expected_value->Equals(actual_value));
 }
 
 base::DictionaryValue* GetDictionaryFromList(int index,
                                              base::ListValue* value) {
   base::DictionaryValue* dictionary;
   if (!value->GetDictionary(index, &dictionary)) {
     ADD_FAILURE() << "Expected a list of dictionaries";
     return NULL;
   }
@@ skipping 21 matching lines @@
                           "device_id");
 
   device_tracker.Add(&device_info1);
   device_tracker.Add(&device_info2);
 
   EXPECT_CALL(*pss_mock, GetDeviceInfoTracker())
       .WillOnce(Return(&device_tracker));
 
   EXPECT_CALL(*pss_mock, Shutdown());
 
-  scoped_ptr<base::ListValue> result(RunFunctionAndReturnList(
-      new SignedInDevicesGetFunction(), "[null]"));
+  std::unique_ptr<base::ListValue> result(
+      RunFunctionAndReturnList(new SignedInDevicesGetFunction(), "[null]"));
 
   // Ensure dictionary matches device info.
   VerifyDictionaryWithDeviceInfo(GetDictionaryFromList(0, result.get()),
                                  &device_info1);
   VerifyDictionaryWithDeviceInfo(GetDictionaryFromList(1, result.get()),
                                  &device_info2);
 
   // Ensure public ids are set and unique.
   std::string public_id1 = GetPublicId(GetDictionaryFromList(0, result.get()));
   std::string public_id2 = GetPublicId(GetDictionaryFromList(1, result.get()));
@@ skipping 14 matching lines @@
       .WillOnce(Return(&device_tracker));
   EXPECT_CALL(*pss_mock, Shutdown());
 
   ScopedVector<DeviceInfo> output = GetAllSignedInDevices(
       extension()->id(), profile());
 
   EXPECT_TRUE(output.empty());
 }
 
 }  // namespace extensions