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

chrome/browser/chromeos/policy/device_local_account_browsertest.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/chromeos/policy/device_local_account.h"
 
 #include <stddef.h>
+
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/system/chromeos/session/logout_confirmation_controller.h"
 #include "ash/system/chromeos/session/logout_confirmation_dialog.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 187 matching lines @@
       const std::string& relative_update_url);
 
   // When an update manifest is requested for the given extension |id|, indicate
   // that |version| of the extension can be downloaded at |crx_url|.
   void AddUpdate(const std::string& id,
                  const std::string& version,
                  const GURL& crx_url);
 
   // This method must be registered with the test's EmbeddedTestServer to start
   // serving update manifests.
-  scoped_ptr<net::test_server::HttpResponse> HandleRequest(
+  std::unique_ptr<net::test_server::HttpResponse> HandleRequest(
       const net::test_server::HttpRequest& request);
 
  private:
   struct Update {
    public:
     Update(const std::string& version, const GURL& crx_url);
     Update();
 
     std::string version;
     GURL crx_url;
@@ skipping 51 matching lines @@
     : relative_update_url_(relative_update_url) {
 }
 
 void TestingUpdateManifestProvider::AddUpdate(const std::string& id,
                                               const std::string& version,
                                               const GURL& crx_url) {
   base::AutoLock auto_lock(lock_);
   updates_[id] = Update(version, crx_url);
 }
 
-scoped_ptr<net::test_server::HttpResponse>
+std::unique_ptr<net::test_server::HttpResponse>
 TestingUpdateManifestProvider::HandleRequest(
     const net::test_server::HttpRequest& request) {
   base::AutoLock auto_lock(lock_);
   const GURL url("http://localhost" + request.relative_url);
   if (url.path() != relative_update_url_)
-    return scoped_ptr<net::test_server::HttpResponse>();
+    return std::unique_ptr<net::test_server::HttpResponse>();
 
   std::string content = kUpdateManifestHeader;
   for (net::QueryIterator it(url); !it.IsAtEnd(); it.Advance()) {
     if (it.GetKey() != "x")
       continue;
     // Extract the extension id from the subquery. Since GetValueForKeyInQuery()
     // expects a complete URL, dummy scheme and host must be prepended.
     std::string id;
     net::GetValueForKeyInQuery(GURL("http://dummy?" + it.GetUnescapedValue()),
                                "id", &id);
     UpdateMap::const_iterator entry = updates_.find(id);
     if (entry != updates_.end()) {
       content += base::StringPrintf(kUpdateManifestTemplate,
                                     id.c_str(),
                                     entry->second.crx_url.spec().c_str(),
                                     entry->second.version.c_str());
     }
   }
   content += kUpdateManifestFooter;
-  scoped_ptr<net::test_server::BasicHttpResponse>
-      http_response(new net::test_server::BasicHttpResponse);
+  std::unique_ptr<net::test_server::BasicHttpResponse> http_response(
+      new net::test_server::BasicHttpResponse);
   http_response->set_code(net::HTTP_OK);
   http_response->set_content(content);
   http_response->set_content_type("text/xml");
   return std::move(http_response);
 }
 
 TestingUpdateManifestProvider::~TestingUpdateManifestProvider() {
 }
 
 DictionaryPrefValueWaiter::DictionaryPrefValueWaiter(
@@ skipping 30 matching lines @@
 }
 
 bool DoesInstallFailureReferToId(const std::string& id,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   return content::Details<const extensions::CrxInstallError>(details)
              ->message()
              .find(base::UTF8ToUTF16(id)) != base::string16::npos;
 }
 
-scoped_ptr<net::FakeURLFetcher> RunCallbackAndReturnFakeURLFetcher(
+std::unique_ptr<net::FakeURLFetcher> RunCallbackAndReturnFakeURLFetcher(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     const base::Closure& callback,
     const GURL& url,
     net::URLFetcherDelegate* delegate,
     const std::string& response_data,
     net::HttpStatusCode response_code,
     net::URLRequestStatus::Status status) {
   task_runner->PostTask(FROM_HERE, callback);
-  return make_scoped_ptr(new net::FakeURLFetcher(
-      url, delegate, response_data, response_code, status));
+  return base::WrapUnique(new net::FakeURLFetcher(url, delegate, response_data,
+                                                  response_code, status));
 }
 
 bool IsSessionStarted() {
   return user_manager::UserManager::Get()->IsSessionStarted();
 }
 
 void PolicyChangedCallback(const base::Closure& callback,
                            const base::Value* old_value,
                            const base::Value* new_value) {
   callback.Run();
@@ skipping 11 matching lines @@
             base::StringPrintf(kPublicSessionInputMethodIDTemplate,
                                chromeos::extension_ime_util::kXkbExtensionId)),
         contents_(NULL) {
     set_exit_when_last_browser_closes(false);
   }
 
   ~DeviceLocalAccountTest() override {}
 
   void SetUp() override {
     // Configure and start the test server.
-    scoped_ptr<crypto::RSAPrivateKey> signing_key(
+    std::unique_ptr<crypto::RSAPrivateKey> signing_key(
         PolicyBuilder::CreateTestSigningKey());
     ASSERT_TRUE(test_server_.SetSigningKeyAndSignature(
         signing_key.get(), PolicyBuilder::GetTestSigningKeySignature()));
     signing_key.reset();
     test_server_.RegisterClient(PolicyBuilder::kFakeToken,
                                 PolicyBuilder::kFakeDeviceId);
     ASSERT_TRUE(test_server_.Start());
 
     BrowserList::AddObserver(this);
 
@@ skipping 343 matching lines @@
           DeviceLocalAccount::TYPE_PUBLIC_SESSION));
   const AccountId account_id_2_ =
       AccountId::FromUserEmail(GenerateDeviceLocalAccountUserId(
           kAccountId2,
           DeviceLocalAccount::TYPE_PUBLIC_SESSION));
   const std::string public_session_input_method_id_;
 
   std::string initial_locale_;
   std::string initial_language_;
 
-  scoped_ptr<base::RunLoop> run_loop_;
+  std::unique_ptr<base::RunLoop> run_loop_;
 
   UserPolicyBuilder device_local_account_policy_;
   LocalPolicyTestServer test_server_;
 
   content::WebContents* contents_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeviceLocalAccountTest);
 };
 
@@ skipping 417 matching lines @@
           ->browser_policy_connector_chromeos()
           ->GetDeviceLocalAccountPolicyService()
           ->GetBrokerForUser(account_id_1_.GetUserEmail());
   ASSERT_TRUE(broker);
   chromeos::ExternalCache* cache =
       broker->extension_loader()->GetExternalCacheForTesting();
   ASSERT_TRUE(cache);
   EXPECT_FALSE(cache->GetExtension(kGoodExtensionID, NULL, NULL));
 }
 
