base: Use scoped_ptr for ownership of pointers in unittests.

base/json/json_writer_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 "base/json/json_writer.h"
 #include "base/values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 TEST(JSONWriterTest, BasicTypes) {
   std::string output_js;
 
   // Test null.
-  Value* root = Value::CreateNullValue();
-  EXPECT_TRUE(JSONWriter::Write(root, &output_js));
+  scoped_ptr<Value> root = make_scoped_ptr(Value::CreateNullValue());

[Nico, 2015/05/11 18:16:08]

Do you need make_scoped_ptr here? Doesn't just

  scoped_ptr<Value> root(Value::CreateNullValue());

work? (I thought make_scoped_ptr is when you call a function that takes a
scoped_ptr so that you don't have to write scoped_ptr<Type>(foo()) when foo()
already returns a Type* – but you're already typing out Type on the lhs here so
make_scoped_ptr doesn't do much here?)

[danakj, 2015/05/11 18:17:51]

Ya I can/should use that constructor instead, done. I was using the
scoped_ptr<U>&& constructor.

+  EXPECT_TRUE(JSONWriter::Write(root.get(), &output_js));
   EXPECT_EQ("null", output_js);
-  delete root;
 
   // Test empty dict.
-  root = new DictionaryValue;
-  EXPECT_TRUE(JSONWriter::Write(root, &output_js));
+  root = make_scoped_ptr(new DictionaryValue);
+  EXPECT_TRUE(JSONWriter::Write(root.get(), &output_js));
   EXPECT_EQ("{}", output_js);
-  delete root;
 
   // Test empty list.
-  root = new ListValue;
-  EXPECT_TRUE(JSONWriter::Write(root, &output_js));
+  root = make_scoped_ptr(new ListValue);
+  EXPECT_TRUE(JSONWriter::Write(root.get(), &output_js));
   EXPECT_EQ("[]", output_js);
-  delete root;
 
   // Test integer values.
-  root = new FundamentalValue(42);
-  EXPECT_TRUE(JSONWriter::Write(root, &output_js));
+  root = make_scoped_ptr(new FundamentalValue(42));
+  EXPECT_TRUE(JSONWriter::Write(root.get(), &output_js));
   EXPECT_EQ("42", output_js);
-  delete root;
 
   // Test boolean values.
-  root = new FundamentalValue(true);
-  EXPECT_TRUE(JSONWriter::Write(root, &output_js));
+  root = make_scoped_ptr(new FundamentalValue(true));
+  EXPECT_TRUE(JSONWriter::Write(root.get(), &output_js));
   EXPECT_EQ("true", output_js);
-  delete root;
 
   // Test Real values should always have a decimal or an 'e'.
-  root = new FundamentalValue(1.0);
-  EXPECT_TRUE(JSONWriter::Write(root, &output_js));
+  root = make_scoped_ptr(new FundamentalValue(1.0));
+  EXPECT_TRUE(JSONWriter::Write(root.get(), &output_js));
   EXPECT_EQ("1.0", output_js);
-  delete root;
 
   // Test Real values in the the range (-1, 1) must have leading zeros
-  root = new FundamentalValue(0.2);
-  EXPECT_TRUE(JSONWriter::Write(root, &output_js));
+  root = make_scoped_ptr(new FundamentalValue(0.2));
+  EXPECT_TRUE(JSONWriter::Write(root.get(), &output_js));
   EXPECT_EQ("0.2", output_js);
-  delete root;
 
   // Test Real values in the the range (-1, 1) must have leading zeros
-  root = new FundamentalValue(-0.8);
-  EXPECT_TRUE(JSONWriter::Write(root, &output_js));
+  root = make_scoped_ptr(new FundamentalValue(-0.8));
+  EXPECT_TRUE(JSONWriter::Write(root.get(), &output_js));
   EXPECT_EQ("-0.8", output_js);
-  delete root;
 
   // Test String values.
-  root = new StringValue("foo");
-  EXPECT_TRUE(JSONWriter::Write(root, &output_js));
+  root = make_scoped_ptr(new StringValue("foo"));
+  EXPECT_TRUE(JSONWriter::Write(root.get(), &output_js));
   EXPECT_EQ("\"foo\"", output_js);
-  delete root;
 }
 
 
 TEST(JSONWriterTest, NestedTypes) {
   std::string output_js;
 
   // Writer unittests like empty list/dict nesting,
   // list list nesting, etc.
   DictionaryValue root_dict;
   scoped_ptr<ListValue> list(new ListValue());
@@ skipping 44 matching lines @@
   period_dict3.SetIntegerWithoutPathExpansion("a.b", 1);
   EXPECT_TRUE(JSONWriter::Write(&period_dict3, &output_js));
   EXPECT_EQ("{\"a\":{\"b\":2},\"a.b\":1}", output_js);
 }
 
 TEST(JSONWriterTest, BinaryValues) {
   std::string output_js;
 
   // Binary values should return errors unless suppressed via the
   // OPTIONS_OMIT_BINARY_VALUES flag.
-  Value* root = BinaryValue::CreateWithCopiedBuffer("asdf", 4);
-  EXPECT_FALSE(JSONWriter::Write(root, &output_js));
+  scoped_ptr<Value> root =
+      make_scoped_ptr(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
+  EXPECT_FALSE(JSONWriter::Write(root.get(), &output_js));
   EXPECT_TRUE(JSONWriter::WriteWithOptions(
-      root, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
+      root.get(), JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
   EXPECT_TRUE(output_js.empty());
-  delete root;
 
   ListValue binary_list;
   binary_list.Append(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
-  binary_list.Append(new FundamentalValue(5));
+  binary_list.Append(make_scoped_ptr(new FundamentalValue(5)));
   binary_list.Append(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
-  binary_list.Append(new FundamentalValue(2));
+  binary_list.Append(make_scoped_ptr(new FundamentalValue(2)));
   binary_list.Append(BinaryValue::CreateWithCopiedBuffer("asdf", 4));
   EXPECT_FALSE(JSONWriter::Write(&binary_list, &output_js));
   EXPECT_TRUE(JSONWriter::WriteWithOptions(
       &binary_list, JSONWriter::OPTIONS_OMIT_BINARY_VALUES, &output_js));
   EXPECT_EQ("[5,2]", output_js);
 
   DictionaryValue binary_dict;
   binary_dict.Set(
       "a", make_scoped_ptr(BinaryValue::CreateWithCopiedBuffer("asdf", 4)));
   binary_dict.SetInteger("b", 5);
@@ skipping 14 matching lines @@
   // Test allowing a double with no fractional part to be written as an integer.
   FundamentalValue double_value(1e10);
   EXPECT_TRUE(JSONWriter::WriteWithOptions(
       &double_value,
       JSONWriter::OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION,
       &output_js));
   EXPECT_EQ("10000000000", output_js);
 }
 
 }  // namespace base