Return a unique_ptr from BinaryValue::CreateWithCopiedBuffer.

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

Index: chrome/browser/extensions/api/audio_modem/audio_modem_api_unittest.cc
diff --git a/chrome/browser/extensions/api/audio_modem/audio_modem_api_unittest.cc b/chrome/browser/extensions/api/audio_modem/audio_modem_api_unittest.cc
index f72d44a24404e60457740b3337b0acc0387baee1..22daaff577c5f2a29cb82884f77f2ad2f3f5e472 100644
--- a/chrome/browser/extensions/api/audio_modem/audio_modem_api_unittest.cc
+++ b/chrome/browser/extensions/api/audio_modem/audio_modem_api_unittest.cc
@@ -59,28 +59,29 @@ std::unique_ptr<KeyedService> ApiFactoryFunction(BrowserContext* context) {
       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;
 }
 
@@ -226,8 +227,9 @@ TEST_F(AudioModemApiUnittest, TransmitBasic) {
   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>(
@@ -235,14 +237,14 @@ TEST_F(AudioModemApiUnittest, TransmitBasic) {
   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));
 }
 
@@ -253,8 +255,9 @@ TEST_F(AudioModemApiUnittest, ReceiveBasic) {
   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;
@@ -289,14 +292,14 @@ TEST_F(AudioModemApiUnittest, ReceiveBasic) {
   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));
 }
 
@@ -311,8 +314,10 @@ TEST_F(AudioModemApiUnittest, TransmitMultiple) {
   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.
@@ -332,10 +337,13 @@ TEST_F(AudioModemApiUnittest, TransmitMultiple) {
 
   // 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));
 }
 
@@ -362,8 +370,10 @@ TEST_F(AudioModemApiUnittest, ReceiveMultiple) {
                                   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.
@@ -375,8 +385,10 @@ TEST_F(AudioModemApiUnittest, ReceiveMultiple) {
   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));
 }