Convert //base to use std::unique_ptr

base/trace_event/memory_dump_manager_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_dump_manager.h"
 
 #include <stdint.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/bind_helpers.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_io_thread.h"
 #include "base/test/trace_event_analyzer.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread.h"
@@ skipping 202 matching lines @@
 
   bool IsPeriodicDumpingEnabled() const {
     return mdm_->periodic_dump_timer_.IsRunning();
   }
 
   int GetMaxConsecutiveFailuresCount() const {
     return MemoryDumpManager::kMaxConsecutiveFailuresCount;
   }
 
   const MemoryDumpProvider::Options kDefaultOptions;
-  scoped_ptr<MemoryDumpManager> mdm_;
-  scoped_ptr<MemoryDumpManagerDelegateForTesting> delegate_;
+  std::unique_ptr<MemoryDumpManager> mdm_;
+  std::unique_ptr<MemoryDumpManagerDelegateForTesting> delegate_;
   bool last_callback_success_;
 
  private:
-  scoped_ptr<MessageLoop> message_loop_;
+  std::unique_ptr<MessageLoop> message_loop_;
 
   // We want our singleton torn down after each test.
   ShadowingAtExitManager at_exit_manager_;
 };
 
 // Basic sanity checks. Registers a memory dump provider and checks that it is
 // called, but only when memory-infra is enabled.
 TEST_F(MemoryDumpManagerTest, SingleDumper) {
   InitializeMemoryDumpManager(false /* is_coordinator */);
   MockMemoryDumpProvider mdp;
@@ skipping 186 matching lines @@
 }
 
 // Checks that the MemoryDumpManager respects the thread affinity when a
 // MemoryDumpProvider specifies a task_runner(). The test starts creating 8
 // threads and registering a MemoryDumpProvider on each of them. At each
 // iteration, one thread is removed, to check the live unregistration logic.
 TEST_F(MemoryDumpManagerTest, RespectTaskRunnerAffinity) {
   InitializeMemoryDumpManager(false /* is_coordinator */);
   const uint32_t kNumInitialThreads = 8;
 
-  std::vector<scoped_ptr<Thread>> threads;
-  std::vector<scoped_ptr<MockMemoryDumpProvider>> mdps;
+  std::vector<std::unique_ptr<Thread>> threads;
+  std::vector<std::unique_ptr<MockMemoryDumpProvider>> mdps;
 
   // Create the threads and setup the expectations. Given that at each iteration
   // we will pop out one thread/MemoryDumpProvider, each MDP is supposed to be
   // invoked a number of times equal to its index.
   for (uint32_t i = kNumInitialThreads; i > 0; --i) {
-    threads.push_back(make_scoped_ptr(new Thread("test thread")));
+    threads.push_back(WrapUnique(new Thread("test thread")));
     auto thread = threads.back().get();
     thread->Start();
     scoped_refptr<SingleThreadTaskRunner> task_runner = thread->task_runner();
-    mdps.push_back(make_scoped_ptr(new MockMemoryDumpProvider()));
+    mdps.push_back(WrapUnique(new MockMemoryDumpProvider()));
     auto mdp = mdps.back().get();
     RegisterDumpProvider(mdp, task_runner, kDefaultOptions);
     EXPECT_CALL(*mdp, OnMemoryDump(_, _))
         .Times(i)
         .WillRepeatedly(Invoke(
             [task_runner](const MemoryDumpArgs&, ProcessMemoryDump*) -> bool {
               EXPECT_TRUE(task_runner->RunsTasksOnCurrentThread());
               return true;
             }));
   }
@@ skipping 173 matching lines @@
                              MemoryDumpLevelOfDetail::DETAILED);
   }
 
   DisableTracing();
 }
 
 // Checks that the dump does not abort when unregistering a provider while
 // dumping from a different thread than the dumping thread.
 TEST_F(MemoryDumpManagerTest, UnregisterDumperFromThreadWhileDumping) {
   InitializeMemoryDumpManager(false /* is_coordinator */);
-  std::vector<scoped_ptr<TestIOThread>> threads;
-  std::vector<scoped_ptr<MockMemoryDumpProvider>> mdps;
+  std::vector<std::unique_ptr<TestIOThread>> threads;
+  std::vector<std::unique_ptr<MockMemoryDumpProvider>> mdps;
 
   for (int i = 0; i < 2; i++) {
     threads.push_back(
-        make_scoped_ptr(new TestIOThread(TestIOThread::kAutoStart)));
-    mdps.push_back(make_scoped_ptr(new MockMemoryDumpProvider()));
+        WrapUnique(new TestIOThread(TestIOThread::kAutoStart)));
+    mdps.push_back(WrapUnique(new MockMemoryDumpProvider()));
     RegisterDumpProvider(mdps.back().get(), threads.back()->task_runner(),
                          kDefaultOptions);
   }
 
   int on_memory_dump_call_count = 0;
 
   // When OnMemoryDump is called on either of the dump providers, it will
   // unregister the other one.
