Replaces instances of the deprecated TimeTicks::HighResNow() with TimeTicks::Now().

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/debug/trace_event.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "ui/events/latency_info.h"
 
@@ skipping 183 matching lines @@
                                       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::HighResNow(), 1);
+                                base::TimeTicks::Now(), 1);
 }
 
 void LatencyInfo::AddLatencyNumberWithTimestamp(LatencyComponentType component,
                                                 int64 id,
                                                 int64 component_sequence_number,
                                                 base::TimeTicks time,
                                                 uint32 event_count) {
 
   static const unsigned char* benchmark_enabled =
       TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("benchmark");
@@ skipping 16 matching lines @@
                       &component) ||
           FindLatency(INPUT_EVENT_LATENCY_UI_COMPONENT,
                       0,
                       &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::HighResNow().ToInternalValue() -
+        int64 diff = base::TimeTicks::Now().ToInternalValue() -
             base::TimeTicks::NowFromSystemTraceTime().ToInternalValue();
         ts = component.event_time.ToInternalValue() - diff;
       } else {
         ts = base::TimeTicks::NowFromSystemTraceTime().ToInternalValue();
       }
       TRACE_EVENT_ASYNC_BEGIN_WITH_TIMESTAMP0(
           "benchmark",
           "InputLatency",
           TRACE_ID_DONT_MANGLE(trace_id),
           ts);
@@ skipping 69 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