Add process lifetime annotations to stack samples.

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 211 matching lines @@
   memcpy(&name_bytes[0], &basename[0], basename_length_in_bytes);
   return base::HashMetricName(name_bytes);
 }
 
 // Transcode |sample| into |proto_sample|, using base addresses in |modules| to
 // compute module instruction pointer offsets.
 void CopySampleToProto(
     const StackSamplingProfiler::Sample& sample,
     const std::vector<StackSamplingProfiler::Module>& modules,
     CallStackProfile::Sample* proto_sample) {
-  for (const StackSamplingProfiler::Frame& frame : sample) {
+  for (const StackSamplingProfiler::Frame& frame : sample.frames) {
     CallStackProfile::Entry* entry = proto_sample->add_entry();
     // A frame may not have a valid module. If so, we can't compute the
     // instruction pointer offset, and we don't want to send bare pointers, so
     // leave call_stack_entry empty.
     if (frame.module_index == StackSamplingProfiler::Frame::kUnknownModuleIndex)
       continue;
     int64_t module_offset =
         reinterpret_cast<const char*>(frame.instruction_pointer) -
         reinterpret_cast<const char*>(modules[frame.module_index].base_address);
     DCHECK_GE(module_offset, 0);
     entry->set_address(static_cast<uint64_t>(module_offset));
     entry->set_module_id_index(frame.module_index);
   }
 }
 
 // Transcode |profile| into |proto_profile|.
 void CopyProfileToProto(
     const StackSamplingProfiler::CallStackProfile& profile,
     CallStackProfileParams::SampleOrderingSpec ordering_spec,
     CallStackProfile* proto_profile) {
   if (profile.samples.empty())
     return;
 
   if (ordering_spec == CallStackProfileParams::PRESERVE_ORDER) {
     // Collapse only consecutive repeated samples together.
     CallStackProfile::Sample* current_sample_proto = nullptr;
+    uint32_t phases = 0;
+    uint32_t activities = 0;
     for (auto it = profile.samples.begin(); it != profile.samples.end(); ++it) {
       if (!current_sample_proto || *it != *(it - 1)) {
         current_sample_proto = proto_profile->add_sample();
         CopySampleToProto(*it, profile.modules, current_sample_proto);
         current_sample_proto->set_count(1);
+
+        // Phases are "set only" so current is always superset of last-seen.

[Mike Wittman, 2016/11/02 21:44:04]

Also, this logic could stand to be extracted into its own function.

[Mike Wittman, 2016/11/02 21:44:04]

The process phase/activities encoding should have tests.

[bcwhite, 2016/11/03 18:29:50]

OMG the existing tests are ugly!  <shudder>
Done.

[bcwhite, 2016/11/03 18:29:50]

Done.

+        uint32_t bits = it->process_phases & ~phases;
+        for (size_t bit = 0; bits != 0 && bit < sizeof(phases) * 8;
+             ++bit, bits >>= 1) {
+          if (bits & 1) {
+            current_sample_proto->add_process_phase(
+                static_cast<metrics::ProcessPhase>(1 << bit));
+          }
+        }
+
+        // New activities can begin.
+        bits = it->current_activities & ~activities;
+        for (size_t bit = 0; bits != 0 && bit < sizeof(phases) * 8;
+             ++bit, bits >>= 1) {
+          if (bits & 1) {
+            current_sample_proto->add_activities_begun(
+                static_cast<metrics::ProcessActivity>(1 << bit));
+          }
+        }
+
+        // And existing activities can end.
+        bits = activities & ~it->current_activities;
+        for (size_t bit = 0; bits != 0 && bit < sizeof(phases) * 8;
+             ++bit, bits >>= 1) {
+          if (bits & 1) {
+            current_sample_proto->add_activities_ended(
+                static_cast<metrics::ProcessActivity>(1 << bit));
+          }
+        }
+
+        phases = it->process_phases;
+        activities = it->current_activities;
       } else {
         current_sample_proto->set_count(current_sample_proto->count() + 1);
       }
     }
   } else {
     // Collapse all repeated samples together.
     std::map<StackSamplingProfiler::Sample, int> sample_index;
     for (auto it = profile.samples.begin(); it != profile.samples.end(); ++it) {
       auto location = sample_index.find(*it);
       if (location == sample_index.end()) {
@@ skipping 175 matching lines @@
 
 // static
 bool CallStackProfileMetricsProvider::IsReportingEnabledByFieldTrial() {
   const std::string group_name = base::FieldTrialList::FindFullName(
       CallStackProfileMetricsProvider::kFieldTrialName);
   return group_name ==
       CallStackProfileMetricsProvider::kReportProfilesGroupName;
 }
 
 }  // namespace metrics