Remove more usage of the base::ListValue::Append(Value*) overload.

chrome/test/chromedriver/window_commands.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/window_commands.h"
 
 #include <stddef.h>
 
 #include <list>
 #include <string>
@@ skipping 66 matching lines @@
   std::string name;
   std::string value;
   std::string domain;
   std::string path;
   double expiry;
   bool http_only;
   bool secure;
   bool session;
 };
 
-base::DictionaryValue* CreateDictionaryFrom(const Cookie& cookie) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+std::unique_ptr<base::DictionaryValue> CreateDictionaryFrom(
+    const Cookie& cookie) {
+  std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("name", cookie.name);
   dict->SetString("value", cookie.value);
   if (!cookie.domain.empty())
     dict->SetString("domain", cookie.domain);
   if (!cookie.path.empty())
     dict->SetString("path", cookie.path);
   if (!cookie.session)
     dict->SetDouble("expiry", cookie.expiry);
   dict->SetBoolean("httpOnly", cookie.http_only);
   dict->SetBoolean("secure", cookie.secure);
@@ skipping 240 matching lines @@
   if (id->IsType(base::Value::TYPE_NULL)) {
     session->SwitchToTopFrame();
     return Status(kOk);
   }
 
   std::string script;
   base::ListValue args;
   const base::DictionaryValue* id_dict;
   if (id->GetAsDictionary(&id_dict)) {
     script = "function(elem) { return elem; }";
-    args.Append(id_dict->DeepCopy());
+    args.Append(id_dict->CreateDeepCopy());
   } else {
     script =
         "function(xpath) {"
         "  return document.evaluate(xpath, document, null, "
         "      XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;"
         "}";
     std::string xpath = "(/html/body//iframe|/html/frameset//frame)";
     std::string id_string;
     int id_int;
     if (id->GetAsString(&id_string)) {
@@ skipping 20 matching lines @@
   const base::DictionaryValue* element;
   if (!result->GetAsDictionary(&element))
     return Status(kUnknownError, "fail to locate the sub frame element");
 
   std::string chrome_driver_id = GenerateId();
   const char kSetFrameIdentifier[] =
       "function(frame, id) {"
       "  frame.setAttribute('cd_frame_id_', id);"
       "}";
   base::ListValue new_args;
-  new_args.Append(element->DeepCopy());
+  new_args.Append(element->CreateDeepCopy());
   new_args.AppendString(chrome_driver_id);
   result.reset(NULL);
   status = web_view->CallFunction(
       session->GetCurrentFrameId(), kSetFrameIdentifier, new_args, &result);
   if (status.IsError())
     return status;
   session->SwitchToSubFrame(frame, chrome_driver_id);
   return Status(kOk);
 }
 
@@ skipping 494 matching lines @@
 
 Status ExecuteAddCookie(Session* session,
                         WebView* web_view,
                         const base::DictionaryValue& params,
                         std::unique_ptr<base::Value>* value,
                         Timeout* timeout) {
   const base::DictionaryValue* cookie;
   if (!params.GetDictionary("cookie", &cookie))
     return Status(kUnknownError, "missing 'cookie'");
   base::ListValue args;
-  args.Append(cookie->DeepCopy());
+  args.Append(cookie->CreateDeepCopy());
   std::unique_ptr<base::Value> result;
   return web_view->CallFunction(
       session->GetCurrentFrameId(), kAddCookieScript, args, &result);
 }
 
 Status ExecuteDeleteCookie(Session* session,
                            WebView* web_view,
                            const base::DictionaryValue& params,
                            std::unique_ptr<base::Value>* value,
                            Timeout* timeout) {
@@ skipping 147 matching lines @@
   return status;
 }
 
 Status ExecuteTakeHeapSnapshot(Session* session,
                                WebView* web_view,
                                const base::DictionaryValue& params,
                                std::unique_ptr<base::Value>* value,
                                Timeout* timeout) {
   return web_view->TakeHeapSnapshot(value);
 }