Report LatencyInfo through trace buffer

ui/events/latency_info.h

 // Copyright 2013 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.
 
 #ifndef UI_EVENTS_LATENCY_INFO_H_
 #define UI_EVENTS_LATENCY_INFO_H_
 
 #include <map>
 #include <utility>
 
 #include "base/basictypes.h"
+#include "base/debug/trace_event.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "ui/events/events_export.h"
 
 namespace ui {
 
+// This class is for converting latency info to trace buffer friendly format.
+class LatencyInfoTracedValue : public base::debug::ConvertableToTraceFormat {

[nduca, 2013/10/01 21:43:44]

i think you can put this implementation in the cc file since its not visible
elsewhere

[Yufeng Shen (Slow to review), 2013/10/04 00:29:51]

Done.

+ public:
+  static scoped_ptr<ConvertableToTraceFormat> FromValue(
+      base::Value* value);
+
+  virtual ~LatencyInfoTracedValue();
+
+  virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE;
+
+ private:
+  explicit LatencyInfoTracedValue(base::Value* value);
+
+  scoped_ptr<base::Value> value_;
+
+  DISALLOW_COPY_AND_ASSIGN(LatencyInfoTracedValue);
+};
+
 enum LatencyComponentType {
   // Timestamp when the input event is sent from RenderWidgetHost to renderer.
   INPUT_EVENT_LATENCY_RWH_COMPONENT,

[nduca, 2013/10/01 21:43:44]

lets prefix this with a name to indicate that it begins the flow

[Yufeng Shen (Slow to review), 2013/10/04 00:29:51]

Done.

   // Timestamp when the scroll update gesture event is sent from RWH to
   // renderer. In Aura, touch event's LatencyInfo is carried over to the gesture
   // event. So gesture event's INPUT_EVENT_LATENCY_RWH_COMPONENT is the
   // timestamp when its original touch events is sent from RWH to renderer.
   // In non-aura platform, INPUT_EVENT_LATENCY_SCROLL_UPDATE_RWH_COMPONENT
   // is the same as INPUT_EVENT_LATENCY_RWH_COMPONENT.
   INPUT_EVENT_LATENCY_SCROLL_UPDATE_RWH_COMPONENT,
   // The original timestamp of the touch event which converts to scroll update.
   INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT,
   // Original timestamp for input event (e.g. timestamp from kernel).
   INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
   // Timestamp when the UI event is created.
   INPUT_EVENT_LATENCY_UI_COMPONENT,
-  // Timestamp when the event is acked from renderer. This is currently set
-  // only for touch events.
-  INPUT_EVENT_LATENCY_ACKED_COMPONENT
+  // Timestamp when the mouse event is acked from renderer.
+  INPUT_EVENT_LATENCY_ACKED_MOUSE_COMPONENT,

[nduca, 2013/10/01 21:43:44]

lets try calling these FINISH_ or TERMINAL ... latency_finished_at_blahblah for
example 

[Rick Byers, 2013/10/03 13:12:41]

Is the idea that these will always be terminal?  Won't even the common case of
touch scrolling have a ACKED_TOUCH, ACKED_GESTURE AND a FRAME_SWAP?  

[Yufeng Shen (Slow to review), 2013/10/04 00:29:51]

Done.

[Yufeng Shen (Slow to review), 2013/10/04 00:29:51]

As offline talk, we will only allow one terminal component.
so for a touch event. See the comments in the new patch.

+  // Timestamp when the touch event is acked from renderer.
+  INPUT_EVENT_LATENCY_ACKED_TOUCH_COMPONENT,
+  // Timestamp when the gesture event is acked from renderer.
+  INPUT_EVENT_LATENCY_ACKED_GESTURE_COMPONENT,
+  // Timestamp when the frame is swapped.
+  INPUT_EVENT_LATENCY_FRAME_SWAP_COMPONENT,
 };
 
 struct EVENTS_EXPORT LatencyInfo {
   struct LatencyComponent {
     // Nondecreasing number that can be used to determine what events happened
     // in the component at the time this struct was sent on to the next
     // component.
     int64 sequence_number;
     // Average time of events that happened in this component.
     base::TimeTicks event_time;
     // Count of events that happened in this component
     uint32 event_count;
   };
 
   // Map a Latency Component (with a component-specific int64 id) to a
   // component info.
   typedef std::map<std::pair<LatencyComponentType, int64>, LatencyComponent>
       LatencyMap;
 
   LatencyInfo();
 
   ~LatencyInfo();
 
+  // When the LatencyInfo is considered to have finished its lifetime, call
+  // this function. |terminal_component| is added to indicate when & why
+  // this function is called. And then the whole latency info is reported
+  // to system (i.e. dumped to trace buffer).
+  void Report(LatencyComponentType terminal_component);
+  scoped_ptr<base::debug::ConvertableToTraceFormat> AsTraceableData() const;

[jdduke (slow), 2013/10/01 23:45:31]

AsTraceableData() appears to be used only be Report().  Could you make make it a
static/scoped method inside latency_info.cc?  Or make it private? You could then
have it take the "terminal" latency component as an argument, which in turn
would allow you to make Report(...) const, perhaps something like

AsTraceableData(const LatencyInfo& latency, LatencyComponentType
terminal_component);

[Yufeng Shen (Slow to review), 2013/10/04 00:29:51]

moved into cc file as a global function. 

+
   // Merges the contents of another LatencyInfo into this one.
   void MergeWith(const LatencyInfo& other);
 
   // Add LatencyComponents that are in |other| but not in |this|.
   void AddNewLatencyFrom(const LatencyInfo& other);
 
   // Modifies the current sequence number for a component, and adds a new
   // sequence number with the current timestamp.
   void AddLatencyNumber(LatencyComponentType component,
                         int64 id,
@@ skipping 10 matching lines @@
   // Returns true if the a component with |type| and |id| is found in
   // the latency_components and the component is stored to |output| if
   // |output| is not NULL. Returns false if no such component is found.
   bool FindLatency(LatencyComponentType type,
                    int64 id,
                    LatencyComponent* output) const;
 
   void Clear();
 
   LatencyMap latency_components;
-
-  // This represents the final time that a frame is displayed it.
-  base::TimeTicks swap_timestamp;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_LATENCY_INFO_H_