Introducing phased profiling framework

components/metrics/profiler/tracking_synchronizer_observer.h

Index: components/metrics/profiler/tracking_synchronizer_observer.h
diff --git a/components/metrics/profiler/tracking_synchronizer_observer.h b/components/metrics/profiler/tracking_synchronizer_observer.h
index b9301bb268e4d0c97319916752f2d31dd231834e..bc7a5b9d01ca1dad1b6778f974aead330a47fafc 100644
--- a/components/metrics/profiler/tracking_synchronizer_observer.h
+++ b/components/metrics/profiler/tracking_synchronizer_observer.h
@@ -5,21 +5,47 @@
 #ifndef COMPONENTS_METRICS_PROFILER_TRACKING_SYNCHRONIZER_OBSERVER_H_
 #define COMPONENTS_METRICS_PROFILER_TRACKING_SYNCHRONIZER_OBSERVER_H_
 
+#include <vector>
+
+#include "base/process/process_handle.h"
+#include "components/metrics/proto/chrome_user_metrics_extension.pb.h"
+#include "content/public/common/process_type.h"
+
+namespace base {
+class TimeDelta;
+}
+
 namespace tracked_objects {
-struct ProcessDataSnapshot;
+struct ProcessDataPhaseSnapshot;
 }
 
 namespace metrics {
 
+// Set of profiling events, in no guaranteed order. Implemented as a vector
+// because we don't need to have an efficient .find() on it, so vector<> is more
+// efficient.
+typedef std::vector<ProfilerEventProto::ProfilerEvent> ProfilerEvents;
+
 // Observer for notifications from the TrackingSynchronizer class.
 class TrackingSynchronizerObserver {
  public:
-  // Received |profiler_data| from a single process of |process_type|.
+  // Received |process_data_phase| for profiling phase |profiling_phase| from a
+  // single process of |process_type|. The phase start and finish times,
+  // relative to the start time are |phase_start| and
+  // |phase_finish|. All profiling phases prior to the reported one have already
+  // completed, and each completion was associated with an instance of
+  // ProfilerEventProto::ProfilerEvent. |past_events| contains events associated
+  // with completions of phases prior to the reported one.
   // The observer should assume there might be more data coming until
-  // |FinishedReceivingData()| is called.
+  // FinishedReceivingData() is called.
   virtual void ReceivedProfilerData(
-      const tracked_objects::ProcessDataSnapshot& profiler_data,
-      int process_type) = 0;
+      const tracked_objects::ProcessDataPhaseSnapshot& process_data_phase,
+      base::ProcessId process_id,
+      content::ProcessType process_type,
+      int profiling_phase,
+      const base::TimeDelta& phase_start,
+      const base::TimeDelta& phase_finish,
+      const ProfilerEvents& past_events) = 0;

[Ilya Sherman, 2015/03/14 00:20:35]

I don't think it's appropriate to pass a list (or set) of past events, as this
is only used by the metrics service client.  Please instead pass the event for
the phase itself.  The metrics service can manage its own cache, if need be. 
(In fact, since you're already passing the profiling_phase, there's probably no
need to pass the ProfilerEvent at all; or vice-versa.  One can be inferred from
the other.)

[vadimt, 2015/03/14 01:39:15]

This is very similar to the other theme that we decided to discuss at the later
CL.
Let's just speak about this later...

 
   // The observer should not expect any more calls to |ReceivedProfilerData()|
   // (without re-registering).  This is sent either when data from all processes