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

base/profiler/stack_sampling_profiler.h

 // 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.
 
 #ifndef BASE_PROFILER_STACK_SAMPLING_PROFILER_H_
 #define BASE_PROFILER_STACK_SAMPLING_PROFILER_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 95 matching lines @@
     // module state directly here to save space.
     size_t module_index;
   };
 
   // Sample represents a set of stack frames.
   using Sample = std::vector<Frame>;
 
   // CallStackProfile represents a set of samples.
   struct BASE_EXPORT CallStackProfile {
     CallStackProfile();
-    CallStackProfile(const CallStackProfile& other);
+    CallStackProfile(CallStackProfile&& other);
     ~CallStackProfile();
 
+    CallStackProfile& operator=(CallStackProfile&& other);
+
+    CallStackProfile CopyForTesting() const;
+
     std::vector<Module> modules;
     std::vector<Sample> samples;
 
     // Duration of this profile.
     TimeDelta profile_duration;
 
     // Time between samples.
     TimeDelta sampling_period;
+
+   private:
+    // Copying is possible but expensive so disallow it; use std::move instead.

[Mike Wittman, 2016/10/21 18:05:29]

nit: ... disallow it _from outside the class_ ...

[bcwhite, 2016/10/24 13:17:45]

Done.

+    CallStackProfile(const CallStackProfile& other);

[Mike Wittman, 2016/10/21 18:05:29]

should we have DISALLOW_ASSIGN here?

[bcwhite, 2016/10/24 13:17:45]

Done, though I don't think it's necessary because I don't believe the method
will get generated when there is a "move" version that is defined explicitly.

   };
 
   using CallStackProfiles = std::vector<CallStackProfile>;
 
   // Represents parameters that configure the sampling.
   struct BASE_EXPORT SamplingParams {
     SamplingParams();
 
     // Time to delay before first samples are taken. Defaults to 0.
     TimeDelta initial_delay;
 
     // Number of sampling bursts to perform. Defaults to 1.
     int bursts;
 
     // Interval between sampling bursts. This is the desired duration from the
     // start of one burst to the start of the next burst. Defaults to 10s.
     TimeDelta burst_interval;
 
     // Number of samples to record per burst. Defaults to 300.
     int samples_per_burst;
 
     // Interval between samples during a sampling burst. This is the desired
     // duration from the start of one sample to the start of the next
     // sample. Defaults to 100ms.
     TimeDelta sampling_interval;
   };
 
-  // The callback type used to collect completed profiles.
+  // The callback type used to collect completed profiles. The passed |profiles|
+  // are move-only.
   //
   // IMPORTANT NOTE: the callback is invoked on a thread the profiler
   // constructs, rather than on the thread used to construct the profiler and
   // set the callback, and thus the callback must be callable on any thread. For
   // threads with message loops that create StackSamplingProfilers, posting a
   // task to the message loop with a copy of the profiles is the recommended
   // thread-safe callback implementation.
-  using CompletedCallback = Callback<void(const CallStackProfiles&)>;
+  using CompletedCallback = Callback<void(CallStackProfiles)>;
 
   // Creates a profiler that sends completed profiles to |callback|. The second
   // constructor is for test purposes.
   StackSamplingProfiler(PlatformThreadId thread_id,
                         const SamplingParams& params,
                         const CompletedCallback& callback);
   StackSamplingProfiler(PlatformThreadId thread_id,
                         const SamplingParams& params,
                         const CompletedCallback& callback,
                         NativeStackSamplerTestDelegate* test_delegate);
@@ skipping 79 matching lines @@
 BASE_EXPORT bool operator==(const StackSamplingProfiler::Module& a,
                             const StackSamplingProfiler::Module& b);
 BASE_EXPORT bool operator==(const StackSamplingProfiler::Frame& a,
                             const StackSamplingProfiler::Frame& b);
 BASE_EXPORT bool operator<(const StackSamplingProfiler::Frame& a,
                            const StackSamplingProfiler::Frame& b);
 
 }  // namespace base
 
 #endif  // BASE_PROFILER_STACK_SAMPLING_PROFILER_H_