-  for (const scoped_ptr<MockMemoryDumpProvider>& mdp : mdps) {
+  for (const std::unique_ptr<MockMemoryDumpProvider>& mdp : mdps) {
     int other_idx = (mdps.front() == mdp);
     TestIOThread* other_thread = threads[other_idx].get();
     MockMemoryDumpProvider* other_mdp = mdps[other_idx].get();
     auto on_dump = [this, other_thread, other_mdp, &on_memory_dump_call_count](
         const MemoryDumpArgs& args, ProcessMemoryDump* pmd) {
       other_thread->PostTaskAndWait(
           FROM_HERE, base::Bind(&MemoryDumpManager::UnregisterDumpProvider,
                                 base::Unretained(&*mdm_), other_mdp));
       on_memory_dump_call_count++;
       return true;
@@ skipping 14 matching lines @@
   ASSERT_EQ(1, on_memory_dump_call_count);
   ASSERT_TRUE(last_callback_success_);
 
   DisableTracing();
 }
 
 // If a thread (with a dump provider living on it) is torn down during a dump
 // its dump provider should be skipped but the dump itself should succeed.
 TEST_F(MemoryDumpManagerTest, TearDownThreadWhileDumping) {
   InitializeMemoryDumpManager(false /* is_coordinator */);
-  std::vector<scoped_ptr<TestIOThread>> threads;
-  std::vector<scoped_ptr<MockMemoryDumpProvider>> mdps;
+  std::vector<std::unique_ptr<TestIOThread>> threads;
+  std::vector<std::unique_ptr<MockMemoryDumpProvider>> mdps;
 
   for (int i = 0; i < 2; i++) {
     threads.push_back(
-        make_scoped_ptr(new TestIOThread(TestIOThread::kAutoStart)));
-    mdps.push_back(make_scoped_ptr(new MockMemoryDumpProvider()));
+        WrapUnique(new TestIOThread(TestIOThread::kAutoStart)));
+    mdps.push_back(WrapUnique(new MockMemoryDumpProvider()));
     RegisterDumpProvider(mdps.back().get(), threads.back()->task_runner(),
                          kDefaultOptions);
   }
 
   int on_memory_dump_call_count = 0;
 
   // When OnMemoryDump is called on either of the dump providers, it will
   // tear down the thread of the other one.
-  for (const scoped_ptr<MockMemoryDumpProvider>& mdp : mdps) {
+  for (const std::unique_ptr<MockMemoryDumpProvider>& mdp : mdps) {
     int other_idx = (mdps.front() == mdp);
     TestIOThread* other_thread = threads[other_idx].get();
     auto on_dump = [other_thread, &on_memory_dump_call_count](
         const MemoryDumpArgs& args, ProcessMemoryDump* pmd) {
       other_thread->Stop();
       on_memory_dump_call_count++;
       return true;
     };
 
     // OnMemoryDump is called once for the provider that dumps first, and zero
@@ skipping 152 matching lines @@
   DisableTracing();
 }
 
 // Tests against race conditions that might arise when disabling tracing in the
 // middle of a global memory dump.
 TEST_F(MemoryDumpManagerTest, DisableTracingWhileDumping) {
   base::WaitableEvent tracing_disabled_event(false, false);
   InitializeMemoryDumpManager(false /* is_coordinator */);
 
   // Register a bound dump provider.
-  scoped_ptr<Thread> mdp_thread(new Thread("test thread"));
+  std::unique_ptr<Thread> mdp_thread(new Thread("test thread"));
   mdp_thread->Start();
   MockMemoryDumpProvider mdp_with_affinity;
   RegisterDumpProvider(&mdp_with_affinity, mdp_thread->task_runner(),
                        kDefaultOptions);
 
   // Register also an unbound dump provider. Unbound dump providers are always
   // invoked after bound ones.
   MockMemoryDumpProvider unbound_mdp;
   RegisterDumpProvider(&unbound_mdp, nullptr, kDefaultOptions);
 
@@ skipping 86 matching lines @@
   TraceResultBuffer::SimpleOutput trace_output;
   buffer.SetOutputCallback(trace_output.GetCallback());
   RunLoop run_loop;
   buffer.Start();
   trace_event::TraceLog::GetInstance()->Flush(
       Bind(&OnTraceDataCollected, run_loop.QuitClosure(), Unretained(&buffer)));
   run_loop.Run();
   buffer.Finish();
 
   // Analyze the JSON.
-  scoped_ptr<trace_analyzer::TraceAnalyzer> analyzer = make_scoped_ptr(
+  std::unique_ptr<trace_analyzer::TraceAnalyzer> analyzer = WrapUnique(
       trace_analyzer::TraceAnalyzer::Create(trace_output.json_output));
   trace_analyzer::TraceEventVector events;
   analyzer->FindEvents(Query::EventPhaseIs(TRACE_EVENT_PHASE_MEMORY_DUMP),
                        &events);
 
   ASSERT_EQ(3u, events.size());
   ASSERT_EQ(1u, trace_analyzer::CountMatches(events, Query::EventPidIs(123)));
   ASSERT_EQ(1u, trace_analyzer::CountMatches(events, Query::EventPidIs(456)));
   ASSERT_EQ(1u, trace_analyzer::CountMatches(
                     events, Query::EventPidIs(GetCurrentProcId())));
   ASSERT_EQ(events[0]->id, events[1]->id);
   ASSERT_EQ(events[0]->id, events[2]->id);
 }
 
 // Tests the basics of the UnregisterAndDeleteDumpProviderSoon(): the
 // unregistration should actually delete the providers and not leak them.
 TEST_F(MemoryDumpManagerTest, UnregisterAndDeleteDumpProviderSoon) {
   InitializeMemoryDumpManager(false /* is_coordinator */);
   static const int kNumProviders = 3;
   int dtor_count = 0;
-  std::vector<scoped_ptr<MemoryDumpProvider>> mdps;
+  std::vector<std::unique_ptr<MemoryDumpProvider>> mdps;
   for (int i = 0; i < kNumProviders; ++i) {
-    scoped_ptr<MockMemoryDumpProvider> mdp(new MockMemoryDumpProvider);
+    std::unique_ptr<MockMemoryDumpProvider> mdp(new MockMemoryDumpProvider);
     mdp->enable_mock_destructor = true;
     EXPECT_CALL(*mdp, Destructor())
         .WillOnce(Invoke([&dtor_count]() { dtor_count++; }));
     RegisterDumpProvider(mdp.get(), nullptr, kDefaultOptions);
     mdps.push_back(std::move(mdp));
   }
 
   while (!mdps.empty()) {
     mdm_->UnregisterAndDeleteDumpProviderSoon(std::move(mdps.back()));
     mdps.pop_back();
   }
 
   ASSERT_EQ(kNumProviders, dtor_count);
 }
 
 // This test checks against races when unregistering an unbound dump provider
 // from another thread while dumping. It registers one MDP and, when
 // OnMemoryDump() is called, it invokes UnregisterAndDeleteDumpProviderSoon()
 // from another thread. The OnMemoryDump() and the dtor call are expected to
 // happen on the same thread (the MemoryDumpManager utility thread).
 TEST_F(MemoryDumpManagerTest, UnregisterAndDeleteDumpProviderSoonDuringDump) {
   InitializeMemoryDumpManager(false /* is_coordinator */);
-  scoped_ptr<MockMemoryDumpProvider> mdp(new MockMemoryDumpProvider);
+  std::unique_ptr<MockMemoryDumpProvider> mdp(new MockMemoryDumpProvider);
   mdp->enable_mock_destructor = true;
   RegisterDumpProvider(mdp.get(), nullptr, kDefaultOptions);
 
   base::PlatformThreadRef thread_ref;
   auto self_unregister_from_another_thread = [&mdp, &thread_ref](
       const MemoryDumpArgs&, ProcessMemoryDump*) -> bool {
     thread_ref = PlatformThread::CurrentRef();
     TestIOThread thread_for_unregistration(TestIOThread::kAutoStart);
     thread_for_unregistration.PostTaskAndWait(
         FROM_HERE,
         base::Bind(
             &MemoryDumpManager::UnregisterAndDeleteDumpProviderSoon,
             base::Unretained(MemoryDumpManager::GetInstance()),
-            base::Passed(scoped_ptr<MemoryDumpProvider>(std::move(mdp)))));
+            base::Passed(std::unique_ptr<MemoryDumpProvider>(std::move(mdp)))));
     thread_for_unregistration.Stop();
     return true;
   };
   EXPECT_CALL(*mdp, OnMemoryDump(_, _))
       .Times(1)
       .WillOnce(Invoke(self_unregister_from_another_thread));
   EXPECT_CALL(*mdp, Destructor())
       .Times(1)
       .WillOnce(Invoke([&thread_ref]() {
         EXPECT_EQ(thread_ref, PlatformThread::CurrentRef());
       }));
 
   EnableTracingWithLegacyCategories(MemoryDumpManager::kTraceCategory);
   EXPECT_CALL(*delegate_, RequestGlobalMemoryDump(_, _)).Times(2);
   for (int i = 0; i < 2; ++i) {
     RequestGlobalDumpAndWait(MemoryDumpType::EXPLICITLY_TRIGGERED,
                              MemoryDumpLevelOfDetail::DETAILED);
   }
   DisableTracing();
 }
 
 }  // namespace trace_event
 }  // namespace base