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