Refactor CallStackProfile::Params into base/ for use over IPC.

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 <algorithm>
 #include <cstring>
 #include <map>
 #include <utility>
@@ skipping 17 matching lines @@
 
 namespace metrics {
 
 namespace {
 
 // ProfilesState --------------------------------------------------------------
 
 // A set of profiles and the CallStackProfileMetricsProvider state associated
 // with them.
 struct ProfilesState {
-  ProfilesState(const CallStackProfileMetricsProvider::Params& params,
+  ProfilesState(const base::CallStackProfileParams& params,
                 const base::StackSamplingProfiler::CallStackProfiles& profiles,
                 base::TimeTicks start_timestamp);
 
   // The metrics-related parameters provided to
   // CallStackProfileMetricsProvider::GetProfilerCallback().
-  CallStackProfileMetricsProvider::Params params;
+  base::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;
 };
 
 ProfilesState::ProfilesState(
-    const CallStackProfileMetricsProvider::Params& params,
+    const base::CallStackProfileParams& params,
     const base::StackSamplingProfiler::CallStackProfiles& profiles,
     base::TimeTicks start_timestamp)
-    : params(params),
-      profiles(profiles),
-      start_timestamp(start_timestamp) {
-}
+    : params(params), profiles(profiles), start_timestamp(start_timestamp) {}
 
 // 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.
@@ skipping 105 matching lines @@
 // CallStackProfileMetricsProvider.
 PendingProfiles::PendingProfiles() : collection_enabled_(true) {}
 
 PendingProfiles::~PendingProfiles() {}
 
 // Functions to process completed profiles ------------------------------------
 
 // Invoked on the profiler's thread. Provides the profiles to PendingProfiles to
 // append, if the collecting state allows.
 void ReceiveCompletedProfiles(
-    const CallStackProfileMetricsProvider::Params& params,
+    const base::CallStackProfileParams& params,
     base::TimeTicks start_timestamp,
     const StackSamplingProfiler::CallStackProfiles& profiles) {
   PendingProfiles::GetInstance()->CollectProfilesIfCollectionEnabled(
       ProfilesState(params, profiles, start_timestamp));
 }
 
 // Invoked on an arbitrary thread. Ignores the provided profiles.
 void IgnoreCompletedProfiles(
     const StackSamplingProfiler::CallStackProfiles& profiles) {
 }
@@ skipping 82 matching lines @@
 
   proto_profile->set_profile_duration_ms(
       profile.profile_duration.InMilliseconds());
   proto_profile->set_sampling_period_ms(
       profile.sampling_period.InMilliseconds());
 }
 
 // Translates CallStackProfileMetricsProvider's trigger to the corresponding
 // SampledProfile TriggerEvent.
 SampledProfile::TriggerEvent ToSampledProfileTriggerEvent(
-    CallStackProfileMetricsProvider::Trigger trigger) {
+    base::CallStackProfileParams::Trigger trigger) {
   switch (trigger) {
-    case CallStackProfileMetricsProvider::UNKNOWN:
+    case base::CallStackProfileParams::UNKNOWN:
       return SampledProfile::UNKNOWN_TRIGGER_EVENT;
       break;
-    case CallStackProfileMetricsProvider::PROCESS_STARTUP:
+    case base::CallStackProfileParams::PROCESS_STARTUP:
       return SampledProfile::PROCESS_STARTUP;
       break;
-    case CallStackProfileMetricsProvider::JANKY_TASK:
+    case base::CallStackProfileParams::JANKY_TASK:
       return SampledProfile::JANKY_TASK;
       break;
-    case CallStackProfileMetricsProvider::THREAD_HUNG:
+    case base::CallStackProfileParams::THREAD_HUNG:
       return SampledProfile::THREAD_HUNG;
       break;
   }
   NOTREACHED();
   return SampledProfile::UNKNOWN_TRIGGER_EVENT;
 }
 
 }  // namespace
 
-// CallStackProfileMetricsProvider::Params ------------------------------------
-
-CallStackProfileMetricsProvider::Params::Params(
-    CallStackProfileMetricsProvider::Trigger trigger)
-    : Params(trigger, false) {
-}
-
-CallStackProfileMetricsProvider::Params::Params(
-    CallStackProfileMetricsProvider::Trigger trigger,
-    bool preserve_sample_ordering)
-    : trigger(trigger),
-      preserve_sample_ordering(preserve_sample_ordering) {
-}
-
 // CallStackProfileMetricsProvider --------------------------------------------
 
 const char CallStackProfileMetricsProvider::kFieldTrialName[] =
     "StackProfiling";
 const char CallStackProfileMetricsProvider::kReportProfilesGroupName[] =
     "Report profiles";
 
 CallStackProfileMetricsProvider::CallStackProfileMetricsProvider() {
 }
 
 CallStackProfileMetricsProvider::~CallStackProfileMetricsProvider() {
 }
 
 // This function can be invoked on an abitrary thread.
 base::StackSamplingProfiler::CompletedCallback
-CallStackProfileMetricsProvider::GetProfilerCallback(const Params& params) {
+CallStackProfileMetricsProvider::GetProfilerCallback(
+    const base::CallStackProfileParams& params) {
   // Ignore the profiles if the collection is disabled. If the collection state
   // changes while collecting, this will be detected by the callback and
   // profiles will be ignored at that point.
   if (!PendingProfiles::GetInstance()->IsCollectionEnabled())
     return base::Bind(&IgnoreCompletedProfiles);
 
   return base::Bind(&ReceiveCompletedProfiles, params, base::TimeTicks::Now());
 }
 
 void CallStackProfileMetricsProvider::OnRecordingEnabled() {
@@ skipping 31 matching lines @@
 
 // static
 bool CallStackProfileMetricsProvider::IsReportingEnabledByFieldTrial() {
   const std::string group_name = base::FieldTrialList::FindFullName(
       CallStackProfileMetricsProvider::kFieldTrialName);
   return group_name ==
       CallStackProfileMetricsProvider::kReportProfilesGroupName;
 }
 
 }  // namespace metrics