Implement cc::CompositorFrameMetadata StructTraits

This CL replaces the simple mus CompositorFrameMetadata struct with a
full fidelity struct along with StructTraits. w00t! Soon full fidelity
CompositorFrames in Mus without extra copies!

BUG=611802
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review-Url: https://codereview.chromium.org/2042643002
Cr-Commit-Position: refs/heads/master@{#398222}

cc/ipc/BUILD.gn

@@ -38,6 +38,7 @@ component("ipc") {
 mojom("interfaces") {
   sources = [
     "begin_frame_args.mojom",
+    "compositor_frame_metadata.mojom",
     "render_pass_id.mojom",
     "returned_resource.mojom",
     "selection.mojom",
@@ -49,6 +50,7 @@ mojom("interfaces") {
   public_deps = [
     "//gpu/ipc/common:interfaces",
     "//mojo/common:common_custom_types",
+    "//ui/events/mojo:interfaces",
     "//ui/gfx/geometry/mojo",
     "//ui/gfx/mojo",
   ]

cc/ipc/compositor_frame_metadata.mojom

+// 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.
+
+module cc.mojom;
+
+import "cc/ipc/selection.mojom";
+import "cc/ipc/surface_id.mojom";
+import "ui/events/mojo/latency_info.mojom";
+import "ui/gfx/geometry/mojo/geometry.mojom";
+
+// See cc/output/compositor_frame_metadata.h.
+struct CompositorFrameMetadata {
+  float device_scale_factor;
+  gfx.mojom.Vector2dF root_scroll_offset;
+  float page_scale_factor;
+  gfx.mojom.SizeF scrollable_viewport_size;
+  gfx.mojom.SizeF root_layer_size;
+  float min_page_scale_factor;
+  float max_page_scale_factor;
+  bool root_overflow_x_hidden;
+  bool root_overflow_y_hidden;
+  gfx.mojom.Vector2dF location_bar_offset;
+  gfx.mojom.Vector2dF location_bar_content_translation;
+  uint32 root_background_color;
+  Selection selection;
+  array<ui.mojom.LatencyInfo> latency_info;
+  array<uint32> satisfies_sequences;
+  array<SurfaceId> referenced_surfaces;
+};

cc/ipc/compositor_frame_metadata.typemap

+# 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.
+
+mojom = "//cc/ipc/compositor_frame_metadata.mojom"
+public_headers = [ "//cc/output/compositor_frame_metadata.h" ]
+traits_headers = [ "//cc/ipc/compositor_frame_metadata_struct_traits.h" ]
+deps = [ "//cc", "//ui/gfx", "//ui/events:events_base" ]
+type_mappings = [ "cc.mojom.CompositorFrameMetadata=cc::CompositorFrameMetadata" ]

cc/ipc/compositor_frame_metadata_struct_traits.h

+// 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.
+
+#ifndef CC_IPC_COMPOSITOR_FRAME_METADATA_STRUCT_TRAITS_H_
+#define CC_IPC_COMPOSITOR_FRAME_METADATA_STRUCT_TRAITS_H_
+
+#include "cc/ipc/compositor_frame_metadata.mojom.h"
+#include "cc/output/compositor_frame_metadata.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<cc::mojom::CompositorFrameMetadata,
+                    cc::CompositorFrameMetadata> {
+  static float device_scale_factor(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.device_scale_factor;
+  }
+
+  static gfx::Vector2dF root_scroll_offset(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.root_scroll_offset;
+  }
+
+  static float page_scale_factor(const cc::CompositorFrameMetadata& metadata) {
+    return metadata.page_scale_factor;
+  }
+
+  static gfx::SizeF scrollable_viewport_size(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.scrollable_viewport_size;
+  }
+
+  static gfx::SizeF root_layer_size(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.root_layer_size;
+  }
+
+  static float min_page_scale_factor(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.min_page_scale_factor;
+  }
+
+  static float max_page_scale_factor(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.max_page_scale_factor;
+  }
+
+  static bool root_overflow_x_hidden(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.root_overflow_x_hidden;
+  }
+
+  static bool root_overflow_y_hidden(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.root_overflow_y_hidden;
+  }
+
+  static gfx::Vector2dF location_bar_offset(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.location_bar_offset;
+  }
+
+  static gfx::Vector2dF location_bar_content_translation(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.location_bar_content_translation;
+  }
+
+  static uint32_t root_background_color(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.root_background_color;
+  }
+
+  static const cc::Selection<gfx::SelectionBound>& selection(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.selection;
+  }
+
+  static const std::vector<ui::LatencyInfo>& latency_info(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.latency_info;
+  }
+
+  static const std::vector<uint32_t>& satisfies_sequences(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.satisfies_sequences;
+  }
+
+  static const std::vector<cc::SurfaceId>& referenced_surfaces(
+      const cc::CompositorFrameMetadata& metadata) {
+    return metadata.referenced_surfaces;
+  }
+
+  static bool Read(cc::mojom::CompositorFrameMetadataDataView data,
+                   cc::CompositorFrameMetadata* out) {
+    out->device_scale_factor = data.device_scale_factor();
+    if (!data.ReadRootScrollOffset(&out->root_scroll_offset))
+      return false;
+
+    out->page_scale_factor = data.page_scale_factor();
+    if (!data.ReadScrollableViewportSize(&out->scrollable_viewport_size) ||
+        !data.ReadRootLayerSize(&out->root_layer_size)) {
+      return false;
+    }
+
+    out->min_page_scale_factor = data.min_page_scale_factor();
+    out->max_page_scale_factor = data.max_page_scale_factor();
+    out->root_overflow_x_hidden = data.root_overflow_x_hidden();
+    out->root_overflow_y_hidden = data.root_overflow_y_hidden();
+    if (!data.ReadLocationBarOffset(&out->location_bar_offset) ||
+        !data.ReadLocationBarContentTranslation(
+            &out->location_bar_content_translation)) {
+      return false;
+    }
+
+    out->root_background_color = data.root_background_color();
+    if (!data.ReadSelection(&out->selection) ||
+        !data.ReadLatencyInfo(&out->latency_info) ||
+        !data.ReadSatisfiesSequences(&out->satisfies_sequences) ||
+        !data.ReadReferencedSurfaces(&out->referenced_surfaces)) {
+      return false;
+    }
+    return true;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // CC_IPC_COMPOSITOR_FRAME_METADATA_STRUCT_TRAITS_H_

cc/ipc/struct_traits_unittest.cc

@@ -29,6 +29,12 @@ class StructTraitsTest : public testing::Test, public mojom::TraitsTestService {
     callback.Run(b);
   }
 
+  void EchoCompositorFrameMetadata(
+      const CompositorFrameMetadata& c,
+      const EchoCompositorFrameMetadataCallback& callback) override {
+    callback.Run(c);
+  }
+
   void EchoRenderPassId(const RenderPassId& r,
                         const EchoRenderPassIdCallback& callback) override {
     callback.Run(r);
@@ -90,6 +96,88 @@ TEST_F(StructTraitsTest, BeginFrameArgs) {
   EXPECT_EQ(on_critical_path, output.on_critical_path);
 }
 
+TEST_F(StructTraitsTest, CompositorFrameMetadata) {
+  const float device_scale_factor = 2.6f;
+  const gfx::Vector2dF root_scroll_offset(1234.5f, 6789.1f);
+  const float page_scale_factor = 1337.5f;
+  const gfx::SizeF scrollable_viewport_size(1337.7f, 1234.5f);
+  const gfx::SizeF root_layer_size(1234.5f, 5432.1f);
+  const float min_page_scale_factor = 3.5f;
+  const float max_page_scale_factor = 4.6f;
+  const bool root_overflow_x_hidden = true;
+  const bool root_overflow_y_hidden = true;
+  const gfx::Vector2dF location_bar_offset(1234.5f, 5432.1f);
+  const gfx::Vector2dF location_bar_content_translation(1234.5f, 5432.1f);
+  const uint32_t root_background_color = 1337;
+  Selection<gfx::SelectionBound> selection;
+  selection.start.SetEdge(gfx::PointF(1234.5f, 67891.f),
+                          gfx::PointF(5432.1f, 1987.6f));
+  selection.start.set_visible(true);
+  selection.start.set_type(gfx::SelectionBound::CENTER);
+  selection.end.SetEdge(gfx::PointF(1337.5f, 52124.f),
+                        gfx::PointF(1234.3f, 8765.6f));
+  selection.end.set_visible(false);
+  selection.end.set_type(gfx::SelectionBound::RIGHT);
+  selection.is_editable = true;
+  selection.is_empty_text_form_control = true;
+  ui::LatencyInfo latency_info;
+  latency_info.AddLatencyNumber(
+      ui::LATENCY_BEGIN_SCROLL_LISTENER_UPDATE_MAIN_COMPONENT, 1337, 7331);
+  std::vector<ui::LatencyInfo> latency_infos = {latency_info};
+  std::vector<uint32_t> satisfies_sequences = {1234, 1337};
+  std::vector<SurfaceId> referenced_surfaces;
+  SurfaceId id(1234, 5678, 9101112);
+  referenced_surfaces.push_back(id);
+
+  CompositorFrameMetadata input;
+  input.device_scale_factor = device_scale_factor;
+  input.root_scroll_offset = root_scroll_offset;
+  input.page_scale_factor = page_scale_factor;
+  input.scrollable_viewport_size = scrollable_viewport_size;
+  input.root_layer_size = root_layer_size;
+  input.min_page_scale_factor = min_page_scale_factor;
+  input.max_page_scale_factor = max_page_scale_factor;
+  input.root_overflow_x_hidden = root_overflow_x_hidden;
+  input.root_overflow_y_hidden = root_overflow_y_hidden;
+  input.location_bar_offset = location_bar_offset;
+  input.location_bar_content_translation = location_bar_content_translation;
+  input.root_background_color = root_background_color;
+  input.selection = selection;
+  input.latency_info = latency_infos;
+  input.satisfies_sequences = satisfies_sequences;
+  input.referenced_surfaces = referenced_surfaces;
+
+  mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
+  CompositorFrameMetadata output;
+  proxy->EchoCompositorFrameMetadata(input, &output);
+  EXPECT_EQ(device_scale_factor, output.device_scale_factor);
+  EXPECT_EQ(root_scroll_offset, output.root_scroll_offset);
+  EXPECT_EQ(page_scale_factor, output.page_scale_factor);
+  EXPECT_EQ(scrollable_viewport_size, output.scrollable_viewport_size);
+  EXPECT_EQ(root_layer_size, output.root_layer_size);
+  EXPECT_EQ(min_page_scale_factor, output.min_page_scale_factor);
+  EXPECT_EQ(max_page_scale_factor, output.max_page_scale_factor);
+  EXPECT_EQ(root_overflow_x_hidden, output.root_overflow_x_hidden);
+  EXPECT_EQ(root_overflow_y_hidden, output.root_overflow_y_hidden);
+  EXPECT_EQ(location_bar_offset, output.location_bar_offset);
+  EXPECT_EQ(location_bar_content_translation,
+            output.location_bar_content_translation);
+  EXPECT_EQ(root_background_color, output.root_background_color);
+  EXPECT_EQ(selection, output.selection);
+  EXPECT_EQ(latency_infos.size(), output.latency_info.size());
+  ui::LatencyInfo::LatencyComponent component;
+  EXPECT_TRUE(output.latency_info[0].FindLatency(
+      ui::LATENCY_BEGIN_SCROLL_LISTENER_UPDATE_MAIN_COMPONENT, 1337,
+      &component));
+  EXPECT_EQ(7331, component.sequence_number);
+  EXPECT_EQ(satisfies_sequences.size(), output.satisfies_sequences.size());
+  for (uint32_t i = 0; i < satisfies_sequences.size(); ++i)
+    EXPECT_EQ(satisfies_sequences[i], output.satisfies_sequences[i]);
+  EXPECT_EQ(referenced_surfaces.size(), output.referenced_surfaces.size());
+  for (uint32_t i = 0; i < referenced_surfaces.size(); ++i)
+    EXPECT_EQ(referenced_surfaces[i], output.referenced_surfaces[i]);
+}
+
 TEST_F(StructTraitsTest, RenderPassId) {
   const int layer_id = 1337;
   const uint32_t index = 0xdeadbeef;

cc/ipc/traits_test_service.mojom

@@ -5,6 +5,7 @@
 module cc.mojom;
 
 import "cc/ipc/begin_frame_args.mojom";
+import "cc/ipc/compositor_frame_metadata.mojom";
 import "cc/ipc/render_pass_id.mojom";
 import "cc/ipc/returned_resource.mojom";
 import "cc/ipc/selection.mojom";
@@ -19,8 +20,11 @@ interface TraitsTestService {
   EchoBeginFrameArgs(BeginFrameArgs b) => (BeginFrameArgs pass);
 
   [Sync]
-  EchoRenderPassId(RenderPassId r) => (RenderPassId pass);
+  EchoCompositorFrameMetadata(CompositorFrameMetadata c) =>
+      (CompositorFrameMetadata pass);
 
+  [Sync]
+  EchoRenderPassId(RenderPassId r) => (RenderPassId pass);
 
   [Sync]
   EchoReturnedResource(ReturnedResource r) => (ReturnedResource pass);

cc/ipc/typemaps.gni

@@ -4,6 +4,7 @@
 
 typemaps = [
   "//cc/ipc/begin_frame_args.typemap",
+  "//cc/ipc/compositor_frame_metadata.typemap",
   "//cc/ipc/render_pass_id.typemap",
   "//cc/ipc/returned_resource.typemap",
   "//cc/ipc/selection.typemap",

components/bitmap_uploader/bitmap_uploader.cc

@@ -75,10 +75,7 @@ void BitmapUploader::Upload() {
   mus::mojom::CompositorFramePtr frame = mus::mojom::CompositorFrame::New();
 
   // TODO(rjkroege): Support device scale factor in PDF viewer
-  mus::mojom::CompositorFrameMetadataPtr meta =
-      mus::mojom::CompositorFrameMetadata::New();
-  meta->device_scale_factor = 1.0f;
-  frame->metadata = std::move(meta);
+  frame->metadata.device_scale_factor = 1.0f;
 
   frame->resources.resize(0u);
 

components/mus/public/cpp/surfaces/custom_surface_converter.h

@@ -9,6 +9,7 @@
 #include "components/mus/public/interfaces/quads.mojom.h"
 
 namespace cc {
+class CompositorFrameMetadata;
 class RenderPass;
 class SharedQuadState;
 }  // namespace cc
@@ -21,7 +22,7 @@ class CustomSurfaceConverter {
  public:
   virtual bool ConvertSurfaceDrawQuad(
       const mus::mojom::QuadPtr& input,
-      const mus::mojom::CompositorFrameMetadataPtr& metadata,
+      const cc::CompositorFrameMetadata& metadata,
       cc::SharedQuadState* sqs,
       cc::RenderPass* render_pass) = 0;
 

components/mus/public/cpp/surfaces/surfaces_type_converters.cc

@@ -30,8 +30,6 @@ using mus::mojom::Color;
 using mus::mojom::ColorPtr;
 using mus::mojom::CompositorFrame;
 using mus::mojom::CompositorFramePtr;
-using mus::mojom::CompositorFrameMetadata;
-using mus::mojom::CompositorFrameMetadataPtr;
 using mus::mojom::DebugBorderQuadState;
 using mus::mojom::DebugBorderQuadStatePtr;
 using mus::mojom::Pass;
@@ -79,7 +77,7 @@ static_assert(cc::YUVVideoDrawQuad::REC_601 ==
 namespace {
 
 bool ConvertDrawQuad(const QuadPtr& input,
-                     const CompositorFrameMetadataPtr& metadata,
+                     const cc::CompositorFrameMetadata& metadata,
                      cc::SharedQuadState* sqs,
                      cc::RenderPass* render_pass,
                      CustomSurfaceConverter* custom_converter) {
@@ -363,7 +361,7 @@ PassPtr TypeConverter<PassPtr, cc::RenderPass>::Convert(
 // static
 std::unique_ptr<cc::RenderPass> ConvertToRenderPass(
     const PassPtr& input,
-    const CompositorFrameMetadataPtr& metadata,
+    const cc::CompositorFrameMetadata& metadata,
     CustomSurfaceConverter* custom_converter) {
   std::unique_ptr<cc::RenderPass> pass = cc::RenderPass::Create(
       input->shared_quad_states.size(), input->quads.size());
@@ -392,29 +390,11 @@ std::unique_ptr<cc::RenderPass> ConvertToRenderPass(
 std::unique_ptr<cc::RenderPass>
 TypeConverter<std::unique_ptr<cc::RenderPass>, PassPtr>::Convert(
     const PassPtr& input) {
-  mus::mojom::CompositorFrameMetadataPtr metadata;
+  cc::CompositorFrameMetadata metadata;
   return ConvertToRenderPass(input, metadata,
                              nullptr /* CustomSurfaceConverter */);
 }
 
-// static
-CompositorFrameMetadataPtr
-TypeConverter<CompositorFrameMetadataPtr, cc::CompositorFrameMetadata>::Convert(
-    const cc::CompositorFrameMetadata& input) {
-  CompositorFrameMetadataPtr metadata = CompositorFrameMetadata::New();
-  metadata->device_scale_factor = input.device_scale_factor;
-  return metadata;
-}
-
-// static
-cc::CompositorFrameMetadata
-TypeConverter<cc::CompositorFrameMetadata, CompositorFrameMetadataPtr>::Convert(
-    const CompositorFrameMetadataPtr& input) {
-  cc::CompositorFrameMetadata metadata;
-  metadata.device_scale_factor = input->device_scale_factor;
-  return metadata;
-}
-
 // static
 CompositorFramePtr
 TypeConverter<CompositorFramePtr, cc::CompositorFrame>::Convert(
@@ -424,7 +404,7 @@ TypeConverter<CompositorFramePtr, cc::CompositorFrame>::Convert(
   cc::DelegatedFrameData* frame_data = input.delegated_frame_data.get();
   frame->resources =
       mojo::Array<cc::TransferableResource>(frame_data->resource_list);
-  frame->metadata = CompositorFrameMetadata::From(input.metadata);
+  frame->metadata = input.metadata;
   const cc::RenderPassList& pass_list = frame_data->render_pass_list;
   frame->passes = Array<PassPtr>::New(pass_list.size());
   for (size_t i = 0; i < pass_list.size(); ++i) {
@@ -450,8 +430,7 @@ std::unique_ptr<cc::CompositorFrame> ConvertToCompositorFrame(
     frame_data->render_pass_list.push_back(std::move(pass));
   }
   std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
-  cc::CompositorFrameMetadata metadata =
-      input->metadata.To<cc::CompositorFrameMetadata>();
+  cc::CompositorFrameMetadata metadata = input->metadata;
   frame->delegated_frame_data = std::move(frame_data);
   return frame;
 }

components/mus/public/cpp/surfaces/surfaces_type_converters.h

@@ -49,7 +49,7 @@ struct MOJO_SURFACES_EXPORT TypeConverter<mus::mojom::QuadPtr, cc::DrawQuad> {
 
 std::unique_ptr<cc::RenderPass> ConvertToRenderPass(
     const mus::mojom::PassPtr& input,
-    const mus::mojom::CompositorFrameMetadataPtr& metadata,
+    const cc::CompositorFrameMetadata& metadata,
     CustomSurfaceConverter* custom_converter);
 
 template <>
@@ -65,21 +65,6 @@ struct MOJO_SURFACES_EXPORT
 };
 
 // Types from compositor_frame.mojom
-template <>
-struct MOJO_SURFACES_EXPORT
-    TypeConverter<mus::mojom::CompositorFrameMetadataPtr,
-                  cc::CompositorFrameMetadata> {
-  static mus::mojom::CompositorFrameMetadataPtr Convert(
-      const cc::CompositorFrameMetadata& input);
-};
-template <>
-struct MOJO_SURFACES_EXPORT
-    TypeConverter<cc::CompositorFrameMetadata,
-                  mus::mojom::CompositorFrameMetadataPtr> {
-  static cc::CompositorFrameMetadata Convert(
-      const mus::mojom::CompositorFrameMetadataPtr& input);
-};
-
 MOJO_SURFACES_EXPORT std::unique_ptr<cc::CompositorFrame>
 ConvertToCompositorFrame(const mus::mojom::CompositorFramePtr& input,
                          CustomSurfaceConverter* custom_converter);

components/mus/public/cpp/surfaces/tests/surface_unittest.cc

@@ -25,8 +25,6 @@ using mus::mojom::Color;
 using mus::mojom::ColorPtr;
 using mus::mojom::CompositorFrame;
 using mus::mojom::CompositorFramePtr;
-using mus::mojom::CompositorFrameMetadata;
-using mus::mojom::CompositorFrameMetadataPtr;
 using mus::mojom::DebugBorderQuadState;
 using mus::mojom::DebugBorderQuadStatePtr;
 using mus::mojom::Pass;

components/mus/public/interfaces/compositor_frame.mojom

@@ -4,6 +4,7 @@
 
 module mus.mojom;
 
+import "cc/ipc/compositor_frame_metadata.mojom";
 import "cc/ipc/returned_resource.mojom";
 import "cc/ipc/transferable_resource.mojom";
 import "components/mus/public/interfaces/quads.mojom";
@@ -11,14 +12,9 @@ import "ui/gfx/geometry/mojo/geometry.mojom";
 import "gpu/ipc/common/mailbox_holder.mojom";
 import "gpu/ipc/common/sync_token.mojom";
 
-// See cc/output/compositor_frame_metadata.h.
-struct CompositorFrameMetadata {
-  float device_scale_factor;
-};
-
 // See src/cc/output/compositor_frame.h.
 struct CompositorFrame {
-  CompositorFrameMetadata metadata;
+  cc.mojom.CompositorFrameMetadata metadata;
   array<cc.mojom.TransferableResource> resources;
   array<Pass> passes;
 };

components/mus/ws/server_window_surface.cc

@@ -103,7 +103,7 @@ ServerWindowSurface::ConvertCompositorFrame(
 
 bool ServerWindowSurface::ConvertSurfaceDrawQuad(
     const mojom::QuadPtr& input,
-    const mojom::CompositorFrameMetadataPtr& metadata,
+    const cc::CompositorFrameMetadata& metadata,
     cc::SharedQuadState* sqs,
     cc::RenderPass* render_pass) {
   // Surface ids originate from the client, meaning they are ClientWindowIds

components/mus/ws/server_window_surface.h

@@ -74,7 +74,7 @@ class ServerWindowSurface : public mojom::Surface,
 
   // Overriden from CustomSurfaceConverter:
   bool ConvertSurfaceDrawQuad(const mojom::QuadPtr& input,
-                              const mojom::CompositorFrameMetadataPtr& metadata,
+                              const cc::CompositorFrameMetadata& metadata,
                               cc::SharedQuadState* sqs,
                               cc::RenderPass* render_pass) override;