From 59be4dbc6242ed7c8d5c29aec529f9fc7c7e9da9 Mon Sep 17 00:00:00 2001 From: "danakj@chromium.org" Date: Wed, 23 Apr 2014 15:48:48 +0000 Subject: [PATCH] Remove QuadSink::MaybeAppend and the QuadCuller unit tests. The QuadCuller unit tests are now testing the TiledLayerImpl instead of the QuadCuller, and have been superceded by the FooLayerImpl.Occlusion tests for each LayerImpl subclass. R=enne@chromium.org BUG=344962 Review URL: https://codereview.chromium.org/248223002 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@265653 0039d316-1c4b-4281-b951-d872f2087c98 --- cc/cc_tests.gyp | 1 - cc/layers/quad_sink.h | 4 - .../surface_aggregator_test_helpers.cc | 2 +- cc/test/mock_quad_culler.cc | 8 - cc/test/mock_quad_culler.h | 1 - cc/test/render_pass_test_utils.cc | 10 +- cc/trees/layer_tree_host_impl.cc | 12 +- cc/trees/layer_tree_host_impl_unittest.cc | 4 +- cc/trees/quad_culler.cc | 47 +- cc/trees/quad_culler.h | 5 +- cc/trees/quad_culler_unittest.cc | 785 ------------------ 11 files changed, 15 insertions(+), 864 deletions(-) delete mode 100644 cc/trees/quad_culler_unittest.cc diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp index dbd5ffd58b3c7f..83233cc24172ce 100644 --- a/cc/cc_tests.gyp +++ b/cc/cc_tests.gyp @@ -108,7 +108,6 @@ 'trees/layer_tree_host_unittest_scroll.cc', 'trees/layer_tree_host_unittest_video.cc', 'trees/occlusion_tracker_unittest.cc', - 'trees/quad_culler_unittest.cc', 'trees/tree_synchronizer_unittest.cc', ], 'cc_surfaces_unit_tests_source_files': [ diff --git a/cc/layers/quad_sink.h b/cc/layers/quad_sink.h index add4e996af5d51..7312781a7e309e 100644 --- a/cc/layers/quad_sink.h +++ b/cc/layers/quad_sink.h @@ -37,10 +37,6 @@ class CC_EXPORT QuadSink { const gfx::Rect& content_rect, const gfx::Transform& draw_transform) = 0; - // Returns true if the quad is added to the list, and false if the quad is - // entirely culled. - virtual bool MaybeAppend(scoped_ptr draw_quad) = 0; - virtual void Append(scoped_ptr draw_quad) = 0; }; diff --git a/cc/surfaces/surface_aggregator_test_helpers.cc b/cc/surfaces/surface_aggregator_test_helpers.cc index cc14ddede06f28..2ac32898f210e0 100644 --- a/cc/surfaces/surface_aggregator_test_helpers.cc +++ b/cc/surfaces/surface_aggregator_test_helpers.cc @@ -76,7 +76,7 @@ void AddTestRenderPassQuad(TestRenderPass* pass, gfx::RectF(), FilterOperations(), FilterOperations()); - quad_sink.MaybeAppend(quad.PassAs()); + quad_sink.Append(quad.PassAs()); } void AddQuadInPass(TestRenderPass* pass, Quad desc) { diff --git a/cc/test/mock_quad_culler.cc b/cc/test/mock_quad_culler.cc index 781647d9381bbe..773430fa6a6e24 100644 --- a/cc/test/mock_quad_culler.cc +++ b/cc/test/mock_quad_culler.cc @@ -60,14 +60,6 @@ gfx::Rect MockQuadCuller::UnoccludedContributingSurfaceContentRect( return result; } -bool MockQuadCuller::MaybeAppend(scoped_ptr draw_quad) { - if (!draw_quad->rect.IsEmpty()) { - active_quad_list_->push_back(draw_quad.Pass()); - return true; - } - return false; -} - void MockQuadCuller::Append(scoped_ptr draw_quad) { DCHECK(!draw_quad->rect.IsEmpty()); DCHECK(!draw_quad->visible_rect.IsEmpty()); diff --git a/cc/test/mock_quad_culler.h b/cc/test/mock_quad_culler.h index 541f66b388321c..6e3436a86a5bbf 100644 --- a/cc/test/mock_quad_culler.h +++ b/cc/test/mock_quad_culler.h @@ -29,7 +29,6 @@ class MockQuadCuller : public QuadSink { virtual gfx::Rect UnoccludedContributingSurfaceContentRect( const gfx::Rect& content_rect, const gfx::Transform& draw_transform) OVERRIDE; - virtual bool MaybeAppend(scoped_ptr draw_quad) OVERRIDE; virtual void Append(scoped_ptr draw_quad) OVERRIDE; const QuadList& quad_list() const { return *active_quad_list_; } diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc index 679ce1928b3cf2..8d0d955e35a2e7 100644 --- a/cc/test/render_pass_test_utils.cc +++ b/cc/test/render_pass_test_utils.cc @@ -44,7 +44,7 @@ SolidColorDrawQuad* AddQuad(TestRenderPass* pass, scoped_ptr quad = SolidColorDrawQuad::Create(); quad->SetNew(shared_state, rect, rect, color, false); SolidColorDrawQuad* quad_ptr = quad.get(); - quad_sink.MaybeAppend(quad.PassAs()); + quad_sink.Append(quad.PassAs()); return quad_ptr; } @@ -64,7 +64,7 @@ SolidColorDrawQuad* AddClippedQuad(TestRenderPass* pass, scoped_ptr quad = SolidColorDrawQuad::Create(); quad->SetNew(shared_state, rect, rect, color, false); SolidColorDrawQuad* quad_ptr = quad.get(); - quad_sink.MaybeAppend(quad.PassAs()); + quad_sink.Append(quad.PassAs()); return quad_ptr; } @@ -80,7 +80,7 @@ SolidColorDrawQuad* AddTransformedQuad(TestRenderPass* pass, scoped_ptr quad = SolidColorDrawQuad::Create(); quad->SetNew(shared_state, rect, rect, color, false); SolidColorDrawQuad* quad_ptr = quad.get(); - quad_sink.MaybeAppend(quad.PassAs()); + quad_sink.Append(quad.PassAs()); return quad_ptr; } @@ -109,7 +109,7 @@ void AddRenderPassQuad(TestRenderPass* to_pass, gfx::RectF(), FilterOperations(), FilterOperations()); - quad_sink.MaybeAppend(quad.PassAs()); + quad_sink.Append(quad.PassAs()); } void AddRenderPassQuad(TestRenderPass* to_pass, @@ -140,7 +140,7 @@ void AddRenderPassQuad(TestRenderPass* to_pass, gfx::RectF(), filters, FilterOperations()); - quad_sink.MaybeAppend(quad.PassAs()); + quad_sink.Append(quad.PassAs()); } } // namespace cc diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc index f11911aa91d64b..80dd6c0004495a 100644 --- a/cc/trees/layer_tree_host_impl.cc +++ b/cc/trees/layer_tree_host_impl.cc @@ -569,12 +569,10 @@ static void AppendQuadsForLayer( LayerImpl* layer, const OcclusionTracker& occlusion_tracker, AppendQuadsData* append_quads_data) { - bool for_surface = false; QuadCuller quad_culler(&target_render_pass->quad_list, &target_render_pass->shared_quad_state_list, layer, - occlusion_tracker, - for_surface); + occlusion_tracker); layer->AppendQuads(&quad_culler, append_quads_data); } @@ -584,12 +582,10 @@ static void AppendQuadsForRenderSurfaceLayer( const RenderPass* contributing_render_pass, const OcclusionTracker& occlusion_tracker, AppendQuadsData* append_quads_data) { - bool for_surface = true; QuadCuller quad_culler(&target_render_pass->quad_list, &target_render_pass->shared_quad_state_list, layer, - occlusion_tracker, - for_surface); + occlusion_tracker); bool is_replica = false; layer->render_surface()->AppendQuads(&quad_culler, @@ -632,12 +628,10 @@ static void AppendQuadsToFillScreen( screen_background_color_region.Intersect(root_scroll_layer_rect); } - bool for_surface = false; QuadCuller quad_culler(&target_render_pass->quad_list, &target_render_pass->shared_quad_state_list, root_layer, - occlusion_tracker, - for_surface); + occlusion_tracker); // Manually create the quad state for the gutter quads, as the root layer // doesn't have any bounds and so can't generate this itself. diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc index 06b99a9a42dd99..dfea47b244d4c9 100644 --- a/cc/trees/layer_tree_host_impl_unittest.cc +++ b/cc/trees/layer_tree_host_impl_unittest.cc @@ -3305,7 +3305,7 @@ class BlendStateCheckLayer : public LayerImpl { test_blending_draw_quad->visible_rect = quad_visible_rect_; EXPECT_EQ(blend_, test_blending_draw_quad->ShouldDrawWithBlending()); EXPECT_EQ(has_render_surface_, !!render_surface()); - quad_sink->MaybeAppend(test_blending_draw_quad.PassAs()); + quad_sink->Append(test_blending_draw_quad.PassAs()); } void SetExpectation(bool blend, bool has_render_surface) { @@ -4081,7 +4081,7 @@ class FakeLayerWithQuads : public LayerImpl { scoped_ptr my_quad = SolidColorDrawQuad::Create(); my_quad->SetNew( shared_quad_state, quad_rect, visible_quad_rect, gray, false); - quad_sink->MaybeAppend(my_quad.PassAs()); + quad_sink->Append(my_quad.PassAs()); } private: diff --git a/cc/trees/quad_culler.cc b/cc/trees/quad_culler.cc index 68ef157f8127bb..d828675444d77b 100644 --- a/cc/trees/quad_culler.cc +++ b/cc/trees/quad_culler.cc @@ -19,14 +19,13 @@ namespace cc { QuadCuller::QuadCuller(QuadList* quad_list, SharedQuadStateList* shared_quad_state_list, const LayerImpl* layer, - const OcclusionTracker& occlusion_tracker, - bool for_surface) + const OcclusionTracker& occlusion_tracker) : quad_list_(quad_list), shared_quad_state_list_(shared_quad_state_list), layer_(layer), occlusion_tracker_(occlusion_tracker), - current_shared_quad_state_(NULL), - for_surface_(for_surface) {} + current_shared_quad_state_(NULL) { +} SharedQuadState* QuadCuller::UseSharedQuadState( scoped_ptr shared_quad_state) { @@ -51,46 +50,6 @@ gfx::Rect QuadCuller::UnoccludedContributingSurfaceContentRect( layer_, content_rect, draw_transform); } -static inline bool AppendQuadInternal( - scoped_ptr draw_quad, - const gfx::Rect& culled_rect, - QuadList* quad_list, - const OcclusionTracker& occlusion_tracker, - const LayerImpl* layer) { - bool keep_quad = !culled_rect.IsEmpty(); - if (keep_quad) { - draw_quad->visible_rect = culled_rect; - quad_list->push_back(draw_quad.Pass()); - } - return keep_quad; -} - -bool QuadCuller::MaybeAppend(scoped_ptr draw_quad) { - DCHECK(draw_quad->shared_quad_state == current_shared_quad_state_); - DCHECK(!shared_quad_state_list_->empty()); - DCHECK(shared_quad_state_list_->back() == current_shared_quad_state_); - - gfx::Rect culled_rect; - if (for_surface_) { - RenderSurfaceImpl* surface = layer_->render_surface(); - const RenderPassDrawQuad* rpdq = - RenderPassDrawQuad::MaterialCast(draw_quad.get()); - gfx::Transform draw_transform = rpdq->is_replica - ? surface->replica_draw_transform() - : surface->draw_transform(); - culled_rect = occlusion_tracker_.UnoccludedContributingSurfaceContentRect( - layer_, draw_quad->visible_rect, draw_transform); - } else { - culled_rect = - occlusion_tracker_.UnoccludedContentRect(layer_->render_target(), - draw_quad->visible_rect, - draw_quad->quadTransform()); - } - - return AppendQuadInternal( - draw_quad.Pass(), culled_rect, quad_list_, occlusion_tracker_, layer_); -} - void QuadCuller::Append(scoped_ptr draw_quad) { DCHECK(draw_quad->shared_quad_state == current_shared_quad_state_); DCHECK(!shared_quad_state_list_->empty()); diff --git a/cc/trees/quad_culler.h b/cc/trees/quad_culler.h index de2aa3ea116f2c..6377b13d812800 100644 --- a/cc/trees/quad_culler.h +++ b/cc/trees/quad_culler.h @@ -20,8 +20,7 @@ class CC_EXPORT QuadCuller : public QuadSink { QuadCuller(QuadList* quad_list, SharedQuadStateList* shared_quad_state_list, const LayerImpl* layer, - const OcclusionTracker& occlusion_tracker, - bool for_surface); + const OcclusionTracker& occlusion_tracker); virtual ~QuadCuller() {} // QuadSink implementation. @@ -33,7 +32,6 @@ class CC_EXPORT QuadCuller : public QuadSink { virtual gfx::Rect UnoccludedContributingSurfaceContentRect( const gfx::Rect& content_rect, const gfx::Transform& draw_transform) OVERRIDE; - virtual bool MaybeAppend(scoped_ptr draw_quad) OVERRIDE; virtual void Append(scoped_ptr draw_quad) OVERRIDE; private: @@ -43,7 +41,6 @@ class CC_EXPORT QuadCuller : public QuadSink { const OcclusionTracker& occlusion_tracker_; SharedQuadState* current_shared_quad_state_; - bool for_surface_; DISALLOW_COPY_AND_ASSIGN(QuadCuller); }; diff --git a/cc/trees/quad_culler_unittest.cc b/cc/trees/quad_culler_unittest.cc deleted file mode 100644 index ed1b69e723c405..00000000000000 --- a/cc/trees/quad_culler_unittest.cc +++ /dev/null @@ -1,785 +0,0 @@ -// Copyright 2012 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/trees/quad_culler.h" - -#include - -#include "cc/base/math_util.h" -#include "cc/layers/append_quads_data.h" -#include "cc/layers/render_surface_impl.h" -#include "cc/layers/tiled_layer_impl.h" -#include "cc/quads/render_pass_draw_quad.h" -#include "cc/quads/solid_color_draw_quad.h" -#include "cc/quads/tile_draw_quad.h" -#include "cc/resources/layer_tiling_data.h" -#include "cc/test/fake_impl_proxy.h" -#include "cc/test/fake_layer_tree_host_impl.h" -#include "cc/test/test_occlusion_tracker.h" -#include "cc/test/test_shared_bitmap_manager.h" -#include "cc/trees/occlusion_tracker.h" -#include "cc/trees/single_thread_proxy.h" -#include "testing/gmock/include/gmock/gmock.h" -#include "testing/gtest/include/gtest/gtest.h" -#include "ui/gfx/transform.h" - -namespace cc { -namespace { - -typedef LayerIterator LayerIteratorType; - -class QuadCullerTest : public testing::Test { - public: - QuadCullerTest() - : host_impl_(&proxy_, &shared_bitmap_manager_), layer_id_(1) {} - - scoped_ptr MakeLayer(TiledLayerImpl* parent, - const gfx::Transform& draw_transform, - const gfx::Rect& layer_rect, - float opacity, - bool opaque, - const gfx::Rect& layer_opaque_rect, - LayerImplList& surface_layer_list) { - scoped_ptr layer = - TiledLayerImpl::Create(host_impl_.active_tree(), layer_id_++); - scoped_ptr tiler = LayerTilingData::Create( - gfx::Size(100, 100), LayerTilingData::NO_BORDER_TEXELS); - tiler->SetTilingRect(layer_rect); - layer->SetTilingData(*tiler); - layer->set_skips_draw(false); - layer->SetDrawsContent(true); - layer->draw_properties().target_space_transform = draw_transform; - layer->draw_properties().screen_space_transform = draw_transform; - layer->draw_properties().visible_content_rect = layer_rect; - layer->draw_properties().opacity = opacity; - layer->SetContentsOpaque(opaque); - layer->SetBounds(layer_rect.size()); - layer->SetContentBounds(layer_rect.size()); - - ResourceProvider::ResourceId resource_id = 1; - for (int i = 0; i < tiler->num_tiles_x(); ++i) { - for (int j = 0; j < tiler->num_tiles_y(); ++j) { - gfx::Rect tile_opaque_rect = - opaque - ? tiler->tile_bounds(i, j) - : gfx::IntersectRects(tiler->tile_bounds(i, j), layer_opaque_rect); - layer->PushTileProperties(i, j, resource_id++, tile_opaque_rect, false); - } - } - - gfx::Rect rect_in_target = MathUtil::MapEnclosingClippedRect( - layer->draw_transform(), layer->visible_content_rect()); - if (!parent) { - layer->CreateRenderSurface(); - layer->render_surface()->SetContentRect(rect_in_target); - surface_layer_list.push_back(layer.get()); - layer->render_surface()->layer_list().push_back(layer.get()); - } else { - layer->draw_properties().render_target = parent->render_target(); - parent->render_surface()->layer_list().push_back(layer.get()); - rect_in_target.Union(MathUtil::MapEnclosingClippedRect( - parent->draw_transform(), parent->visible_content_rect())); - parent->render_surface()->SetContentRect(rect_in_target); - } - layer->draw_properties().drawable_content_rect = rect_in_target; - - return layer.Pass(); - } - - void AppendQuads(QuadList* quad_list, - SharedQuadStateList* shared_state_list, - TiledLayerImpl* layer, - LayerIteratorType* it, - OcclusionTracker* occlusion_tracker) { - occlusion_tracker->EnterLayer(*it); - QuadCuller quad_culler( - quad_list, shared_state_list, layer, *occlusion_tracker, false); - AppendQuadsData data; - layer->AppendQuads(&quad_culler, &data); - occlusion_tracker->LeaveLayer(*it); - ++it; - } - - protected: - FakeImplProxy proxy_; - TestSharedBitmapManager shared_bitmap_manager_; - FakeLayerTreeHostImpl host_impl_; - int layer_id_; - - private: - DISALLOW_COPY_AND_ASSIGN(QuadCullerTest); -}; - -#define DECLARE_AND_INITIALIZE_TEST_QUADS() \ - QuadList quad_list; \ - SharedQuadStateList shared_state_list; \ - LayerImplList render_surface_layer_list; \ - gfx::Transform child_transform; \ - gfx::Size root_size = gfx::Size(300, 300); \ - gfx::Rect root_rect = gfx::Rect(root_size); \ - gfx::Size child_size = gfx::Size(200, 200); \ - gfx::Rect child_rect = gfx::Rect(child_size); - -TEST_F(QuadCullerTest, NoCulling) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - scoped_ptr root_layer = MakeLayer(NULL, - gfx::Transform(), - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - gfx::Transform(), - child_rect, - 1.f, - false, - gfx::Rect(), - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - EXPECT_EQ(13u, quad_list.size()); -} - -TEST_F(QuadCullerTest, CullChildLinesUpTopLeft) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - scoped_ptr root_layer = MakeLayer(NULL, - gfx::Transform(), - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - gfx::Transform(), - child_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - EXPECT_EQ(9u, quad_list.size()); -} - -TEST_F(QuadCullerTest, CullWhenChildOpacityNotOne) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - scoped_ptr root_layer = MakeLayer(NULL, - gfx::Transform(), - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - child_transform, - child_rect, - 0.9f, - true, - gfx::Rect(), - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - EXPECT_EQ(13u, quad_list.size()); -} - -TEST_F(QuadCullerTest, CullWhenChildOpaqueFlagFalse) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - scoped_ptr root_layer = MakeLayer(NULL, - gfx::Transform(), - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - child_transform, - child_rect, - 1.f, - false, - gfx::Rect(), - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - EXPECT_EQ(13u, quad_list.size()); -} - -TEST_F(QuadCullerTest, CullCenterTileOnly) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - child_transform.Translate(50, 50); - scoped_ptr root_layer = MakeLayer(NULL, - gfx::Transform(), - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - child_transform, - child_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - ASSERT_EQ(quad_list.size(), 12u); - - gfx::Rect quad_visible_rect1 = quad_list[5]->visible_rect; - EXPECT_EQ(50, quad_visible_rect1.height()); - - gfx::Rect quad_visible_rect3 = quad_list[7]->visible_rect; - EXPECT_EQ(50, quad_visible_rect3.width()); - - // Next index is 8, not 9, since centre quad culled. - gfx::Rect quad_visible_rect4 = quad_list[8]->visible_rect; - EXPECT_EQ(50, quad_visible_rect4.width()); - EXPECT_EQ(250, quad_visible_rect4.x()); - - gfx::Rect quad_visible_rect6 = quad_list[10]->visible_rect; - EXPECT_EQ(50, quad_visible_rect6.height()); - EXPECT_EQ(250, quad_visible_rect6.y()); -} - -TEST_F(QuadCullerTest, CullCenterTileNonIntegralSize1) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - child_transform.Translate(100, 100); - - // Make the root layer's quad have extent (99.1, 99.1) -> (200.9, 200.9) to - // make sure it doesn't get culled due to transform rounding. - gfx::Transform root_transform; - root_transform.Translate(99.1f, 99.1f); - root_transform.Scale(1.018f, 1.018f); - - root_rect = child_rect = gfx::Rect(0, 0, 100, 100); - - scoped_ptr root_layer = MakeLayer(NULL, - root_transform, - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - child_transform, - child_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - EXPECT_EQ(2u, quad_list.size()); -} - -TEST_F(QuadCullerTest, CullCenterTileNonIntegralSize2) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - // Make the child's quad slightly smaller than, and centred over, the root - // layer tile. Verify the child does not cause the quad below to be culled - // due to rounding. - child_transform.Translate(100.1f, 100.1f); - child_transform.Scale(0.982f, 0.982f); - - gfx::Transform root_transform; - root_transform.Translate(100, 100); - - root_rect = child_rect = gfx::Rect(0, 0, 100, 100); - - scoped_ptr root_layer = MakeLayer(NULL, - root_transform, - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - child_transform, - child_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - EXPECT_EQ(2u, quad_list.size()); -} - -TEST_F(QuadCullerTest, CullChildLinesUpBottomRight) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - child_transform.Translate(100, 100); - scoped_ptr root_layer = MakeLayer(NULL, - gfx::Transform(), - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - child_transform, - child_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - EXPECT_EQ(9u, quad_list.size()); -} - -TEST_F(QuadCullerTest, CullSubRegion) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - child_transform.Translate(50, 50); - scoped_ptr root_layer = MakeLayer(NULL, - gfx::Transform(), - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - gfx::Rect child_opaque_rect(child_rect.x() + child_rect.width() / 4, - child_rect.y() + child_rect.height() / 4, - child_rect.width() / 2, - child_rect.height() / 2); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - child_transform, - child_rect, - 1.f, - false, - child_opaque_rect, - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - EXPECT_EQ(12u, quad_list.size()); -} - -TEST_F(QuadCullerTest, CullSubRegion2) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - child_transform.Translate(50, 10); - scoped_ptr root_layer = MakeLayer(NULL, - gfx::Transform(), - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - gfx::Rect child_opaque_rect(child_rect.x() + child_rect.width() / 4, - child_rect.y() + child_rect.height() / 4, - child_rect.width() / 2, - child_rect.height() * 3 / 4); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - child_transform, - child_rect, - 1.f, - false, - child_opaque_rect, - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - EXPECT_EQ(12u, quad_list.size()); -} - -TEST_F(QuadCullerTest, CullSubRegionCheckOvercull) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - child_transform.Translate(50, 49); - scoped_ptr root_layer = MakeLayer(NULL, - gfx::Transform(), - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - gfx::Rect child_opaque_rect(child_rect.x() + child_rect.width() / 4, - child_rect.y() + child_rect.height() / 4, - child_rect.width() / 2, - child_rect.height() / 2); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - child_transform, - child_rect, - 1.f, - false, - child_opaque_rect, - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - EXPECT_EQ(13u, quad_list.size()); -} - -TEST_F(QuadCullerTest, NonAxisAlignedQuadsDontOcclude) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - // Use a small rotation so as to not disturb the geometry significantly. - child_transform.Rotate(1); - - scoped_ptr root_layer = MakeLayer(NULL, - gfx::Transform(), - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - child_transform, - child_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - EXPECT_EQ(13u, quad_list.size()); -} - -// This test requires some explanation: here we are rotating the quads to be -// culled. The 2x2 tile child layer remains in the top-left corner, unrotated, -// but the 3x3 tile parent layer is rotated by 1 degree. Of the four tiles the -// child would normally occlude, three will move (slightly) out from under the -// child layer, and one moves further under the child. Only this last tile -// should be culled. -TEST_F(QuadCullerTest, NonAxisAlignedQuadsSafelyCulled) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - // Use a small rotation so as to not disturb the geometry significantly. - gfx::Transform parent_transform; - parent_transform.Rotate(1); - - scoped_ptr root_layer = MakeLayer(NULL, - parent_transform, - root_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - scoped_ptr child_layer = MakeLayer(root_layer.get(), - gfx::Transform(), - child_rect, - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - TestOcclusionTracker occlusion_tracker( - gfx::Rect(-100, -100, 1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - AppendQuads(&quad_list, - &shared_state_list, - child_layer.get(), - &it, - &occlusion_tracker); - AppendQuads(&quad_list, - &shared_state_list, - root_layer.get(), - &it, - &occlusion_tracker); - EXPECT_EQ(12u, quad_list.size()); -} - -TEST_F(QuadCullerTest, PartialCullingNotDestroyed) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - scoped_ptr dummy_layer = MakeLayer(NULL, - gfx::Transform(), - gfx::Rect(), - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - - TestOcclusionTracker occlusion_tracker(gfx::Rect(1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - QuadCuller culler(&quad_list, - &shared_state_list, - dummy_layer.get(), - occlusion_tracker, - false); - - SharedQuadState* sqs = culler.UseSharedQuadState(SharedQuadState::Create()); - - scoped_ptr color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew( - sqs, gfx::Rect(100, 100), gfx::Rect(100, 100), SK_ColorRED, false); - - scoped_ptr pass_quad = RenderPassDrawQuad::Create(); - pass_quad->SetNew(sqs, - gfx::Rect(100, 100), - gfx::Rect(100, 100), - RenderPass::Id(10, 10), - false, - 0, - gfx::Rect(), - gfx::RectF(), - FilterOperations(), - FilterOperations()); - - scoped_ptr replica_quad = RenderPassDrawQuad::Create(); - replica_quad->SetNew(sqs, - gfx::Rect(100, 100), - gfx::Rect(100, 100), - RenderPass::Id(10, 10), - true, - 0, - gfx::Rect(), - gfx::RectF(), - FilterOperations(), - FilterOperations()); - - // Set a visible rect on the quads. - color_quad->visible_rect = gfx::Rect(20, 30, 10, 11); - pass_quad->visible_rect = gfx::Rect(50, 60, 13, 14); - replica_quad->visible_rect = gfx::Rect(30, 40, 15, 16); - - // Nothing is occluding. - occlusion_tracker.EnterLayer(it); - - EXPECT_EQ(0u, quad_list.size()); - - culler.MaybeAppend(color_quad.PassAs()); - culler.MaybeAppend(pass_quad.PassAs()); - culler.MaybeAppend(replica_quad.PassAs()); - - ASSERT_EQ(3u, quad_list.size()); - - // The partial culling is preserved. - EXPECT_EQ(gfx::Rect(20, 30, 10, 11).ToString(), - quad_list[0]->visible_rect.ToString()); - EXPECT_EQ(gfx::Rect(50, 60, 13, 14).ToString(), - quad_list[1]->visible_rect.ToString()); - EXPECT_EQ(gfx::Rect(30, 40, 15, 16).ToString(), - quad_list[2]->visible_rect.ToString()); -} - -TEST_F(QuadCullerTest, PartialCullingWithOcclusionNotDestroyed) { - DECLARE_AND_INITIALIZE_TEST_QUADS(); - - scoped_ptr dummy_layer = MakeLayer(NULL, - gfx::Transform(), - gfx::Rect(), - 1.f, - true, - gfx::Rect(), - render_surface_layer_list); - - TestOcclusionTracker occlusion_tracker(gfx::Rect(1000, 1000)); - LayerIteratorType it = LayerIteratorType::Begin(&render_surface_layer_list); - - QuadCuller culler(&quad_list, - &shared_state_list, - dummy_layer.get(), - occlusion_tracker, - false); - - SharedQuadState* sqs = culler.UseSharedQuadState(SharedQuadState::Create()); - - scoped_ptr color_quad = SolidColorDrawQuad::Create(); - color_quad->SetNew( - sqs, gfx::Rect(100, 100), gfx::Rect(100, 100), SK_ColorRED, false); - - scoped_ptr pass_quad = RenderPassDrawQuad::Create(); - pass_quad->SetNew(sqs, - gfx::Rect(100, 100), - gfx::Rect(100, 100), - RenderPass::Id(10, 10), - false, - 0, - gfx::Rect(), - gfx::RectF(), - FilterOperations(), - FilterOperations()); - - scoped_ptr replica_quad = RenderPassDrawQuad::Create(); - replica_quad->SetNew(sqs, - gfx::Rect(100, 100), - gfx::Rect(100, 100), - RenderPass::Id(10, 10), - true, - 0, - gfx::Rect(), - gfx::RectF(), - FilterOperations(), - FilterOperations()); - - // Set a visible rect on the quads. - color_quad->visible_rect = gfx::Rect(10, 10, 10, 11); - pass_quad->visible_rect = gfx::Rect(10, 20, 13, 14); - replica_quad->visible_rect = gfx::Rect(10, 30, 15, 16); - - // Occlude the left part of the visible rects. - occlusion_tracker.EnterLayer(it); - occlusion_tracker.set_occlusion_from_outside_target(gfx::Rect(0, 0, 15, 100)); - - EXPECT_EQ(0u, quad_list.size()); - - culler.MaybeAppend(color_quad.PassAs()); - culler.MaybeAppend(pass_quad.PassAs()); - culler.MaybeAppend(replica_quad.PassAs()); - - ASSERT_EQ(3u, quad_list.size()); - - // The partial culling is preserved, while the left side of the quads is newly - // occluded. - EXPECT_EQ(gfx::Rect(15, 10, 5, 11).ToString(), - quad_list[0]->visible_rect.ToString()); - EXPECT_EQ(gfx::Rect(15, 20, 8, 14).ToString(), - quad_list[1]->visible_rect.ToString()); - EXPECT_EQ(gfx::Rect(15, 30, 10, 16).ToString(), - quad_list[2]->visible_rect.ToString()); -} - -} // namespace -} // namespace cc