LatencyInfo mojo: Avoid extra copy of LatencyComponents

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 {
 
@@ skipping 258 matching lines @@
     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;
 
-  // TODO(fsamuel): Figure out how to optimize deserialization.
-  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;
+  mojo::ArrayDataView<ui::mojom::LatencyComponentPairDataView> components;
+  data.GetLatencyComponentsDataView(&components);
+  for (uint32_t i = 0; i < components.size(); ++i) {
+    ui::mojom::LatencyComponentPairDataView component_pair;
+    components.GetDataView(i, &component_pair);

[yzshen1, 2016/08/23 21:23:05]

This change itself LGTM.

Performance fyi: It would be more efficient to store keys and values in two
parallel arrays, rather than putting them in a single array of pair struct.
Because that would save the cost of serializing/validating pair structs.

(But Daniel discussed with me about his concern that checking size of the two
parallel arrays matches would be one more thing to consider. So if this is
really performance critical and you decide to change it to two parallel arrays,
you might want to discuss with him. There is a feature request filed to support
object keys for mojo map.)

+    ui::LatencyInfo::LatencyMap::key_type key;
+    if (!component_pair.ReadKey(&key))
+      return false;
+    auto& value = out->latency_components_[key];
+    if (!component_pair.ReadValue(&value))
+      return false;
+  }
 
   InputCoordinateArray input_coordinate_array = {
       0, ui::LatencyInfo::kMaxInputCoordinates, out->input_coordinates_};
   if (!data.ReadInputCoordinates(&input_coordinate_array))
     return false;
   // TODO(fsamuel): ui::LatencyInfo::input_coordinates_size_ should be a size_t.
   out->input_coordinates_size_ =
       static_cast<uint32_t>(input_coordinate_array.size);
 
   out->trace_id_ = data.trace_id();
   out->coalesced_ = data.coalesced();
   out->terminated_ = data.terminated();
   return true;
 }
 
 }  // namespace mojo