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

base/profiler/stack_sampling_profiler.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/profiler/stack_sampling_profiler.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/profiler/native_stack_sampler.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/timer/elapsed_timer.h"
@@ skipping 88 matching lines @@
 StackSamplingProfiler::CallStackProfile::CallStackProfile() {}
 
 StackSamplingProfiler::CallStackProfile::~CallStackProfile() {}
 
 // StackSamplingProfiler::SamplingThread --------------------------------------
 
 StackSamplingProfiler::SamplingThread::SamplingThread(
     scoped_ptr<NativeStackSampler> native_sampler,
     const SamplingParams& params,
     const CompletedCallback& completed_callback)
-    : native_sampler_(native_sampler.Pass()),
+    : native_sampler_(std::move(native_sampler)),
       params_(params),
       stop_event_(false, false),
-      completed_callback_(completed_callback) {
-}
+      completed_callback_(completed_callback) {}
 
 StackSamplingProfiler::SamplingThread::~SamplingThread() {}
 
 void StackSamplingProfiler::SamplingThread::ThreadMain() {
   PlatformThread::SetName("Chrome_SamplingProfilerThread");
 
   // For now, just ignore any requests to profile while another profiler is
   // working.
   if (!concurrent_profiling_lock.Get().Try())
     return;
@@ skipping 118 matching lines @@
 
 void StackSamplingProfiler::Start() {
   if (completed_callback_.is_null())
     return;
 
   scoped_ptr<NativeStackSampler> native_sampler =
       NativeStackSampler::Create(thread_id_, test_delegate_);
   if (!native_sampler)
     return;
 
-  sampling_thread_.reset(
-      new SamplingThread(native_sampler.Pass(), params_, completed_callback_));
+  sampling_thread_.reset(new SamplingThread(std::move(native_sampler), params_,
+                                            completed_callback_));
   if (!PlatformThread::Create(0, sampling_thread_.get(),
                               &sampling_thread_handle_))
     sampling_thread_.reset();
 }
 
 void StackSamplingProfiler::Stop() {
   if (sampling_thread_)
     sampling_thread_->Stop();
 }
 
 // StackSamplingProfiler::Frame global functions ------------------------------
 
 bool operator==(const StackSamplingProfiler::Frame &a,
                 const StackSamplingProfiler::Frame &b) {
   return a.instruction_pointer == b.instruction_pointer &&
       a.module_index == b.module_index;
 }
 
 bool operator<(const StackSamplingProfiler::Frame &a,
                const StackSamplingProfiler::Frame &b) {
   return (a.module_index < b.module_index) ||
       (a.module_index == b.module_index &&
        a.instruction_pointer < b.instruction_pointer);
 }
 
 }  // namespace base