1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef UI_EVENTS_LATENCY_INFO_H_ 6 #define UI_EVENTS_LATENCY_INFO_H_ 7 8 #include <utility> 9 #include <vector> 10 11 #include "base/basictypes.h" 12 #include "base/containers/small_map.h" 13 #include "base/time/time.h" 14 #include "ui/events/events_base_export.h" 15 16 namespace ui { 17 18 enum LatencyComponentType { 19 // ---------------------------BEGIN COMPONENT------------------------------- 20 // BEGIN COMPONENT is when we show the latency begin in chrome://tracing. 21 // Timestamp when the input event is sent from RenderWidgetHost to renderer. 22 INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 23 // Timestamp when the input event is received in plugin. 24 INPUT_EVENT_LATENCY_BEGIN_PLUGIN_COMPONENT, 25 // ---------------------------NORMAL COMPONENT------------------------------- 26 // Timestamp when the scroll update gesture event is sent from RWH to 27 // renderer. In Aura, touch event's LatencyInfo is carried over to the gesture 28 // event. So gesture event's INPUT_EVENT_LATENCY_RWH_COMPONENT is the 29 // timestamp when its original touch events is sent from RWH to renderer. 30 // In non-aura platform, INPUT_EVENT_LATENCY_SCROLL_UPDATE_RWH_COMPONENT 31 // is the same as INPUT_EVENT_LATENCY_RWH_COMPONENT. 32 INPUT_EVENT_LATENCY_SCROLL_UPDATE_RWH_COMPONENT, 33 // The original timestamp of the touch event which converts to scroll update. 34 INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT, 35 // Original timestamp for input event (e.g. timestamp from kernel). 36 INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 37 // Timestamp when the UI event is created. 38 INPUT_EVENT_LATENCY_UI_COMPONENT, 39 // This is special component indicating there is rendering scheduled for 40 // the event associated with this LatencyInfo. 41 INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_COMPONENT, 42 // Timestamp when the touch event is acked. 43 INPUT_EVENT_LATENCY_ACKED_TOUCH_COMPONENT, 44 // Frame number when a window snapshot was requested. The snapshot 45 // is taken when the rendering results actually reach the screen. 46 WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT, 47 // ---------------------------TERMINAL COMPONENT----------------------------- 48 // TERMINAL COMPONENT is when we show the latency end in chrome://tracing. 49 // Timestamp when the mouse event is acked from renderer and it does not 50 // cause any rendering scheduled. 51 INPUT_EVENT_LATENCY_TERMINATED_MOUSE_COMPONENT, 52 // Timestamp when the touch event is acked from renderer and it does not 53 // cause any rendering schedueld and does not generate any gesture event. 54 INPUT_EVENT_LATENCY_TERMINATED_TOUCH_COMPONENT, 55 // Timestamp when the gesture event is acked from renderer, and it does not 56 // cause any rendering schedueld. 57 INPUT_EVENT_LATENCY_TERMINATED_GESTURE_COMPONENT, 58 // Timestamp when the frame is swapped (i.e. when the rendering caused by 59 // input event actually takes effect). 60 INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 61 // This component indicates that the input causes a commit to be scheduled 62 // but the commit failed. 63 INPUT_EVENT_LATENCY_TERMINATED_COMMIT_FAILED_COMPONENT, 64 // This component indicates that the input causes a swap to be scheduled 65 // but the swap failed. 66 INPUT_EVENT_LATENCY_TERMINATED_SWAP_FAILED_COMPONENT, 67 // This component indicates that the cached LatencyInfo number exceeds the 68 // maximal allowed size. 69 LATENCY_INFO_LIST_TERMINATED_OVERFLOW_COMPONENT, 70 // Timestamp when the input event is considered not cause any rendering 71 // damage in plugin and thus terminated. 72 INPUT_EVENT_LATENCY_TERMINATED_PLUGIN_COMPONENT, 73 LATENCY_COMPONENT_TYPE_LAST = INPUT_EVENT_LATENCY_TERMINATED_PLUGIN_COMPONENT 74 }; 75 76 struct EVENTS_BASE_EXPORT LatencyInfo { 77 struct LatencyComponent { 78 // Nondecreasing number that can be used to determine what events happened 79 // in the component at the time this struct was sent on to the next 80 // component. 81 int64 sequence_number; 82 // Average time of events that happened in this component. 83 base::TimeTicks event_time; 84 // Count of events that happened in this component 85 uint32 event_count; 86 }; 87 88 // Empirically determined constant based on a typical scroll sequence. 89 enum { kTypicalMaxComponentsPerLatencyInfo = 6 }; 90 91 // Map a Latency Component (with a component-specific int64 id) to a 92 // component info. 93 typedef base::SmallMap< 94 std::map<std::pair<LatencyComponentType, int64>, LatencyComponent>, 95 kTypicalMaxComponentsPerLatencyInfo> LatencyMap; 96 97 LatencyInfo(); 98 99 ~LatencyInfo(); 100 101 // Returns true if the vector |latency_info| is valid. Returns false 102 // if it is not valid and log the |referring_msg|. 103 // This function is mainly used to check the latency_info vector that 104 // is passed between processes using IPC message has reasonable size 105 // so that we are confident the IPC message is not corrupted/compromised. 106 // This check will go away once the IPC system has better built-in scheme 107 // for corruption/compromise detection. 108 static bool Verify(const std::vector<LatencyInfo>& latency_info, 109 const char* referring_msg); 110 111 // Copy LatencyComponents with type |type| from |other| into |this|. 112 void CopyLatencyFrom(const LatencyInfo& other, LatencyComponentType type); 113 114 // Add LatencyComponents that are in |other| but not in |this|. 115 void AddNewLatencyFrom(const LatencyInfo& other); 116 117 // Modifies the current sequence number for a component, and adds a new 118 // sequence number with the current timestamp. 119 void AddLatencyNumber(LatencyComponentType component, 120 int64 id, 121 int64 component_sequence_number); 122 123 // Modifies the current sequence number and adds a certain number of events 124 // for a specific component. 125 void AddLatencyNumberWithTimestamp(LatencyComponentType component, 126 int64 id, 127 int64 component_sequence_number, 128 base::TimeTicks time, 129 uint32 event_count); 130 131 // Returns true if the a component with |type| and |id| is found in 132 // the latency_components and the component is stored to |output| if 133 // |output| is not NULL. Returns false if no such component is found. 134 bool FindLatency(LatencyComponentType type, 135 int64 id, 136 LatencyComponent* output) const; 137 138 void RemoveLatency(LatencyComponentType type); 139 140 void Clear(); 141 142 // Records the |event_type| in trace buffer as TRACE_EVENT_ASYNC_STEP. 143 void TraceEventType(const char* event_type); 144 145 LatencyMap latency_components; 146 // The unique id for matching the ASYNC_BEGIN/END trace event. 147 int64 trace_id; 148 // Whether a terminal component has been added. 149 bool terminated; 150 }; 151 152 } // namespace ui 153 154 #endif // UI_EVENTS_LATENCY_INFO_H_ 155