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

chrome/browser/chromeos/app_mode/kiosk_app_manager_browsertest.cc

 // Copyright 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/chromeos/app_mode/kiosk_app_manager.h"
 
 #include <stddef.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/app_mode/fake_cws.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_data.h"
 #include "chrome/browser/chromeos/app_mode/kiosk_app_manager_observer.h"
 #include "chrome/browser/chromeos/ownership/fake_owner_settings_service.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
@@ skipping 62 matching lines @@
 }
 
 scoped_refptr<extensions::Extension> MakeKioskApp(
     const std::string& name,
     const std::string& version,
     const std::string& id,
     const std::string& required_platform_version) {
   base::DictionaryValue value;
   value.SetString("name", name);
   value.SetString("version", version);
-  scoped_ptr<base::ListValue> scripts(new base::ListValue);
+  std::unique_ptr<base::ListValue> scripts(new base::ListValue);
   scripts->AppendString("main.js");
   value.Set("app.background.scripts", std::move(scripts));
   value.SetBoolean("kiosk_enabled", true);
   value.SetString("kiosk.required_platform_version", required_platform_version);
 
   std::string err;
   scoped_refptr<extensions::Extension> app =
       extensions::Extension::Create(
           base::FilePath(),
           extensions::Manifest::INTERNAL,
@@ skipping 157 matching lines @@
       if (i > 0)
         str += ',';
       str += apps[i].app_id;
     }
 
     return str;
   }
 
   // Locks device for enterprise.
   policy::EnterpriseInstallAttributes::LockResult LockDeviceForEnterprise() {
-    scoped_ptr<policy::EnterpriseInstallAttributes::LockResult> lock_result(
-        new policy::EnterpriseInstallAttributes::LockResult(
+    std::unique_ptr<policy::EnterpriseInstallAttributes::LockResult>
+        lock_result(new policy::EnterpriseInstallAttributes::LockResult(
             policy::EnterpriseInstallAttributes::LOCK_NOT_READY));
     scoped_refptr<content::MessageLoopRunner> runner =
         new content::MessageLoopRunner;
     policy::BrowserPolicyConnectorChromeOS* connector =
         g_browser_process->platform_part()->browser_policy_connector_chromeos();
     connector->GetInstallAttributes()->LockDevice(
         "user@domain.com",
         policy::DEVICE_MODE_ENTERPRISE,
         "device-id",
         base::Bind(
             &OnEnterpriseDeviceLock, lock_result.get(), runner->QuitClosure()));
     runner->Run();
     return *lock_result.get();
   }
 
   void SetExistingApp(const std::string& app_id,
                       const std::string& app_name,
                       const std::string& icon_file_name,
                       const std::string& required_platform_version) {
     base::FilePath test_dir;
     ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_dir));
     base::FilePath data_dir = test_dir.AppendASCII("chromeos/app_mode/");
 
     // Copy the icon file to temp dir for using because ClearAppData test
     // deletes it.
     base::FilePath icon_path =
         CopyFileToTempDir(data_dir.AppendASCII(icon_file_name));
 
-    scoped_ptr<base::DictionaryValue> apps_dict(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> apps_dict(new base::DictionaryValue);
     apps_dict->SetString(app_id + ".name", app_name);
     apps_dict->SetString(app_id + ".icon", icon_path.MaybeAsASCII());
     apps_dict->SetString(app_id + ".required_platform_version",
                          required_platform_version);
 
     PrefService* local_state = g_browser_process->local_state();
     DictionaryPrefUpdate dict_update(local_state,
                                      KioskAppManager::kKioskDictionaryName);
     dict_update->Set(KioskAppManager::kKeyApps, apps_dict.release());
 
     // Make the app appear in device settings.
     base::ListValue device_local_accounts;
-    scoped_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
+    std::unique_ptr<base::DictionaryValue> entry(new base::DictionaryValue);
     // Fake an account id. Note this needs to match GenerateKioskAppAccountId
     // in kiosk_app_manager.cc to make SetAutoLaunchApp work with the
     // existing app entry created here.
     entry->SetStringWithoutPathExpansion(kAccountsPrefDeviceLocalAccountsKeyId,
                                          app_id + "@kiosk-apps");
     entry->SetIntegerWithoutPathExpansion(
         kAccountsPrefDeviceLocalAccountsKeyType,
         policy::DeviceLocalAccount::TYPE_KIOSK_APP);
     entry->SetStringWithoutPathExpansion(
         kAccountsPrefDeviceLocalAccountsKeyKioskAppId,
@@ skipping 102 matching lines @@
 
   KioskAppData* GetAppDataMutable(const std::string& app_id) {
     return manager()->GetAppDataMutable(app_id);
   }
 
   KioskAppManager* manager() const { return KioskAppManager::Get(); }
   FakeCWS* fake_cws() { return fake_cws_.get(); }
 
  protected:
   ScopedCrosSettingsTestHelper settings_helper_;
-  scoped_ptr<FakeOwnerSettingsService> owner_settings_service_;
+  std::unique_ptr<FakeOwnerSettingsService> owner_settings_service_;
 
  private:
   base::ScopedTempDir temp_dir_;
-  scoped_ptr<FakeCWS> fake_cws_;
+  std::unique_ptr<FakeCWS> fake_cws_;
 
   DISALLOW_COPY_AND_ASSIGN(KioskAppManagerTest);
 };
 
 IN_PROC_BROWSER_TEST_F(KioskAppManagerTest, Basic) {
   // Add a couple of apps. Use "fake_app_x" that do not have data on the test
   // server to avoid pending data loads that could be lingering on tear down and
   // cause DCHECK failure in utility_process_host_impl.cc.
   manager()->AddApp("fake_app_1", owner_settings_service_.get());
   manager()->AddApp("fake_app_2", owner_settings_service_.get());
@@ skipping 303 matching lines @@
   content::RunAllBlockingPoolTasksUntilIdle();
   manager()->GetApps(&apps);
   ASSERT_EQ(0u, apps.size());
   // Verify both v1 and v2 crx files are removed.
   EXPECT_FALSE(base::PathExists(v1_crx_path));
   EXPECT_FALSE(base::PathExists(v2_crx_path));
   EXPECT_FALSE(GetCachedCrx(kTestLocalFsKioskApp, &v2_crx_path, &version));
 }
 
 IN_PROC_BROWSER_TEST_F(KioskAppManagerTest, EnableConsumerKiosk) {
-  scoped_ptr<KioskAppManager::ConsumerKioskAutoLaunchStatus> status(
+  std::unique_ptr<KioskAppManager::ConsumerKioskAutoLaunchStatus> status(
       new KioskAppManager::ConsumerKioskAutoLaunchStatus(
           KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_DISABLED));
-  scoped_ptr<bool> locked(new bool(false));
+  std::unique_ptr<bool> locked(new bool(false));
 
   scoped_refptr<content::MessageLoopRunner> runner =
       new content::MessageLoopRunner;
   manager()->GetConsumerKioskAutoLaunchStatus(
       base::Bind(&ConsumerKioskAutoLaunchStatusCheck,
                  status.get(),
                  runner->QuitClosure()));
   runner->Run();
   EXPECT_EQ(*status.get(),
             KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_CONFIGURABLE);
@@ skipping 17 matching lines @@
   EXPECT_EQ(*status.get(),
             KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_ENABLED);
 }
 
 IN_PROC_BROWSER_TEST_F(KioskAppManagerTest,
                        PreventEnableConsumerKioskForEnterprise) {
   // First, lock the device as enterprise.
   EXPECT_EQ(LockDeviceForEnterprise(),
             policy::EnterpriseInstallAttributes::LOCK_SUCCESS);
 
-  scoped_ptr<KioskAppManager::ConsumerKioskAutoLaunchStatus> status(
+  std::unique_ptr<KioskAppManager::ConsumerKioskAutoLaunchStatus> status(
       new KioskAppManager::ConsumerKioskAutoLaunchStatus(
           KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_DISABLED));
-  scoped_ptr<bool> locked(new bool(true));
+  std::unique_ptr<bool> locked(new bool(true));
 
   scoped_refptr<content::MessageLoopRunner> runner =
       new content::MessageLoopRunner;
   manager()->GetConsumerKioskAutoLaunchStatus(
       base::Bind(&ConsumerKioskAutoLaunchStatusCheck,
                  status.get(),
                  runner->QuitClosure()));
   runner->Run();
   EXPECT_EQ(*status.get(),
             KioskAppManager::CONSUMER_KIOSK_AUTO_LAUNCH_DISABLED);
@@ skipping 43 matching lines @@
   // No require platform version if auto launched app has a non-zero delay set.
   settings_helper_.SetInteger(kAccountsPrefDeviceLocalAccountAutoLoginDelay, 1);
   EXPECT_EQ("", manager()->GetAutoLaunchAppRequiredPlatformVersion());
 
   settings_helper_.SetInteger(kAccountsPrefDeviceLocalAccountAutoLoginDelay, 0);
   EXPECT_EQ(kRequiredPlatformVersion,
             manager()->GetAutoLaunchAppRequiredPlatformVersion());
 }
 
 }  // namespace chromeos