Switch to standard integer types in content/renderer/.

content/renderer/input/render_widget_input_handler.cc

 // Copyright 2015 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 "content/renderer/input/render_widget_input_handler.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/auto_reset.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event_synthetic_delay.h"
+#include "build/build_config.h"
 #include "cc/trees/swap_promise_monitor.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "content/common/input/input_event_ack.h"
 #include "content/common/input/input_event_ack_state.h"
 #include "content/common/input/web_input_event_traits.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
 #include "content/renderer/ime_event_guard.h"
 #include "content/renderer/input/render_widget_input_handler_delegate.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_widget.h"
@@ skipping 20 matching lines @@
 namespace content {
 
 namespace {
 
 // TODO(brianderson): Replace the hard-coded threshold with a fraction of
 // the BeginMainFrame interval.
 // 4166us will allow 1/4 of a 60Hz interval or 1/2 of a 120Hz interval to
 // be spent in input hanlders before input starts getting throttled.
 const int kInputHandlingTimeThrottlingThresholdMicroseconds = 4166;
 
-int64 GetEventLatencyMicros(double event_timestamp, base::TimeTicks now) {
+int64_t GetEventLatencyMicros(double event_timestamp, base::TimeTicks now) {
   return (now - base::TimeDelta::FromSecondsD(event_timestamp))
       .ToInternalValue();
 }
 
 void LogInputEventLatencyUmaImpl(WebInputEvent::Type event_type,
                                  double event_timestamp,
                                  base::TimeTicks now) {
   UMA_HISTOGRAM_CUSTOM_COUNTS("Event.AggregatedLatency.Renderer2",
                               GetEventLatencyMicros(event_timestamp, now), 1,
                               10000000, 100);
@@ skipping 52 matching lines @@
 void LogInputEventLatencyUma(const WebInputEvent& event,
                              base::TimeTicks now,
                              const ui::LatencyInfo& latency_info) {
   LogInputEventLatencyUmaImpl(event.type, event.timeStampSeconds, now);
   for (size_t i = 0; i < latency_info.coalesced_events_size(); i++) {
     LogInputEventLatencyUmaImpl(
         event.type, latency_info.timestamps_of_coalesced_events()[i], now);
   }
 }
 
-void LogPassiveLatency(int64 latency) {
+void LogPassiveLatency(int64_t latency) {
   UMA_HISTOGRAM_CUSTOM_COUNTS("Event.PassiveListeners.Latency", latency, 1,
                               10000000, 100);
 }
 
 void LogPassiveEventListenersUma(WebInputEventResult result,
                                  bool passive,
                                  bool cancelable,
                                  double event_timestamp,
                                  const ui::LatencyInfo& latency_info) {
   enum {
@@ skipping 347 matching lines @@
   if (pending_input_event_ack_) {
     TRACE_EVENT_ASYNC_END0("input",
                            "RenderWidgetInputHandler::ThrottledInputEventAck",
                            pending_input_event_ack_.get());
     delegate_->OnInputEventAck(std::move(pending_input_event_ack_));
   }
   total_input_handling_time_this_frame_ = base::TimeDelta();
 }
 
 }  // namespace content