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

mojo/common/common_custom_types_unittest.cc

 // Copyright 2016 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 "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_math.h"
 #include "base/run_loop.h"
@@ skipping 104 matching lines @@
   mojo::Binding<TestTime> binding_;
 };
 
 class TestValueImpl : public TestValue {
  public:
   explicit TestValueImpl(TestValueRequest request)
       : binding_(this, std::move(request)) {}
 
   // 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:
   mojo::Binding<TestValue> binding_;
 };
 
 class TestString16Impl : public TestString16 {
  public:
   explicit TestString16Impl(TestString16Request request)
       : binding_(this, std::move(request)) {}
@@ skipping 114 matching lines @@
 
   ptr->BounceTimeTicks(t, ExpectResponse(&t, run_loop.QuitClosure()));
 
   run_loop.Run();
 }
 
 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()));
+  base::Optional<base::Value> input = *base::Value::CreateNullValue();
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
 
-  input = base::MakeUnique<base::Value>(123);
-  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
-  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
+  input = base::Value(123);
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
 
-  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::Value(1.23);
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
 
-  input = base::MakeUnique<base::Value>(false);
-  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
-  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
+  input = base::Value(false);
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
 
-  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::Value("test string");
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
 
-  input = base::BinaryValue::CreateWithCopiedBuffer("mojo", 4);
-  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
-  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
+  input = base::Value(std::vector<char>{'m', 'o', 'j', 'o'});
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
 
-  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::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()));
+  ASSERT_TRUE(ptr->BounceValue(input, &output));
+  EXPECT_EQ(input, output);
 
-  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());
+  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) {
   base::RunLoop run_loop;
 
   TestString16Ptr ptr;
   TestString16Impl impl(MakeRequest(&ptr));
 
   base::string16 str16 = base::ASCIIToUTF16("hello world");
 
@@ skipping 69 matching lines @@
   for (size_t i = 0; i < arraysize(kTestDirections); i++) {
     base::i18n::TextDirection direction_out;
     ASSERT_TRUE(ptr->BounceTextDirection(kTestDirections[i], &direction_out));
     EXPECT_EQ(kTestDirections[i], direction_out);
   }
 }
 
 }  // namespace test
 }  // namespace common
 }  // namespace mojo