[Page Load Metrics] PageLoadMetrics Mojofication.

chrome/common/page_load_metrics/page_load_metrics_struct_traits.h

+// Copyright 2017 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.
+
+#ifndef CHROME_COMMON_PAGE_LOAD_METRICS_PAGE_LOAD_METRICS_STRUCT_TRAITS_H_
+#define CHROME_COMMON_PAGE_LOAD_METRICS_PAGE_LOAD_METRICS_STRUCT_TRAITS_H_
+
+#include "base/time/time.h"
+#include "chrome/common/page_load_metrics/page_load_metrics.mojom.h"
+#include "chrome/common/page_load_metrics/page_load_timing.h"
+#include "mojo/common/common_custom_types_struct_traits.h"
+#include "mojo/public/cpp/bindings/struct_traits.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<page_load_metrics::mojom::DocumentTimingDataView,

[Bryan McQuade, 2017/04/24 21:50:56]

interesting, this is a lot of boilerplate that seems like maybe could be
automatically emitted by a mojo compiler. i guess that's not currently possible
but it does seem like this is a fine area for bugs to be introduced (e.g. we
copy/paste a struct trait and reference the wrong field). do you know if there's
any current way or future plan to trim down the amount of StructTraits code that
needs to be written?

i notice in this much older iteration to move this system to mojo
https://codereview.chromium.org/2056153002/ there was no such StructTraits. is
it possible to avoid StructTraits as in that change for simple types that don't
need any special behavior?

[lpy, 2017/04/25 09:03:37]

I was following the mojo wiki so I am not sure if there's any better approach or
future plan.
+ rockot@ for further answer.

[Ken Rockot(use gerrit already), 2017/04/25 19:31:46]

I don't think there is any reasonable way to automate StructTraits generation.
It's almost certainly not worth the complexity to do it well and cover all the
weird possible edge cases.

[Bryan McQuade, 2017/04/26 01:55:42]

ah, ok. what are all the static methods that just return the member variable
needed for? those do seem like they could be autogenerated. the Read() methods
seem like they probably need someone to implement them though.

[Ken Rockot(use gerrit already), 2017/04/26 03:08:01]

This is documented at [1], but the gist is, you have a static method per mojom
field which defines a (fast, i.e., copy-free) way of mapping the object's data
into something the serializer knows how to serialize.

They cannot be autogenerated. It might seem that way for the simplest cases, but
only for the simplest cases. For fields that are POD types for example this is
trivial, and you could imagine us adding a helper macro like:

#define DEFINE_TRIVIAL_STRUCT_TRAITS_FIELD(type, name) \
    static decltype(std::declval<type>().name) name(const type& value) { \
      return value.name; }

so then you could write

DEFINE_TRIVIAL_STRUCT_TRAITS_FIELD(page_load_metrics::DocumentTiming,
first_layout);
DEFINE_TRIVIAL_STRUCT_TRAITS_FIELD(page_load_metrics::DocumentTiming,
load_event_start);

etc, instead of

static base::Optional<base::TimeDelta> first_layout(
    const page_load_metrics::DocumentTiming& value) {
  return value.first_layout;
}

but it saves very little typing and hides behind a magic macro what would
otherwise be easily understandable code.

Keep in mind that many field accessors are not trivial, and do not return the
exact same type as the native type's field (e.g. static std::string accessors
typically return a base::StringPiece); or they don't correspond verbatim to an
existing field on the object (e.g. maybe they're accessed by some other public
accessor method or for various reasons don't have the same name as the mojom
field). In some cases they need to be mapped to some other serializer-compatible
view type (e.g. maybe you use mojo::CArray<uint8_t> to serialize some
specialized buffer type as a mojom array<uint8>), and so on.

[1]
https://chromium.googlesource.com/chromium/src/+/master/mojo/public/cpp/bindi...

