Collapse the API surface on WebInputEvent via accessor functions.

content/browser/renderer_host/input/render_widget_host_latency_tracker.cc

 // Copyright 2014 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/browser/renderer_host/input/render_widget_host_latency_tracker.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 42 matching lines @@
 void UpdateLatencyCoordinatesImpl(const WebMouseWheelEvent& wheel,
                                   LatencyInfo* latency,
                                   float device_scale_factor) {
   latency->AddInputCoordinate(gfx::PointF(wheel.x * device_scale_factor,
                                           wheel.y * device_scale_factor));
 }
 
 void UpdateLatencyCoordinates(const WebInputEvent& event,
                               float device_scale_factor,
                               LatencyInfo* latency) {
-  if (WebInputEvent::isMouseEventType(event.type)) {
+  if (WebInputEvent::isMouseEventType(event.type())) {
     UpdateLatencyCoordinatesImpl(static_cast<const WebMouseEvent&>(event),
                                  latency, device_scale_factor);
-  } else if (WebInputEvent::isGestureEventType(event.type)) {
+  } else if (WebInputEvent::isGestureEventType(event.type())) {
     UpdateLatencyCoordinatesImpl(static_cast<const WebGestureEvent&>(event),
                                  latency, device_scale_factor);
-  } else if (WebInputEvent::isTouchEventType(event.type)) {
+  } else if (WebInputEvent::isTouchEventType(event.type())) {
     UpdateLatencyCoordinatesImpl(static_cast<const WebTouchEvent&>(event),
                                  latency, device_scale_factor);
-  } else if (event.type == WebInputEvent::MouseWheel) {
+  } else if (event.type() == WebInputEvent::MouseWheel) {
     UpdateLatencyCoordinatesImpl(static_cast<const WebMouseWheelEvent&>(event),
                                  latency, device_scale_factor);
   }
 }
 
 // Touch to scroll latency that is mostly under 1 second.
 #define UMA_HISTOGRAM_TOUCH_TO_SCROLL_LATENCY(name, start, end)               \
   UMA_HISTOGRAM_CUSTOM_COUNTS(                                                \
       name, (end.event_time - start.event_time).InMicroseconds(), 1, 1000000, \
       100)
@@ skipping 494 matching lines @@
 
 void RenderWidgetHostLatencyTracker::OnInputEvent(
     const blink::WebInputEvent& event,
     LatencyInfo* latency) {
   DCHECK(latency);
   if (latency->FindLatency(ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT,
                            latency_component_id_, NULL)) {
     return;
   }
 
-  if (event.timeStampSeconds &&
-      !latency->FindLatency(ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
-                            0, NULL)) {
+  if (event.timeStampSeconds() &&
+      !latency->FindLatency(ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0,
+                            NULL)) {
     base::TimeTicks timestamp_now = base::TimeTicks::Now();
-    base::TimeTicks timestamp_original = base::TimeTicks() +
-        base::TimeDelta::FromSecondsD(event.timeStampSeconds);
+    base::TimeTicks timestamp_original =
+        base::TimeTicks() +
+        base::TimeDelta::FromSecondsD(event.timeStampSeconds());
 
     // Timestamp from platform input can wrap, e.g. 32 bits timestamp
     // for Xserver and Window MSG time will wrap about 49.6 days. Do a
     // sanity check here and if wrap does happen, use TimeTicks::Now()
     // as the timestamp instead.
     if ((timestamp_now - timestamp_original).InDays() > 0)
       timestamp_original = timestamp_now;
 
     latency->AddLatencyNumberWithTimestamp(
         ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT,
         0,
         0,
         timestamp_original,
         1);
   }
 
   latency->AddLatencyNumberWithTraceName(
       ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, latency_component_id_,
-      ++last_event_id_, WebInputEvent::GetName(event.type));
+      ++last_event_id_, WebInputEvent::GetName(event.type()));
 
   UpdateLatencyCoordinates(event, device_scale_factor_, latency);
 
-  if (event.type == blink::WebInputEvent::GestureScrollBegin) {
+  if (event.type() == blink::WebInputEvent::GestureScrollBegin) {
     has_seen_first_gesture_scroll_update_ = false;
-  } else if (event.type == blink::WebInputEvent::GestureScrollUpdate) {
+  } else if (event.type() == blink::WebInputEvent::GestureScrollUpdate) {
     // Make a copy of the INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT with a
     // different name INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT.
     // So we can track the latency specifically for scroll update events.
     LatencyInfo::LatencyComponent original_component;
     if (latency->FindLatency(ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT, 0,
                              &original_component)) {
       latency->AddLatencyNumberWithTimestamp(
           has_seen_first_gesture_scroll_update_
               ? ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT
               : ui::INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL_COMPONENT,
           latency_component_id_, original_component.sequence_number,
           original_component.event_time, original_component.event_count);
     }
 
     has_seen_first_gesture_scroll_update_ = true;
   }
 }
 
 void RenderWidgetHostLatencyTracker::OnInputEventAck(
     const blink::WebInputEvent& event,
     LatencyInfo* latency, InputEventAckState ack_result) {
   DCHECK(latency);
 
   // Latency ends when it is acked but does not cause render scheduling.
   bool rendering_scheduled = latency->FindLatency(
       ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN_COMPONENT, 0, nullptr);
   rendering_scheduled |= latency->FindLatency(
       ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL_COMPONENT, 0, nullptr);
 
-  if (WebInputEvent::isGestureEventType(event.type)) {
+  if (WebInputEvent::isGestureEventType(event.type())) {
     if (!rendering_scheduled) {
       latency->AddLatencyNumber(
           ui::INPUT_EVENT_LATENCY_TERMINATED_GESTURE_COMPONENT, 0, 0);
       // TODO(jdduke): Consider exposing histograms for gesture event types.
     }
     return;
   }
 
-  if (WebInputEvent::isTouchEventType(event.type)) {
+  if (WebInputEvent::isTouchEventType(event.type())) {
     const WebTouchEvent& touch_event =
         *static_cast<const WebTouchEvent*>(&event);
-    if (event.type == WebInputEvent::TouchStart) {
+    if (event.type() == WebInputEvent::TouchStart) {
       DCHECK(touch_event.touchesLength >= 1);
       multi_finger_gesture_ = touch_event.touchesLength != 1;
       touch_start_default_prevented_ =
           ack_result == INPUT_EVENT_ACK_STATE_CONSUMED;
     }
 
     latency->AddLatencyNumber(ui::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT, 0, 0);
 
     if (!rendering_scheduled) {
       latency->AddLatencyNumber(
           ui::INPUT_EVENT_LATENCY_TERMINATED_TOUCH_COMPONENT, 0, 0);
     }
-    ComputeInputLatencyHistograms(event.type, latency_component_id_, *latency,
+    ComputeInputLatencyHistograms(event.type(), latency_component_id_, *latency,
                                   ack_result);
     return;
   }
 
-  if (event.type == WebInputEvent::MouseWheel) {
+  if (event.type() == WebInputEvent::MouseWheel) {
     latency->AddLatencyNumber(ui::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT, 0, 0);
     if (!rendering_scheduled) {
       latency->AddLatencyNumber(
           ui::INPUT_EVENT_LATENCY_TERMINATED_MOUSE_WHEEL_COMPONENT, 0, 0);
     }
-    ComputeInputLatencyHistograms(event.type, latency_component_id_, *latency,
+    ComputeInputLatencyHistograms(event.type(), latency_component_id_, *latency,
                                   ack_result);
     return;
   }
 
-  if (WebInputEvent::isMouseEventType(event.type) && !rendering_scheduled) {
-      latency->AddLatencyNumber(
-          ui::INPUT_EVENT_LATENCY_TERMINATED_MOUSE_COMPONENT, 0, 0);
+  if (WebInputEvent::isMouseEventType(event.type()) && !rendering_scheduled) {
+    latency->AddLatencyNumber(
+        ui::INPUT_EVENT_LATENCY_TERMINATED_MOUSE_COMPONENT, 0, 0);
     return;
   }
 
-  if (WebInputEvent::isKeyboardEventType(event.type) && !rendering_scheduled) {
-      latency->AddLatencyNumber(
-          ui::INPUT_EVENT_LATENCY_TERMINATED_KEYBOARD_COMPONENT, 0, 0);
+  if (WebInputEvent::isKeyboardEventType(event.type()) &&
+      !rendering_scheduled) {
+    latency->AddLatencyNumber(
+        ui::INPUT_EVENT_LATENCY_TERMINATED_KEYBOARD_COMPONENT, 0, 0);
     return;
   }
 }
 
 void RenderWidgetHostLatencyTracker::OnSwapCompositorFrame(
     std::vector<LatencyInfo>* latencies) {
   DCHECK(latencies);
   for (LatencyInfo& latency : *latencies) {
     AddLatencyInfoComponentIds(&latency, latency_component_id_);
     latency.AddLatencyNumber(
@@ skipping 54 matching lines @@
         latency, is_running_navigation_hint_task);
   }
 }
 
 void RenderWidgetHostLatencyTracker::SetDelegate(
     RenderWidgetHostDelegate* delegate) {
   render_widget_host_delegate_ = delegate;
 }
 
 }  // namespace content