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 // Timestamp when a scroll update for the main thread is begun. 26 INPUT_EVENT_LATENCY_BEGIN_SCROLL_UPDATE_MAIN_COMPONENT, 27 // ---------------------------NORMAL COMPONENT------------------------------- 28 // Timestamp when the scroll update gesture event is sent from RWH to 29 // renderer. In Aura, touch event's LatencyInfo is carried over to the gesture 30 // event. So gesture event's INPUT_EVENT_LATENCY_RWH_COMPONENT is the 31 // timestamp when its original touch events is sent from RWH to renderer. 32 // In non-aura platform, INPUT_EVENT_LATENCY_SCROLL_UPDATE_RWH_COMPONENT 33 // is the same as INPUT_EVENT_LATENCY_RWH_COMPONENT. 34 INPUT_EVENT_LATENCY_SCROLL_UPDATE_RWH_COMPONENT, 35 // The original timestamp of the touch event which converts to scroll update. 36 INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT, 37 // Original timestamp for input event (e.g. timestamp from kernel). 38 INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 39 // Timestamp when the UI event is created. 40 INPUT_EVENT_LATENCY_UI_COMPONENT, 41 // This is special component indicating there is rendering scheduled for 42 // the event associated with this LatencyInfo. 43 INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_COMPONENT, 44 // Timestamp when a scroll update is forwarded to the main thread. 45 INPUT_EVENT_LATENCY_FORWARD_SCROLL_UPDATE_TO_MAIN_COMPONENT, 46 // Timestamp when the touch event is acked. 47 INPUT_EVENT_LATENCY_ACKED_TOUCH_COMPONENT, 48 // Frame number when a window snapshot was requested. The snapshot 49 // is taken when the rendering results actually reach the screen. 50 WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT, 51 // Frame number for a snapshot requested via 52 // gpuBenchmarking.beginWindowSnapshotPNG 53 // TODO(vkuzkokov): remove when patch adding this hits Stable 54 WINDOW_OLD_SNAPSHOT_FRAME_NUMBER_COMPONENT, 55 // Timestamp when a tab is requested to be shown. 56 TAB_SHOW_COMPONENT, 57 // ---------------------------TERMINAL COMPONENT----------------------------- 58 // TERMINAL COMPONENT is when we show the latency end in chrome://tracing. 59 // Timestamp when the mouse event is acked from renderer and it does not 60 // cause any rendering scheduled. 61 INPUT_EVENT_LATENCY_TERMINATED_MOUSE_COMPONENT, 62 // Timestamp when the touch event is acked from renderer and it does not 63 // cause any rendering schedueld and does not generate any gesture event. 64 INPUT_EVENT_LATENCY_TERMINATED_TOUCH_COMPONENT, 65 // Timestamp when the gesture event is acked from renderer, and it does not 66 // cause any rendering schedueld. 67 INPUT_EVENT_LATENCY_TERMINATED_GESTURE_COMPONENT, 68 // Timestamp when the frame is swapped (i.e. when the rendering caused by 69 // input event actually takes effect). 70 INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT, 71 // This component indicates that the input causes a commit to be scheduled 72 // but the commit failed. 73 INPUT_EVENT_LATENCY_TERMINATED_COMMIT_FAILED_COMPONENT, 74 // This component indicates that the input causes a commit to be scheduled 75 // but the commit was aborted since it carried no new information. 76 INPUT_EVENT_LATENCY_TERMINATED_COMMIT_NO_UPDATE_COMPONENT, 77 // This component indicates that the input causes a swap to be scheduled 78 // but the swap failed. 79 INPUT_EVENT_LATENCY_TERMINATED_SWAP_FAILED_COMPONENT, 80 // Timestamp when the input event is considered not cause any rendering 81 // damage in plugin and thus terminated. 82 INPUT_EVENT_LATENCY_TERMINATED_PLUGIN_COMPONENT, 83 LATENCY_COMPONENT_TYPE_LAST = INPUT_EVENT_LATENCY_TERMINATED_PLUGIN_COMPONENT 84 }; 85 86 struct EVENTS_BASE_EXPORT LatencyInfo { 87 struct LatencyComponent { 88 // Nondecreasing number that can be used to determine what events happened 89 // in the component at the time this struct was sent on to the next 90 // component. 91 int64 sequence_number; 92 // Average time of events that happened in this component. 93 base::TimeTicks event_time; 94 // Count of events that happened in this component 95 uint32 event_count; 96 }; 97 98 struct EVENTS_BASE_EXPORT InputCoordinate { 99 InputCoordinate(); 100 InputCoordinate(float x, float y); 101 102 float x; 103 float y; 104 }; 105 106 // Empirically determined constant based on a typical scroll sequence. 107 enum { kTypicalMaxComponentsPerLatencyInfo = 6 }; 108 109 enum { kMaxInputCoordinates = 2 }; 110 111 // Map a Latency Component (with a component-specific int64 id) to a 112 // component info. 113 typedef base::SmallMap< 114 std::map<std::pair<LatencyComponentType, int64>, LatencyComponent>, 115 kTypicalMaxComponentsPerLatencyInfo> LatencyMap; 116 117 LatencyInfo(); 118 119 ~LatencyInfo(); 120 121 // Returns true if the vector |latency_info| is valid. Returns false 122 // if it is not valid and log the |referring_msg|. 123 // This function is mainly used to check the latency_info vector that 124 // is passed between processes using IPC message has reasonable size 125 // so that we are confident the IPC message is not corrupted/compromised. 126 // This check will go away once the IPC system has better built-in scheme 127 // for corruption/compromise detection. 128 static bool Verify(const std::vector<LatencyInfo>& latency_info, 129 const char* referring_msg); 130 131 // Copy LatencyComponents with type |type| from |other| into |this|. 132 void CopyLatencyFrom(const LatencyInfo& other, LatencyComponentType type); 133 134 // Add LatencyComponents that are in |other| but not in |this|. 135 void AddNewLatencyFrom(const LatencyInfo& other); 136 137 // Modifies the current sequence number for a component, and adds a new 138 // sequence number with the current timestamp. 139 void AddLatencyNumber(LatencyComponentType component, 140 int64 id, 141 int64 component_sequence_number); 142 143 // Modifies the current sequence number and adds a certain number of events 144 // for a specific component. 145 void AddLatencyNumberWithTimestamp(LatencyComponentType component, 146 int64 id, 147 int64 component_sequence_number, 148 base::TimeTicks time, 149 uint32 event_count); 150 151 // Returns true if the a component with |type| and |id| is found in 152 // the latency_components and the component is stored to |output| if 153 // |output| is not NULL. Returns false if no such component is found. 154 bool FindLatency(LatencyComponentType type, 155 int64 id, 156 LatencyComponent* output) const; 157 158 void RemoveLatency(LatencyComponentType type); 159 160 void Clear(); 161 162 // Records the |event_type| in trace buffer as TRACE_EVENT_ASYNC_STEP. 163 void TraceEventType(const char* event_type); 164 165 LatencyMap latency_components; 166 167 // These coordinates represent window coordinates of the original input event. 168 uint32 input_coordinates_size; 169 InputCoordinate input_coordinates[kMaxInputCoordinates]; 170 171 // The unique id for matching the ASYNC_BEGIN/END trace event. 172 int64 trace_id; 173 // Whether a terminal component has been added. 174 bool terminated; 175 }; 176 177 } // namespace ui 178 179 #endif // UI_EVENTS_LATENCY_INFO_H_ 180