Enable startup profiling by Win x64 stack sampling profiler

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 <cstring>
 #include <map>
 #include <utility>
 
+#include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/metrics/field_trial.h"
 #include "base/profiler/stack_sampling_profiler.h"
 #include "components/metrics/metrics_hashes.h"
 #include "components/metrics/proto/chrome_user_metrics_extension.pb.h"
 
 using base::StackSamplingProfiler;
 
 namespace metrics {
 
 namespace {
 
+bool IsSamplingProfilingReportingEnabled() {

[Ilya Sherman, 2015/03/24 04:02:03]

nit: Doc string, please.

[Mike Wittman, 2015/03/24 18:37:39]

Done.

+  const std::string group_name =
+      base::FieldTrialList::FindFullName(
+          CallStackProfileMetricsProvider::kFieldTrialName);
+  return group_name ==
+      CallStackProfileMetricsProvider::kReportProfilesGroupName;
+}
+
 // The protobuf expects the MD5 checksum prefix of the module name.
 uint64 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');
   memcpy(&name_bytes[0], &basename[0], basename_length_in_bytes);
   return HashMetricName(name_bytes);
 }
@@ skipping 63 matching lines @@
     CallStackProfile::ModuleIdentifier* module_id =
         proto_profile->add_module_id();
     module_id->set_build_id(module.id);
     module_id->set_name_md5_prefix(HashModuleFilename(module.filename));
   }
 
   proto_profile->set_profile_duration_ms(
       profile.profile_duration.InMilliseconds());
   proto_profile->set_sampling_period_ms(
       profile.sampling_period.InMilliseconds());
 }

[Ilya Sherman, 2015/03/24 04:02:03]

nit: Please leave a blank line here.

[Mike Wittman, 2015/03/24 18:37:39]

Done.

 }  // namespace
 
-CallStackProfileMetricsProvider::CallStackProfileMetricsProvider() {}
+const char CallStackProfileMetricsProvider::kFieldTrialName[] =
+    "StackProfiling";
+const char CallStackProfileMetricsProvider::kReportProfilesGroupName[] =
+    "Report profiles";
 
-CallStackProfileMetricsProvider::~CallStackProfileMetricsProvider() {}
+CallStackProfileMetricsProvider::CallStackProfileMetricsProvider()
+    : weak_factory_(this) {
+}
+
+CallStackProfileMetricsProvider::~CallStackProfileMetricsProvider() {
+  StackSamplingProfiler::SetDefaultCompletedCallback(
+      StackSamplingProfiler::CompletedCallback());
+}
+
+void CallStackProfileMetricsProvider::OnRecordingEnabled() {
+  StackSamplingProfiler::SetDefaultCompletedCallback(
+      base::Bind(&CallStackProfileMetricsProvider::ReceiveCompletedProfiles,
+                 weak_factory_.GetWeakPtr()));

[Ilya Sherman, 2015/03/24 04:02:03]

Note that weak pointers are only safe to read on their originating thread.

[Mike Wittman, 2015/03/24 18:37:39]

Ah, didn't realize that. Updated to post a task back to the metrics provider's
thread.

+}
+
+void CallStackProfileMetricsProvider::OnRecordingDisabled() {
+  StackSamplingProfiler::SetDefaultCompletedCallback(
+      base::Bind(&CallStackProfileMetricsProvider::IgnoreCompletedProfiles));
+  {
+    base::AutoLock scoped_lock(pending_profiles_lock_);
+    pending_profiles_.clear();
+  }
+}
 
 void CallStackProfileMetricsProvider::ProvideGeneralMetrics(
     ChromeUserMetricsExtension* uma_proto) {
   std::vector<StackSamplingProfiler::Profile> profiles;
-  if (!source_profiles_for_test_.empty())
-    profiles.swap(source_profiles_for_test_);
-  else
-    StackSamplingProfiler::GetPendingProfiles(&profiles);
+  {
+    base::AutoLock scoped_lock(pending_profiles_lock_);
+    profiles.swap(pending_profiles_);
+  }
+
+  if (!IsSamplingProfilingReportingEnabled())
+    return;
 
   for (const StackSamplingProfiler::Profile& profile : profiles) {
     CallStackProfile* call_stack_profile =
         uma_proto->add_sampled_profile()->mutable_call_stack_profile();
     CopyProfileToProto(profile, call_stack_profile);
   }
 }
 
 void CallStackProfileMetricsProvider::SetSourceProfilesForTesting(
     const std::vector<StackSamplingProfiler::Profile>& profiles) {
-  source_profiles_for_test_ = profiles;
+  base::AutoLock scoped_lock(pending_profiles_lock_);
+  pending_profiles_ = profiles;
+}
+
+void CallStackProfileMetricsProvider::ReceiveCompletedProfiles(
+    const std::vector<base::StackSamplingProfiler::Profile>& profiles) {
+  base::AutoLock scoped_lock(pending_profiles_lock_);
+  pending_profiles_.insert(pending_profiles_.end(), profiles.begin(),
+                           profiles.end());
+}
+
+// static
+void CallStackProfileMetricsProvider::IgnoreCompletedProfiles(
+    const std::vector<base::StackSamplingProfiler::Profile>& profiles) {
 }
 
 }  // namespace metrics