Home | History | Annotate | Download | only in base 
      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_BASE_LATENCY_INFO_H_
      6 #define UI_BASE_LATENCY_INFO_H_
      7 
      8 #include <map>
      9 #include <utility>
     10 
     11 #include "base/basictypes.h"
     12 #include "base/time/time.h"
     13 #include "ui/base/ui_export.h"
     14 
     15 namespace ui {
     16 
     17 enum LatencyComponentType {
     18   // Timestamp when the input event is sent from RenderWidgetHost to renderer.
     19   INPUT_EVENT_LATENCY_RWH_COMPONENT,
     20   // Timestamp when the scroll update gesture event is sent from RWH to
     21   // renderer. In Aura, touch event's LatencyInfo is carried over to the gesture
     22   // event. So gesture event's INPUT_EVENT_LATENCY_RWH_COMPONENT is the
     23   // timestamp when its original touch events is sent from RWH to renderer.
     24   // In non-aura platform, INPUT_EVENT_LATENCY_SCROLL_UPDATE_RWH_COMPONENT
     25   // is the same as INPUT_EVENT_LATENCY_RWH_COMPONENT.
     26   INPUT_EVENT_LATENCY_SCROLL_UPDATE_RWH_COMPONENT,
     27   // The original timestamp of the touch event which converts to scroll update.
     28   INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT,
     29   // Original timestamp for input event (e.g. timestamp from kernel).
     30   INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
     31   // Timestamp when the UI event is created.
     32   INPUT_EVENT_LATENCY_UI_COMPONENT,
     33   // Timestamp when the event is acked from renderer. This is currently set
     34   // only for touch events.
     35   INPUT_EVENT_LATENCY_ACKED_COMPONENT
     36 };
     37 
     38 struct UI_EXPORT LatencyInfo {
     39   struct LatencyComponent {
     40     // Nondecreasing number that can be used to determine what events happened
     41     // in the component at the time this struct was sent on to the next
     42     // component.
     43     int64 sequence_number;
     44     // Average time of events that happened in this component.
     45     base::TimeTicks event_time;
     46     // Count of events that happened in this component
     47     uint32 event_count;
     48   };
     49 
     50   // Map a Latency Component (with a component-specific int64 id) to a
     51   // component info.
     52   typedef std::map<std::pair<LatencyComponentType, int64>, LatencyComponent>
     53       LatencyMap;
     54 
     55   LatencyInfo();
     56 
     57   ~LatencyInfo();
     58 
     59   // Merges the contents of another LatencyInfo into this one.
     60   void MergeWith(const LatencyInfo& other);
     61 
     62   // Add LatencyComponents that are in |other| but not in |this|.
     63   void AddNewLatencyFrom(const LatencyInfo& other);
     64 
     65   // Modifies the current sequence number for a component, and adds a new
     66   // sequence number with the current timestamp.
     67   void AddLatencyNumber(LatencyComponentType component,
     68                         int64 id,
     69                         int64 component_sequence_number);
     70 
     71   // Modifies the current sequence number and adds a certain number of events
     72   // for a specific component.
     73   void AddLatencyNumberWithTimestamp(LatencyComponentType component,
     74                                      int64 id,
     75                                      int64 component_sequence_number,
     76                                      base::TimeTicks time,
     77                                      uint32 event_count);
     78 
     79   // Returns true if the a component with |type| and |id| is found in
     80   // the latency_components and the component is stored to |output| if
     81   // |output| is not NULL. Returns false if no such component is found.
     82   bool FindLatency(LatencyComponentType type,
     83                    int64 id,
     84                    LatencyComponent* output) const;
     85 
     86   void Clear();
     87 
     88   LatencyMap latency_components;
     89 
     90   // This represents the final time that a frame is displayed it.
     91   base::TimeTicks swap_timestamp;
     92 };
     93 
     94 }  // namespace ui
     95 
     96 #endif  // UI_BASE_LATENCY_INFO_H_
     97