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

chrome/browser/ui/webui/options/preferences_browsertest.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/ui/webui/options/preferences_browsertest.h"
 
 #include <stddef.h>
 
 #include <iostream>
+#include <memory>
 #include <sstream>
 
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
@@ skipping 231 matching lines @@
   else if (dict->HasKey("uncommitted"))
     VerifyKeyValue(*dict, "uncommitted", base::FundamentalValue(false));
 }
 
 void PreferencesBrowserTest::VerifyObservedPref(const std::string& json,
                                                 const std::string& name,
                                                 const base::Value* value,
                                                 const std::string& controlledBy,
                                                 bool disabled,
                                                 bool uncommitted) {
-  scoped_ptr<base::Value> observed_value_ptr = base::JSONReader::Read(json);
+  std::unique_ptr<base::Value> observed_value_ptr =
+      base::JSONReader::Read(json);
   const base::DictionaryValue* observed_dict;
   ASSERT_TRUE(observed_value_ptr.get());
   ASSERT_TRUE(observed_value_ptr->GetAsDictionary(&observed_dict));
   VerifyPref(observed_dict, name, value, controlledBy, disabled, uncommitted);
 }
 
 void PreferencesBrowserTest::VerifyObservedPrefs(
     const std::string& json,
     const std::vector<std::string>& names,
     const std::vector<base::Value*>& values,
     const std::string& controlledBy,
     bool disabled,
     bool uncommitted) {
-  scoped_ptr<base::Value> observed_value_ptr = base::JSONReader::Read(json);
+  std::unique_ptr<base::Value> observed_value_ptr =
+      base::JSONReader::Read(json);
   const base::DictionaryValue* observed_dict;
   ASSERT_TRUE(observed_value_ptr.get());
   ASSERT_TRUE(observed_value_ptr->GetAsDictionary(&observed_dict));
   for (size_t i = 0; i < names.size(); ++i) {
     VerifyPref(observed_dict, names[i], values[i], controlledBy, disabled,
                uncommitted);
   }
 }
 
 void PreferencesBrowserTest::ExpectNoCommit(const std::string& name) {
@@ skipping 47 matching lines @@
     observed_json = &temp_observed_json;
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), observed_json));
 }
 
 void PreferencesBrowserTest::SetPref(const std::string& name,
                                      const std::string& type,
                                      const base::Value* value,
                                      bool commit,
                                      std::string* observed_json) {
-  scoped_ptr<base::Value> commit_ptr(new base::FundamentalValue(commit));
+  std::unique_ptr<base::Value> commit_ptr(new base::FundamentalValue(commit));
   std::stringstream javascript;
   javascript << "testEnv.runAndReply(function() {"
              << "  Preferences.set" << type << "Pref("
              << "      '" << name << "',"
              << "      " << *value << ","
              << "      " << *commit_ptr << ");"
              << "});";
   ASSERT_TRUE(content::ExecuteScriptAndExtractString(
       render_view_host_, javascript.str(), observed_json));
 }
@@ skipping 352 matching lines @@
   VerifyObservedPrefs(observed_json, pref_names_,
                       decorated_non_default_values.get(),
                       std::string(), false, false);
 }
 
 class ManagedPreferencesBrowserTest : public PreferencesBrowserTest {
  protected:
   // PreferencesBrowserTest implementation:
   void SetUpInProcessBrowserTestFixture() override {
     // Set up fake install attributes.
-    scoped_ptr<policy::StubEnterpriseInstallAttributes> attributes(
+    std::unique_ptr<policy::StubEnterpriseInstallAttributes> attributes(
         new policy::StubEnterpriseInstallAttributes());
     attributes->SetDomain("example.com");
     attributes->SetRegistrationUser("user@example.com");
     policy::BrowserPolicyConnectorChromeOS::SetInstallAttributesForTesting(
         attributes.release());
 
     PreferencesBrowserTest::SetUpInProcessBrowserTestFixture();
   }
 };
 
@@ skipping 79 matching lines @@
 const char* kUserProfilePath = "user_profile";
 
 }  // namespace
 
 class ProxyPreferencesBrowserTest : public PreferencesBrowserTest {
  public:
   void SetUpOnMainThread() override {
     SetupNetworkEnvironment();
     content::RunAllPendingInMessageLoop();
 
-    scoped_ptr<base::DictionaryValue> proxy_config_dict(
+    std::unique_ptr<base::DictionaryValue> proxy_config_dict(
         ProxyConfigDictionary::CreateFixedServers("127.0.0.1:8080",
                                                   "*.google.com, 1.2.3.4:22"));
 
     ProxyConfigDictionary proxy_config(proxy_config_dict.get());
 
     const chromeos::NetworkState* network = GetDefaultNetwork();
     ASSERT_TRUE(network);
     chromeos::proxy_config::SetProxyConfigForNetwork(proxy_config, *network);
 
     std::string url = base::StringPrintf("%s?network=%s",
@@ skipping 80 matching lines @@
 
     std::string observed_json;
     SetPref(name, type, &value, true, &observed_json);
   }
 
   void VerifyCurrentProxyServer(const std::string& expected_server,
                                 onc::ONCSource expected_source) {
     const chromeos::NetworkState* network = GetDefaultNetwork();
     ASSERT_TRUE(network);
     onc::ONCSource actual_source;
-    scoped_ptr<ProxyConfigDictionary> proxy_dict =
+    std::unique_ptr<ProxyConfigDictionary> proxy_dict =
         chromeos::proxy_config::GetProxyConfigForNetwork(
-            pref_service_,
-            g_browser_process->local_state(),
-            *network,
+            pref_service_, g_browser_process->local_state(), *network,
             &actual_source);
     ASSERT_TRUE(proxy_dict);
     std::string actual_proxy_server;
     EXPECT_TRUE(proxy_dict->GetProxyServer(&actual_proxy_server));
     EXPECT_EQ(expected_server, actual_proxy_server);
     EXPECT_EQ(expected_source, actual_source);
   }
 };
 
 // Verifies that proxy settings are correctly pushed to JavaScript during
@@ skipping 144 matching lines @@
   SetProxyPref(chromeos::kProxyHttpsPort, base::FundamentalValue(2));
   SetProxyPref(chromeos::kProxyFtpPort, base::FundamentalValue(3));
   SetProxyPref(chromeos::kProxySocksPort, base::FundamentalValue(4));
 
   VerifyCurrentProxyServer(
       "http=a.com:1;https=4.3.2.1:2;ftp=c.com:3;socks=socks4://d.com:4",
       onc::ONC_SOURCE_NONE);
 }
 
 #endif