LatencyInfo: enable async event reporting for both latencyInfo and benchmark categories

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"
@@ skipping 95 matching lines @@
 void LatencyInfoTracedValue::AppendAsTraceFormat(std::string* out) const {
   std::string tmp;
   base::JSONWriter::Write(*value_, &tmp);
   *out += tmp;
 }
 
 LatencyInfoTracedValue::LatencyInfoTracedValue(base::Value* value)
     : value_(value) {
 }
 
-struct BenchmarkEnabledInitializer {
-  BenchmarkEnabledInitializer() :
-      benchmark_enabled(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
-          "benchmark")) {
+const char kTraceCategoriesForAsyncEvents[] = "benchmark,latencyInfo";
+
+struct LatencyInfoEnabledInitializer {
+  LatencyInfoEnabledInitializer() :
+      latency_info_enabled(TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(
+          kTraceCategoriesForAsyncEvents)) {
   }
 
-  const unsigned char* benchmark_enabled;
+  const unsigned char* latency_info_enabled;
 };
 
-static base::LazyInstance<BenchmarkEnabledInitializer>::Leaky
-  g_benchmark_enabled = LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<LatencyInfoEnabledInitializer>::Leaky
+  g_latency_info_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 78 matching lines @@
 }
 
 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;
+  const unsigned char* latency_info_enabled =
+      g_latency_info_enabled.Get().latency_info_enabled;
 
   if (IsBeginComponent(component)) {
     // Should only ever add begin component once.
     CHECK_EQ(-1, trace_id_);
     trace_id_ = component_sequence_number;
 
-    if (*benchmark_enabled) {
+    if (*latency_info_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
       // originally created, e.g. the timestamp of its ORIGINAL/UI_COMPONENT,
       // not when we actually issue the ASYNC_BEGIN trace event.
       LatencyComponent begin_component;
       int64 ts = 0;
       if (FindLatency(INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
                       0,
                       &begin_component) ||
           FindLatency(INPUT_EVENT_LATENCY_UI_COMPONENT,
                       0,
                       &begin_component)) {
         ts = begin_component.event_time.ToInternalValue();
       } else {
         ts = base::TimeTicks::Now().ToInternalValue();
       }
 
       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",
+          kTraceCategoriesForAsyncEvents,
           trace_name_.c_str(),
           TRACE_ID_DONT_MANGLE(trace_id_),
           ts);
     }
 
     TRACE_EVENT_WITH_FLOW1("input,benchmark",
                            "LatencyInfo.Flow",
                            TRACE_ID_DONT_MANGLE(trace_id_),
                            TRACE_EVENT_FLAG_FLOW_OUT,
                            "trace_id", trace_id_);
@@ skipping 16 matching lines @@
           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_COPY_ASYNC_END2("benchmark,latencyInfo", trace_name_.c_str(),
-                                  TRACE_ID_DONT_MANGLE(trace_id_), "data",
-                                  AsTraceableData(), "coordinates",
-                                  CoordinatesAsTraceableData());
+    if (*latency_info_enabled) {
+      TRACE_EVENT_COPY_ASYNC_END2(kTraceCategoriesForAsyncEvents,
+                                  trace_name_.c_str(),
+                                  TRACE_ID_DONT_MANGLE(trace_id_),
+                                  "data", AsTraceableData(),
+                                  "coordinates", CoordinatesAsTraceableData());
     }
 
     TRACE_EVENT_WITH_FLOW0("input,benchmark",
                            "LatencyInfo.Flow",
                            TRACE_ID_DONT_MANGLE(trace_id_),
                            TRACE_EVENT_FLAG_FLOW_IN);
   }
 }
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
@@ skipping 61 matching lines @@
 }
 
 bool LatencyInfo::AddCoalescedEventTimestamp(double timestamp) {
   if (coalesced_events_size_ >= kMaxCoalescedEventTimestamps)
     return false;
   timestamps_of_coalesced_events_[coalesced_events_size_++] = timestamp;
   return true;
 }
 
 }  // namespace ui