Add struct traits for base::Value.

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/message_loop/message_loop.h"
 #include "base/numerics/safe_math.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "mojo/common/test_common_custom_types.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace common {
 namespace test {
 namespace {
 
 template <typename T>
 struct BounceTestTraits {
   static void ExpectEquality(const T& a, const T& b) {
     EXPECT_EQ(a, b);
   }
 };
 
-template <>
-struct BounceTestTraits<base::DictionaryValue> {
-  static void ExpectEquality(const base::DictionaryValue& a,
-                             const base::DictionaryValue& b) {
-    EXPECT_TRUE(a.Equals(&b));
-  }
-};
-
-template <>
-struct BounceTestTraits<base::ListValue> {
-  static void ExpectEquality(const base::ListValue& a,
-                             const base::ListValue& b) {
-    EXPECT_TRUE(a.Equals(&b));
-  }
-};
-
 template <typename T>
 struct PassTraits {
   using Type = const T&;
 };
 
 template <>
 struct PassTraits<base::Time> {
   using Type = base::Time;
 };
 
@@ skipping 76 matching lines @@
   mojo::Binding<TestTime> binding_;
 };
 
 class TestValueImpl : public TestValue {
  public:
   explicit TestValueImpl(TestValueRequest request)
       : binding_(this, std::move(request)) {}
 
   // TestValue implementation:
   void BounceDictionaryValue(
-      const base::DictionaryValue& in,
+      std::unique_ptr<base::DictionaryValue> in,
       const BounceDictionaryValueCallback& callback) override {
-    callback.Run(in);
+    callback.Run(std::move(in));
   }
-  void BounceListValue(const base::ListValue& in,
+
+  void BounceListValue(std::unique_ptr<base::ListValue> in,
                        const BounceListValueCallback& callback) override {
-    callback.Run(in);
+    callback.Run(std::move(in));
+  }
+
+  void BounceValue(std::unique_ptr<base::Value> in,
+                   const BounceValueCallback& callback) override {
+    callback.Run(std::move(in));
   }
 
  private:
   mojo::Binding<TestValue> binding_;
 };
 
 class TestString16Impl : public TestString16 {
  public:
   explicit TestString16Impl(TestString16Request request)
       : binding_(this, std::move(request)) {}
@@ skipping 98 matching lines @@
 
   ptr->BounceTimeTicks(t, ExpectResponse(&t, run_loop.QuitClosure()));
 
   run_loop.Run();
 }
 
 TEST_F(CommonCustomTypesTest, Value) {
   TestValuePtr ptr;
   TestValueImpl impl(MakeRequest(&ptr));
 
-  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));
+  std::unique_ptr<base::Value> output;
+
+  ASSERT_TRUE(ptr->BounceValue(nullptr, &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::FundamentalValue>(123);
+  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
+  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
+
+  input = base::MakeUnique<base::FundamentalValue>(1.23);
+  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
+  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
+
+  input = base::MakeUnique<base::FundamentalValue>(false);
+  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
+  EXPECT_TRUE(base::Value::Equals(input.get(), output.get()));
+
+  input = base::MakeUnique<base::StringValue>("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());
   {
     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));
-  }
-  {
-    base::RunLoop run_loop;
-    ptr->BounceDictionaryValue(
-        dict, ExpectResponse(&dict, run_loop.QuitClosure()));
-    run_loop.Run();
+    dict->Set("list", std::move(dict_list));
   }
 
-  base::ListValue list;
-  list.AppendString("string");
-  list.AppendDouble(42.1);
-  list.AppendBoolean(true);
-  list.Append(base::BinaryValue::CreateWithCopiedBuffer("mojo", 4));
+  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()));
+
+  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());
   {
     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));
   }
-  {
-    base::RunLoop run_loop;
-    ptr->BounceListValue(list, ExpectResponse(&list, run_loop.QuitClosure()));
-    run_loop.Run();
-  }
+  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()));
+
+  input = std::move(list);
+  ASSERT_TRUE(ptr->BounceValue(input->CreateDeepCopy(), &output));
+  ASSERT_TRUE(base::Value::Equals(input.get(), output.get()));
 }
 
 TEST_F(CommonCustomTypesTest, String16) {
   base::RunLoop run_loop;
 
   TestString16Ptr ptr;
   TestString16Impl impl(MakeRequest(&ptr));
 
   base::string16 str16 = base::ASCIIToUTF16("hello world");
 
@@ skipping 54 matching lines @@
       temp_dir.GetPath().AppendASCII("test_file.txt"),
       base::File::FLAG_CREATE | base::File::FLAG_WRITE | base::File::FLAG_READ);
 
   ASSERT_TRUE(ptr->BounceFile(base::File(), &file_out));
   EXPECT_FALSE(file_out.IsValid());
 }
 
 }  // namespace test
 }  // namespace common
 }  // namespace mojo