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

components/metrics/call_stack_profile_metrics_provider.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 "components/metrics/call_stack_profile_metrics_provider.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 21 matching lines @@
 namespace metrics {
 
 namespace {
 
 // ProfilesState --------------------------------------------------------------
 
 // A set of profiles and the CallStackProfileMetricsProvider state associated
 // with them.
 struct ProfilesState {
   ProfilesState(const CallStackProfileParams& params,
-                const base::StackSamplingProfiler::CallStackProfiles& profiles,
+                base::StackSamplingProfiler::CallStackProfiles profiles,
                 base::TimeTicks start_timestamp);
+  ProfilesState(ProfilesState&&);
+  ProfilesState& operator=(ProfilesState&&);
 
   // The metrics-related parameters provided to
   // CallStackProfileMetricsProvider::GetProfilerCallback().
   CallStackProfileParams params;
 
   // The call stack profiles collected by the profiler.
   base::StackSamplingProfiler::CallStackProfiles profiles;
 
   // The time at which the CallStackProfileMetricsProvider became aware of the
   // request for profiling. In particular, this is when callback was requested
   // via CallStackProfileMetricsProvider::GetProfilerCallback(). Used to
   // determine if collection was disabled during the collection of the profile.
   base::TimeTicks start_timestamp;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ProfilesState);
 };
 
 ProfilesState::ProfilesState(
     const CallStackProfileParams& params,
-    const base::StackSamplingProfiler::CallStackProfiles& profiles,
+    base::StackSamplingProfiler::CallStackProfiles profiles,
     base::TimeTicks start_timestamp)
     : params(params),
-      profiles(profiles),
-      start_timestamp(start_timestamp) {
-}
+      profiles(std::move(profiles)),
+      start_timestamp(start_timestamp) {}
+
+ProfilesState::ProfilesState(ProfilesState&&) = default;
+
+// Some versions of GCC need this for push_back to work with std::move.
+ProfilesState& ProfilesState::operator=(ProfilesState&&) = default;
 
 // PendingProfiles ------------------------------------------------------------
 
 // Singleton class responsible for retaining profiles received via the callback
 // created by CallStackProfileMetricsProvider::GetProfilerCallback(). These are
 // then sent to UMA on the invocation of
 // CallStackProfileMetricsProvider::ProvideGeneralMetrics(). We need to store
 // the profiles outside of a CallStackProfileMetricsProvider instance since
 // callers may start profiling before the CallStackProfileMetricsProvider is
 // created.
 //
 // Member functions on this class may be called on any thread.
 class PendingProfiles {
  public:
   static PendingProfiles* GetInstance();
 
   void Clear();
   void Swap(std::vector<ProfilesState>* profiles);
 
   // Enables the collection of profiles by CollectProfilesIfCollectionEnabled if
   // |enabled| is true. Otherwise, clears current profiles and ignores profiles
   // provided to future invocations of CollectProfilesIfCollectionEnabled.
   void SetCollectionEnabled(bool enabled);
 
   // True if profiles are being collected.
   bool IsCollectionEnabled() const;
 
-  // Adds |profile| to the list of profiles if collection is enabled.
-  void CollectProfilesIfCollectionEnabled(const ProfilesState& profiles);
+  // Adds |profiles| to the list of profiles if collection is enabled; it is
+  // not const& because it must be passed with std::move.
+  void CollectProfilesIfCollectionEnabled(ProfilesState profiles);
 
   // Allows testing against the initial state multiple times.
   void ResetToDefaultStateForTesting();
 
  private:
   friend struct base::DefaultSingletonTraits<PendingProfiles>;
 
   PendingProfiles();
   ~PendingProfiles();
 
@@ skipping 40 matching lines @@
     last_collection_disable_time_ = base::TimeTicks::Now();
   }
 }
 
 bool PendingProfiles::IsCollectionEnabled() const {
   base::AutoLock scoped_lock(lock_);
   return collection_enabled_;
 }
 
 void PendingProfiles::CollectProfilesIfCollectionEnabled(
-    const ProfilesState& profiles) {
+    ProfilesState profiles) {
   base::AutoLock scoped_lock(lock_);
 
   // Only collect if collection is not disabled and hasn't been disabled
   // since the start of collection for this profile.
   if (!collection_enabled_ ||
       (!last_collection_disable_time_.is_null() &&
        last_collection_disable_time_ >= profiles.start_timestamp)) {
     return;
   }
 
-  profiles_.push_back(profiles);
+  profiles_.push_back(std::move(profiles));
 }
 
 void PendingProfiles::ResetToDefaultStateForTesting() {
   base::AutoLock scoped_lock(lock_);
 
   collection_enabled_ = true;
   last_collection_disable_time_ = base::TimeTicks();
   profiles_.clear();
 }
 
 // |collection_enabled_| is initialized to true to collect any profiles that are
 // generated prior to creation of the CallStackProfileMetricsProvider. The
 // ultimate disposition of these pre-creation collected profiles will be
 // determined by the initial recording state provided to
 // CallStackProfileMetricsProvider.
 PendingProfiles::PendingProfiles() : collection_enabled_(true) {}
 
 PendingProfiles::~PendingProfiles() {}
 
 // Functions to process completed profiles ------------------------------------
 
 // Will be invoked on either the main thread or the profiler's thread. Provides
 // the profiles to PendingProfiles to append, if the collecting state allows.
 void ReceiveCompletedProfilesImpl(
     const CallStackProfileParams& params,
     base::TimeTicks start_timestamp,
-    const StackSamplingProfiler::CallStackProfiles& profiles) {
+    StackSamplingProfiler::CallStackProfiles profiles) {
   PendingProfiles::GetInstance()->CollectProfilesIfCollectionEnabled(
-      ProfilesState(params, profiles, start_timestamp));
+      ProfilesState(params, std::move(profiles), start_timestamp));
 }
 
 // Invoked on an arbitrary thread. Ignores the provided profiles.
 void IgnoreCompletedProfiles(
-    const StackSamplingProfiler::CallStackProfiles& profiles) {
-}
+    StackSamplingProfiler::CallStackProfiles profiles) {}
 
 // Functions to encode protobufs ----------------------------------------------
 
 // The protobuf expects the MD5 checksum prefix of the module name.
 uint64_t HashModuleFilename(const base::FilePath& filename) {
   const base::FilePath::StringType basename = filename.BaseName().value();
   // Copy the bytes in basename into a string buffer.
   size_t basename_length_in_bytes =
       basename.size() * sizeof(base::FilePath::CharType);
   std::string name_bytes(basename_length_in_bytes, '\0');
@@ skipping 178 matching lines @@
     return base::Bind(&IgnoreCompletedProfiles);
 
   return base::Bind(&ReceiveCompletedProfilesImpl, params,
                     base::TimeTicks::Now());
 }
 
 // static
 void CallStackProfileMetricsProvider::ReceiveCompletedProfiles(
     const CallStackProfileParams& params,
     base::TimeTicks start_timestamp,
-    const base::StackSamplingProfiler::CallStackProfiles& profiles) {
-  ReceiveCompletedProfilesImpl(params, start_timestamp, profiles);
+    base::StackSamplingProfiler::CallStackProfiles profiles) {
+  ReceiveCompletedProfilesImpl(params, start_timestamp, std::move(profiles));
 }
 
 void CallStackProfileMetricsProvider::OnRecordingEnabled() {
   PendingProfiles::GetInstance()->SetCollectionEnabled(true);
 }
 
 void CallStackProfileMetricsProvider::OnRecordingDisabled() {
   PendingProfiles::GetInstance()->SetCollectionEnabled(false);
 }
 
@@ skipping 27 matching lines @@
 
 // static
 bool CallStackProfileMetricsProvider::IsReportingEnabledByFieldTrial() {
   const std::string group_name = base::FieldTrialList::FindFullName(
       CallStackProfileMetricsProvider::kFieldTrialName);
   return group_name ==
       CallStackProfileMetricsProvider::kReportProfilesGroupName;
 }
 
 }  // namespace metrics