Sync ui/events to chromium @ https://codereview.chromium.org/1210203002

ui/events/latency_info.cc

 // 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.
 
+#include "ui/events/latency_info.h"
+
+#include <algorithm>
+#include <string>
+
 #include "base/json/json_writer.h"
+#include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
-#include "ui/events/latency_info.h"
-
-#include <algorithm>
 
 namespace {
 
 const size_t kMaxLatencyInfoNumber = 100;
 
 const char* GetComponentName(ui::LatencyComponentType type) {
 #define CASE_TYPE(t) case ui::t:  return #t
   switch (type) {
     CASE_TYPE(INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_BEGIN_PLUGIN_COMPONENT);
-    CASE_TYPE(INPUT_EVENT_LATENCY_BEGIN_SCROLL_UPDATE_MAIN_COMPONENT);
+    CASE_TYPE(LATENCY_BEGIN_SCROLL_LISTENER_UPDATE_MAIN_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_UI_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_FORWARD_SCROLL_UPDATE_TO_MAIN_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT);
     CASE_TYPE(WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT);
-    CASE_TYPE(WINDOW_OLD_SNAPSHOT_FRAME_NUMBER_COMPONENT);
     CASE_TYPE(TAB_SHOW_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT);
     CASE_TYPE(INPUT_EVENT_BROWSER_RECEIVED_RENDERER_SWAP_COMPONENT);
     CASE_TYPE(INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_TERMINATED_MOUSE_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_TERMINATED_TOUCH_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_TERMINATED_GESTURE_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_TERMINATED_COMMIT_FAILED_COMPONENT);
     CASE_TYPE(INPUT_EVENT_LATENCY_TERMINATED_COMMIT_NO_UPDATE_COMPONENT);
@@ skipping 19 matching lines @@
     case ui::INPUT_EVENT_LATENCY_TERMINATED_PLUGIN_COMPONENT:
       return true;
     default:
       return false;
   }
 }
 
 bool IsBeginComponent(ui::LatencyComponentType type) {
   return (type == ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT ||
           type == ui::INPUT_EVENT_LATENCY_BEGIN_PLUGIN_COMPONENT ||
-          type == ui::INPUT_EVENT_LATENCY_BEGIN_SCROLL_UPDATE_MAIN_COMPONENT);
+          type == ui::LATENCY_BEGIN_SCROLL_LISTENER_UPDATE_MAIN_COMPONENT);
+}
+
+bool IsInputLatencyBeginComponent(ui::LatencyComponentType type) {
+  return (type == ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT ||
+          type == ui::INPUT_EVENT_LATENCY_BEGIN_PLUGIN_COMPONENT);
 }
 
 // This class is for converting latency info to trace buffer friendly format.
 class LatencyInfoTracedValue
     : public base::trace_event::ConvertableToTraceFormat {
  public:
   static scoped_refptr<ConvertableToTraceFormat> FromValue(
       scoped_ptr<base::Value> value);
 
   void AppendAsTraceFormat(std::string* out) const override;
@@ skipping 31 matching lines @@
     const ui::LatencyInfo& latency) {
   scoped_ptr<base::DictionaryValue> record_data(new base::DictionaryValue());
   for (ui::LatencyInfo::LatencyMap::const_iterator it =
            latency.latency_components.begin();
        it != latency.latency_components.end(); ++it) {
     base::DictionaryValue* component_info = new base::DictionaryValue();
     component_info->SetDouble("comp_id", static_cast<double>(it->first.second));
     component_info->SetDouble(
         "time", static_cast<double>(it->second.event_time.ToInternalValue()));
     component_info->SetDouble("count", it->second.event_count);
+    component_info->SetDouble("sequence_number", it->second.sequence_number);
     record_data->Set(GetComponentName(it->first.first), component_info);
   }
   record_data->SetDouble("trace_id", static_cast<double>(latency.trace_id));
 
   scoped_ptr<base::ListValue> coordinates(new base::ListValue());
   for (size_t i = 0; i < latency.input_coordinates_size; i++) {
     scoped_ptr<base::DictionaryValue> coordinate_pair(
         new base::DictionaryValue());
     coordinate_pair->SetDouble("x", latency.input_coordinates[i].x);
     coordinate_pair->SetDouble("y", latency.input_coordinates[i].y);
     coordinates->Append(coordinate_pair.release());
   }
   record_data->Set("coordinates", coordinates.release());
   return LatencyInfoTracedValue::FromValue(record_data.Pass());
 }
 
+struct BenchmarkEnabledInitializer {
+  BenchmarkEnabledInitializer() :
+      benchmark_enabled(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
+          "benchmark")) {
+  }
+
+  const unsigned char* benchmark_enabled;
+};
+
+static base::LazyInstance<BenchmarkEnabledInitializer>::Leaky
+  g_benchmark_enabled = LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 namespace ui {
 
 LatencyInfo::InputCoordinate::InputCoordinate() : x(0), y(0) {
 }
 
 LatencyInfo::InputCoordinate::InputCoordinate(float x, float y) : x(x), y(y) {
 }
 
@@ skipping 47 matching lines @@
                                       it->second.sequence_number,
                                       it->second.event_time,
                                       it->second.event_count);
       }
     }
 }
 
 void LatencyInfo::AddLatencyNumber(LatencyComponentType component,
                                    int64 id,
                                    int64 component_sequence_number) {
-  AddLatencyNumberWithTimestamp(component, id, component_sequence_number,
-                                base::TimeTicks::Now(), 1);
+  AddLatencyNumberWithTimestampImpl(component, id, component_sequence_number,
+                                    base::TimeTicks::Now(), 1, nullptr);
+}
+
+void LatencyInfo::AddLatencyNumberWithTraceName(
+    LatencyComponentType component,
+    int64 id,
+    int64 component_sequence_number,
+    const char* trace_name_str) {
+  AddLatencyNumberWithTimestampImpl(component, id, component_sequence_number,
+                                    base::TimeTicks::Now(), 1, trace_name_str);
 }
 
 void LatencyInfo::AddLatencyNumberWithTimestamp(LatencyComponentType component,
                                                 int64 id,
                                                 int64 component_sequence_number,
                                                 base::TimeTicks time,
                                                 uint32 event_count) {
+  AddLatencyNumberWithTimestampImpl(component, id, component_sequence_number,
+                                    time, event_count, nullptr);
+}
 
