Add detection for rotation and flip overlay transforms

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 "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 "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
@@ skipping 90 matching lines @@
 
 TEST_F(SurfaceLibQuadTest, TextureQuad) {
   cc::TextureDrawQuad* texture_quad =
       pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
   unsigned resource_id = 9;
   bool premultiplied_alpha = true;
   gfx::PointF uv_top_left(1.7f, 2.1f);
   gfx::PointF uv_bottom_right(-7.f, 16.3f);
   SkColor background_color = SK_ColorYELLOW;
   float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f};
-  bool flipped = false;
+  bool y_flipped = false;
   bool nearest_neighbor = false;
   texture_quad->SetAll(sqs,
                        rect,
                        opaque_rect,
                        visible_rect,
                        needs_blending,
                        resource_id,
                        premultiplied_alpha,
                        uv_top_left,
                        uv_bottom_right,
                        background_color,
                        vertex_opacity,
-                       flipped,
+                       y_flipped,
                        nearest_neighbor);
 
   QuadPtr mojo_quad = Quad::From<cc::DrawQuad>(*texture_quad);
   ASSERT_FALSE(mojo_quad.is_null());
   EXPECT_EQ(MATERIAL_TEXTURE_CONTENT, mojo_quad->material);
   ASSERT_TRUE(mojo_quad->texture_quad_state);
   TextureQuadStatePtr& mojo_texture_state = mojo_quad->texture_quad_state;
   EXPECT_EQ(resource_id, mojo_texture_state->resource_id);
   EXPECT_EQ(premultiplied_alpha, mojo_texture_state->premultiplied_alpha);
   EXPECT_EQ(PointF::From(uv_top_left), mojo_texture_state->uv_top_left);
   EXPECT_EQ(PointF::From(uv_bottom_right), mojo_texture_state->uv_bottom_right);
   EXPECT_EQ(Color::From(background_color),
             mojo_texture_state->background_color);
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(vertex_opacity[i], mojo_texture_state->vertex_opacity[i]) << i;
   }
-  EXPECT_EQ(flipped, mojo_texture_state->flipped);
+  EXPECT_EQ(y_flipped, mojo_texture_state->y_flipped);
 }
 
 TEST_F(SurfaceLibQuadTest, TextureQuadEmptyVertexOpacity) {
   QuadPtr mojo_texture_quad = Quad::New();
   mojo_texture_quad->material = MATERIAL_TEXTURE_CONTENT;
   TextureQuadStatePtr mojo_texture_state = TextureQuadState::New();
   mojo_texture_state->background_color = Color::New();
   mojo_texture_quad->texture_quad_state = mojo_texture_state.Pass();
   PassPtr mojo_pass = Pass::New();
   mojo_pass->id = RenderPassId::New();
@@ skipping 116 matching lines @@
       sqs, rect, opaque_rect, visible_rect, needs_blending, arbitrary_id);
 
   cc::TextureDrawQuad* texture_quad =
       pass->CreateAndAppendDrawQuad<cc::TextureDrawQuad>();
   unsigned resource_id = 9;
   bool premultiplied_alpha = true;
   gfx::PointF uv_top_left(1.7f, 2.1f);
   gfx::PointF uv_bottom_right(-7.f, 16.3f);
   SkColor background_color = SK_ColorYELLOW;
   float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f};
-  bool flipped = false;
+  bool y_flipped = false;
   bool nearest_neighbor = false;
   texture_quad->SetAll(sqs,
                        rect,
                        opaque_rect,
                        visible_rect,
                        needs_blending,
                        resource_id,
                        premultiplied_alpha,
                        uv_top_left,
                        uv_bottom_right,
                        background_color,
                        vertex_opacity,
-                       flipped,
+                       y_flipped,
                        nearest_neighbor);
 
   PassPtr mojo_pass = Pass::From(*pass);
   ASSERT_FALSE(mojo_pass.is_null());
   EXPECT_EQ(6, mojo_pass->id->index);
   EXPECT_EQ(Rect::From(output_rect), mojo_pass->output_rect);
   EXPECT_EQ(Rect::From(damage_rect), mojo_pass->damage_rect);
   EXPECT_EQ(Transform::From(transform_to_root_target),
             mojo_pass->transform_to_root_target);
   EXPECT_EQ(has_transparent_background, mojo_pass->has_transparent_background);
@@ skipping 53 matching lines @@
       cc::TextureDrawQuad::MaterialCast(round_trip_quad);
   EXPECT_EQ(resource_id, round_trip_texture_quad->resource_id);
   EXPECT_EQ(premultiplied_alpha, round_trip_texture_quad->premultiplied_alpha);
   EXPECT_EQ(uv_top_left, round_trip_texture_quad->uv_top_left);
   EXPECT_EQ(uv_bottom_right, round_trip_texture_quad->uv_bottom_right);
   EXPECT_EQ(background_color, round_trip_texture_quad->background_color);
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(vertex_opacity[i], round_trip_texture_quad->vertex_opacity[i])
         << i;
   }
-  EXPECT_EQ(flipped, round_trip_texture_quad->flipped);
+  EXPECT_EQ(y_flipped, round_trip_texture_quad->y_flipped);
 }
 
 TEST(SurfaceLibTest, Mailbox) {
   gpu::Mailbox mailbox;
   mailbox.Generate();
 
   MailboxPtr mojo_mailbox = Mailbox::From(mailbox);
   EXPECT_EQ(0, memcmp(mailbox.name, &mojo_mailbox->name.storage()[0], 64));
 
   gpu::Mailbox round_trip_mailbox = mojo_mailbox.To<gpu::Mailbox>();
@@ skipping 86 matching lines @@
   cc::ReturnedResource round_trip_resource =
       mojo_resource.To<cc::ReturnedResource>();
   EXPECT_EQ(id, round_trip_resource.id);
   EXPECT_EQ(sync_point, round_trip_resource.sync_point);
   EXPECT_EQ(count, round_trip_resource.count);
   EXPECT_EQ(lost, round_trip_resource.lost);
 }
 
 }  // namespace
 }  // namespace mojo