Change PopDataAsValue to return a std::unique_ptr.

dbus/values_util_unittest.cc

 // Copyright (c) 2012 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 "dbus/values_util.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
@@ skipping 34 matching lines @@
   writer.AppendString(kStringValue);
   const std::string kEmptyStringValue;
   writer.AppendString(kEmptyStringValue);
   const ObjectPath kObjectPathValue("/ObjectPath");
   writer.AppendObjectPath(kObjectPathValue);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   std::unique_ptr<base::Value> expected_value;
   // Pop a byte.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kByteValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a bool.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kBoolValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an int16_t.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kInt16Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a uint16_t.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kUint16Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an int32_t.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kInt32Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a uint32_t.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(
       new base::FundamentalValue(static_cast<double>(kUint32Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an int64_t.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(
       new base::FundamentalValue(static_cast<double>(kInt64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a uint64_t.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(
       new base::FundamentalValue(static_cast<double>(kUint64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a double.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kDoubleValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a string.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::StringValue(kStringValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an empty string.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::StringValue(kEmptyStringValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an object path.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::StringValue(kObjectPathValue.value()));
   EXPECT_TRUE(value->Equals(expected_value.get()));
 }
 
 TEST(ValuesUtilTest, PopVariant) {
   std::unique_ptr<Response> response(Response::CreateEmpty());
   // Append variant values.
   MessageWriter writer(response.get());
   const bool kBoolValue = true;
   writer.AppendVariantOfBool(kBoolValue);
   const int32_t kInt32Value = -45;
   writer.AppendVariantOfInt32(kInt32Value);
   const double kDoubleValue = 4.9;
   writer.AppendVariantOfDouble(kDoubleValue);
   const std::string kStringValue = "fifty";
   writer.AppendVariantOfString(kStringValue);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   std::unique_ptr<base::Value> expected_value;
   // Pop a bool.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kBoolValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop an int32_t.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kInt32Value));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a double.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::FundamentalValue(kDoubleValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   // Pop a string.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(new base::StringValue(kStringValue));
   EXPECT_TRUE(value->Equals(expected_value.get()));
 }
 
 // Pop extremely large integers which cannot be precisely represented in
 // double.
 TEST(ValuesUtilTest, PopExtremelyLargeIntegers) {
   std::unique_ptr<Response> response(Response::CreateEmpty());
   // Append large integers.
   MessageWriter writer(response.get());
   const int64_t kInt64Value = -123456789012345689LL;
   writer.AppendInt64(kInt64Value);
   const uint64_t kUint64Value = 9876543210987654321ULL;
   writer.AppendUint64(kUint64Value);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
   std::unique_ptr<base::Value> expected_value;
   double double_value = 0;
   // Pop an int64_t.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(
       new base::FundamentalValue(static_cast<double>(kInt64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   ASSERT_TRUE(value->GetAsDouble(&double_value));
   EXPECT_NE(kInt64Value, static_cast<int64_t>(double_value));
   // Pop a uint64_t.
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   expected_value.reset(
       new base::FundamentalValue(static_cast<double>(kUint64Value)));
   EXPECT_TRUE(value->Equals(expected_value.get()));
   ASSERT_TRUE(value->GetAsDouble(&double_value));
   EXPECT_NE(kUint64Value, static_cast<uint64_t>(double_value));
 }
 
 TEST(ValuesUtilTest, PopIntArray) {
   std::unique_ptr<Response> response(Response::CreateEmpty());
@@ skipping 209 matching lines @@
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendBasicTypeValueData(&writer, kBoolValue);
   AppendBasicTypeValueData(&writer, kIntegerValue);
   AppendBasicTypeValueData(&writer, kDoubleValue);
   AppendBasicTypeValueData(&writer, kStringValue);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kBoolValue));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kIntegerValue));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kDoubleValue));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kStringValue));
 }
 
 TEST(ValuesUtilTest, AppendBasicTypesAsVariant) {
   const base::FundamentalValue kBoolValue(false);
   const base::FundamentalValue kIntegerValue(42);
   const base::FundamentalValue kDoubleValue(4.2);
   const base::StringValue kStringValue("string");
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendBasicTypeValueDataAsVariant(&writer, kBoolValue);
   AppendBasicTypeValueDataAsVariant(&writer, kIntegerValue);
   AppendBasicTypeValueDataAsVariant(&writer, kDoubleValue);
   AppendBasicTypeValueDataAsVariant(&writer, kStringValue);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kBoolValue));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kIntegerValue));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kDoubleValue));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kStringValue));
 }
 
 TEST(ValuesUtilTest, AppendValueDataBasicTypes) {
   const base::FundamentalValue kBoolValue(false);
   const base::FundamentalValue kIntegerValue(42);
   const base::FundamentalValue kDoubleValue(4.2);
   const base::StringValue kStringValue("string");
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueData(&writer, kBoolValue);
   AppendValueData(&writer, kIntegerValue);
   AppendValueData(&writer, kDoubleValue);
   AppendValueData(&writer, kStringValue);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kBoolValue));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kIntegerValue));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kDoubleValue));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kStringValue));
 }
 
 TEST(ValuesUtilTest, AppendValueDataAsVariantBasicTypes) {
   const base::FundamentalValue kBoolValue(false);
   const base::FundamentalValue kIntegerValue(42);
   const base::FundamentalValue kDoubleValue(4.2);
   const base::StringValue kStringValue("string");
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueDataAsVariant(&writer, kBoolValue);
   AppendValueDataAsVariant(&writer, kIntegerValue);
   AppendValueDataAsVariant(&writer, kDoubleValue);
   AppendValueDataAsVariant(&writer, kStringValue);
 
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kBoolValue));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kIntegerValue));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kDoubleValue));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&kStringValue));
 }
 
 TEST(ValuesUtilTest, AppendDictionary) {
   // Set up the input dictionary.
   const std::string kKey1 = "one";
   const std::string kKey2 = "two";
   const std::string kKey3 = "three";
   const std::string kKey4 = "four";
@@ skipping 23 matching lines @@
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueData(&writer, test_dictionary);
   base::FundamentalValue int_value(kInt32Value);
   AppendValueData(&writer, int_value);
 
   // Read the data.
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&test_dictionary));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&int_value));
 }
 
 TEST(ValuesUtilTest, AppendDictionaryAsVariant) {
   // Set up the input dictionary.
   const std::string kKey1 = "one";
   const std::string kKey2 = "two";
   const std::string kKey3 = "three";
   const std::string kKey4 = "four";
@@ skipping 23 matching lines @@
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueDataAsVariant(&writer, test_dictionary);
   base::FundamentalValue int_value(kInt32Value);
   AppendValueData(&writer, int_value);
 
   // Read the data.
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&test_dictionary));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&int_value));
 }
 
 TEST(ValuesUtilTest, AppendList) {
   // Set up the input list.
   const std::string kKey1 = "one";
   const std::string kKey2 = "two";
 
   const bool kBoolValue = true;
@@ skipping 19 matching lines @@
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueData(&writer, test_list);
   base::FundamentalValue int_value(kInt32Value);
   AppendValueData(&writer, int_value);
 
   // Read the data.
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&test_list));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&int_value));
 }
 
 TEST(ValuesUtilTest, AppendListAsVariant) {
   // Set up the input list.
   const std::string kKey1 = "one";
   const std::string kKey2 = "two";
 
   const bool kBoolValue = true;
@@ skipping 19 matching lines @@
 
   std::unique_ptr<Response> response(Response::CreateEmpty());
   MessageWriter writer(response.get());
   AppendValueDataAsVariant(&writer, test_list);
   base::FundamentalValue int_value(kInt32Value);
   AppendValueData(&writer, int_value);
 
   // Read the data.
   MessageReader reader(response.get());
   std::unique_ptr<base::Value> value;
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&test_list));
-  value.reset(PopDataAsValue(&reader));
+  value = PopDataAsValue(&reader);
   ASSERT_TRUE(value.get() != NULL);
   EXPECT_TRUE(value->Equals(&int_value));
 }
 
 }  // namespace dbus