Convert //base to use std::unique_ptr

base/trace_event/memory_dump_manager.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 <algorithm>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
+#include "base/memory/ptr_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/trace_event/heap_profiler_allocation_context_tracker.h"
 #include "base/trace_event/heap_profiler_stack_frame_deduplicator.h"
 #include "base/trace_event/heap_profiler_type_name_deduplicator.h"
 #include "base/trace_event/malloc_dump_provider.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/memory_dump_session_state.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 50 matching lines @@
 
   if (!wrapped_callback.is_null()) {
     wrapped_callback.Run(dump_guid, success);
     wrapped_callback.Reset();
   }
 }
 
 // Proxy class which wraps a ConvertableToTraceFormat owned by the
 // |session_state| into a proxy object that can be added to the trace event log.
 // This is to solve the problem that the MemoryDumpSessionState is refcounted
-// but the tracing subsystem wants a scoped_ptr<ConvertableToTraceFormat>.
+// but the tracing subsystem wants a std::unique_ptr<ConvertableToTraceFormat>.
 template <typename T>
 struct SessionStateConvertableProxy : public ConvertableToTraceFormat {
   using GetterFunctPtr = T* (MemoryDumpSessionState::*)() const;
 
   SessionStateConvertableProxy(
       scoped_refptr<MemoryDumpSessionState> session_state,
       GetterFunctPtr getter_function)
       : session_state(session_state), getter_function(getter_function) {}
 
   void AppendAsTraceFormat(std::string* out) const override {
@@ skipping 165 matching lines @@
 
   if (heap_profiling_enabled_)
     mdp->OnHeapProfilingEnabled(true);
 }
 
 void MemoryDumpManager::UnregisterDumpProvider(MemoryDumpProvider* mdp) {
   UnregisterDumpProviderInternal(mdp, false /* delete_async */);
 }
 
 void MemoryDumpManager::UnregisterAndDeleteDumpProviderSoon(
-    scoped_ptr<MemoryDumpProvider> mdp) {
+    std::unique_ptr<MemoryDumpProvider> mdp) {
   UnregisterDumpProviderInternal(mdp.release(), true /* delete_async */);
 }
 
 void MemoryDumpManager::UnregisterDumpProviderInternal(
     MemoryDumpProvider* mdp,
     bool take_mdp_ownership_and_delete_async) {
-  scoped_ptr<MemoryDumpProvider> owned_mdp;
+  std::unique_ptr<MemoryDumpProvider> owned_mdp;
   if (take_mdp_ownership_and_delete_async)
     owned_mdp.reset(mdp);
 
   AutoLock lock(lock_);
 
   auto mdp_iter = dump_providers_.begin();
   for (; mdp_iter != dump_providers_.end(); ++mdp_iter) {
     if ((*mdp_iter)->dump_provider == mdp)
       break;
   }
@@ skipping 75 matching lines @@
     MemoryDumpType dump_type,
     MemoryDumpLevelOfDetail level_of_detail) {
   RequestGlobalDump(dump_type, level_of_detail, MemoryDumpCallback());
 }
 
 void MemoryDumpManager::CreateProcessDump(const MemoryDumpRequestArgs& args,
                                           const MemoryDumpCallback& callback) {
   TRACE_EVENT_NESTABLE_ASYNC_BEGIN0(kTraceCategory, "ProcessMemoryDump",
                                     TRACE_ID_MANGLE(args.dump_guid));
 
-  scoped_ptr<ProcessMemoryDumpAsyncState> pmd_async_state;
+  std::unique_ptr<ProcessMemoryDumpAsyncState> pmd_async_state;
   {
     AutoLock lock(lock_);
     // |dump_thread_| can be nullptr is tracing was disabled before reaching
     // here. SetupNextMemoryDump() is robust enough to tolerate it and will
     // NACK the dump.
     pmd_async_state.reset(new ProcessMemoryDumpAsyncState(
         args, dump_providers_, session_state_, callback,
         dump_thread_ ? dump_thread_->task_runner() : nullptr));
   }
 
   TRACE_EVENT_WITH_FLOW0(kTraceCategory, "MemoryDumpManager::CreateProcessDump",
                          TRACE_ID_MANGLE(args.dump_guid),
                          TRACE_EVENT_FLAG_FLOW_OUT);
 
   // Start the process dump. This involves task runner hops as specified by the
   // MemoryDumpProvider(s) in RegisterDumpProvider()).
   SetupNextMemoryDump(std::move(pmd_async_state));
 }
 
 // PostTask InvokeOnMemoryDump() to the dump provider's sequenced task runner. A
 // PostTask is always required for a generic SequencedTaskRunner to ensure that
 // no other task is running on it concurrently. SetupNextMemoryDump() and
 // InvokeOnMemoryDump() are called alternatively which linearizes the dump
 // provider's OnMemoryDump invocations.
 // At most one of either SetupNextMemoryDump() or InvokeOnMemoryDump() can be
 // active at any time for a given PMD, regardless of status of the |lock_|.
 // |lock_| is used in these functions purely to ensure consistency w.r.t.
 // (un)registrations of |dump_providers_|.
 void MemoryDumpManager::SetupNextMemoryDump(
-    scoped_ptr<ProcessMemoryDumpAsyncState> pmd_async_state) {
+    std::unique_ptr<ProcessMemoryDumpAsyncState> pmd_async_state) {
   // Initalizes the ThreadLocalEventBuffer to guarantee that the TRACE_EVENTs
   // in the PostTask below don't end up registering their own dump providers
   // (for discounting trace memory overhead) while holding the |lock_|.
   TraceLog::GetInstance()->InitializeThreadLocalEventBufferIfSupported();
 
   // If this was the last hop, create a trace event, add it to the trace and
   // finalize process dump (invoke callback).
   if (pmd_async_state->pending_dump_providers.empty())
     return FinalizeDumpAndAddToTrace(std::move(pmd_async_state));
 
@@ skipping 61 matching lines @@
 // (unless disabled).
 void MemoryDumpManager::InvokeOnMemoryDump(
     ProcessMemoryDumpAsyncState* owned_pmd_async_state) {
   // In theory |owned_pmd_async_state| should be a scoped_ptr. The only reason
   // why it isn't is because of the corner case logic of |did_post_task|
   // above, which needs to take back the ownership of the |pmd_async_state| when
   // the PostTask() fails.
   // Unfortunately, PostTask() destroys the scoped_ptr arguments upon failure
   // to prevent accidental leaks. Using a scoped_ptr would prevent us to to
   // skip the hop and move on. Hence the manual naked -> scoped ptr juggling.
-  auto pmd_async_state = make_scoped_ptr(owned_pmd_async_state);
+  auto pmd_async_state = WrapUnique(owned_pmd_async_state);
   owned_pmd_async_state = nullptr;
 
   // Read MemoryDumpProviderInfo thread safety considerations in
   // memory_dump_manager.h when accessing |mdpinfo| fields.
   MemoryDumpProviderInfo* mdpinfo =
       pmd_async_state->pending_dump_providers.back().get();
 
   DCHECK(!mdpinfo->task_runner ||
          mdpinfo->task_runner->RunsTasksOnCurrentThread());
 
@@ skipping 32 matching lines @@
     mdpinfo->consecutive_failures =
         dump_successful ? 0 : mdpinfo->consecutive_failures + 1;
   }
 
   pmd_async_state->pending_dump_providers.pop_back();
   SetupNextMemoryDump(std::move(pmd_async_state));
 }
 
 // static
 void MemoryDumpManager::FinalizeDumpAndAddToTrace(
-    scoped_ptr<ProcessMemoryDumpAsyncState> pmd_async_state) {
+    std::unique_ptr<ProcessMemoryDumpAsyncState> pmd_async_state) {
   DCHECK(pmd_async_state->pending_dump_providers.empty());
   const uint64_t dump_guid = pmd_async_state->req_args.dump_guid;
   if (!pmd_async_state->callback_task_runner->BelongsToCurrentThread()) {
     scoped_refptr<SingleThreadTaskRunner> callback_task_runner =
         pmd_async_state->callback_task_runner;
     callback_task_runner->PostTask(
         FROM_HERE, Bind(&MemoryDumpManager::FinalizeDumpAndAddToTrace,
                         Passed(&pmd_async_state)));
     return;
   }
 
   TRACE_EVENT_WITH_FLOW0(kTraceCategory,
                          "MemoryDumpManager::FinalizeDumpAndAddToTrace",
                          TRACE_ID_MANGLE(dump_guid), TRACE_EVENT_FLAG_FLOW_IN);
 
   for (const auto& kv : pmd_async_state->process_dumps) {
     ProcessId pid = kv.first;  // kNullProcessId for the current process.
     ProcessMemoryDump* process_memory_dump = kv.second.get();
-    scoped_ptr<TracedValue> traced_value(new TracedValue);
+    std::unique_ptr<TracedValue> traced_value(new TracedValue);
     process_memory_dump->AsValueInto(traced_value.get());
     traced_value->SetString("level_of_detail",
                             MemoryDumpLevelOfDetailToString(
                                 pmd_async_state->req_args.level_of_detail));
     const char* const event_name =
         MemoryDumpTypeToString(pmd_async_state->req_args.dump_type);
 
-    scoped_ptr<ConvertableToTraceFormat> event_value(std::move(traced_value));
+    std::unique_ptr<ConvertableToTraceFormat> event_value(
+        std::move(traced_value));
     TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_PROCESS_ID(
         TRACE_EVENT_PHASE_MEMORY_DUMP,
         TraceLog::GetCategoryGroupEnabled(kTraceCategory), event_name,
         trace_event_internal::kGlobalScope, dump_guid, pid,
         kTraceEventNumArgs, kTraceEventArgNames,
         kTraceEventArgTypes, nullptr /* arg_values */, &event_value,
         TRACE_EVENT_FLAG_HAS_ID);
   }
 
   bool tracing_still_enabled;
@@ skipping 15 matching lines @@
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(kTraceCategory, &enabled);
   if (!enabled)
     return;
 
   // Initialize the TraceLog for the current thread. This is to avoid that the
   // TraceLog memory dump provider is registered lazily in the PostTask() below
   // while the |lock_| is taken;
   TraceLog::GetInstance()->InitializeThreadLocalEventBufferIfSupported();
 
   // Spin-up the thread used to invoke unbound dump providers.
-  scoped_ptr<Thread> dump_thread(new Thread("MemoryInfra"));
+  std::unique_ptr<Thread> dump_thread(new Thread("MemoryInfra"));
   if (!dump_thread->Start()) {
     LOG(ERROR) << "Failed to start the memory-infra thread for tracing";
     return;
   }
 
   AutoLock lock(lock_);
 
   DCHECK(delegate_);  // At this point we must have a delegate.
   session_state_ = new MemoryDumpSessionState;
 
   if (heap_profiling_enabled_) {
     // If heap profiling is enabled, the stack frame deduplicator and type name
     // deduplicator will be in use. Add a metadata events to write the frames
     // and type IDs.
     session_state_->SetStackFrameDeduplicator(
-        make_scoped_ptr(new StackFrameDeduplicator));
+        WrapUnique(new StackFrameDeduplicator));
 
     session_state_->SetTypeNameDeduplicator(
-        make_scoped_ptr(new TypeNameDeduplicator));
+        WrapUnique(new TypeNameDeduplicator));
 
     TRACE_EVENT_API_ADD_METADATA_EVENT(
         TraceLog::GetCategoryGroupEnabled("__metadata"), "stackFrames",
         "stackFrames",
-        make_scoped_ptr(
+        WrapUnique(
             new SessionStateConvertableProxy<StackFrameDeduplicator>(
                 session_state_,
                 &MemoryDumpSessionState::stack_frame_deduplicator)));
 
     TRACE_EVENT_API_ADD_METADATA_EVENT(
         TraceLog::GetCategoryGroupEnabled("__metadata"), "typeNames",
         "typeNames",
-        make_scoped_ptr(new SessionStateConvertableProxy<TypeNameDeduplicator>(
+        WrapUnique(new SessionStateConvertableProxy<TypeNameDeduplicator>(
             session_state_, &MemoryDumpSessionState::type_name_deduplicator)));
   }
 
   DCHECK(!dump_thread_);
   dump_thread_ = std::move(dump_thread);
   subtle::NoBarrier_Store(&memory_tracing_enabled_, 1);
 
   // TODO(primiano): This is a temporary hack to disable periodic memory dumps
   // when running memory benchmarks until telemetry uses TraceConfig to
   // enable/disable periodic dumps. See crbug.com/529184 .
@@ skipping 31 matching lines @@
   periodic_dump_timer_.Start(FROM_HERE,
                              TimeDelta::FromMilliseconds(min_timer_period_ms),
                              base::Bind(&RequestPeriodicGlobalDump));
 }
 
 void MemoryDumpManager::OnTraceLogDisabled() {
   // There might be a memory dump in progress while this happens. Therefore,
   // ensure that the MDM state which depends on the tracing enabled / disabled
   // state is always accessed by the dumping methods holding the |lock_|.
   subtle::NoBarrier_Store(&memory_tracing_enabled_, 0);
-  scoped_ptr<Thread> dump_thread;
+  std::unique_ptr<Thread> dump_thread;
   {
     AutoLock lock(lock_);
     dump_thread = std::move(dump_thread_);
     session_state_ = nullptr;
   }
 
   // Thread stops are blocking and must be performed outside of the |lock_|
   // or will deadlock (e.g., if SetupNextMemoryDump() tries to acquire it).
   periodic_dump_timer_.Stop();
   if (dump_thread)
@@ skipping 46 matching lines @@
   pending_dump_providers.assign(dump_providers.rbegin(), dump_providers.rend());
 }
 
 MemoryDumpManager::ProcessMemoryDumpAsyncState::~ProcessMemoryDumpAsyncState() {
 }
 
 ProcessMemoryDump* MemoryDumpManager::ProcessMemoryDumpAsyncState::
     GetOrCreateMemoryDumpContainerForProcess(ProcessId pid) {
   auto iter = process_dumps.find(pid);
   if (iter == process_dumps.end()) {
-    scoped_ptr<ProcessMemoryDump> new_pmd(new ProcessMemoryDump(session_state));
+    std::unique_ptr<ProcessMemoryDump> new_pmd(
+        new ProcessMemoryDump(session_state));
     iter = process_dumps.insert(std::make_pair(pid, std::move(new_pmd))).first;
   }
   return iter->second.get();
 }
 
 }  // namespace trace_event
 }  // namespace base