Add detection for rotation and flip overlay transforms

cc/output/overlay_unittest.cc

Index: cc/output/overlay_unittest.cc
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index 545b5f54eb368d6bd809ed5480ba1252880df188..7d91e998119a0676ce4dce7d8f1e7eb390e13327 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -31,6 +31,7 @@ namespace cc {
 namespace {
 
 const gfx::Rect kOverlayRect(0, 0, 128, 128);
+const gfx::RectF kExpectedDisplayRect(0, 0, 128, 128);
 const gfx::Rect kOverlayTopLeftRect(0, 0, 64, 64);
 const gfx::Rect kOverlayBottomRightRect(64, 64, 64, 64);
 const gfx::PointF kUVTopLeft(0.1f, 0.2f);
@@ -61,10 +62,14 @@ void SingleOverlayValidator::CheckOverlaySupport(
   ASSERT_EQ(2U, surfaces->size());
 
   OverlayCandidate& candidate = surfaces->back();
-  if (candidate.display_rect.width() == 64)
+  if (candidate.display_rect.width() == 64) {
     EXPECT_EQ(kOverlayBottomRightRect, candidate.display_rect);
-  else
-    EXPECT_EQ(kOverlayRect, candidate.display_rect);
+  } else {
+    EXPECT_NEAR(kOverlayRect.x(), candidate.display_rect.x(), 0.01f);
+    EXPECT_NEAR(kOverlayRect.y(), candidate.display_rect.y(), 0.01f);
+    EXPECT_NEAR(kOverlayRect.width(), candidate.display_rect.width(), 0.01f);
+    EXPECT_NEAR(kOverlayRect.height(), candidate.display_rect.height(), 0.01f);
+  }
   EXPECT_EQ(BoundingRect(kUVTopLeft, kUVBottomRight).ToString(),
             candidate.uv_rect.ToString());
   candidate.overlay_handled = true;
@@ -540,7 +545,7 @@ TEST_F(SingleOverlayOnTopTest, RejectOpacity) {
   EXPECT_EQ(0U, candidate_list.size());
 }
 
-TEST_F(SingleOverlayOnTopTest, RejectNonScaleTransform) {
+TEST_F(SingleOverlayOnTopTest, RejectNonAxisAlignedTransform) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   CreateFullscreenCandidateQuad(resource_provider_.get(),
                                 pass->shared_quad_state_list.back(),
@@ -556,11 +561,13 @@ TEST_F(SingleOverlayOnTopTest, RejectNonScaleTransform) {
   EXPECT_EQ(0U, candidate_list.size());
 }
 
-TEST_F(SingleOverlayOnTopTest, RejectNegativeScaleTransform) {
+TEST_F(SingleOverlayOnTopTest, AllowVerticalFlip) {
+  gfx::Rect rect = kOverlayRect;
+  rect.set_width(rect.width() / 2);

[danakj, 2015/05/12 23:32:15]

why the width/2 ?

[halliwell, 2015/05/13 00:49:50]

Following the same pattern as existing tests (you can see the same thing in
AllowPositiveScaleTransform). 
The way these tests are set up, it always asserts (in the validator's
CheckOverlaySupport) that the final rect is equal to kOverlayRect.  So if the
test has x-axis scale of 2, as this one does, it has to halve the input quad
width.

[danakj, 2015/05/13 16:29:25]

Ah, missed the scale2 down there.

+  rect.Offset(0, -rect.height());
   scoped_ptr<RenderPass> pass = CreateRenderPass();
-  CreateFullscreenCandidateQuad(resource_provider_.get(),
-                                pass->shared_quad_state_list.back(),
-                                pass.get());
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(), rect);
   pass->shared_quad_state_list.back()->content_to_target_transform.Scale(2.0f,
                                                                          -1.0f);
 
@@ -569,7 +576,29 @@ TEST_F(SingleOverlayOnTopTest, RejectNegativeScaleTransform) {
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
-  EXPECT_EQ(0U, candidate_list.size());
+  ASSERT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL,
+            candidate_list.back().transform);
+}
+
+TEST_F(SingleOverlayOnTopTest, AllowHorizontalFlip) {
+  gfx::Rect rect = kOverlayRect;
+  rect.set_height(rect.height() / 2);

[danakj, 2015/05/12 23:32:15]

why height/2 ?

[halliwell, 2015/05/13 00:49:50]

Same reason as previous test.  In this case, y scale is 2.

+  rect.Offset(-rect.width(), 0);
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(), rect);
+  pass->shared_quad_state_list.back()->content_to_target_transform.Scale(-1.0f,
+                                                                         2.0f);
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  ASSERT_EQ(1U, pass_list.size());
+  ASSERT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL,
+            candidate_list.back().transform);
 }
 
 TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) {
@@ -589,6 +618,60 @@ TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) {
   EXPECT_EQ(2U, candidate_list.size());
 }
 
+TEST_F(SingleOverlayOnTopTest, Allow90DegreeRotation) {
+  gfx::Rect rect = kOverlayRect;
+  rect.Offset(0, -rect.height());
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(), rect);
+  pass->shared_quad_state_list.back()
+      ->content_to_target_transform.RotateAboutZAxis(90.f);
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  ASSERT_EQ(1U, pass_list.size());
+  ASSERT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90, candidate_list.back().transform);
+}
+
+TEST_F(SingleOverlayOnTopTest, Allow180DegreeRotation) {
+  gfx::Rect rect = kOverlayRect;
+  rect.Offset(-rect.width(), -rect.height());
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(), rect);
+  pass->shared_quad_state_list.back()
+      ->content_to_target_transform.RotateAboutZAxis(180.f);
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  ASSERT_EQ(1U, pass_list.size());
+  ASSERT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_180, candidate_list.back().transform);
+}
+
+TEST_F(SingleOverlayOnTopTest, Allow270DegreeRotation) {
+  gfx::Rect rect = kOverlayRect;
+  rect.Offset(-rect.width(), 0);
+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateCandidateQuadAt(resource_provider_.get(),
+                        pass->shared_quad_state_list.back(), pass.get(), rect);
+  pass->shared_quad_state_list.back()
+      ->content_to_target_transform.RotateAboutZAxis(270.f);
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+  OverlayCandidateList candidate_list;
+  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  ASSERT_EQ(1U, pass_list.size());
+  ASSERT_EQ(2U, candidate_list.size());
+  EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270, candidate_list.back().transform);
+}
+
 TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   CreateCheckeredQuadAt(resource_provider_.get(),