-static void OnPutExtension(scoped_ptr<base::RunLoop>* run_loop,
-                    const base::FilePath& file_path,
-                    bool file_ownership_passed) {
+static void OnPutExtension(std::unique_ptr<base::RunLoop>* run_loop,
+                           const base::FilePath& file_path,
+                           bool file_ownership_passed) {
   ASSERT_TRUE(*run_loop);
   (*run_loop)->Quit();
 }
 
 static void OnExtensionCacheImplInitialized(
-    scoped_ptr<base::RunLoop>* run_loop) {
+    std::unique_ptr<base::RunLoop>* run_loop) {
   ASSERT_TRUE(*run_loop);
   (*run_loop)->Quit();
 }
 
 static void CreateFile(const base::FilePath& file,
                 size_t size,
                 const base::Time& timestamp) {
   std::string data(size, 0);
   EXPECT_EQ(base::WriteFile(file, data.data(), data.size()), int(size));
   EXPECT_TRUE(base::TouchFile(file, timestamp, timestamp));
@@ skipping 14 matching lines @@
       base::Bind(&TestingUpdateManifestProvider::HandleRequest,
                  testing_update_manifest_provider));
   // Create and initialize local cache.
   base::ScopedTempDir cache_dir;
   EXPECT_TRUE(cache_dir.CreateUniqueTempDir());
   const base::FilePath impl_path = cache_dir.path();
   EXPECT_TRUE(base::CreateDirectory(impl_path));
   CreateFile(impl_path.Append(
                  extensions::LocalExtensionCache::kCacheReadyFlagFileName),
              0, base::Time::Now());
-  extensions::ExtensionCacheImpl cache_impl(make_scoped_ptr(
+  extensions::ExtensionCacheImpl cache_impl(base::WrapUnique(
       new extensions::ChromeOSExtensionCacheDelegate(impl_path)));
-  scoped_ptr<base::RunLoop> run_loop;
+  std::unique_ptr<base::RunLoop> run_loop;
   run_loop.reset(new base::RunLoop);
   cache_impl.Start(base::Bind(&OnExtensionCacheImplInitialized, &run_loop));
   run_loop->Run();
 
   // Put extension in the local cache.
   base::ScopedTempDir temp_dir;
   EXPECT_TRUE(temp_dir.CreateUniqueTempDir());
   const base::FilePath temp_path = temp_dir.path();
   EXPECT_TRUE(base::CreateDirectory(temp_path));
   const base::FilePath temp_file =
@@ skipping 60 matching lines @@
   // prevented from seeing the policy change.
   reinterpret_cast<chromeos::ChromeUserManagerImpl*>(
       user_manager::UserManager::Get())->StopPolicyObserverForTesting();
 
   UploadDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
   WaitForPolicy();
 
   // Start serving external data at |kExternalDataURL|.
-  scoped_ptr<base::RunLoop> run_loop(new base::RunLoop);
-  scoped_ptr<net::FakeURLFetcherFactory> fetcher_factory(
+  std::unique_ptr<base::RunLoop> run_loop(new base::RunLoop);
+  std::unique_ptr<net::FakeURLFetcherFactory> fetcher_factory(
       new net::FakeURLFetcherFactory(
           NULL, base::Bind(&RunCallbackAndReturnFakeURLFetcher,
                            base::ThreadTaskRunnerHandle::Get(),
                            run_loop->QuitClosure())));
   fetcher_factory->SetFakeResponse(GURL(kExternalDataURL),
                                    kExternalData,
                                    net::HTTP_OK,
                                    net::URLRequestStatus::SUCCESS);
 
   // Specify an external data reference for the key::kUserAvatarImage policy.
-  scoped_ptr<base::DictionaryValue> metadata =
+  std::unique_ptr<base::DictionaryValue> metadata =
       test::ConstructExternalDataReference(kExternalDataURL, kExternalData);
   std::string policy;
   base::JSONWriter::Write(*metadata, &policy);
   device_local_account_policy_.payload().mutable_useravatarimage()->set_value(
       policy);
   UploadAndInstallDeviceLocalAccountPolicy();
   policy::BrowserPolicyConnectorChromeOS* connector =
       g_browser_process->platform_part()->browser_policy_connector_chromeos();
   DeviceLocalAccountPolicyBroker* broker =
       connector->GetDeviceLocalAccountPolicyService()->GetBrokerForUser(
@@ skipping 10 matching lines @@
 
   const PolicyMap::Entry* policy_entry =
       broker->core()->store()->policy_map().Get(key::kUserAvatarImage);
   ASSERT_TRUE(policy_entry);
   ASSERT_TRUE(policy_entry->external_data_fetcher);
 
   // Retrieve the external data. Although the data is no longer being served at
   // |kExternalDataURL|, the retrieval should succeed because the data has been
   // cached.
   run_loop.reset(new base::RunLoop);
-  scoped_ptr<std::string> fetched_external_data;
+  std::unique_ptr<std::string> fetched_external_data;
   policy_entry->external_data_fetcher->Fetch(base::Bind(
       &test::ExternalDataFetchCallback,
       &fetched_external_data,
       run_loop->QuitClosure()));
   run_loop->Run();
 
   ASSERT_TRUE(fetched_external_data);
   EXPECT_EQ(kExternalData, *fetched_external_data);
 
   ASSERT_NO_FATAL_FAILURE(StartLogin(std::string(), std::string()));
@@ skipping 58 matching lines @@
       connector->GetDeviceLocalAccountPolicyService()->GetBrokerForUser(
           account_id_1_.GetUserEmail());
   ASSERT_TRUE(broker);
 
   run_loop_.reset(new base::RunLoop);
   user_manager::UserManager::Get()->AddObserver(this);
   broker->core()->store()->Load();
   run_loop_->Run();
   user_manager::UserManager::Get()->RemoveObserver(this);
 
-  scoped_ptr<gfx::ImageSkia> policy_image = chromeos::test::ImageLoader(
-      test_dir.Append(chromeos::test::kUserAvatarImage1RelativePath)).Load();
+  std::unique_ptr<gfx::ImageSkia> policy_image =
+      chromeos::test::ImageLoader(
+          test_dir.Append(chromeos::test::kUserAvatarImage1RelativePath))
+          .Load();
   ASSERT_TRUE(policy_image);
 
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(account_id_1_);
   ASSERT_TRUE(user);
 
   base::FilePath user_data_dir;
   ASSERT_TRUE(PathService::Get(chrome::DIR_USER_DATA, &user_data_dir));
   const base::FilePath saved_image_path =
       user_data_dir.Append(account_id_1_.GetUserEmail()).AddExtension("jpg");
 
   EXPECT_FALSE(user->HasDefaultImage());
   EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, user->image_index());
   EXPECT_TRUE(chromeos::test::AreImagesEqual(*policy_image, user->GetImage()));
   const base::DictionaryValue* images_pref =
       g_browser_process->local_state()->GetDictionary("user_image_info");
   ASSERT_TRUE(images_pref);
   const base::DictionaryValue* image_properties;
   ASSERT_TRUE(images_pref->GetDictionaryWithoutPathExpansion(
       account_id_1_.GetUserEmail(), &image_properties));
   int image_index;
   std::string image_path;
   ASSERT_TRUE(image_properties->GetInteger("index", &image_index));
   ASSERT_TRUE(image_properties->GetString("path", &image_path));
   EXPECT_EQ(user_manager::User::USER_IMAGE_EXTERNAL, image_index);
   EXPECT_EQ(saved_image_path.value(), image_path);
 
-  scoped_ptr<gfx::ImageSkia> saved_image =
+  std::unique_ptr<gfx::ImageSkia> saved_image =
       chromeos::test::ImageLoader(saved_image_path).Load();
   ASSERT_TRUE(saved_image);
 
   // Check image dimensions. Images can't be compared since JPEG is lossy.
   EXPECT_EQ(policy_image->width(), saved_image->width());
   EXPECT_EQ(policy_image->height(), saved_image->height());
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, LastWindowClosedLogoutReminder) {
   UploadAndInstallDeviceLocalAccountPolicy();
@@ skipping 285 matching lines @@
       "    .getPodWithUsername_('%s').querySelector('.language-select');"
       "var locales = [];"
       "for (var i = 0; i < languageSelect.length; ++i)"
       "  locales.push(languageSelect.options[i].value);"
       "domAutomationController.send(JSON.stringify(locales));",
       account_id_1_.Serialize().c_str());
   std::string json;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(contents_,
                                                      get_locale_list,
                                                      &json));
-  scoped_ptr<base::Value> value_ptr = base::JSONReader::Read(json);
+  std::unique_ptr<base::Value> value_ptr = base::JSONReader::Read(json);
   const base::ListValue* locales = NULL;
   ASSERT_TRUE(value_ptr);
   ASSERT_TRUE(value_ptr->GetAsList(&locales));
   EXPECT_LT(arraysize(kRecommendedLocales1), locales->GetSize());
 
   // Verify that the list starts with the recommended locales, in correct order.
   for (size_t i = 0; i < arraysize(kRecommendedLocales1); ++i) {
     std::string locale;
     EXPECT_TRUE(locales->GetString(i, &locale));
     EXPECT_EQ(kRecommendedLocales1[i], locale);
@@ skipping 555 matching lines @@
       "  domAutomationController.send(JSON.stringify(status));"
       "  observer.disconnect();"
       "  return true;"
       "}"
       "var observer = new MutationObserver(SendReplyIfDownloadDone);"
       "if (!SendReplyIfDownloadDone()) {"
       "  var options = { attributes: true, attributeFilter: [ 'class' ] };"
       "  observer.observe(screenElement, options);"
       "}",
       &json));
-  scoped_ptr<base::Value> value_ptr = base::JSONReader::Read(json);
+  std::unique_ptr<base::Value> value_ptr = base::JSONReader::Read(json);
   const base::DictionaryValue* status = NULL;
   ASSERT_TRUE(value_ptr);
   ASSERT_TRUE(value_ptr->GetAsDictionary(&status));
   std::string heading;
   EXPECT_TRUE(status->GetString("heading", &heading));
   std::string subheading;
   EXPECT_TRUE(status->GetString("subheading", &subheading));
   std::string content_heading;
   EXPECT_TRUE(status->GetString("contentHeading", &content_heading));
   std::string content;
@@ skipping 40 matching lines @@
   ASSERT_TRUE(content::ExecuteScript(contents_,
                                      "$('tos-accept-button').click();"));
 
   WaitForSessionStart();
 }
 
 INSTANTIATE_TEST_CASE_P(TermsOfServiceDownloadTestInstance,
                         TermsOfServiceDownloadTest, testing::Bool());
 
 }  // namespace policy