Update from https://crrev.com/333737

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 "base/json/json_writer.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"
 
@@ skipping 83 matching lines @@
 LatencyInfoTracedValue::FromValue(scoped_ptr<base::Value> value) {
   return scoped_refptr<base::trace_event::ConvertableToTraceFormat>(
       new LatencyInfoTracedValue(value.release()));
 }
 
 LatencyInfoTracedValue::~LatencyInfoTracedValue() {
 }
 
 void LatencyInfoTracedValue::AppendAsTraceFormat(std::string* out) const {
   std::string tmp;
-  base::JSONWriter::Write(value_.get(), &tmp);
+  base::JSONWriter::Write(*value_, &tmp);
   *out += tmp;
 }
 
 LatencyInfoTracedValue::LatencyInfoTracedValue(base::Value* value)
     : value_(value) {
 }
 
 // Converts latencyinfo into format that can be dumped into trace buffer.
 scoped_refptr<base::trace_event::ConvertableToTraceFormat> AsTraceableData(
     const ui::LatencyInfo& latency) {
@@ skipping 106 matching lines @@
     // 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
       // originally created, e.g. the timestamp of its ORIGINAL/UI_COMPONENT,
       // not when we actually issue the ASYNC_BEGIN trace event.
-      LatencyComponent component;
+      LatencyComponent begin_component;
       int64 ts = 0;
       if (FindLatency(INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
                       0,
-                      &component) ||
+                      &begin_component) ||
           FindLatency(INPUT_EVENT_LATENCY_UI_COMPONENT,
                       0,
-                      &component)) {
+                      &begin_component)) {
         // The timestamp stored in ORIGINAL/UI_COMPONENT is using clock
         // CLOCK_MONOTONIC while TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP0
         // 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.
-        int64 diff = base::TimeTicks::Now().ToInternalValue() -
-            base::TimeTicks::NowFromSystemTraceTime().ToInternalValue();
-        ts = component.event_time.ToInternalValue() - diff;
+        base::TimeDelta diff = (base::TimeTicks::Now() - base::TimeTicks()) -
+            (base::TraceTicks::Now() - base::TraceTicks());
+        ts = (begin_component.event_time - diff).ToInternalValue();
       } else {
-        ts = base::TimeTicks::NowFromSystemTraceTime().ToInternalValue();
+        ts = base::TraceTicks::Now().ToInternalValue();
       }
       TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP0(
           "benchmark",
           "InputLatency",
           TRACE_ID_DONT_MANGLE(trace_id),
           ts);
     }
 
     TRACE_EVENT_FLOW_BEGIN0(
         "input,benchmark", "LatencyInfo.Flow", TRACE_ID_DONT_MANGLE(trace_id));
@@ skipping 65 matching lines @@
 }
 
 void LatencyInfo::TraceEventType(const char* event_type) {
   TRACE_EVENT_ASYNC_STEP_INTO0("benchmark",
                                "InputLatency",
                                TRACE_ID_DONT_MANGLE(trace_id),
                                event_type);
 }
 
 }  // namespace ui