Return a unique_ptr from BinaryValue::CreateWithCopiedBuffer.

chrome/browser/extensions/api/audio_modem/audio_modem_api_unittest.cc

 // Copyright 2015 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/extensions/api/audio_modem/audio_modem_api.h"
 
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 41 matching lines @@
 // Create a test AudioModemAPI and store the modem it uses.
 std::unique_ptr<KeyedService> ApiFactoryFunction(BrowserContext* context) {
   StubModem* modem = new StubModem;
   g_modems[context] = modem;
   return base::WrapUnique(new AudioModemAPI(
       context,
       base::WrapUnique<audio_modem::WhispernetClient>(new StubWhispernetClient),
       base::WrapUnique<audio_modem::Modem>(modem)));
 }
 
-DictionaryValue* CreateParams(const std::string& audio_band) {
-  DictionaryValue* params = new DictionaryValue;
+std::unique_ptr<DictionaryValue> CreateParams(const std::string& audio_band) {
+  std::unique_ptr<DictionaryValue> params(new DictionaryValue);
   params->SetInteger("timeoutMillis", 60000);
   params->SetString("band", audio_band);
   params->SetInteger("encoding.tokenLength", 4);
   return params;
 }
 
-BinaryValue* CreateToken(const std::string& token) {
+std::unique_ptr<BinaryValue> CreateToken(const std::string& token) {
   return BinaryValue::CreateWithCopiedBuffer(token.c_str(), token.size());
 }
 
-std::unique_ptr<ListValue> CreateList(Value* single_elt) {
+std::unique_ptr<ListValue> CreateList(std::unique_ptr<Value> single_elt) {

[dcheng, 2016/06/15 08:34:03]

IIRC, we're passing something created by BinaryValue::CreateWithCopiedBuffer to
this helper. The corresponding changes are to make everything else still build.

   std::unique_ptr<ListValue> list(new ListValue);
-  list->Append(single_elt);
+  list->Append(std::move(single_elt));
   return list;
 }
 
-std::unique_ptr<ListValue> CreateList(Value* elt1, Value* elt2) {
+std::unique_ptr<ListValue> CreateList(std::unique_ptr<Value> elt1,
+                                      std::unique_ptr<Value> elt2) {
   std::unique_ptr<ListValue> list(new ListValue);
-  list->Append(elt1);
-  list->Append(elt2);
+  list->Append(std::move(elt1));
+  list->Append(std::move(elt2));
   return list;
 }
 
 DictionaryValue* CreateReceivedToken(const std::string& token,
                                      const std::string& audio_band) {
   DictionaryValue* out = new DictionaryValue;
   out->Set("token", CreateToken(token));
   out->SetString("band", audio_band);
   return out;
 }
@@ skipping 125 matching lines @@
       events_by_extension_id_;
 };
 
 TEST_F(AudioModemApiUnittest, TransmitBasic) {
   // Start transmitting inaudibly.
   EXPECT_EQ("success", RunFunction<AudioModemTransmitFunction>(
       CreateList(CreateParams("inaudible"), CreateToken("1234"))));
   EXPECT_TRUE(GetModem()->IsPlaying(INAUDIBLE));
 
   // Can't cancel audible transmit - we haven't started it yet.
-  EXPECT_EQ("invalidRequest", RunFunction<AudioModemStopTransmitFunction>(
-      CreateList(new StringValue("audible"))));
+  EXPECT_EQ("invalidRequest",
+            RunFunction<AudioModemStopTransmitFunction>(
+                CreateList(base::MakeUnique<StringValue>("audible"))));
 
   // Start transmitting audibly.
   EXPECT_EQ("success", RunFunction<AudioModemTransmitFunction>(
       CreateList(CreateParams("audible"), CreateToken("ABCD"))));
   EXPECT_TRUE(GetModem()->IsPlaying(AUDIBLE));
 
   // Stop audible transmit. We're still transmitting inaudibly.
-  EXPECT_EQ("success", RunFunction<AudioModemStopTransmitFunction>(
-      CreateList(new StringValue("audible"))));
+  EXPECT_EQ("success", RunFunction<AudioModemStopTransmitFunction>(CreateList(
+                           base::MakeUnique<StringValue>("audible"))));
   EXPECT_FALSE(GetModem()->IsPlaying(AUDIBLE));
   EXPECT_TRUE(GetModem()->IsPlaying(INAUDIBLE));
 
   // Stop inaudible transmit.
-  EXPECT_EQ("success", RunFunction<AudioModemStopTransmitFunction>(
-      CreateList(new StringValue("inaudible"))));
+  EXPECT_EQ("success", RunFunction<AudioModemStopTransmitFunction>(CreateList(
+                           base::MakeUnique<StringValue>("inaudible"))));
   EXPECT_FALSE(GetModem()->IsPlaying(INAUDIBLE));
 }
 
 TEST_F(AudioModemApiUnittest, ReceiveBasic) {
   // Start listening for audible tokens.
   EXPECT_EQ("success", RunFunction<AudioModemReceiveFunction>(
       CreateList(CreateParams("audible"))));
   EXPECT_TRUE(GetModem()->IsRecording(AUDIBLE));
 
   // Can't cancel inaudible receive - we haven't started it yet.
-  EXPECT_EQ("invalidRequest", RunFunction<AudioModemStopReceiveFunction>(
-      CreateList(new StringValue("inaudible"))));
+  EXPECT_EQ("invalidRequest",
+            RunFunction<AudioModemStopReceiveFunction>(
+                CreateList(base::MakeUnique<StringValue>("inaudible"))));
 
   // Send some audible tokens.
   std::vector<AudioToken> tokens;
   tokens.push_back(AudioToken("1234", true));
   tokens.push_back(AudioToken("ABCD", true));
   tokens.push_back(AudioToken("abcd", false));
   GetModem()->DeliverTokens(tokens);
 
   // Check the tokens received.
   EXPECT_EQ(1u, GetEvents().size());
@@ skipping 14 matching lines @@
   GetModem()->DeliverTokens(tokens);
 
   // Check the tokens received.
   EXPECT_EQ(2u, GetEvents().size());
   expected_tokens->Append(CreateReceivedToken("abcd", "inaudible"));
   expected_tokens->Append(CreateReceivedToken("5678", "inaudible"));
   GetEvents()[1]->event_args->GetList(0, &received_tokens);
   EXPECT_TRUE(received_tokens->Equals(expected_tokens.get()));
 
   // Stop audible receive. We're still receiving inaudible.
-  EXPECT_EQ("success", RunFunction<AudioModemStopReceiveFunction>(
-      CreateList(new StringValue("audible"))));
+  EXPECT_EQ("success", RunFunction<AudioModemStopReceiveFunction>(CreateList(
+                           base::MakeUnique<StringValue>("audible"))));
   EXPECT_FALSE(GetModem()->IsRecording(AUDIBLE));
   EXPECT_TRUE(GetModem()->IsRecording(INAUDIBLE));
 
   // Stop inaudible receive.
-  EXPECT_EQ("success", RunFunction<AudioModemStopReceiveFunction>(
-      CreateList(new StringValue("inaudible"))));
+  EXPECT_EQ("success", RunFunction<AudioModemStopReceiveFunction>(CreateList(
+                           base::MakeUnique<StringValue>("inaudible"))));
   EXPECT_FALSE(GetModem()->IsRecording(INAUDIBLE));
 }
 
 TEST_F(AudioModemApiUnittest, TransmitMultiple) {
   // Start transmit.
   EXPECT_EQ("success", RunFunction<AudioModemTransmitFunction>(
       CreateList(CreateParams("audible"), CreateToken("1234")),
       GetExtension("ext1")));
   EXPECT_TRUE(GetModem()->IsPlaying(AUDIBLE));
 
   // Another extension can't interfere with the first one.
   EXPECT_EQ("inUse", RunFunction<AudioModemTransmitFunction>(
       CreateList(CreateParams("audible"), CreateToken("ABCD")),
       GetExtension("ext2")));
-  EXPECT_EQ("invalidRequest", RunFunction<AudioModemStopTransmitFunction>(
-      CreateList(new StringValue("audible")), GetExtension("ext2")));
+  EXPECT_EQ("invalidRequest",
+            RunFunction<AudioModemStopTransmitFunction>(
+                CreateList(base::MakeUnique<StringValue>("audible")),
+                GetExtension("ext2")));
   EXPECT_TRUE(GetModem()->IsPlaying(AUDIBLE));
 
   // The other extension can use the other audio band, however.
   EXPECT_EQ("success", RunFunction<AudioModemTransmitFunction>(
       CreateList(CreateParams("inaudible"), CreateToken("ABCD")),
       GetExtension("ext2")));
   EXPECT_TRUE(GetModem()->IsPlaying(INAUDIBLE));
 
   // The first extension can change its token.
   // But the other band is still in use.
   EXPECT_EQ("success", RunFunction<AudioModemTransmitFunction>(
       CreateList(CreateParams("audible"), CreateToken("abcd")),
       GetExtension("ext1")));
   EXPECT_EQ("inUse", RunFunction<AudioModemTransmitFunction>(
       CreateList(CreateParams("inaudible"), CreateToken("1234")),
       GetExtension("ext1")));
 
   // Stop transmission.
   EXPECT_EQ("success", RunFunction<AudioModemStopTransmitFunction>(
-      CreateList(new StringValue("audible")), GetExtension("ext1")));
+                           CreateList(base::MakeUnique<StringValue>("audible")),
+                           GetExtension("ext1")));
   EXPECT_FALSE(GetModem()->IsPlaying(AUDIBLE));
-  EXPECT_EQ("success", RunFunction<AudioModemStopTransmitFunction>(
-      CreateList(new StringValue("inaudible")), GetExtension("ext2")));
+  EXPECT_EQ("success",
+            RunFunction<AudioModemStopTransmitFunction>(
+                CreateList(base::MakeUnique<StringValue>("inaudible")),
+                GetExtension("ext2")));
   EXPECT_FALSE(GetModem()->IsPlaying(INAUDIBLE));
 }
 
 TEST_F(AudioModemApiUnittest, ReceiveMultiple) {
   // Start receive. Multiple extensions can receive on the same band.
   EXPECT_EQ("success", RunFunction<AudioModemReceiveFunction>(
       CreateList(CreateParams("inaudible")), GetExtension("ext1")));
   EXPECT_TRUE(GetModem()->IsRecording(INAUDIBLE));
   EXPECT_EQ("success", RunFunction<AudioModemReceiveFunction>(
       CreateList(CreateParams("inaudible")), GetExtension("ext2")));
 
   // Receive a token.
   GetModem()->DeliverTokens(std::vector<AudioToken>(
       1, AudioToken("abcd", false)));
   EXPECT_EQ(1u, GetEventsForExtension("ext1").size());
   EXPECT_EQ(1u, GetEventsForExtension("ext2").size());
 
   // Check the token received.
   std::unique_ptr<DictionaryValue> expected_token(
       CreateReceivedToken("abcd", "inaudible"));
   EXPECT_TRUE(ReceivedSingleToken(GetEventsForExtension("ext1")[0].get(),
                                   expected_token.get()));
   EXPECT_TRUE(ReceivedSingleToken(GetEventsForExtension("ext2")[0].get(),
                                   expected_token.get()));
 
   // If one extension stops, the modem is still receiving for the other.
-  EXPECT_EQ("success", RunFunction<AudioModemStopReceiveFunction>(
-      CreateList(new StringValue("inaudible")), GetExtension("ext1")));
+  EXPECT_EQ("success",
+            RunFunction<AudioModemStopReceiveFunction>(
+                CreateList(base::MakeUnique<StringValue>("inaudible")),
+                GetExtension("ext1")));
   EXPECT_TRUE(GetModem()->IsRecording(INAUDIBLE));
 
   // Receive another token. Should only go to ext2.
   GetModem()->DeliverTokens(std::vector<AudioToken>(
       1, AudioToken("1234", false)));
   EXPECT_EQ(1u, GetEventsForExtension("ext1").size());
   EXPECT_EQ(2u, GetEventsForExtension("ext2").size());
   expected_token.reset(CreateReceivedToken("1234", "inaudible"));
   EXPECT_TRUE(ReceivedSingleToken(GetEventsForExtension("ext2")[1].get(),
                                   expected_token.get()));
 
-  EXPECT_EQ("success", RunFunction<AudioModemStopReceiveFunction>(
-      CreateList(new StringValue("inaudible")), GetExtension("ext2")));
+  EXPECT_EQ("success",
+            RunFunction<AudioModemStopReceiveFunction>(
+                CreateList(base::MakeUnique<StringValue>("inaudible")),
+                GetExtension("ext2")));
   EXPECT_FALSE(GetModem()->IsRecording(INAUDIBLE));
 }
 
 }  // namespace extensions