Implement cc::SharedQuadState StructTraits

BUG=611802
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

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

cc/ipc/BUILD.gn

@@ -40,6 +40,7 @@ mojom("interfaces") {
     "begin_frame_args.mojom",
     "render_pass_id.mojom",
     "returned_resource.mojom",
+    "shared_quad_state.mojom",
     "surface_id.mojom",
     "transferable_resource.mojom",
   ]
@@ -48,6 +49,7 @@ mojom("interfaces") {
     "//gpu/ipc/common:interfaces",
     "//mojo/common:common_custom_types",
     "//ui/gfx/geometry/mojo",
+    "//ui/gfx/mojo",
   ]
 }
 

cc/ipc/shared_quad_state.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 "ui/gfx/geometry/mojo/geometry.mojom";
+import "ui/gfx/mojo/transform.mojom";
+
+struct SharedQuadState {
+  // gfx.mojom.Transforms quad rects into the target content space.
+  gfx.mojom.Transform quad_to_target_transform;
+
+  // The size of the quads' originating layer in the space of the quad rects.
+  gfx.mojom.Size quad_layer_bounds;
+
+  // The size of the visible area in the quads' originating layer, in the space
+  // of the quad rects.
+  gfx.mojom.Rect visible_quad_layer_rect;
+
+  // This rect lives in the target content space.
+  gfx.mojom.Rect clip_rect;
+
+  bool is_clipped;
+  float opacity;
+  // TODO(fsamuel): Change this to an SkXfermode enum once native enums are
+  // supported.
+  uint32 blend_mode;
+  int32 sorting_context_id;
+};
+

cc/ipc/shared_quad_state.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/shared_quad_state.mojom"
+public_headers = [ "//cc/quads/shared_quad_state.h" ]
+traits_headers = [ "//cc/ipc/shared_quad_state_struct_traits.h" ]
+deps = [ "//cc", ]
+public_deps = [ "//cc", ]
+type_mappings = [ "cc.mojom.SharedQuadState=cc::SharedQuadState" ]

