Implement DrawQuad StructTraits

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

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/resource_provider.h"
 #include "components/mus/public/cpp/surfaces/surfaces_type_converters.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 
-using cc::mojom::Color;
-using cc::mojom::ColorPtr;
 using cc::mojom::DebugBorderQuadState;
 using cc::mojom::DebugBorderQuadStatePtr;
 using cc::mojom::DrawQuad;
 using cc::mojom::DrawQuadPtr;
 using cc::mojom::RenderPass;
 using cc::mojom::RenderPassPtr;
 using cc::mojom::RenderPassQuadState;
 using cc::mojom::RenderPassQuadStatePtr;
 using cc::mojom::SolidColorQuadState;
 using cc::mojom::SolidColorQuadStatePtr;
 using cc::mojom::SurfaceQuadState;
 using cc::mojom::SurfaceQuadStatePtr;
 using cc::mojom::TextureQuadState;
 using cc::mojom::TextureQuadStatePtr;
 using cc::mojom::TileQuadState;
 using cc::mojom::TileQuadStatePtr;
 using cc::mojom::YUVColorSpace;
 using cc::mojom::YUVVideoQuadState;
 using cc::mojom::YUVVideoQuadStatePtr;
 using mus::mojom::CompositorFrame;
 using mus::mojom::CompositorFramePtr;
 
 namespace mojo {
 namespace {
 
 
-TEST(SurfaceLibTest, Color) {
-  SkColor arbitrary_color = SK_ColorMAGENTA;
-  SkColor round_trip = Color::From(arbitrary_color).To<SkColor>();
-  EXPECT_EQ(arbitrary_color, round_trip);
-}
-
 class SurfaceLibQuadTest : public testing::Test {
  public:
   SurfaceLibQuadTest()
       : rect(5, 7, 13, 19),
         opaque_rect(rect),
         visible_rect(9, 11, 5, 7),
         needs_blending(false) {
     pass = cc::RenderPass::Create();
     sqs = pass->CreateAndAppendSharedQuadState();
   }
@@ skipping 22 matching lines @@
 
   DrawQuadPtr mus_quad = DrawQuad::From<cc::DrawQuad>(*color_quad);
   ASSERT_FALSE(mus_quad.is_null());
   EXPECT_EQ(cc::mojom::Material::SOLID_COLOR, mus_quad->material);
   EXPECT_EQ(rect, mus_quad->rect);
   EXPECT_EQ(opaque_rect, mus_quad->opaque_rect);
   EXPECT_EQ(visible_rect, mus_quad->visible_rect);
   EXPECT_EQ(needs_blending, mus_quad->needs_blending);
   ASSERT_TRUE(mus_quad->solid_color_quad_state);
   SolidColorQuadStatePtr& mus_color_state = mus_quad->solid_color_quad_state;
-  EXPECT_TRUE(Color::From(arbitrary_color).Equals(mus_color_state->color));
+  EXPECT_EQ(arbitrary_color, mus_color_state->color);
   EXPECT_EQ(force_anti_aliasing_off, mus_color_state->force_anti_aliasing_off);
 }
 
 TEST_F(SurfaceLibQuadTest, SurfaceQuad) {
   cc::SurfaceDrawQuad* surface_quad =
       pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
   cc::SurfaceId arbitrary_id(0, 5, 0);
   surface_quad->SetAll(
       sqs, rect, opaque_rect, visible_rect, needs_blending, arbitrary_id);
 
@@ skipping 25 matching lines @@
 
   DrawQuadPtr mus_quad = DrawQuad::From<cc::DrawQuad>(*texture_quad);
   ASSERT_FALSE(mus_quad.is_null());
   EXPECT_EQ(cc::mojom::Material::TEXTURE_CONTENT, mus_quad->material);
   ASSERT_TRUE(mus_quad->texture_quad_state);
   TextureQuadStatePtr& mus_texture_state = mus_quad->texture_quad_state;
   EXPECT_EQ(resource_id, mus_texture_state->resource_id);
   EXPECT_EQ(premultiplied_alpha, mus_texture_state->premultiplied_alpha);
   EXPECT_EQ(uv_top_left, mus_texture_state->uv_top_left);
   EXPECT_EQ(uv_bottom_right, mus_texture_state->uv_bottom_right);
-  EXPECT_TRUE(Color::From(background_color)
-                  .Equals(mus_texture_state->background_color));
+  EXPECT_EQ(background_color, mus_texture_state->background_color);
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(vertex_opacity[i], mus_texture_state->vertex_opacity[i]) << i;
   }
   EXPECT_EQ(y_flipped, mus_texture_state->y_flipped);
   EXPECT_EQ(secure_output_only, mus_texture_state->secure_output_only);
 }
 
 TEST_F(SurfaceLibQuadTest, TextureQuadEmptyVertexOpacity) {
   DrawQuadPtr mus_texture_quad = DrawQuad::New();
   mus_texture_quad->material = cc::mojom::Material::TEXTURE_CONTENT;
   TextureQuadStatePtr mus_texture_state = TextureQuadState::New();
-  mus_texture_state->background_color = Color::New();
   mus_texture_quad->texture_quad_state = std::move(mus_texture_state);
   RenderPassPtr mus_pass = RenderPass::New();
   mus_pass->id.layer_id = 1;
   mus_pass->id.index = 1u;
   mus_pass->quads.push_back(std::move(mus_texture_quad));
   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_F(SurfaceLibQuadTest, TextureQuadEmptyBackgroundColor) {
-  DrawQuadPtr mus_texture_quad = DrawQuad::New();
-  mus_texture_quad->material = cc::mojom::Material::TEXTURE_CONTENT;
-  TextureQuadStatePtr mus_texture_state = TextureQuadState::New();
-  mus_texture_state->vertex_opacity = mojo::Array<float>::New(4);
-  mus_texture_quad->texture_quad_state = std::move(mus_texture_state);
-  RenderPassPtr mus_pass = RenderPass::New();
-  mus_pass->id.layer_id = 1;
-  mus_pass->id.index = 1u;
-  mus_pass->quads.push_back(std::move(mus_texture_quad));
-  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, RenderPass) {
   std::unique_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
   cc::RenderPassId pass_id(1, 6);
   gfx::Rect output_rect(4, 9, 13, 71);
   gfx::Rect damage_rect(9, 17, 41, 45);
   gfx::Transform transform_to_root_target;
   transform_to_root_target.Skew(0.0, 43.0);
   bool has_transparent_background = false;
   pass->SetAll(pass_id,
                output_rect,
@@ skipping 144 matching lines @@
   DrawQuadPtr mus_quad = DrawQuad::From<cc::DrawQuad>(*debug_border_quad);
   ASSERT_FALSE(mus_quad.is_null());
   EXPECT_EQ(cc::mojom::Material::DEBUG_BORDER, mus_quad->material);
   EXPECT_EQ(rect, mus_quad->rect);
   EXPECT_EQ(opaque_rect, mus_quad->opaque_rect);
   EXPECT_EQ(visible_rect, mus_quad->visible_rect);
   EXPECT_EQ(needs_blending, mus_quad->needs_blending);
   ASSERT_TRUE(mus_quad->debug_border_quad_state);
   DebugBorderQuadStatePtr& mus_debug_border_state =
       mus_quad->debug_border_quad_state;
-  EXPECT_TRUE(
-      Color::From(arbitrary_color).Equals(mus_debug_border_state->color));
+  EXPECT_EQ(arbitrary_color, mus_debug_border_state->color);
   EXPECT_EQ(width, mus_debug_border_state->width);
 }
 
 }  // namespace
 }  // namespace mojo