+                    page_load_metrics::DocumentTiming> {
+  static base::Optional<base::TimeDelta> dom_content_loaded_event_start(
+      const page_load_metrics::DocumentTiming& document_timing) {
+    return document_timing.dom_content_loaded_event_start;
+  }
+
+  static base::Optional<base::TimeDelta> load_event_start(
+      const page_load_metrics::DocumentTiming& document_timing) {
+    return document_timing.load_event_start;
+  }
+
+  static base::Optional<base::TimeDelta> first_layout(
+      const page_load_metrics::DocumentTiming& document_timing) {
+    return document_timing.first_layout;
+  }
+
+  static bool Read(page_load_metrics::mojom::DocumentTimingDataView data,
+                   page_load_metrics::DocumentTiming* out);
+};
+
+template <>
+struct StructTraits<page_load_metrics::mojom::PaintTimingDataView,
+                    page_load_metrics::PaintTiming> {
+  static base::Optional<base::TimeDelta> first_paint(
+      const page_load_metrics::PaintTiming& paint_timing) {
+    return paint_timing.first_paint;
+  }
+
+  static base::Optional<base::TimeDelta> first_text_paint(
+      const page_load_metrics::PaintTiming& paint_timing) {
+    return paint_timing.first_text_paint;
+  }
+
+  static base::Optional<base::TimeDelta> first_image_paint(
+      const page_load_metrics::PaintTiming& paint_timing) {
+    return paint_timing.first_image_paint;
+  }
+
+  static base::Optional<base::TimeDelta> first_contentful_paint(
+      const page_load_metrics::PaintTiming& paint_timing) {
+    return paint_timing.first_contentful_paint;
+  }
+
+  static base::Optional<base::TimeDelta> first_meaningful_paint(
+      const page_load_metrics::PaintTiming& paint_timing) {
+    return paint_timing.first_meaningful_paint;
+  }
+
+  static bool Read(page_load_metrics::mojom::PaintTimingDataView data,
+                   page_load_metrics::PaintTiming* out);
+};
+
+template <>
+struct StructTraits<page_load_metrics::mojom::ParseTimingDataView,
+                    page_load_metrics::ParseTiming> {
+  static base::Optional<base::TimeDelta> parse_start(
+      const page_load_metrics::ParseTiming& parse_timing) {
+    return parse_timing.parse_start;
+  }
+
+  static base::Optional<base::TimeDelta> parse_stop(
+      const page_load_metrics::ParseTiming& parse_timing) {
+    return parse_timing.parse_stop;
+  }
+
+  static base::Optional<base::TimeDelta> parse_blocked_on_script_load_duration(
+      const page_load_metrics::ParseTiming& parse_timing) {
+    return parse_timing.parse_blocked_on_script_load_duration;
+  }
+
+  static base::Optional<base::TimeDelta>
+  parse_blocked_on_script_load_from_document_write_duration(
+      const page_load_metrics::ParseTiming& parse_timing) {
+    return parse_timing
+        .parse_blocked_on_script_load_from_document_write_duration;
+  }
+
+  static base::Optional<base::TimeDelta>
+  parse_blocked_on_script_execution_duration(
+      const page_load_metrics::ParseTiming& parse_timing) {
+    return parse_timing.parse_blocked_on_script_execution_duration;
+  }
+
+  static base::Optional<base::TimeDelta>
+  parse_blocked_on_script_execution_from_document_write_duration(
+      const page_load_metrics::ParseTiming& parse_timing) {
+    return parse_timing
+        .parse_blocked_on_script_execution_from_document_write_duration;
+  }
+
+  static bool Read(page_load_metrics::mojom::ParseTimingDataView data,
+                   page_load_metrics::ParseTiming* out);
+};
+
+template <>
+struct StructTraits<page_load_metrics::mojom::StyleSheetTimingDataView,
+                    page_load_metrics::StyleSheetTiming> {
+  static base::Optional<base::TimeDelta>
+  author_style_sheet_parse_duration_before_fcp(
+      const page_load_metrics::StyleSheetTiming& style_sheet_timing) {
+    return style_sheet_timing.author_style_sheet_parse_duration_before_fcp;
+  }
+
+  static base::Optional<base::TimeDelta> update_style_duration_before_fcp(
+      const page_load_metrics::StyleSheetTiming& style_sheet_timing) {
+    return style_sheet_timing.update_style_duration_before_fcp;
+  }
+
+  static bool Read(page_load_metrics::mojom::StyleSheetTimingDataView data,
+                   page_load_metrics::StyleSheetTiming* out);
+};
+
+template <>
+struct StructTraits<page_load_metrics::mojom::PageLoadTimingDataView,
+                    page_load_metrics::PageLoadTiming> {
+  static base::Time navigation_start(
+      const page_load_metrics::PageLoadTiming& page_load_timing) {
+    return page_load_timing.navigation_start;
+  }
+
+  static base::Optional<base::TimeDelta> response_start(
+      const page_load_metrics::PageLoadTiming& page_load_timing) {
+    return page_load_timing.response_start;
+  }
+
+  static page_load_metrics::DocumentTiming document_timing(
+      const page_load_metrics::PageLoadTiming& page_load_timing) {
+    return page_load_timing.document_timing;
+  }
+
+  static page_load_metrics::PaintTiming paint_timing(
+      const page_load_metrics::PageLoadTiming& page_load_timing) {
+    return page_load_timing.paint_timing;
+  }
+
+  static page_load_metrics::ParseTiming parse_timing(
+      const page_load_metrics::PageLoadTiming& page_load_timing) {
+    return page_load_timing.parse_timing;
+  }
+
+  static page_load_metrics::StyleSheetTiming style_sheet_timing(
+      const page_load_metrics::PageLoadTiming& page_load_timing) {
+    return page_load_timing.style_sheet_timing;
+  }
+
+  static bool Read(page_load_metrics::mojom::PageLoadTimingDataView data,
+                   page_load_metrics::PageLoadTiming* out);
+};
+
+template <>
+struct StructTraits<page_load_metrics::mojom::PageLoadMetadataDataView,
+                    page_load_metrics::PageLoadMetadata> {
+  static int behavior_flags(
+      const page_load_metrics::PageLoadMetadata& page_load_metadata) {
+    return page_load_metadata.behavior_flags;
+  }
+
+  static bool Read(page_load_metrics::mojom::PageLoadMetadataDataView data,
+                   page_load_metrics::PageLoadMetadata* out);
+};
+
+}  // namespace mojo
+
+#endif  // CHROME_COMMON_PAGE_LOAD_METRICS_PAGE_LOAD_METRICS_STRUCT_TRAITS_H_