Switch base::Value typemapping to be by value instead of by unique_ptr.

mojo/common/common_custom_types_unittest.cc

Index: mojo/common/common_custom_types_unittest.cc
diff --git a/mojo/common/common_custom_types_unittest.cc b/mojo/common/common_custom_types_unittest.cc
index e3571d9d86cf65e54718868e089bf976101d4929..4b1b9edde5aab9f17a44af163ba809ddeac5bbc8 100644
--- a/mojo/common/common_custom_types_unittest.cc
+++ b/mojo/common/common_custom_types_unittest.cc
@@ -122,19 +122,19 @@ class TestValueImpl : public TestValue {
 
   // TestValue implementation:
   void BounceDictionaryValue(
-      std::unique_ptr<base::DictionaryValue> in,
+      const base::DictionaryValue& in,
       const BounceDictionaryValueCallback& callback) override {
-    callback.Run(std::move(in));
+    callback.Run(in);
   }
 
-  void BounceListValue(std::unique_ptr<base::ListValue> in,
+  void BounceListValue(const base::ListValue& in,
                        const BounceListValueCallback& callback) override {
-    callback.Run(std::move(in));
+    callback.Run(in);
   }
 
-  void BounceValue(std::unique_ptr<base::Value> in,
+  void BounceValue(const base::Optional<base::Value>& in,
                    const BounceValueCallback& callback) override {
-    callback.Run(std::move(in));
+    callback.Run(in);
   }
 
  private:
@@ -269,79 +269,78 @@ TEST_F(CommonCustomTypesTest, Value) {
   TestValuePtr ptr;
   TestValueImpl impl(MakeRequest(&ptr));
 
-  std::unique_ptr<base::Value> output;
+  base::Optional<base::Value> output;
 
-  ASSERT_TRUE(ptr->BounceValue(nullptr, &output));
+  ASSERT_TRUE(ptr->BounceValue(base::nullopt, &output));
   EXPECT_FALSE(output);
 
-  std::unique_ptr<base::Value> input = base::Value::CreateNullValue();
-  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
-  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
-
-  input = base::MakeUnique<base::Value>(123);
-  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
-  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
-
-  input = base::MakeUnique<base::Value>(1.23);
-  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
-  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
-
-  input = base::MakeUnique<base::Value>(false);
-  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
-  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
-
-  input = base::MakeUnique<base::Value>("test string");
-  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
-  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
-
-  input = base::BinaryValue::CreateWithCopiedBuffer("mojo", 4);
-  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
-  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
-
-  auto dict = base::MakeUnique<base::DictionaryValue>();
-  dict->SetBoolean("bool", false);
-  dict->SetInteger("int", 2);
-  dict->SetString("string", "some string");
-  dict->SetBoolean("nested.bool", true);
-  dict->SetInteger("nested.int", 9);
-  dict->Set("some_binary",
-            base::BinaryValue::CreateWithCopiedBuffer("mojo", 4));
-  dict->Set("null_value", base::Value::CreateNullValue());
-  dict->SetIntegerWithoutPathExpansion("non_nested.int", 10);
+  base::Optional<base::Value> input = *base::Value::CreateNullValue();
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
+
+  input = base::Value(123);
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
+
+  input = base::Value(1.23);
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
+
+  input = base::Value(false);
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
+
+  input = base::Value("test string");
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
+
+  input = base::Value(std::vector<char>{'m', 'o', 'j', 'o'});
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
+
+  base::DictionaryValue dict;
+  dict.SetBoolean("bool", false);
+  dict.SetInteger("int", 2);
+  dict.SetString("string", "some string");
+  dict.SetBoolean("nested.bool", true);
+  dict.SetInteger("nested.int", 9);
+  dict.Set("some_binary", base::BinaryValue::CreateWithCopiedBuffer("mojo", 4));
+  dict.Set("null_value", base::Value::CreateNullValue());
+  dict.SetIntegerWithoutPathExpansion("non_nested.int", 10);
   {
     std::unique_ptr<base::ListValue> dict_list(new base::ListValue());
     dict_list->AppendString("string");
     dict_list->AppendBoolean(true);
-    dict->Set("list", std::move(dict_list));
+    dict.Set("list", std::move(dict_list));
   }
 
-  std::unique_ptr<base::DictionaryValue> dict_output;
-  ASSERT_TRUE(ptr->BounceDictionaryValue(dict->CreateDeepCopy(), &dict_output));
-  EXPECT_TRUE(base::Value::Equals(dict.get(), dict_output.get()));
+  base::DictionaryValue dict_output;
+  ASSERT_TRUE(ptr->BounceDictionaryValue(dict, &dict_output));
+  EXPECT_EQ(dict, dict_output);
 
   input = std::move(dict);
-  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
-  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
-
-  auto list = base::MakeUnique<base::ListValue>();
-  list->AppendString("string");
-  list->AppendDouble(42.1);
-  list->AppendBoolean(true);
-  list->Append(base::BinaryValue::CreateWithCopiedBuffer("mojo", 4));
-  list->Append(base::Value::CreateNullValue());
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
+
+  base::ListValue list;
+  list.AppendString("string");
+  list.AppendDouble(42.1);
+  list.AppendBoolean(true);
+  list.Append(base::BinaryValue::CreateWithCopiedBuffer("mojo", 4));
+  list.Append(base::Value::CreateNullValue());
   {
     std::unique_ptr<base::DictionaryValue> list_dict(
         new base::DictionaryValue());
     list_dict->SetString("string", "str");
-    list->Append(std::move(list_dict));
+    list.Append(std::move(list_dict));
   }
-  std::unique_ptr<base::ListValue> list_output;
-  ASSERT_TRUE(ptr->BounceListValue(list->CreateDeepCopy(), &list_output));
-  EXPECT_TRUE(base::Value::Equals(list.get(), list_output.get()));
+  base::ListValue list_output;
+  ASSERT_TRUE(ptr->BounceListValue(list, &list_output));
+  EXPECT_EQ(list, list_output);
 
   input = std::move(list);
-  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
-  ASSERT_TRUE(base::Value::Equals(input.get(), output.get()));
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
 }
 
 TEST_F(CommonCustomTypesTest, String16) {