Remove raw DictionaryValue::Set in //chrome

chrome/test/chromedriver/chrome/devtools_client_impl_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.
 
 #include "chrome/test/chromedriver/chrome/devtools_client_impl.h"
 
 #include <list>
 #include <memory>
 #include <string>
 
@@ skipping 54 matching lines @@
 
   SyncWebSocket::StatusCode ReceiveNextMessage(
       std::string* message,
       const Timeout& timeout) override {
     if (timeout.IsExpired())
       return SyncWebSocket::kTimeout;
     base::DictionaryValue response;
     response.SetInteger("id", id_);
     base::DictionaryValue result;
     result.SetInteger("param", 1);
-    response.Set("result", result.DeepCopy());
+    response.Set("result", base::MakeUnique<base::Value>(result));
     base::JSONWriter::Write(response, message);
     --queued_messages_;
     return SyncWebSocket::kOk;
   }
 
   bool HasNextMessage() override { return queued_messages_ > 0; }
 
  protected:
   bool connected_;
   int id_;
@@ skipping 633 matching lines @@
     EXPECT_TRUE(value->GetAsDictionary(&dict));
     if (!dict)
       return false;
     int id;
     EXPECT_TRUE(dict->GetInteger("id", &id));
     std::string method;
     EXPECT_TRUE(dict->GetString("method", &method));
 
     base::DictionaryValue response;
     response.SetInteger("id", id);
-    response.Set("result", new base::DictionaryValue());
+    response.Set("result", base::MakeUnique<base::DictionaryValue>());
     std::string json_response;
     base::JSONWriter::Write(response, &json_response);
     queued_response_.push_back(json_response);
 
     // Push one event.
     base::DictionaryValue event;
     event.SetString("method", "updateEvent");
-    event.Set("params", new base::DictionaryValue());
+    event.Set("params", base::MakeUnique<base::DictionaryValue>());
     std::string json_event;
     base::JSONWriter::Write(event, &json_event);
     queued_response_.push_back(json_event);
 
     return true;
   }
 
   SyncWebSocket::StatusCode ReceiveNextMessage(
       std::string* message,
       const Timeout& timeout) override {
@@ skipping 393 matching lines @@
       const Timeout& timeout) override {
     EXPECT_LE(sent_responses_, 1);
     EXPECT_EQ(sent_messages_, 2);
     base::DictionaryValue response;
     if (sent_responses_ == 0)
       response.SetInteger("id", 1);
     else
       response.SetInteger("id", 2);
     base::DictionaryValue result;
     result.SetInteger("param", 1);
-    response.Set("result", result.DeepCopy());
+    response.Set("result", base::MakeUnique<base::Value>(result));
     base::JSONWriter::Write(response, message);
     sent_responses_++;
     return SyncWebSocket::kOk;
   }
 
   bool HasNextMessage() override { return sent_messages_ > sent_responses_; }
 
 private:
   int id_;
   int sent_messages_;
   int sent_responses_;
 };
 
 } // namespace
 
 TEST_F(DevToolsClientImplTest, SendCommandAndIgnoreResponse) {
   SyncWebSocketFactory factory =
       base::Bind(&CreateMockSyncWebSocket<MockSyncWebSocket7>);
   DevToolsClientImpl client(factory, "http://url", "id",
                             base::Bind(&CloserFunc));
   ASSERT_EQ(kOk, client.ConnectIfNecessary().code());
   base::DictionaryValue params;
   params.SetInteger("param", 1);
   ASSERT_EQ(kOk, client.SendCommandAndIgnoreResponse("method", params).code());
   ASSERT_EQ(kOk, client.SendCommand("method", params).code());
 }