Remove raw DictionaryValue::Set in //chrome

chrome/test/chromedriver/capabilities_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/test/chromedriver/capabilities.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/chrome/log.h"
 #include "chrome/test/chromedriver/chrome/status.h"
@@ skipping 122 matching lines @@
   ASSERT_TRUE(status.IsOk());
   ASSERT_STREQ("path/to/logfile", capabilities.log_path.c_str());
 }
 
 TEST(ParseCapabilities, Args) {
   Capabilities capabilities;
   base::ListValue args;
   args.AppendString("arg1");
   args.AppendString("arg2=val");
   base::DictionaryValue caps;
-  caps.Set("chromeOptions.args", args.DeepCopy());
+  caps.Set("chromeOptions.args", base::MakeUnique<base::Value>(args));
 
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
 
   ASSERT_EQ(2u, capabilities.switches.GetSize());
   ASSERT_TRUE(capabilities.switches.HasSwitch("arg1"));
   ASSERT_TRUE(capabilities.switches.HasSwitch("arg2"));
   ASSERT_EQ("", capabilities.switches.GetSwitchValue("arg1"));
   ASSERT_EQ("val", capabilities.switches.GetSwitchValue("arg2"));
 }
 
 TEST(ParseCapabilities, Prefs) {
   Capabilities capabilities;
   base::DictionaryValue prefs;
   prefs.SetString("key1", "value1");
   prefs.SetString("key2.k", "value2");
   base::DictionaryValue caps;
-  caps.Set("chromeOptions.prefs", prefs.DeepCopy());
+  caps.Set("chromeOptions.prefs", base::MakeUnique<base::Value>(prefs));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_TRUE(capabilities.prefs->Equals(&prefs));
 }
 
 TEST(ParseCapabilities, LocalState) {
   Capabilities capabilities;
   base::DictionaryValue local_state;
   local_state.SetString("s1", "v1");
   local_state.SetString("s2.s", "v2");
   base::DictionaryValue caps;
-  caps.Set("chromeOptions.localState", local_state.DeepCopy());
+  caps.Set("chromeOptions.localState",
+           base::MakeUnique<base::Value>(local_state));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_TRUE(capabilities.local_state->Equals(&local_state));
 }
 
 TEST(ParseCapabilities, Extensions) {
   Capabilities capabilities;
   base::ListValue extensions;
   extensions.AppendString("ext1");
   extensions.AppendString("ext2");
   base::DictionaryValue caps;
-  caps.Set("chromeOptions.extensions", extensions.DeepCopy());
+  caps.Set("chromeOptions.extensions",
+           base::MakeUnique<base::Value>(extensions));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(2u, capabilities.extensions.size());
   ASSERT_EQ("ext1", capabilities.extensions[0]);
   ASSERT_EQ("ext2", capabilities.extensions[1]);
 }
 
 TEST(ParseCapabilities, UnrecognizedProxyType) {
   Capabilities capabilities;
   base::DictionaryValue proxy;
   proxy.SetString("proxyType", "unknown proxy type");
   base::DictionaryValue caps;
-  caps.Set("proxy", proxy.DeepCopy());
+  caps.Set("proxy", base::MakeUnique<base::Value>(proxy));
   Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
 TEST(ParseCapabilities, IllegalProxyType) {
   Capabilities capabilities;
   base::DictionaryValue proxy;
   proxy.SetInteger("proxyType", 123);
   base::DictionaryValue caps;
-  caps.Set("proxy", proxy.DeepCopy());
+  caps.Set("proxy", base::MakeUnique<base::Value>(proxy));
   Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
 TEST(ParseCapabilities, DirectProxy) {
   Capabilities capabilities;
   base::DictionaryValue proxy;
   proxy.SetString("proxyType", "DIRECT");
   base::DictionaryValue caps;
-  caps.Set("proxy", proxy.DeepCopy());
+  caps.Set("proxy", base::MakeUnique<base::Value>(proxy));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(1u, capabilities.switches.GetSize());
   ASSERT_TRUE(capabilities.switches.HasSwitch("no-proxy-server"));
 }
 
 TEST(ParseCapabilities, SystemProxy) {
   Capabilities capabilities;
   base::DictionaryValue proxy;
   proxy.SetString("proxyType", "system");
   base::DictionaryValue caps;
-  caps.Set("proxy", proxy.DeepCopy());
+  caps.Set("proxy", base::MakeUnique<base::Value>(proxy));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(0u, capabilities.switches.GetSize());
 }
 
 TEST(ParseCapabilities, PacProxy) {
   Capabilities capabilities;
   base::DictionaryValue proxy;
   proxy.SetString("proxyType", "PAC");
   proxy.SetString("proxyAutoconfigUrl", "test.wpad");
   base::DictionaryValue caps;
-  caps.Set("proxy", proxy.DeepCopy());
+  caps.Set("proxy", base::MakeUnique<base::Value>(proxy));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(1u, capabilities.switches.GetSize());
   ASSERT_EQ("test.wpad", capabilities.switches.GetSwitchValue("proxy-pac-url"));
 }
 
 TEST(ParseCapabilities, MissingProxyAutoconfigUrl) {
   Capabilities capabilities;
   base::DictionaryValue proxy;
   proxy.SetString("proxyType", "PAC");
   proxy.SetString("httpProxy", "http://localhost:8001");
   base::DictionaryValue caps;
-  caps.Set("proxy", proxy.DeepCopy());
+  caps.Set("proxy", base::MakeUnique<base::Value>(proxy));
   Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
 TEST(ParseCapabilities, AutodetectProxy) {
   Capabilities capabilities;
   base::DictionaryValue proxy;
   proxy.SetString("proxyType", "autodetect");
   base::DictionaryValue caps;
-  caps.Set("proxy", proxy.DeepCopy());
+  caps.Set("proxy", base::MakeUnique<base::Value>(proxy));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(1u, capabilities.switches.GetSize());
   ASSERT_TRUE(capabilities.switches.HasSwitch("proxy-auto-detect"));
 }
 
 TEST(ParseCapabilities, ManualProxy) {
   Capabilities capabilities;
   base::DictionaryValue proxy;
   proxy.SetString("proxyType", "manual");
   proxy.SetString("ftpProxy", "localhost:9001");
   proxy.SetString("httpProxy", "localhost:8001");
   proxy.SetString("sslProxy", "localhost:10001");
   proxy.SetString("noProxy", "google.com, youtube.com");
   base::DictionaryValue caps;
-  caps.Set("proxy", proxy.DeepCopy());
+  caps.Set("proxy", base::MakeUnique<base::Value>(proxy));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(2u, capabilities.switches.GetSize());
   ASSERT_EQ(
       "ftp=localhost:9001;http=localhost:8001;https=localhost:10001",
       capabilities.switches.GetSwitchValue("proxy-server"));
   ASSERT_EQ(
       "google.com, youtube.com",
       capabilities.switches.GetSwitchValue("proxy-bypass-list"));
 }
 
 TEST(ParseCapabilities, MissingSettingForManualProxy) {
   Capabilities capabilities;
   base::DictionaryValue proxy;
   proxy.SetString("proxyType", "manual");
   base::DictionaryValue caps;
-  caps.Set("proxy", proxy.DeepCopy());
+  caps.Set("proxy", base::MakeUnique<base::Value>(proxy));
   Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
 TEST(ParseCapabilities, IgnoreNullValueForManualProxy) {
   Capabilities capabilities;
   base::DictionaryValue proxy;
   proxy.SetString("proxyType", "manual");
   proxy.SetString("ftpProxy", "localhost:9001");
   proxy.Set("sslProxy", base::MakeUnique<base::Value>());
   proxy.Set("noProxy", base::MakeUnique<base::Value>());
   base::DictionaryValue caps;
-  caps.Set("proxy", proxy.DeepCopy());
+  caps.Set("proxy", base::MakeUnique<base::Value>(proxy));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(1u, capabilities.switches.GetSize());
   ASSERT_TRUE(capabilities.switches.HasSwitch("proxy-server"));
   ASSERT_EQ(
       "ftp=localhost:9001",
       capabilities.switches.GetSwitchValue("proxy-server"));
 }
 
 TEST(ParseCapabilities, LoggingPrefsOk) {
   Capabilities capabilities;
   base::DictionaryValue logging_prefs;
   logging_prefs.SetString("Network", "INFO");
   base::DictionaryValue caps;
-  caps.Set("loggingPrefs", logging_prefs.DeepCopy());
+  caps.Set("loggingPrefs", base::MakeUnique<base::Value>(logging_prefs));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(1u, capabilities.logging_prefs.size());
   ASSERT_EQ(Log::kInfo, capabilities.logging_prefs["Network"]);
 }
 
 TEST(ParseCapabilities, LoggingPrefsNotDict) {
   Capabilities capabilities;
   base::DictionaryValue caps;
   caps.SetString("loggingPrefs", "INFO");
   Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
 TEST(ParseCapabilities, PerfLoggingPrefsInspectorDomainStatus) {
   Capabilities capabilities;
   // Perf log must be enabled if performance log preferences are specified.
   base::DictionaryValue logging_prefs;
   logging_prefs.SetString(WebDriverLog::kPerformanceType, "INFO");
   base::DictionaryValue desired_caps;
-  desired_caps.Set("loggingPrefs", logging_prefs.DeepCopy());
+  desired_caps.Set("loggingPrefs",
+                   base::MakeUnique<base::Value>(logging_prefs));
   ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kDefaultEnabled,
             capabilities.perf_logging_prefs.network);
   ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kDefaultEnabled,
             capabilities.perf_logging_prefs.page);
   ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kDefaultDisabled,
             capabilities.perf_logging_prefs.timeline);
   base::DictionaryValue perf_logging_prefs;
   perf_logging_prefs.SetBoolean("enableNetwork", true);
   perf_logging_prefs.SetBoolean("enablePage", false);
   desired_caps.Set("chromeOptions.perfLoggingPrefs",
-                   perf_logging_prefs.DeepCopy());
+                   base::MakeUnique<base::Value>(perf_logging_prefs));
   Status status = capabilities.Parse(desired_caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kExplicitlyEnabled,
             capabilities.perf_logging_prefs.network);
   ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kExplicitlyDisabled,
             capabilities.perf_logging_prefs.page);
   ASSERT_EQ(PerfLoggingPrefs::InspectorDomainStatus::kDefaultDisabled,
             capabilities.perf_logging_prefs.timeline);
 }
 
 TEST(ParseCapabilities, PerfLoggingPrefsTracing) {
   Capabilities capabilities;
   // Perf log must be enabled if performance log preferences are specified.
   base::DictionaryValue logging_prefs;
   logging_prefs.SetString(WebDriverLog::kPerformanceType, "INFO");
   base::DictionaryValue desired_caps;
-  desired_caps.Set("loggingPrefs", logging_prefs.DeepCopy());
+  desired_caps.Set("loggingPrefs",
+                   base::MakeUnique<base::Value>(logging_prefs));
   ASSERT_EQ("", capabilities.perf_logging_prefs.trace_categories);
   base::DictionaryValue perf_logging_prefs;
   perf_logging_prefs.SetString("traceCategories", "benchmark,blink.console");
   perf_logging_prefs.SetInteger("bufferUsageReportingInterval", 1234);
   desired_caps.Set("chromeOptions.perfLoggingPrefs",
-                   perf_logging_prefs.DeepCopy());
+                   base::MakeUnique<base::Value>(perf_logging_prefs));
   Status status = capabilities.Parse(desired_caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ("benchmark,blink.console",
             capabilities.perf_logging_prefs.trace_categories);
   ASSERT_EQ(1234,
             capabilities.perf_logging_prefs.buffer_usage_reporting_interval);
 }
 
 TEST(ParseCapabilities, PerfLoggingPrefsInvalidInterval) {
   Capabilities capabilities;
   // Perf log must be enabled if performance log preferences are specified.
   base::DictionaryValue logging_prefs;
   logging_prefs.SetString(WebDriverLog::kPerformanceType, "INFO");
   base::DictionaryValue desired_caps;
-  desired_caps.Set("loggingPrefs", logging_prefs.DeepCopy());
+  desired_caps.Set("loggingPrefs",
+                   base::MakeUnique<base::Value>(logging_prefs));
   base::DictionaryValue perf_logging_prefs;
   // A bufferUsageReportingInterval interval <= 0 will cause DevTools errors.
   perf_logging_prefs.SetInteger("bufferUsageReportingInterval", 0);
   desired_caps.Set("chromeOptions.perfLoggingPrefs",
-                   perf_logging_prefs.DeepCopy());
+                   base::MakeUnique<base::Value>(perf_logging_prefs));
   Status status = capabilities.Parse(desired_caps);
   ASSERT_FALSE(status.IsOk());
 }
 
 TEST(ParseCapabilities, PerfLoggingPrefsNotDict) {
   Capabilities capabilities;
   // Perf log must be enabled if performance log preferences are specified.
   base::DictionaryValue logging_prefs;
   logging_prefs.SetString(WebDriverLog::kPerformanceType, "INFO");
   base::DictionaryValue desired_caps;
-  desired_caps.Set("loggingPrefs", logging_prefs.DeepCopy());
+  desired_caps.Set("loggingPrefs",
+                   base::MakeUnique<base::Value>(logging_prefs));
   desired_caps.SetString("chromeOptions.perfLoggingPrefs", "traceCategories");
   Status status = capabilities.Parse(desired_caps);
   ASSERT_FALSE(status.IsOk());
 }
 
 TEST(ParseCapabilities, PerfLoggingPrefsNoPerfLogLevel) {
   Capabilities capabilities;
   base::DictionaryValue desired_caps;
   base::DictionaryValue perf_logging_prefs;
   perf_logging_prefs.SetBoolean("enableNetwork", true);
   desired_caps.Set("chromeOptions.perfLoggingPrefs",
-                   perf_logging_prefs.DeepCopy());
+                   base::MakeUnique<base::Value>(perf_logging_prefs));
   // Should fail because perf log must be enabled if perf log prefs specified.
   Status status = capabilities.Parse(desired_caps);
   ASSERT_FALSE(status.IsOk());
 }
 
 TEST(ParseCapabilities, PerfLoggingPrefsPerfLogOff) {
   Capabilities capabilities;
   base::DictionaryValue logging_prefs;
   // Disable performance log by setting logging level to OFF.
   logging_prefs.SetString(WebDriverLog::kPerformanceType, "OFF");
   base::DictionaryValue desired_caps;
-  desired_caps.Set("loggingPrefs", logging_prefs.DeepCopy());
+  desired_caps.Set("loggingPrefs",
+                   base::MakeUnique<base::Value>(logging_prefs));
   base::DictionaryValue perf_logging_prefs;
   perf_logging_prefs.SetBoolean("enableNetwork", true);
   desired_caps.Set("chromeOptions.perfLoggingPrefs",
-                   perf_logging_prefs.DeepCopy());
+                   base::MakeUnique<base::Value>(perf_logging_prefs));
   // Should fail because perf log must be enabled if perf log prefs specified.
   Status status = capabilities.Parse(desired_caps);
   ASSERT_FALSE(status.IsOk());
 }
 
 TEST(ParseCapabilities, ExcludeSwitches) {
   Capabilities capabilities;
   base::ListValue exclude_switches;
   exclude_switches.AppendString("switch1");
   exclude_switches.AppendString("switch2");
   base::DictionaryValue caps;
-  caps.Set("chromeOptions.excludeSwitches", exclude_switches.DeepCopy());
+  caps.Set("chromeOptions.excludeSwitches",
+           base::MakeUnique<base::Value>(exclude_switches));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(2u, capabilities.exclude_switches.size());
   const std::set<std::string>& switches = capabilities.exclude_switches;
   ASSERT_TRUE(switches.find("switch1") != switches.end());
   ASSERT_TRUE(switches.find("switch2") != switches.end());
 }
 
 TEST(ParseCapabilities, UseRemoteBrowser) {
   Capabilities capabilities;
   base::DictionaryValue caps;
   caps.SetString("chromeOptions.debuggerAddress", "abc:123");
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_TRUE(capabilities.IsRemoteBrowser());
   ASSERT_EQ("abc", capabilities.debugger_address.host());
   ASSERT_EQ(123, capabilities.debugger_address.port());
 }
 
 TEST(ParseCapabilities, MobileEmulationUserAgent) {
   Capabilities capabilities;
   base::DictionaryValue mobile_emulation;
   mobile_emulation.SetString("userAgent", "Agent Smith");
   base::DictionaryValue caps;
-  caps.Set("chromeOptions.mobileEmulation", mobile_emulation.DeepCopy());
+  caps.Set("chromeOptions.mobileEmulation",
+           base::MakeUnique<base::Value>(mobile_emulation));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
 
   ASSERT_EQ(1u, capabilities.switches.GetSize());
   ASSERT_TRUE(capabilities.switches.HasSwitch("user-agent"));
   ASSERT_EQ("Agent Smith", capabilities.switches.GetSwitchValue("user-agent"));
 }
 
 TEST(ParseCapabilities, MobileEmulationDeviceMetrics) {
   Capabilities capabilities;
   base::DictionaryValue mobile_emulation;
   mobile_emulation.SetInteger("deviceMetrics.width", 360);
   mobile_emulation.SetInteger("deviceMetrics.height", 640);
   mobile_emulation.SetDouble("deviceMetrics.pixelRatio", 3.0);
   base::DictionaryValue caps;
-  caps.Set("chromeOptions.mobileEmulation", mobile_emulation.DeepCopy());
+  caps.Set("chromeOptions.mobileEmulation",
+           base::MakeUnique<base::Value>(mobile_emulation));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
 
   ASSERT_EQ(360, capabilities.device_metrics->width);
   ASSERT_EQ(640, capabilities.device_metrics->height);
   ASSERT_EQ(3.0, capabilities.device_metrics->device_scale_factor);
 }
 
 TEST(ParseCapabilities, MobileEmulationDeviceName) {
   Capabilities capabilities;
   base::DictionaryValue mobile_emulation;
   mobile_emulation.SetString("deviceName", "Google Nexus 5");
   base::DictionaryValue caps;
-  caps.Set("chromeOptions.mobileEmulation", mobile_emulation.DeepCopy());
+  caps.Set("chromeOptions.mobileEmulation",
+           base::MakeUnique<base::Value>(mobile_emulation));
   Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
 
   ASSERT_EQ(1u, capabilities.switches.GetSize());
   ASSERT_TRUE(capabilities.switches.HasSwitch("user-agent"));
   ASSERT_EQ(
       "Mozilla/5.0 (Linux; Android 4.4.4; Nexus 5 Build/KTU84P) "
       "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/38.0.2125.114 Mobile "
       "Safari/537.36",
       capabilities.switches.GetSwitchValue("user-agent"));
 
   ASSERT_EQ(360, capabilities.device_metrics->width);
   ASSERT_EQ(640, capabilities.device_metrics->height);
   ASSERT_EQ(3.0, capabilities.device_metrics->device_scale_factor);
 }
 
 TEST(ParseCapabilities, MobileEmulationNotDict) {
   Capabilities capabilities;
   base::DictionaryValue caps;
   caps.SetString("chromeOptions.mobileEmulation", "Google Nexus 5");
   Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
 TEST(ParseCapabilities, MobileEmulationDeviceMetricsNotDict) {
   Capabilities capabilities;
   base::DictionaryValue mobile_emulation;
   mobile_emulation.SetInteger("deviceMetrics", 360);
   base::DictionaryValue caps;
-  caps.Set("chromeOptions.mobileEmulation", mobile_emulation.DeepCopy());
+  caps.Set("chromeOptions.mobileEmulation",
+           base::MakeUnique<base::Value>(mobile_emulation));
   Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
 TEST(ParseCapabilities, MobileEmulationDeviceMetricsNotNumbers) {
   Capabilities capabilities;
   base::DictionaryValue mobile_emulation;
   mobile_emulation.SetString("deviceMetrics.width", "360");
   mobile_emulation.SetString("deviceMetrics.height", "640");
   mobile_emulation.SetString("deviceMetrics.pixelRatio", "3.0");
   base::DictionaryValue caps;
-  caps.Set("chromeOptions.mobileEmulation", mobile_emulation.DeepCopy());
+  caps.Set("chromeOptions.mobileEmulation",
+           base::MakeUnique<base::Value>(mobile_emulation));
   Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
 TEST(ParseCapabilities, MobileEmulationBadDict) {
   Capabilities capabilities;
   base::DictionaryValue mobile_emulation;
   mobile_emulation.SetString("deviceName", "Google Nexus 5");
   mobile_emulation.SetInteger("deviceMetrics.width", 360);
   mobile_emulation.SetInteger("deviceMetrics.height", 640);
   mobile_emulation.SetDouble("deviceMetrics.pixelRatio", 3.0);
   base::DictionaryValue caps;
-  caps.Set("chromeOptions.mobileEmulation", mobile_emulation.DeepCopy());
+  caps.Set("chromeOptions.mobileEmulation",
+           base::MakeUnique<base::Value>(mobile_emulation));
   Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }