Implement LatencyInfo StructTraits

ui/events/mojo/latency_info_struct_traits.cc

+// Copyright 2016 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/mojo/latency_info_struct_traits.h"
+
+#include "ipc/ipc_message_utils.h"
+
+namespace mojo {
+
+namespace {
+
+ui::mojom::LatencyComponentType UILatencyComponentTypeToMojo(
+    ui::LatencyComponentType type) {
+  switch (type) {
+    case ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT;
+    case ui::LATENCY_BEGIN_SCROLL_LISTENER_UPDATE_MAIN_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          LATENCY_BEGIN_SCROLL_LISTENER_UPDATE_MAIN_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_UI_COMPONENT:
+      return ui::mojom::LatencyComponentType::INPUT_EVENT_LATENCY_UI_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_RENDERER_MAIN_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_RENDERER_MAIN_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_FORWARD_SCROLL_UPDATE_TO_MAIN_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_FORWARD_SCROLL_UPDATE_TO_MAIN_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT;
+    case ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT;
+    case ui::TAB_SHOW_COMPONENT:
+      return ui::mojom::LatencyComponentType::TAB_SHOW_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT;
+    case ui::INPUT_EVENT_BROWSER_RECEIVED_RENDERER_SWAP_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_BROWSER_RECEIVED_RENDERER_SWAP_COMPONENT;
+    case ui::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_GENERATE_SCROLL_UPDATE_FROM_MOUSE_WHEEL:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_GENERATE_SCROLL_UPDATE_FROM_MOUSE_WHEEL;
+    case ui::INPUT_EVENT_LATENCY_TERMINATED_MOUSE_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_TERMINATED_MOUSE_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_TERMINATED_MOUSE_WHEEL_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_TERMINATED_MOUSE_WHEEL_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_TERMINATED_KEYBOARD_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_TERMINATED_KEYBOARD_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_TERMINATED_TOUCH_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_TERMINATED_TOUCH_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_TERMINATED_GESTURE_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_TERMINATED_GESTURE_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_TERMINATED_COMMIT_FAILED_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_TERMINATED_COMMIT_FAILED_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_TERMINATED_COMMIT_NO_UPDATE_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_TERMINATED_COMMIT_NO_UPDATE_COMPONENT;
+    case ui::INPUT_EVENT_LATENCY_TERMINATED_SWAP_FAILED_COMPONENT:
+      return ui::mojom::LatencyComponentType::
+          INPUT_EVENT_LATENCY_TERMINATED_SWAP_FAILED_COMPONENT;
+  }
+  NOTREACHED();
+  return ui::mojom::LatencyComponentType::LATENCY_COMPONENT_TYPE_LAST;
+}
+
+ui::LatencyComponentType MojoLatencyComponentTypeToUI(
+    ui::mojom::LatencyComponentType type) {
+  switch (type) {
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        LATENCY_BEGIN_SCROLL_LISTENER_UPDATE_MAIN_COMPONENT:
+      return ui::LATENCY_BEGIN_SCROLL_LISTENER_UPDATE_MAIN_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_SCROLL_UPDATE_ORIGINAL_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_FIRST_SCROLL_UPDATE_ORIGINAL_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_ORIGINAL_COMPONENT;
+    case ui::mojom::LatencyComponentType::INPUT_EVENT_LATENCY_UI_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_UI_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_RENDERER_MAIN_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_RENDERER_MAIN_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_MAIN_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_RENDERING_SCHEDULED_IMPL_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_FORWARD_SCROLL_UPDATE_TO_MAIN_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_FORWARD_SCROLL_UPDATE_TO_MAIN_COMPONENT;
+    case ui::mojom::LatencyComponentType::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_ACK_RWH_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT:
+      return ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT;
+    case ui::mojom::LatencyComponentType::TAB_SHOW_COMPONENT:
+      return ui::TAB_SHOW_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_BROWSER_RECEIVED_RENDERER_SWAP_COMPONENT:
+      return ui::INPUT_EVENT_BROWSER_RECEIVED_RENDERER_SWAP_COMPONENT;
+    case ui::mojom::LatencyComponentType::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT:
+      return ui::INPUT_EVENT_GPU_SWAP_BUFFER_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_GENERATE_SCROLL_UPDATE_FROM_MOUSE_WHEEL:
+      return ui::INPUT_EVENT_LATENCY_GENERATE_SCROLL_UPDATE_FROM_MOUSE_WHEEL;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_TERMINATED_MOUSE_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_TERMINATED_MOUSE_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_TERMINATED_MOUSE_WHEEL_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_TERMINATED_MOUSE_WHEEL_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_TERMINATED_KEYBOARD_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_TERMINATED_KEYBOARD_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_TERMINATED_TOUCH_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_TERMINATED_TOUCH_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_TERMINATED_GESTURE_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_TERMINATED_GESTURE_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_TERMINATED_FRAME_SWAP_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_TERMINATED_COMMIT_FAILED_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_TERMINATED_COMMIT_FAILED_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_TERMINATED_COMMIT_NO_UPDATE_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_TERMINATED_COMMIT_NO_UPDATE_COMPONENT;
+    case ui::mojom::LatencyComponentType::
+        INPUT_EVENT_LATENCY_TERMINATED_SWAP_FAILED_COMPONENT:
+      return ui::INPUT_EVENT_LATENCY_TERMINATED_SWAP_FAILED_COMPONENT;
+  }
+  NOTREACHED();
+  return ui::LATENCY_COMPONENT_TYPE_LAST;
+}

[sadrul, 2016/06/06 16:20:13]

This is somewhat unfortunate. Can we cast between the two types?

[Fady Samuel, 2016/06/06 18:00:22]

We decided that this is the best way to catch changes to enums across the C++
version of mojom version.

+
+}  // namespace
+
+// static
+float StructTraits<ui::mojom::InputCoordinate,
+                   ui::LatencyInfo::InputCoordinate>::
+    x(const ui::LatencyInfo::InputCoordinate& input) {
+  return input.x;

[yzshen1, 2016/06/06 16:15:22]

optional: It seems fine to inline such short function bodies. It will save quite
a lot of typing

[Fady Samuel, 2016/06/06 18:00:22]

I inlined InputCoordinate. Done.

+}
+
+// static
+float StructTraits<ui::mojom::InputCoordinate,
+                   ui::LatencyInfo::InputCoordinate>::
+    y(const ui::LatencyInfo::InputCoordinate& input) {
+  return input.y;
+}
+
+// static
+bool StructTraits<ui::mojom::InputCoordinate,
+                  ui::LatencyInfo::InputCoordinate>::
+    Read(ui::mojom::InputCoordinateDataView data,
+         ui::LatencyInfo::InputCoordinate* out) {
+  out->x = data.x();
+  out->y = data.y();
+  return true;
+}
+
+// static
+size_t ArrayTraits<InputCoordinateArray>::GetSize(
+    const InputCoordinateArray& b) {
+  return b.size;
+}
+
+// static
+ui::LatencyInfo::InputCoordinate* ArrayTraits<InputCoordinateArray>::GetData(
+    InputCoordinateArray& b) {
+  return b.data;
+}
+
+// static
+const ui::LatencyInfo::InputCoordinate*
+ArrayTraits<InputCoordinateArray>::GetData(const InputCoordinateArray& b) {
+  return b.data;
+}
+
+// static
+ui::LatencyInfo::InputCoordinate& ArrayTraits<InputCoordinateArray>::GetAt(
+    InputCoordinateArray& b,
+    size_t i) {
+  return b.data[i];
+}
+
+// static
+const ui::LatencyInfo::InputCoordinate&
+ArrayTraits<InputCoordinateArray>::GetAt(const InputCoordinateArray& b,
+                                         size_t i) {
+  return b.data[i];
+}
+
+// static
+void ArrayTraits<InputCoordinateArray>::Resize(InputCoordinateArray& b,
+                                               size_t size) {
+  DCHECK(b.size == size);
+}
+
+// static
+int64_t
+StructTraits<ui::mojom::LatencyComponent, ui::LatencyInfo::LatencyComponent>::
+    sequence_number(const ui::LatencyInfo::LatencyComponent& component) {
+  return component.sequence_number;
+}
+
+// static
+base::TimeTicks
+StructTraits<ui::mojom::LatencyComponent, ui::LatencyInfo::LatencyComponent>::
+    event_time(const ui::LatencyInfo::LatencyComponent& component) {
+  return component.event_time;
+}
+
+// static
+uint32_t
+StructTraits<ui::mojom::LatencyComponent, ui::LatencyInfo::LatencyComponent>::
+    event_count(const ui::LatencyInfo::LatencyComponent& component) {
+  return component.event_count;
+}
+
+// static
+bool StructTraits<ui::mojom::LatencyComponent,
+                  ui::LatencyInfo::LatencyComponent>::
+    Read(ui::mojom::LatencyComponentDataView data,
+         ui::LatencyInfo::LatencyComponent* out) {
+  if (!data.ReadEventTime(&out->event_time))
+    return false;
+  out->sequence_number = data.sequence_number();
+  out->event_count = data.event_count();
+  return true;
+}
+
+// static
+ui::mojom::LatencyComponentType
+StructTraits<ui::mojom::LatencyComponentId,
+             std::pair<ui::LatencyComponentType, int64_t>>::
+    type(const std::pair<ui::LatencyComponentType, int64_t>& id) {
+  return UILatencyComponentTypeToMojo(id.first);
+}
+
+// static
+int64_t StructTraits<ui::mojom::LatencyComponentId,
+                     std::pair<ui::LatencyComponentType, int64_t>>::
+    id(const std::pair<ui::LatencyComponentType, int64_t>& id) {
+  return id.second;
+}
+
+// static
+bool StructTraits<ui::mojom::LatencyComponentId,
+                  std::pair<ui::LatencyComponentType, int64_t>>::
+    Read(ui::mojom::LatencyComponentIdDataView data,
+         std::pair<ui::LatencyComponentType, int64_t>* out) {
+  out->first = MojoLatencyComponentTypeToUI(data.type());
+  out->second = data.id();
+  return true;
+}
+
+std::string StructTraits<ui::mojom::LatencyInfo, ui::LatencyInfo>::trace_name(
+    const ui::LatencyInfo& info) {
+  return info.trace_name_;
+}
+
+mojo::Array<ui::mojom::LatencyComponentPairPtr>
+StructTraits<ui::mojom::LatencyInfo, ui::LatencyInfo>::latency_components(
+    const ui::LatencyInfo& info) {
+  // TODO(fsamuel): It would be nice if we had IterableTraits.
+  auto components = mojo::Array<ui::mojom::LatencyComponentPairPtr>::New(
+      info.latency_components().size());
+  uint32_t i = 0;
+  for (ui::LatencyInfo::LatencyMap::const_iterator
+           it = info.latency_components().begin();
+       it != info.latency_components().end(); ++it, ++i) {
+    auto latency_component_pair = ui::mojom::LatencyComponentPair::New();
+    latency_component_pair->key = it->first;
+    latency_component_pair->value = it->second;
+    components[i] = std::move(latency_component_pair);
+  }
+  return components;
+}
+
+uint32_t
+StructTraits<ui::mojom::LatencyInfo, ui::LatencyInfo>::input_coordinates_size(
+    const ui::LatencyInfo& info) {
+  return info.input_coordinates_size();
+}
+
+InputCoordinateArray
+StructTraits<ui::mojom::LatencyInfo, ui::LatencyInfo>::input_coordinates(
+    const ui::LatencyInfo& info) {
+  // TODO(fsamuel): This can be an ArrayTraits.
+  InputCoordinateArray input_coordinates_array = {
+      info.input_coordinates_size(),
+      const_cast<ui::LatencyInfo::InputCoordinate*>(info.input_coordinates_)};
+  return input_coordinates_array;
+}
+
+int64_t StructTraits<ui::mojom::LatencyInfo, ui::LatencyInfo>::trace_id(
+    const ui::LatencyInfo& info) {
+  return info.trace_id();
+}
+
+bool StructTraits<ui::mojom::LatencyInfo, ui::LatencyInfo>::coalesced(
+    const ui::LatencyInfo& info) {
+  return info.coalesced();
+}
+
+bool StructTraits<ui::mojom::LatencyInfo, ui::LatencyInfo>::terminated(
+    const ui::LatencyInfo& info) {
+  return info.terminated();
+}
+
+bool StructTraits<ui::mojom::LatencyInfo, ui::LatencyInfo>::Read(
+    ui::mojom::LatencyInfoDataView data,
+    ui::LatencyInfo* out) {
+  if (!data.ReadTraceName(&out->trace_name_))
+    return false;
+
+  mojo::Array<ui::mojom::LatencyComponentPairPtr> components;
+  if (!data.ReadLatencyComponents(&components))
+    return false;
+  for (uint32_t i = 0; i < components.size(); ++i)
+    out->latency_components_[components[i]->key] = components[i]->value;
+
+  out->input_coordinates_size_ = data.input_coordinates_size();

[yzshen1, 2016/06/06 16:15:22]

It seems you need to test whether the size from |data| makes sense first.
Otherwise, if |data| has more input coordinate than kMaxInputCoordinates, it
will result in buffer overflow, right?

[Fady Samuel, 2016/06/06 18:00:22]

Done.

+  InputCoordinateArray input_coordinate_array = {data.input_coordinates_size(),
+                                                 out->input_coordinates_};
+  if (!data.ReadInputCoordinates(&input_coordinate_array))
+    return false;
+
+  out->trace_id_ = data.trace_id();
+  out->coalesced_ = data.coalesced();
+  out->terminated_ = data.terminated();
+  return true;
+}
+
+}  // namespace mojo