-  static const unsigned char* benchmark_enabled =
-      TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("benchmark");
+void LatencyInfo::AddLatencyNumberWithTimestampImpl(
+    LatencyComponentType component,
+    int64 id,
+    int64 component_sequence_number,
+    base::TimeTicks time,
+    uint32 event_count,
+    const char* trace_name_str) {
+
+  const unsigned char* benchmark_enabled =
+      g_benchmark_enabled.Get().benchmark_enabled;
 
   if (IsBeginComponent(component)) {
     // Should only ever add begin component once.
     CHECK_EQ(-1, trace_id);
     trace_id = component_sequence_number;
 
     if (*benchmark_enabled) {
       // The timestamp for ASYNC_BEGIN trace event is used for drawing the
       // beginning of the trace event in trace viewer. For better visualization,
       // for an input event, we want to draw the beginning as when the event is
@@ skipping 12 matching lines @@
         // expects timestamp using CLOCK_MONOTONIC or CLOCK_SYSTEM_TRACE (on
         // CrOS). So we need to adjust the diff between in CLOCK_MONOTONIC and
         // CLOCK_SYSTEM_TRACE. Note that the diff is drifting overtime so we
         // can't use a static value.
         base::TimeDelta diff = (base::TimeTicks::Now() - base::TimeTicks()) -
             (base::TraceTicks::Now() - base::TraceTicks());
         ts = (begin_component.event_time - diff).ToInternalValue();
       } else {
         ts = base::TraceTicks::Now().ToInternalValue();
       }
-      TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP0(
-          "benchmark",
-          "InputLatency",
+
+      if (trace_name_str) {
+        if (IsInputLatencyBeginComponent(component))
+          trace_name = std::string("InputLatency::") + trace_name_str;
+        else
+          trace_name = std::string("Latency::") + trace_name_str;
+      }
+
+      TRACE_EVENT_COPY_ASYNC_BEGIN_WITH_TIMESTAMP0(
+          "benchmark,latencyInfo",
+          trace_name.c_str(),
           TRACE_ID_DONT_MANGLE(trace_id),
           ts);
     }
 
-    TRACE_EVENT_FLOW_BEGIN0(
-        "input,benchmark", "LatencyInfo.Flow", TRACE_ID_DONT_MANGLE(trace_id));
+    TRACE_EVENT_FLOW_BEGIN1(
+        "input,benchmark", "LatencyInfo.Flow", TRACE_ID_DONT_MANGLE(trace_id),
+        "trace_id", trace_id);
   }
 
   LatencyMap::key_type key = std::make_pair(component, id);
   LatencyMap::iterator it = latency_components.find(key);
   if (it == latency_components.end()) {
     LatencyComponent info = {component_sequence_number, time, event_count};
     latency_components[key] = info;
   } else {
     it->second.sequence_number = std::max(component_sequence_number,
                                           it->second.sequence_number);
     uint32 new_count = event_count + it->second.event_count;
     if (event_count > 0 && new_count != 0) {
       // Do a weighted average, so that the new event_time is the average of
       // the times of events currently in this structure with the time passed
       // into this method.
       it->second.event_time += (time - it->second.event_time) * event_count /
           new_count;
       it->second.event_count = new_count;
     }
   }
 
   if (IsTerminalComponent(component) && trace_id != -1) {
     // Should only ever add terminal component once.
     CHECK(!terminated);
     terminated = true;
 
     if (*benchmark_enabled) {
-      TRACE_EVENT_ASYNC_END1("benchmark",
-                             "InputLatency",
-                             TRACE_ID_DONT_MANGLE(trace_id),
-                             "data", AsTraceableData(*this));
+      TRACE_EVENT_COPY_ASYNC_END1("benchmark,latencyInfo",
+                                  trace_name.c_str(),
+                                  TRACE_ID_DONT_MANGLE(trace_id),
+                                  "data", AsTraceableData(*this));
     }
 
-    TRACE_EVENT_FLOW_END0(
-        "input,benchmark", "LatencyInfo.Flow", TRACE_ID_DONT_MANGLE(trace_id));
+    // Removed - does not compile
+    // TRACE_EVENT_FLOW_END_BIND_TO_ENCLOSING0(
+    //     "input,benchmark", "LatencyInfo.Flow", TRACE_ID_DONT_MANGLE(trace_id));
   }
 }
 
 bool LatencyInfo::FindLatency(LatencyComponentType type,
                               int64 id,
                               LatencyComponent* output) const {
   LatencyMap::const_iterator it = latency_components.find(
       std::make_pair(type, id));
   if (it == latency_components.end())
     return false;
@@ skipping 12 matching lines @@
     } else {
       it++;
     }
   }
 }
 
 void LatencyInfo::Clear() {
   latency_components.clear();
 }
 
-void LatencyInfo::TraceEventType(const char* event_type) {
-  TRACE_EVENT_ASYNC_STEP_INTO0("benchmark",
-                               "InputLatency",
-                               TRACE_ID_DONT_MANGLE(trace_id),
-                               event_type);
-}
-
 }  // namespace ui