Revert of Stop passing raw pointers to base::Value API in c/b/chromeos and c/b/extensions

chrome/browser/extensions/api/proxy/proxy_api_helpers_unittest.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.
 
 // Unit tests for helper functions for the Chrome Extensions Proxy Settings API.
 
 #include "chrome/browser/extensions/api/proxy/proxy_api_helpers.h"
 
 #include <memory>
 #include <utility>
 
-#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/proxy/proxy_api_constants.h"
 #include "components/proxy_config/proxy_config_dictionary.h"
 #include "components/proxy_config/proxy_prefs.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 namespace keys = proxy_api_constants;
 
 namespace {
 
 const char kSamplePacScript[] = "test";
 const char kSamplePacScriptAsDataUrl[] =
     "data:application/x-ns-proxy-autoconfig;base64,dGVzdA==";
 const char kSamplePacScriptAsDataUrl2[] =
     "data:;base64,dGVzdA==";
 const char kSamplePacScriptUrl[] = "http://wpad/wpad.dat";
 
 // Helper function to create a ProxyServer dictionary as defined in the
 // extension API.
-std::unique_ptr<base::DictionaryValue> CreateTestProxyServerDict(
-    const std::string& host) {
-  auto dict = base::MakeUnique<base::DictionaryValue>();
+base::DictionaryValue* CreateTestProxyServerDict(const std::string& host) {
+  base::DictionaryValue* dict = new base::DictionaryValue;
   dict->SetString(keys::kProxyConfigRuleHost, host);
   return dict;
 }
 
 // Helper function to create a ProxyServer dictionary as defined in the
 // extension API.
-std::unique_ptr<base::DictionaryValue> CreateTestProxyServerDict(
-    const std::string& schema,
-    const std::string& host,
-    int port) {
-  auto dict = base::MakeUnique<base::DictionaryValue>();
+base::DictionaryValue* CreateTestProxyServerDict(const std::string& schema,
+                                                 const std::string& host,
+                                                 int port) {
+  base::DictionaryValue* dict = new base::DictionaryValue;
   dict->SetString(keys::kProxyConfigRuleScheme, schema);
   dict->SetString(keys::kProxyConfigRuleHost, host);
   dict->SetInteger(keys::kProxyConfigRulePort, port);
   return dict;
 }
 
 }  // namespace
 
 namespace proxy_api_helpers {
 
@@ skipping 54 matching lines @@
 
   // Currently we are still missing a PAC script entry.
   // This is silently ignored.
   ASSERT_TRUE(GetPacUrlFromExtensionPref(&proxy_config, &out, &error,
                                          &bad_message));
   EXPECT_EQ(std::string(), out);
   EXPECT_EQ(std::string(), error);
   EXPECT_FALSE(bad_message);
 
   // Set up a pac script.
-  auto pacScriptDict = base::MakeUnique<base::DictionaryValue>();
+  base::DictionaryValue* pacScriptDict = new base::DictionaryValue;
   pacScriptDict->SetString(keys::kProxyConfigPacScriptUrl, kSamplePacScriptUrl);
-  proxy_config.Set(keys::kProxyConfigPacScript, std::move(pacScriptDict));
+  proxy_config.Set(keys::kProxyConfigPacScript, pacScriptDict);
 
   ASSERT_TRUE(GetPacUrlFromExtensionPref(&proxy_config, &out, &error,
                                          &bad_message));
   EXPECT_EQ(kSamplePacScriptUrl, out);
   EXPECT_EQ(std::string(), error);
   EXPECT_FALSE(bad_message);
 }
 
 TEST(ExtensionProxyApiHelpers, GetPacDataFromExtensionPref) {
   std::string out;
   std::string error;
   bool bad_message = false;
 
   base::DictionaryValue proxy_config;
   proxy_config.SetString(
       keys::kProxyConfigMode,
       ProxyPrefs::ProxyModeToString(ProxyPrefs::MODE_PAC_SCRIPT));
 
   // Currently we are still missing a PAC data entry. This is silently ignored.
   ASSERT_TRUE(GetPacDataFromExtensionPref(&proxy_config, &out, &error,
                                           &bad_message));
   EXPECT_EQ(std::string(), out);
   EXPECT_EQ(std::string(), error);
   EXPECT_FALSE(bad_message);
 
   // Set up a PAC script.
-  auto pacScriptDict = base::MakeUnique<base::DictionaryValue>();
+  base::DictionaryValue* pacScriptDict = new base::DictionaryValue;
   pacScriptDict->SetString(keys::kProxyConfigPacScriptData, kSamplePacScript);
-  proxy_config.Set(keys::kProxyConfigPacScript, std::move(pacScriptDict));
+  proxy_config.Set(keys::kProxyConfigPacScript, pacScriptDict);
 
   ASSERT_TRUE(GetPacDataFromExtensionPref(&proxy_config, &out, &error,
                                           &bad_message));
   EXPECT_EQ(kSamplePacScript, out);
   EXPECT_EQ(std::string(), error);
   EXPECT_FALSE(bad_message);
 }
 
 TEST(ExtensionProxyApiHelpers, GetProxyRulesStringFromExtensionPref) {
   std::string out;
   std::string error;
   bool bad_message = false;
 
   base::DictionaryValue proxy_config;
   proxy_config.SetString(
       keys::kProxyConfigMode,
       ProxyPrefs::ProxyModeToString(ProxyPrefs::MODE_FIXED_SERVERS));
 
   // Currently we are still missing a proxy config entry.
   // This is silently ignored.
   ASSERT_TRUE(
       GetProxyRulesStringFromExtensionPref(&proxy_config, &out, &error,
                                            &bad_message));
   EXPECT_EQ(std::string(), out);
   EXPECT_EQ(std::string(), error);
 
-  auto proxy_rules = base::MakeUnique<base::DictionaryValue>();
+  base::DictionaryValue* proxy_rules = new base::DictionaryValue;
   proxy_rules->Set(keys::field_name[1], CreateTestProxyServerDict("proxy1"));
   proxy_rules->Set(keys::field_name[2], CreateTestProxyServerDict("proxy2"));
-  proxy_config.Set(keys::kProxyConfigRules, std::move(proxy_rules));
+  proxy_config.Set(keys::kProxyConfigRules, proxy_rules);
 
   ASSERT_TRUE(
       GetProxyRulesStringFromExtensionPref(&proxy_config, &out, &error,
                                            &bad_message));
   EXPECT_EQ("http=proxy1:80;https=proxy2:80", out);
   EXPECT_EQ(std::string(), error);
   EXPECT_FALSE(bad_message);
 }
 
 TEST(ExtensionProxyApiHelpers, GetBypassListFromExtensionPref) {
   std::string out;
   std::string error;
   bool bad_message = false;
 
   base::DictionaryValue proxy_config;
   proxy_config.SetString(
       keys::kProxyConfigMode,
       ProxyPrefs::ProxyModeToString(ProxyPrefs::MODE_FIXED_SERVERS));
 
   // Currently we are still missing a proxy config entry.
   // This is silently ignored.
   ASSERT_TRUE(
       GetBypassListFromExtensionPref(&proxy_config, &out, &error,
                                      &bad_message));
   EXPECT_EQ(std::string(), out);
   EXPECT_EQ(std::string(), error);
   EXPECT_FALSE(bad_message);
 
-  auto bypass_list = base::MakeUnique<base::ListValue>();
+  base::ListValue* bypass_list = new base::ListValue;
   bypass_list->AppendString("host1");
   bypass_list->AppendString("host2");
-  auto proxy_rules = base::MakeUnique<base::DictionaryValue>();
-  proxy_rules->Set(keys::kProxyConfigBypassList, std::move(bypass_list));
-  proxy_config.Set(keys::kProxyConfigRules, std::move(proxy_rules));
+  base::DictionaryValue* proxy_rules = new base::DictionaryValue;
+  proxy_rules->Set(keys::kProxyConfigBypassList, bypass_list);
+  proxy_config.Set(keys::kProxyConfigRules, proxy_rules);
 
   ASSERT_TRUE(
       GetBypassListFromExtensionPref(&proxy_config, &out, &error,
                                      &bad_message));
   EXPECT_EQ("host1,host2", out);
   EXPECT_EQ(std::string(), error);
   EXPECT_FALSE(bad_message);
 }
 
 TEST(ExtensionProxyApiHelpers, CreateProxyConfigDict) {
@@ skipping 95 matching lines @@
 
   std::unique_ptr<base::DictionaryValue> expected(new base::DictionaryValue);
   expected->Set("proxyForHttp",
                 CreateTestProxyServerDict("http", "proxy1", 80));
   expected->Set("proxyForHttps",
                 CreateTestProxyServerDict("http", "proxy2", 80));
   expected->Set("proxyForFtp",
                 CreateTestProxyServerDict("http", "proxy3", 80));
   expected->Set("fallbackProxy",
                 CreateTestProxyServerDict("socks4", "proxy4", 80));
-  auto bypass_list = base::MakeUnique<base::ListValue>();
+  base::ListValue* bypass_list = new base::ListValue;
   bypass_list->AppendString("localhost");
-  expected->Set(keys::kProxyConfigBypassList, std::move(bypass_list));
+  expected->Set(keys::kProxyConfigBypassList, bypass_list);
 
   EXPECT_TRUE(base::Value::Equals(expected.get(), extension_pref.get()));
 }
 
 // Test multiple proxies per scheme -- expect that only the first is returned.
 TEST(ExtensionProxyApiHelpers, CreateProxyRulesDictMultipleProxies) {
   std::unique_ptr<base::DictionaryValue> browser_pref(
       ProxyConfigDictionary::CreateFixedServers(
           "http=proxy1:80,default://;https=proxy2:80,proxy1:80;ftp=proxy3:80,"
           "https://proxy5:443;socks=proxy4:80,proxy1:80",
           "localhost"));
   ProxyConfigDictionary config(std::move(browser_pref));
   std::unique_ptr<base::DictionaryValue> extension_pref(
       CreateProxyRulesDict(config));
   ASSERT_TRUE(extension_pref.get());
 
   std::unique_ptr<base::DictionaryValue> expected(new base::DictionaryValue);
   expected->Set("proxyForHttp",
                 CreateTestProxyServerDict("http", "proxy1", 80));
   expected->Set("proxyForHttps",
                 CreateTestProxyServerDict("http", "proxy2", 80));
   expected->Set("proxyForFtp",
                 CreateTestProxyServerDict("http", "proxy3", 80));
   expected->Set("fallbackProxy",
                 CreateTestProxyServerDict("socks4", "proxy4", 80));
-  auto bypass_list = base::MakeUnique<base::ListValue>();
+  base::ListValue* bypass_list = new base::ListValue;
   bypass_list->AppendString("localhost");
-  expected->Set(keys::kProxyConfigBypassList, std::move(bypass_list));
+  expected->Set(keys::kProxyConfigBypassList, bypass_list);
 
   EXPECT_TRUE(base::Value::Equals(expected.get(), extension_pref.get()));
 }
 
 // Test if a PAC script URL is specified.
 TEST(ExtensionProxyApiHelpers, CreatePacScriptDictWithUrl) {
   std::unique_ptr<base::DictionaryValue> browser_pref(
       ProxyConfigDictionary::CreatePacScript(kSamplePacScriptUrl, false));
   ProxyConfigDictionary config(std::move(browser_pref));
   std::unique_ptr<base::DictionaryValue> extension_pref(
@@ skipping 28 matching lines @@
   expected.AppendString("s1");
   expected.AppendString("s2");
   expected.AppendString("s3");
 
   std::unique_ptr<base::ListValue> out(TokenizeToStringList("s1;s2;s3", ";"));
   EXPECT_TRUE(base::Value::Equals(&expected, out.get()));
 }
 
 }  // namespace proxy_api_helpers
 }  // namespace extensions