base: Use std::move() instead of Pass() for real movable types.

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/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/malloc_dump_provider.h"
@@ skipping 281 matching lines @@
         dump_thread_->task_runner()));
   }
 
   TRACE_EVENT_WITH_FLOW0(kTraceCategory, "MemoryDumpManager::CreateProcessDump",
                          TRACE_ID_MANGLE(args.dump_guid),
                          TRACE_EVENT_FLAG_FLOW_OUT);
 
   // Start the thread hop. |dump_providers_| are kept sorted by thread, so
   // ContinueAsyncProcessDump will hop at most once per thread (w.r.t. thread
   // affinity specified by the MemoryDumpProvider(s) in RegisterDumpProvider()).
-  ContinueAsyncProcessDump(pmd_async_state.Pass());
+  ContinueAsyncProcessDump(std::move(pmd_async_state));
 }
 
 // At most one ContinueAsyncProcessDump() can be active at any time for a given
 // PMD, regardless of status of the |lock_|. |lock_| is used here purely to
 // ensure consistency w.r.t. (un)registrations of |dump_providers_|.
 // The linearization of dump providers' OnMemoryDump invocations is achieved by
 // means of subsequent PostTask(s).
 //
 // 1) Prologue:
 //   - Check if the dump provider is disabled, if so skip the dump.
@@ skipping 51 matching lines @@
       // Copy the callback + arguments just for the unlikley case in which
       // PostTask fails. In such case the Bind helper will destroy the
       // pmd_async_state and we must keep a copy of the fields to notify the
       // abort.
       MemoryDumpCallback callback = pmd_async_state->callback;
       scoped_refptr<SingleThreadTaskRunner> callback_task_runner =
           pmd_async_state->callback_task_runner;
 
       const bool did_post_task = task_runner->PostTask(
           FROM_HERE, Bind(&MemoryDumpManager::ContinueAsyncProcessDump,
-                          Unretained(this), Passed(pmd_async_state.Pass())));
+                          Unretained(this), Passed(&pmd_async_state)));
       if (did_post_task)
         return;
 
       // The thread is gone. At this point the best thing we can do is to
       // disable the dump provider and abort this dump.
       mdp_info->disabled = true;
       return AbortDumpLocked(callback, callback_task_runner, dump_guid);
     }
   }  // AutoLock(lock_)
 
@@ skipping 31 matching lines @@
       dump_providers_.erase(mdp_info);
   }
 
   if (!skip_dump && !dump_successful) {
     LOG(ERROR) << "MemoryDumpProvider \"" << dump_provider_name << "\" failed, "
                << "possibly due to sandboxing (crbug.com/461788)."
                << "Disabling dumper for current process. Try --no-sandbox.";
   }
 
   if (finalize)
-    return FinalizeDumpAndAddToTrace(pmd_async_state.Pass());
+    return FinalizeDumpAndAddToTrace(std::move(pmd_async_state));
 
-  ContinueAsyncProcessDump(pmd_async_state.Pass());
+  ContinueAsyncProcessDump(std::move(pmd_async_state));
 }
 
 // static
 void MemoryDumpManager::FinalizeDumpAndAddToTrace(
     scoped_ptr<ProcessMemoryDumpAsyncState> pmd_async_state) {
   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.Pass())));
+                        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;
@@ skipping 64 matching lines @@
   if (heap_profiling_enabled_) {
     // If heap profiling is enabled, the stack frame deduplicator will be in
     // use. Add a metadata event to write its frames.
     stack_frame_deduplicator = new StackFrameDeduplicator;
     TRACE_EVENT_API_ADD_METADATA_EVENT(
         "stackFrames", "stackFrames",
         scoped_refptr<ConvertableToTraceFormat>(stack_frame_deduplicator));
   }
 
   DCHECK(!dump_thread_);
-  dump_thread_ = dump_thread.Pass();
+  dump_thread_ = std::move(dump_thread);
   session_state_ = new MemoryDumpSessionState(stack_frame_deduplicator);
 
   for (auto it = dump_providers_.begin(); it != dump_providers_.end(); ++it) {
     it->disabled = false;
     it->consecutive_failures = 0;
   }
 
   subtle::NoBarrier_Store(&memory_tracing_enabled_, 1);
 
   // TODO(primiano): This is a temporary hack to disable periodic memory dumps
@@ skipping 33 matching lines @@
   periodic_dump_timer_.Start(FROM_HERE,
                              TimeDelta::FromMilliseconds(min_timer_period_ms),
                              base::Bind(&RequestPeriodicGlobalDump));
 }
 
 void MemoryDumpManager::OnTraceLogDisabled() {
   subtle::NoBarrier_Store(&memory_tracing_enabled_, 0);
   scoped_ptr<Thread> dump_thread;
   {
     AutoLock lock(lock_);
-    dump_thread = dump_thread_.Pass();
+    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 ContinueAsyncProcessDump() tries to acquire it).
   periodic_dump_timer_.Stop();
   if (dump_thread)
     dump_thread->Stop();
 }
 
@@ skipping 41 matching lines @@
       dump_thread_task_runner(dump_thread_task_runner) {}
 
 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));
-    iter = process_dumps.insert(pid, new_pmd.Pass()).first;
+    iter = process_dumps.insert(pid, std::move(new_pmd)).first;
   }
   return iter->second;
 }
 
 }  // namespace trace_event
 }  // namespace base