[Ozone] Fix SingleOnTop issue by checking if the quad is clipped.

cc/output/overlay_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/base/scoped_ptr_vector.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/overlay_candidate_validator.h"
@@ skipping 18 matching lines @@
 using testing::_;
 using testing::Mock;
 
 namespace cc {
 namespace {
 
 const gfx::Size kDisplaySize(256, 256);
 const gfx::Rect kOverlayRect(0, 0, 128, 128);
 const gfx::Rect kOverlayTopLeftRect(0, 0, 64, 64);
 const gfx::Rect kOverlayBottomRightRect(64, 64, 64, 64);
+const gfx::Rect kOverlayClipRect(10, 20, 64, 64);
 const gfx::PointF kUVTopLeft(0.1f, 0.2f);
 const gfx::PointF kUVBottomRight(1.0f, 1.0f);
 const gfx::Transform kNormalTransform =
     gfx::Transform(0.9f, 0, 0, 0.8f, 0.1f, 0.2f);  // x,y -> x,y.
 const gfx::Transform kXMirrorTransform =
     gfx::Transform(-0.9f, 0, 0, 0.8f, 1.0f, 0.2f);  // x,y -> 1-x,y.
 const gfx::Transform kYMirrorTransform =
     gfx::Transform(0.9f, 0, 0, -0.8f, 0.1f, 1.0f);  // x,y -> x,1-y.
 const gfx::Transform kBothMirrorTransform =
     gfx::Transform(-0.9f, 0, 0, -0.8f, 1.0f, 1.0f);  // x,y -> 1-x,1-y.
@@ skipping 10 matching lines @@
   void GetStrategies(OverlayProcessor::StrategyList* strategies) override {
     strategies->push_back(scoped_ptr<OverlayProcessor::Strategy>(
         new OverlayStrategyCommon(this, new OverlayStrategySingleOnTop)));
     strategies->push_back(scoped_ptr<OverlayProcessor::Strategy>(
         new OverlayStrategyCommon(this, new OverlayStrategyUnderlay)));
   }
   void CheckOverlaySupport(OverlayCandidateList* surfaces) override {
     ASSERT_EQ(2U, surfaces->size());
 
     OverlayCandidate& candidate = surfaces->back();
+    if (candidate.is_clipped &&

[danakj, 2015/09/02 21:50:21]

How come this is added here?

[william.xie1, 2015/09/02 22:04:49]

Hi Dana,
 cc_unittest uses its own OverlayCandidateValidator defined here, that's why I
added the same logic as in DrmOverlayCandidatesHost.

[danakj, 2015/09/03 22:18:42]

How come all the other logic from there isn't replicated here?

+        !candidate.clip_rect.Contains(candidate.quad_rect_in_target_space))
+      return;
     if (candidate.display_rect.width() == 64) {
       EXPECT_EQ(kOverlayBottomRightRect, 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(),
@@ skipping 662 matching lines @@
       ->quad_to_target_transform.RotateAboutXAxis(45.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());
   EXPECT_EQ(0U, candidate_list.size());
 }
 
+TEST_F(SingleOverlayOnTopTest, RejectClipped) {

[danakj, 2015/09/02 21:50:21]

Is this testing OverlayStrategyCommon or is it just testing the
SingleOverlayValidator above?

[william.xie1, 2015/09/02 22:04:49]

It will test OverlayStrategyCommon because ProcessForOverlays will call into
OverlayStrategyCommon, but the final decision is made by
OverlayCandidateValidator.

[danakj, 2015/09/03 22:21:17]

OK I think I see.. there is no point in writing a test that is just checking
test-only logic though.

You could perhaps just use this test to verify that the candidates that come out
have appropriate clipping info in them? There's no need to test accept/reject if
that's just part of the test code.

+  scoped_ptr<RenderPass> pass = CreateRenderPass();
+  CreateFullscreenCandidateQuad(resource_provider_.get(),
+                                pass->shared_quad_state_list.back(),
+                                pass.get());
+  pass->shared_quad_state_list.back()->is_clipped = true;
+  pass->shared_quad_state_list.back()->clip_rect = kOverlayClipRect;

[danakj, 2015/09/02 21:50:21]

can you test the case where the clip rect exists but contains the overlay?

[william.xie1, 2015/09/02 22:04:49]

Done.

+
+  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());
+  EXPECT_EQ(0U, candidate_list.size());
+}
+
 TEST_F(SingleOverlayOnTopTest, AllowVerticalFlip) {
   gfx::Rect rect = kOverlayRect;
   rect.set_width(rect.width() / 2);
   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()->quad_to_target_transform.Scale(2.0f,
                                                                       -1.0f);
 
@@ skipping 721 matching lines @@
   renderer_->BeginDrawingFrame(&frame_no_overlays);
   renderer_->FinishDrawingFrame(&frame_no_overlays);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
   SwapBuffers();
   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1));
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
 
 }  // namespace
 }  // namespace cc