Change mojo geometry structs from using type converters to StructTraits.

mojo/converters/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 "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "gpu/command_buffer/common/sync_token.h"
-#include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
 #include "mojo/converters/transform/transform_type_converters.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 mus::mojom::Color;
 using mus::mojom::ColorPtr;
 using mus::mojom::CompositorFrame;
 using mus::mojom::CompositorFramePtr;
@@ skipping 81 matching lines @@
                      rect,
                      opaque_rect,
                      visible_rect,
                      needs_blending,
                      arbitrary_color,
                      force_anti_aliasing_off);
 
   QuadPtr mus_quad = Quad::From<cc::DrawQuad>(*color_quad);
   ASSERT_FALSE(mus_quad.is_null());
   EXPECT_EQ(mus::mojom::Material::SOLID_COLOR, mus_quad->material);
-  EXPECT_TRUE(Rect::From(rect).Equals(mus_quad->rect));
-  EXPECT_TRUE(Rect::From(opaque_rect).Equals(mus_quad->opaque_rect));
-  EXPECT_TRUE(Rect::From(visible_rect).Equals(mus_quad->visible_rect));
+  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(force_anti_aliasing_off, mus_color_state->force_anti_aliasing_off);
 }
 
 TEST_F(SurfaceLibQuadTest, SurfaceQuad) {
   cc::SurfaceDrawQuad* surface_quad =
       pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
@@ skipping 27 matching lines @@
                        vertex_opacity, y_flipped, nearest_neighbor,
                        secure_output_only);
 
   QuadPtr mus_quad = Quad::From<cc::DrawQuad>(*texture_quad);
   ASSERT_FALSE(mus_quad.is_null());
   EXPECT_EQ(mus::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_TRUE(PointF::From(uv_top_left).Equals(mus_texture_state->uv_top_left));
-  EXPECT_TRUE(
-      PointF::From(uv_bottom_right).Equals(mus_texture_state->uv_bottom_right));
+  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));
   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) {
@@ skipping 48 matching lines @@
   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_TRUE(Transform::From(quad_to_target_transform)
                   .Equals(mus_sqs->quad_to_target_transform));
-  EXPECT_TRUE(Size::From(quad_layer_bounds).Equals(mus_sqs->quad_layer_bounds));
-  EXPECT_TRUE(Rect::From(visible_quad_layer_rect)
-                  .Equals(mus_sqs->visible_quad_layer_rect));
-  EXPECT_TRUE(Rect::From(clip_rect).Equals(mus_sqs->clip_rect));
+  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);
   gfx::Rect output_rect(4, 9, 13, 71);
   gfx::Rect damage_rect(9, 17, 41, 45);
@@ skipping 56 matching lines @@
   bool secure_output_only = false;
   texture_quad->SetAll(sqs, rect, opaque_rect, visible_rect, needs_blending,
                        resource_id, gfx::Size(), premultiplied_alpha,
                        uv_top_left, uv_bottom_right, background_color,
                        vertex_opacity, y_flipped, nearest_neighbor,
                        secure_output_only);
 
   PassPtr mus_pass = Pass::From(*pass);
   ASSERT_FALSE(mus_pass.is_null());
   EXPECT_EQ(6u, mus_pass->id->index);
-  EXPECT_TRUE(Rect::From(output_rect).Equals(mus_pass->output_rect));
-  EXPECT_TRUE(Rect::From(damage_rect).Equals(mus_pass->damage_rect));
+  EXPECT_EQ(output_rect, mus_pass->output_rect);
+  EXPECT_EQ(damage_rect, mus_pass->damage_rect);
   EXPECT_TRUE(Transform::From(transform_to_root_target)
                   .Equals(mus_pass->transform_to_root_target));
   EXPECT_EQ(has_transparent_background, mus_pass->has_transparent_background);
   ASSERT_EQ(1u, mus_pass->shared_quad_states.size());
   ASSERT_EQ(3u, mus_pass->quads.size());
   EXPECT_EQ(0u, mus_pass->quads[0]->shared_quad_state_index);
 
   std::unique_ptr<cc::RenderPass> round_trip_pass =
       mus_pass.To<std::unique_ptr<cc::RenderPass>>();
   EXPECT_EQ(pass_id, round_trip_pass->id);
@@ skipping 68 matching lines @@
   resource.format = format;
   resource.filter = filter;
   resource.size = size;
   resource.mailbox_holder = mailbox_holder;
   resource.is_software = is_software;
 
   TransferableResourcePtr mus_resource = TransferableResource::From(resource);
   EXPECT_EQ(id, mus_resource->id);
   EXPECT_EQ(static_cast<ResourceFormat>(format), mus_resource->format);
   EXPECT_EQ(filter, mus_resource->filter);
-  EXPECT_TRUE(Size::From(size).Equals(mus_resource->size));
+  EXPECT_EQ(size, mus_resource->size);
   EXPECT_EQ(is_software, mus_resource->is_software);
 
   cc::TransferableResource round_trip_resource =
       mus_resource.To<cc::TransferableResource>();
   EXPECT_EQ(id, round_trip_resource.id);
   EXPECT_EQ(format, round_trip_resource.format);
   EXPECT_EQ(filter, round_trip_resource.filter);
   EXPECT_EQ(size, round_trip_resource.size);
   EXPECT_EQ(mailbox_holder.mailbox, round_trip_resource.mailbox_holder.mailbox);
   EXPECT_EQ(mailbox_holder.texture_target,
@@ skipping 39 matching lines @@
                             rect,
                             opaque_rect,
                             visible_rect,
                             needs_blending,
                             arbitrary_color,
                             width);
 
   QuadPtr mus_quad = Quad::From<cc::DrawQuad>(*debug_border_quad);
   ASSERT_FALSE(mus_quad.is_null());
   EXPECT_EQ(mus::mojom::Material::DEBUG_BORDER, mus_quad->material);
-  EXPECT_TRUE(Rect::From(rect).Equals(mus_quad->rect));
-  EXPECT_TRUE(Rect::From(opaque_rect).Equals(mus_quad->opaque_rect));
-  EXPECT_TRUE(Rect::From(visible_rect).Equals(mus_quad->visible_rect));
+  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(width, mus_debug_border_state->width);
 }
 
 }  // namespace
 }  // namespace mojo