Convert //base to use std::unique_ptr

base/trace_event/memory_allocator_dump_unittest.cc

 // Copyright 2015 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/trace_event/memory_allocator_dump.h"
 
 #include <stdint.h>
 
 #include "base/format_macros.h"
 #include "base/strings/stringprintf.h"
@@ skipping 34 matching lines @@
                         MemoryAllocatorDump::kUnitsObjects, 3);
 
     pmd->CreateAllocatorDump("foobar_allocator/sub_heap/empty");
     // Leave the rest of sub heap deliberately uninitialized, to check that
     // CreateAllocatorDump returns a properly zero-initialized object.
 
     return true;
   }
 };
 
-scoped_ptr<Value> CheckAttribute(const MemoryAllocatorDump* dump,
-                                 const std::string& name,
-                                 const char* expected_type,
-                                 const char* expected_units) {
-  scoped_ptr<Value> raw_attrs = dump->attributes_for_testing()->ToBaseValue();
+std::unique_ptr<Value> CheckAttribute(const MemoryAllocatorDump* dump,
+                                      const std::string& name,
+                                      const char* expected_type,
+                                      const char* expected_units) {
+  std::unique_ptr<Value> raw_attrs =
+      dump->attributes_for_testing()->ToBaseValue();
   DictionaryValue* args = nullptr;
   DictionaryValue* arg = nullptr;
   std::string arg_value;
   const Value* out_value = nullptr;
   EXPECT_TRUE(raw_attrs->GetAsDictionary(&args));
   EXPECT_TRUE(args->GetDictionary(name, &arg));
   EXPECT_TRUE(arg->GetString("type", &arg_value));
   EXPECT_EQ(expected_type, arg_value);
   EXPECT_TRUE(arg->GetString("units", &arg_value));
   EXPECT_EQ(expected_units, arg_value);
   EXPECT_TRUE(arg->Get("value", &out_value));
-  return out_value ? out_value->CreateDeepCopy() : scoped_ptr<Value>();
+  return out_value ? out_value->CreateDeepCopy() : std::unique_ptr<Value>();
 }
 
 void CheckString(const MemoryAllocatorDump* dump,
                  const std::string& name,
                  const char* expected_type,
                  const char* expected_units,
                  const std::string& expected_value) {
   std::string attr_str_value;
   auto attr_value = CheckAttribute(dump, name, expected_type, expected_units);
   EXPECT_TRUE(attr_value->GetAsString(&attr_str_value));
@@ skipping 15 matching lines @@
   auto attr_value = CheckAttribute(dump, name, MemoryAllocatorDump::kTypeScalar,
                                    expected_units);
   double attr_double_value;
   EXPECT_TRUE(attr_value->GetAsDouble(&attr_double_value));
   EXPECT_EQ(expected_value, attr_double_value);
 }
 
 }  // namespace
 
 TEST(MemoryAllocatorDumpTest, GuidGeneration) {
-  scoped_ptr<MemoryAllocatorDump> mad(
+  std::unique_ptr<MemoryAllocatorDump> mad(
       new MemoryAllocatorDump("foo", nullptr, MemoryAllocatorDumpGuid(0x42u)));
   ASSERT_EQ("42", mad->guid().ToString());
 
   // If the dumper does not provide a Guid, the MAD will make one up on the
   // flight. Furthermore that Guid will stay stable across across multiple
   // snapshots if the |absolute_name| of the dump doesn't change
   mad.reset(new MemoryAllocatorDump("bar", nullptr));
   const MemoryAllocatorDumpGuid guid_bar = mad->guid();
   ASSERT_FALSE(guid_bar.empty());
   ASSERT_FALSE(guid_bar.ToString().empty());
@@ skipping 42 matching lines @@
       pmd.GetAllocatorDump("foobar_allocator/sub_heap/empty");
   ASSERT_NE(nullptr, empty_sub_heap);
   EXPECT_EQ("foobar_allocator/sub_heap/empty", empty_sub_heap->absolute_name());
   auto raw_attrs = empty_sub_heap->attributes_for_testing()->ToBaseValue();
   DictionaryValue* attrs = nullptr;
   ASSERT_TRUE(raw_attrs->GetAsDictionary(&attrs));
   ASSERT_FALSE(attrs->HasKey(MemoryAllocatorDump::kNameSize));
   ASSERT_FALSE(attrs->HasKey(MemoryAllocatorDump::kNameObjectCount));
 
   // Check that the AsValueInfo doesn't hit any DCHECK.
-  scoped_ptr<TracedValue> traced_value(new TracedValue);
+  std::unique_ptr<TracedValue> traced_value(new TracedValue);
   pmd.AsValueInto(traced_value.get());
 }
 
 // DEATH tests are not supported in Android / iOS.
 #if !defined(NDEBUG) && !defined(OS_ANDROID) && !defined(OS_IOS)
 TEST(MemoryAllocatorDumpTest, ForbidDuplicatesDeathTest) {
   FakeMemoryAllocatorDumpProvider fmadp;
   ProcessMemoryDump pmd(new MemoryDumpSessionState);
   pmd.CreateAllocatorDump("foo_allocator");
   pmd.CreateAllocatorDump("bar_allocator/heap");
   ASSERT_DEATH(pmd.CreateAllocatorDump("foo_allocator"), "");
   ASSERT_DEATH(pmd.CreateAllocatorDump("bar_allocator/heap"), "");
   ASSERT_DEATH(pmd.CreateAllocatorDump(""), "");
 }
 #endif
 
 }  // namespace trace_event
 }  // namespace base