cc/ipc/shared_quad_state_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_SHARED_QUAD_STATE_STRUCT_TRAITS_H_
+#define CC_IPC_SHARED_QUAD_STATE_STRUCT_TRAITS_H_
+
+#include "cc/ipc/shared_quad_state.mojom.h"
+#include "cc/quads/shared_quad_state.h"
+
+namespace mojo {
+
+template <>
+struct StructTraits<cc::mojom::SharedQuadState, cc::SharedQuadState> {
+  static gfx::Transform quad_to_target_transform(
+      const cc::SharedQuadState& sqs) {
+    return sqs.quad_to_target_transform;
+  }
+
+  static gfx::Size quad_layer_bounds(const cc::SharedQuadState& sqs) {
+    return sqs.quad_layer_bounds;
+  }
+
+  static gfx::Rect visible_quad_layer_rect(const cc::SharedQuadState& sqs) {
+    return sqs.visible_quad_layer_rect;
+  }
+
+  static gfx::Rect clip_rect(const cc::SharedQuadState& sqs) {
+    return sqs.clip_rect;
+  }
+
+  static bool is_clipped(const cc::SharedQuadState& sqs) {
+    return sqs.is_clipped;
+  }
+
+  static float opacity(const cc::SharedQuadState& sqs) { return sqs.opacity; }
+
+  static uint32_t blend_mode(const cc::SharedQuadState& sqs) {
+    return sqs.blend_mode;
+  }
+
+  static int32_t sorting_context_id(const cc::SharedQuadState& sqs) {
+    return sqs.sorting_context_id;
+  }
+
+  static bool Read(cc::mojom::SharedQuadStateDataView data,
+                   cc::SharedQuadState* out) {
+    if (!data.ReadQuadToTargetTransform(&out->quad_to_target_transform) ||
+        !data.ReadQuadLayerBounds(&out->quad_layer_bounds) ||
+        !data.ReadVisibleQuadLayerRect(&out->visible_quad_layer_rect) ||
+        !data.ReadClipRect(&out->clip_rect)) {
+      return false;
+    }
+
+    out->is_clipped = data.is_clipped();
+    out->opacity = data.opacity();
+    if (data.blend_mode() > SkXfermode::kLastMode)
+      return false;
+    out->blend_mode = static_cast<SkXfermode::Mode>(data.blend_mode());
+    out->sorting_context_id = data.sorting_context_id();
+    return true;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // CC_IPC_SHARED_QUAD_STATE_STRUCT_TRAITS_H_

cc/ipc/struct_traits_unittest.cc

@@ -39,6 +39,12 @@ class StructTraitsTest : public testing::Test, public mojom::TraitsTestService {
     callback.Run(r);
   }
 
+  void EchoSharedQuadState(
+      const SharedQuadState& s,
+      const EchoSharedQuadStateCallback& callback) override {
+    callback.Run(s);
+  }
+
   void EchoSurfaceId(const SurfaceId& s,
                      const EchoSurfaceIdCallback& callback) override {
     callback.Run(s);
@@ -128,6 +134,34 @@ TEST_F(StructTraitsTest, SurfaceId) {
   EXPECT_EQ(nonce, output.nonce());
 }
 
+TEST_F(StructTraitsTest, SharedQuadState) {
+  const gfx::Transform quad_to_target_transform(1.f, 2.f, 3.f, 4.f, 5.f, 6.f,
+                                                7.f, 8.f, 9.f, 10.f, 11.f, 12.f,
+                                                13.f, 14.f, 15.f, 16.f);
+  const gfx::Size layer_bounds(1234, 5678);
+  const gfx::Rect visible_layer_rect(12, 34, 56, 78);
+  const gfx::Rect clip_rect(123, 456, 789, 101112);
+  const bool is_clipped = true;
+  const float opacity = 0.9f;
+  const SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
+  const int sorting_context_id = 1337;
+  SharedQuadState input_sqs;
+  input_sqs.SetAll(quad_to_target_transform, layer_bounds, visible_layer_rect,
+                   clip_rect, is_clipped, opacity, blend_mode,
+                   sorting_context_id);
+  mojom::TraitsTestServicePtr proxy = GetTraitsTestProxy();
+  SharedQuadState output_sqs;
+  proxy->EchoSharedQuadState(input_sqs, &output_sqs);
+  EXPECT_EQ(quad_to_target_transform, output_sqs.quad_to_target_transform);
+  EXPECT_EQ(layer_bounds, output_sqs.quad_layer_bounds);
+  EXPECT_EQ(visible_layer_rect, output_sqs.visible_quad_layer_rect);
+  EXPECT_EQ(clip_rect, output_sqs.clip_rect);
+  EXPECT_EQ(is_clipped, output_sqs.is_clipped);
+  EXPECT_EQ(opacity, output_sqs.opacity);
+  EXPECT_EQ(blend_mode, output_sqs.blend_mode);
+  EXPECT_EQ(sorting_context_id, output_sqs.sorting_context_id);
+}
+
 TEST_F(StructTraitsTest, TransferableResource) {
   const uint32_t id = 1337;
   const ResourceFormat format = ALPHA_8;

cc/ipc/traits_test_service.mojom

@@ -7,6 +7,7 @@ module cc.mojom;
 import "cc/ipc/begin_frame_args.mojom";
 import "cc/ipc/render_pass_id.mojom";
 import "cc/ipc/returned_resource.mojom";
+import "cc/ipc/shared_quad_state.mojom";
 import "cc/ipc/surface_id.mojom";
 import "cc/ipc/transferable_resource.mojom";
 
@@ -19,9 +20,13 @@ interface TraitsTestService {
   [Sync]
   EchoRenderPassId(RenderPassId r) => (RenderPassId pass);
 
+
   [Sync]
   EchoReturnedResource(ReturnedResource r) => (ReturnedResource pass);
 
+  [Sync]
+  EchoSharedQuadState(SharedQuadState s) => (SharedQuadState pass);
+
   [Sync]
   EchoSurfaceId(SurfaceId s) => (SurfaceId pass);
 

cc/ipc/typemaps.gni

@@ -6,6 +6,7 @@ typemaps = [
   "//cc/ipc/begin_frame_args.typemap",
   "//cc/ipc/render_pass_id.typemap",
   "//cc/ipc/returned_resource.typemap",
+  "//cc/ipc/shared_quad_state.typemap",
   "//cc/ipc/surface_id.typemap",
   "//cc/ipc/transferable_resource.typemap",
 ]

components/bitmap_uploader/bitmap_uploader.cc

@@ -93,8 +93,7 @@ void BitmapUploader::Upload() {
   frame->resources.resize(0u);
 
   pass->quads.resize(0u);
-  pass->shared_quad_states.push_back(
-      mojo::CreateDefaultSQS(bounds.size()));
+  pass->shared_quad_states.push_back(mojo::CreateDefaultSQS(bounds.size()));
 
   if (bitmap_.get()) {
     gpu::gles2::GLES2Interface* gl = gles2_context_->interface();

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

@@ -40,8 +40,6 @@ using mus::mojom::Quad;
 using mus::mojom::QuadPtr;
 using mus::mojom::RenderPassQuadState;
 using mus::mojom::RenderPassQuadStatePtr;
-using mus::mojom::SharedQuadState;
-using mus::mojom::SharedQuadStatePtr;
 using mus::mojom::SolidColorQuadState;
 using mus::mojom::SolidColorQuadStatePtr;
 using mus::mojom::SurfaceQuadState;
@@ -80,18 +78,6 @@ static_assert(cc::YUVVideoDrawQuad::REC_601 ==
 
 namespace {
 
-cc::SharedQuadState* ConvertSharedQuadState(
-    const mus::mojom::SharedQuadStatePtr& input,
-    cc::RenderPass* render_pass) {
-  cc::SharedQuadState* state = render_pass->CreateAndAppendSharedQuadState();
-  state->SetAll(input->quad_to_target_transform, input->quad_layer_bounds,
-                input->visible_quad_layer_rect, input->clip_rect,
-                input->is_clipped, input->opacity,
-                static_cast<::SkXfermode::Mode>(input->blend_mode),
-                input->sorting_context_id);
-  return state;
-}
-
 bool ConvertDrawQuad(const QuadPtr& input,
                      const CompositorFrameMetadataPtr& metadata,
                      cc::SharedQuadState* sqs,
@@ -339,22 +325,6 @@ QuadPtr TypeConverter<QuadPtr, cc::DrawQuad>::Convert(
   return quad;
 }
 
-// static
-mus::mojom::SharedQuadStatePtr
-TypeConverter<mus::mojom::SharedQuadStatePtr, cc::SharedQuadState>::Convert(
-    const cc::SharedQuadState& input) {
-  mus::mojom::SharedQuadStatePtr state = SharedQuadState::New();
-  state->quad_to_target_transform = input.quad_to_target_transform;
-  state->quad_layer_bounds = input.quad_layer_bounds;
-  state->visible_quad_layer_rect = input.visible_quad_layer_rect;
-  state->clip_rect = input.clip_rect;
-  state->is_clipped = input.is_clipped;
-  state->opacity = input.opacity;
-  state->blend_mode = static_cast<mus::mojom::SkXfermode>(input.blend_mode);
-  state->sorting_context_id = input.sorting_context_id;
-  return state;
-}
-
 // static
 PassPtr TypeConverter<PassPtr, cc::RenderPass>::Convert(
     const cc::RenderPass& input) {
@@ -365,7 +335,7 @@ PassPtr TypeConverter<PassPtr, cc::RenderPass>::Convert(
   pass->transform_to_root_target = input.transform_to_root_target;
   pass->has_transparent_background = input.has_transparent_background;
   Array<QuadPtr> quads(input.quad_list.size());
-  Array<mus::mojom::SharedQuadStatePtr> shared_quad_state(
+  Array<cc::SharedQuadState> shared_quad_state(
       input.shared_quad_state_list.size());
   const cc::SharedQuadState* last_sqs = nullptr;
   cc::SharedQuadStateList::ConstIterator next_sqs_iter =
@@ -375,8 +345,7 @@ PassPtr TypeConverter<PassPtr, cc::RenderPass>::Convert(
     const cc::DrawQuad& quad = **iter;
     quads[iter.index()] = Quad::From(quad);
     if (quad.shared_quad_state != last_sqs) {
-      shared_quad_state[next_sqs_iter.index()] =
-          SharedQuadState::From(**next_sqs_iter);
+      shared_quad_state[next_sqs_iter.index()] = **next_sqs_iter;
       last_sqs = *next_sqs_iter;
       ++next_sqs_iter;
     }
@@ -402,7 +371,8 @@ std::unique_ptr<cc::RenderPass> ConvertToRenderPass(
                input->transform_to_root_target,
                input->has_transparent_background);
   for (size_t i = 0; i < input->shared_quad_states.size(); ++i) {
-    ConvertSharedQuadState(input->shared_quad_states[i], pass.get());
+    cc::SharedQuadState* state = pass->CreateAndAppendSharedQuadState();
+    *state = input->shared_quad_states[i];
   }
   cc::SharedQuadStateList::Iterator sqs_iter =
       pass->shared_quad_state_list.begin();

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

@@ -47,13 +47,6 @@ struct MOJO_SURFACES_EXPORT TypeConverter<mus::mojom::QuadPtr, cc::DrawQuad> {
   static mus::mojom::QuadPtr Convert(const cc::DrawQuad& input);
 };
 
-template <>
-struct MOJO_SURFACES_EXPORT
-    TypeConverter<mus::mojom::SharedQuadStatePtr, cc::SharedQuadState> {
-  static mus::mojom::SharedQuadStatePtr Convert(
-      const cc::SharedQuadState& input);
-};
-
 std::unique_ptr<cc::RenderPass> ConvertToRenderPass(
     const mus::mojom::PassPtr& input,
     const mus::mojom::CompositorFrameMetadataPtr& metadata,

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

@@ -10,20 +10,18 @@
 
 using mus::mojom::Pass;
 using mus::mojom::PassPtr;
-using mus::mojom::SharedQuadState;
-using mus::mojom::SharedQuadStatePtr;
 
 namespace mojo {
 
-SharedQuadStatePtr CreateDefaultSQS(const gfx::Size& size) {
-  SharedQuadStatePtr sqs = SharedQuadState::New();
-  sqs->quad_layer_bounds = size;
-  sqs->visible_quad_layer_rect = gfx::Rect(size);
-  sqs->clip_rect = gfx::Rect(size);
-  sqs->is_clipped = false;
-  sqs->opacity = 1.f;
-  sqs->blend_mode = mus::mojom::SkXfermode::kSrc_Mode;
-  sqs->sorting_context_id = 0;
+cc::SharedQuadState CreateDefaultSQS(const gfx::Size& size) {
+  cc::SharedQuadState sqs;
+  sqs.quad_layer_bounds = size;
+  sqs.visible_quad_layer_rect = gfx::Rect(size);
+  sqs.clip_rect = gfx::Rect(size);
+  sqs.is_clipped = false;
+  sqs.opacity = 1.f;
+  sqs.blend_mode = SkXfermode::kSrc_Mode;
+  sqs.sorting_context_id = 0;
   return sqs;
 }
 

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

@@ -8,6 +8,10 @@
 #include "components/mus/public/cpp/surfaces/mojo_surfaces_export.h"
 #include "components/mus/public/interfaces/quads.mojom.h"
 
+namespace cc {
+class SharedQuadState;
+}
+
 namespace gfx {
 class Rect;
 class Size;
@@ -15,7 +19,7 @@ class Size;
 
 namespace mojo {
 
-MOJO_SURFACES_EXPORT mus::mojom::SharedQuadStatePtr CreateDefaultSQS(
+MOJO_SURFACES_EXPORT cc::SharedQuadState CreateDefaultSQS(
     const gfx::Size& size);
 
 // Constructs a pass with the given id, output_rect and damage_rect set to rect,

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

@@ -35,8 +35,6 @@ using mus::mojom::Quad;
 using mus::mojom::QuadPtr;
 using mus::mojom::RenderPassQuadState;
 using mus::mojom::RenderPassQuadStatePtr;
-using mus::mojom::SharedQuadState;
-using mus::mojom::SharedQuadStatePtr;
 using mus::mojom::SolidColorQuadState;
 using mus::mojom::SolidColorQuadStatePtr;
 using mus::mojom::SurfaceQuadState;
@@ -166,8 +164,7 @@ TEST_F(SurfaceLibQuadTest, TextureQuadEmptyVertexOpacity) {
   mus_pass->id.layer_id = 1;
   mus_pass->id.index = 1u;
   mus_pass->quads.push_back(std::move(mus_texture_quad));
-  SharedQuadStatePtr mus_sqs = SharedQuadState::New();
-  mus_pass->shared_quad_states.push_back(std::move(mus_sqs));
+  mus_pass->shared_quad_states.push_back(cc::SharedQuadState());
 
   std::unique_ptr<cc::RenderPass> pass =
       mus_pass.To<std::unique_ptr<cc::RenderPass>>();
@@ -185,41 +182,13 @@ TEST_F(SurfaceLibQuadTest, TextureQuadEmptyBackgroundColor) {
   mus_pass->id.layer_id = 1;
   mus_pass->id.index = 1u;
   mus_pass->quads.push_back(std::move(mus_texture_quad));
-  SharedQuadStatePtr mus_sqs = SharedQuadState::New();
-  mus_pass->shared_quad_states.push_back(std::move(mus_sqs));
+  mus_pass->shared_quad_states.push_back(cc::SharedQuadState());
 
   std::unique_ptr<cc::RenderPass> pass =
       mus_pass.To<std::unique_ptr<cc::RenderPass>>();
   EXPECT_FALSE(pass);
 }
 
-TEST(SurfaceLibTest, SharedQuadState) {
-  gfx::Transform quad_to_target_transform;
-  quad_to_target_transform.Scale3d(0.3f, 0.7f, 0.9f);
-  gfx::Size quad_layer_bounds(57, 39);
-  gfx::Rect visible_quad_layer_rect(3, 7, 28, 42);
-  gfx::Rect clip_rect(9, 12, 21, 31);
-  bool is_clipped = true;
-  float opacity = 0.65f;
-  int sorting_context_id = 13;
-  ::SkXfermode::Mode blend_mode = ::SkXfermode::kSrcOver_Mode;
-  std::unique_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
-  cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
-  sqs->SetAll(quad_to_target_transform, quad_layer_bounds,
-              visible_quad_layer_rect, clip_rect, is_clipped, opacity,
-              blend_mode, sorting_context_id);
-
-  SharedQuadStatePtr mus_sqs = SharedQuadState::From(*sqs);
-  ASSERT_FALSE(mus_sqs.is_null());
-  EXPECT_EQ(quad_to_target_transform, mus_sqs->quad_to_target_transform);
-  EXPECT_EQ(quad_layer_bounds, mus_sqs->quad_layer_bounds);
-  EXPECT_EQ(visible_quad_layer_rect, mus_sqs->visible_quad_layer_rect);
-  EXPECT_EQ(clip_rect, mus_sqs->clip_rect);
-  EXPECT_EQ(is_clipped, mus_sqs->is_clipped);
-  EXPECT_EQ(opacity, mus_sqs->opacity);
-  EXPECT_EQ(sorting_context_id, mus_sqs->sorting_context_id);
-}
-
 TEST(SurfaceLibTest, RenderPass) {
   std::unique_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
   cc::RenderPassId pass_id(1, 6);

components/mus/public/interfaces/quads.mojom

@@ -5,6 +5,7 @@
 module mus.mojom;
 
 import "cc/ipc/render_pass_id.mojom";
+import "cc/ipc/shared_quad_state.mojom";
 import "cc/ipc/surface_id.mojom";
 import "ui/gfx/geometry/mojo/geometry.mojom";
 import "ui/gfx/mojo/transform.mojom";
@@ -156,66 +157,6 @@ struct Quad {
   YUVVideoQuadState? yuv_video_quad_state;
 };
 
-enum SkXfermode {
-  kClear_Mode = 0,    //!< [0, 0]
-  kSrc_Mode,      //!< [Sa, Sc]
-  kDst_Mode,      //!< [Da, Dc]
-  kSrcOver_Mode,  //!< [Sa + Da - Sa*Da, Rc = Sc + (1 - Sa)*Dc]
-  kDstOver_Mode,  //!< [Sa + Da - Sa*Da, Rc = Dc + (1 - Da)*Sc]
-  kSrcIn_Mode,    //!< [Sa * Da, Sc * Da]
-  kDstIn_Mode,    //!< [Sa * Da, Sa * Dc]
-  kSrcOut_Mode,   //!< [Sa * (1 - Da), Sc * (1 - Da)]
-  kDstOut_Mode,   //!< [Da * (1 - Sa), Dc * (1 - Sa)]
-  kSrcATop_Mode,  //!< [Da, Sc * Da + (1 - Sa) * Dc]
-  kDstATop_Mode,  //!< [Sa, Sa * Dc + Sc * (1 - Da)]
-  kXor_Mode,      //!< [Sa + Da - 2 * Sa * Da, Sc * (1 - Da) + (1 - Sa) * Dc]
-  kPlus_Mode,     //!< [Sa + Da, Sc + Dc]
-  kModulate_Mode, // multiplies all components (= alpha and color)
-
-  // Following blend modes are defined in the CSS Compositing standard:
-  // https://dvcs.w3.org/hg/FXTF/rawfile/tip/compositing/index.html#blending
-  kScreen_Mode,
-  kLastCoeffMode = kScreen_Mode,
-
-  kOverlay_Mode,
-  kDarken_Mode,
-  kLighten_Mode,
-  kColorDodge_Mode,
-  kColorBurn_Mode,
-  kHardLight_Mode,
-  kSoftLight_Mode,
-  kDifference_Mode,
-  kExclusion_Mode,
-  kMultiply_Mode,
-  kLastSeparableMode = kMultiply_Mode,
-
-  kHue_Mode,
-  kSaturation_Mode,
-  kColor_Mode,
-  kLuminosity_Mode,
-  kLastMode = kLuminosity_Mode
-};
-
-struct SharedQuadState {
-  // mojo.Transforms quad rects into the target content space.
-  gfx.mojom.Transform quad_to_target_transform;
-
-  // The size of the quads' originating layer in the space of the quad rects.
-  gfx.mojom.Size quad_layer_bounds;
-
-  // The size of the visible area in the quads' originating layer, in the space
-  // of the quad rects.
-  gfx.mojom.Rect visible_quad_layer_rect;
-
-  // This rect lives in the target content space.
-  gfx.mojom.Rect clip_rect;
-
-  bool is_clipped;
-  float opacity;
-  SkXfermode blend_mode;
-  int32 sorting_context_id;
-};
-
 struct Pass {
   cc.mojom.RenderPassId id;
   gfx.mojom.Rect output_rect;
@@ -223,5 +164,5 @@ struct Pass {
   gfx.mojom.Transform transform_to_root_target;
   bool has_transparent_background;
   array<Quad> quads;
-  array<SharedQuadState> shared_quad_states;
+  array<cc.mojom.SharedQuadState> shared_quad_states;
 };