Use movable types for CallStackProfile(s) to remove copying of data.

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"
@@ skipping 22 matching lines @@
  public:
   // Sets up a profiler and arranges for it to be deleted on its completed
   // callback.
   static void Run(PlatformThreadId thread_id,
                   const StackSamplingProfiler::SamplingParams& params,
                   const StackSamplingProfiler::CompletedCallback& callback);
 
  private:
   AsyncRunner();
 
-  // Runs the callback and deletes the AsyncRunner instance.
+  // Runs the callback and deletes the AsyncRunner instance. |profiles| is not
+  // const& because it must be passed with std::move.
   static void RunCallbackAndDeleteInstance(
       std::unique_ptr<AsyncRunner> object_to_be_deleted,
       const StackSamplingProfiler::CompletedCallback& callback,
       scoped_refptr<SingleThreadTaskRunner> task_runner,
-      const StackSamplingProfiler::CallStackProfiles& profiles);
+      StackSamplingProfiler::CallStackProfiles profiles);
 
   std::unique_ptr<StackSamplingProfiler> profiler_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncRunner);
 };
 
 // static
 void AsyncRunner::Run(
     PlatformThreadId thread_id,
     const StackSamplingProfiler::SamplingParams& params,
     const StackSamplingProfiler::CompletedCallback &callback) {
   std::unique_ptr<AsyncRunner> runner(new AsyncRunner);
   AsyncRunner* temp_ptr = runner.get();
   temp_ptr->profiler_.reset(
       new StackSamplingProfiler(thread_id, params,
                                 Bind(&AsyncRunner::RunCallbackAndDeleteInstance,
                                      Passed(&runner), callback,
                                      ThreadTaskRunnerHandle::Get())));
   // The callback won't be called until after Start(), so temp_ptr will still
   // be valid here.
   temp_ptr->profiler_->Start();
 }
 
 AsyncRunner::AsyncRunner() {}
 
 void AsyncRunner::RunCallbackAndDeleteInstance(
     std::unique_ptr<AsyncRunner> object_to_be_deleted,
     const StackSamplingProfiler::CompletedCallback& callback,
     scoped_refptr<SingleThreadTaskRunner> task_runner,
-    const StackSamplingProfiler::CallStackProfiles& profiles) {
-  callback.Run(profiles);
+    StackSamplingProfiler::CallStackProfiles profiles) {
+  callback.Run(std::move(profiles));
   // Delete the instance on the original calling thread.
   task_runner->DeleteSoon(FROM_HERE, object_to_be_deleted.release());
 }
 
 }  // namespace
 
 // StackSamplingProfiler::Module ----------------------------------------------
 
 StackSamplingProfiler::Module::Module() : base_address(0u) {}
 StackSamplingProfiler::Module::Module(uintptr_t base_address,
@@ skipping 13 matching lines @@
 
 StackSamplingProfiler::Frame::Frame()
     : instruction_pointer(0), module_index(kUnknownModuleIndex) {
 }
 
 // StackSamplingProfiler::CallStackProfile ------------------------------------
 
 StackSamplingProfiler::CallStackProfile::CallStackProfile() {}
 
 StackSamplingProfiler::CallStackProfile::CallStackProfile(
+    CallStackProfile&& other) = default;
+
+StackSamplingProfiler::CallStackProfile::~CallStackProfile() {}
+
+StackSamplingProfiler::CallStackProfile&
+StackSamplingProfiler::CallStackProfile::operator=(CallStackProfile&& other) =
+    default;
+
+StackSamplingProfiler::CallStackProfile
+StackSamplingProfiler::CallStackProfile::CopyForTesting() const {
+  return CallStackProfile(*this);
+}
+
+StackSamplingProfiler::CallStackProfile::CallStackProfile(
     const CallStackProfile& other) = default;
 
-StackSamplingProfiler::CallStackProfile::~CallStackProfile() {}
-
 // StackSamplingProfiler::SamplingThread --------------------------------------
 
 StackSamplingProfiler::SamplingThread::SamplingThread(
     std::unique_ptr<NativeStackSampler> native_sampler,
     const SamplingParams& params,
     const CompletedCallback& completed_callback)
     : native_sampler_(std::move(native_sampler)),
       params_(params),
       stop_event_(WaitableEvent::ResetPolicy::AUTOMATIC,
                   WaitableEvent::InitialState::NOT_SIGNALED),
       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;
 
   CallStackProfiles profiles;
   CollectProfiles(&profiles);
   concurrent_profiling_lock.Get().Release();
-  completed_callback_.Run(profiles);
+  completed_callback_.Run(std::move(profiles));
 }
 
 // Depending on how long the sampling takes and the length of the sampling
 // interval, a burst of samples could take arbitrarily longer than
 // samples_per_burst * sampling_interval. In this case, we (somewhat
 // arbitrarily) honor the number of samples requested rather than strictly
 // adhering to the sampling intervals. Once we have established users for the
 // StackSamplingProfiler and the collected data to judge, we may go the other
 // way or make this behavior configurable.
 void StackSamplingProfiler::SamplingThread::CollectProfile(
@@ skipping 43 matching lines @@
       if (stop_event_.TimedWait(
               std::max(params_.burst_interval - previous_elapsed_profile_time,
                        TimeDelta())))
         return;
     }
 
     CallStackProfile profile;
     bool was_stopped = false;
     CollectProfile(&profile, &previous_elapsed_profile_time, &was_stopped);
     if (!profile.samples.empty())
-      profiles->push_back(profile);
+      profiles->push_back(std::move(profile));
 
     if (was_stopped)
       return;
   }
 }
 
 void StackSamplingProfiler::SamplingThread::Stop() {
   stop_event_.Signal();
 }
 
@@ skipping 73 matching lines @@
 }
 
 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