summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authordanakj@chromium.org <danakj@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>2013-07-18 21:37:23 +0000
committerdanakj@chromium.org <danakj@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>2013-07-18 21:37:23 +0000
commit989386c3e4c2e35fa4cf0d41febd1751e9afa3b3 (patch)
tree4869c1c6d2c4233ba654faf7b311c6698d6f1692
parent909f5c42b086a8388abbee04049e0f44091fef6d (diff)
downloadchromium_src-989386c3e4c2e35fa4cf0d41febd1751e9afa3b3.zip
chromium_src-989386c3e4c2e35fa4cf0d41febd1751e9afa3b3.tar.gz
chromium_src-989386c3e4c2e35fa4cf0d41febd1751e9afa3b3.tar.bz2
cc: Clean up the RenderSurface objects in the RenderSurfaceLayerList
When the RenderSurfaceLayerList is cleared, we need to also destroy the RenderSurface objects. Create a RenderSurfaceLayerList subclass of LayerList which does this cleanup in a safe/scoped way, and use that in the public API for LayerTreeHostCommon. R=earthdok, enne BUG=259902 Review URL: https://chromiumcodereview.appspot.com/19236002 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@212437 0039d316-1c4b-4281-b951-d872f2087c98
Diffstat
-rw-r--r--cc/cc.gyp1
-rw-r--r--cc/layers/contents_scaling_layer_unittest.cc2
-rw-r--r--cc/layers/layer_iterator.cc21
-rw-r--r--cc/layers/layer_iterator.h17
-rw-r--r--cc/layers/layer_iterator_unittest.cc66
-rw-r--r--cc/layers/layer_lists.cc60
-rw-r--r--cc/layers/layer_lists.h24
-rw-r--r--cc/layers/render_surface.cc11
-rw-r--r--cc/layers/render_surface.h5
-rw-r--r--cc/layers/scrollbar_layer_unittest.cc4
-rw-r--r--cc/layers/solid_color_layer_impl_unittest.cc2
-rw-r--r--cc/layers/tiled_layer_unittest.cc145
-rw-r--r--cc/trees/damage_tracker_unittest.cc5
-rw-r--r--cc/trees/layer_tree_host.cc21
-rw-r--r--cc/trees/layer_tree_host.h19
-rw-r--r--cc/trees/layer_tree_host_common.cc46
-rw-r--r--cc/trees/layer_tree_host_common.h2
-rw-r--r--cc/trees/layer_tree_host_common_unittest.cc1685
-rw-r--r--cc/trees/layer_tree_host_unittest_occlusion.cc3
-rw-r--r--cc/trees/occlusion_tracker_unittest.cc11
-rw-r--r--webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc68
21 files changed, 1237 insertions, 981 deletions
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 68b4562..4d52719 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -105,6 +105,7 @@
'layers/layer_impl.h',
'layers/layer_iterator.cc',
'layers/layer_iterator.h',
+ 'layers/layer_lists.cc',
'layers/layer_lists.h',
'layers/layer_position_constraint.cc',
'layers/layer_position_constraint.h',
diff --git a/cc/layers/contents_scaling_layer_unittest.cc b/cc/layers/contents_scaling_layer_unittest.cc
index 23f1376..08d3c32 100644
--- a/cc/layers/contents_scaling_layer_unittest.cc
+++ b/cc/layers/contents_scaling_layer_unittest.cc
@@ -37,7 +37,7 @@ class MockContentsScalingLayer : public ContentsScalingLayer {
};
void CalcDrawProps(Layer* root, float device_scale) {
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
LayerTreeHostCommon::CalculateDrawProperties(
root,
gfx::Size(500, 500),
diff --git a/cc/layers/layer_iterator.cc b/cc/layers/layer_iterator.cc
index 6fc9ec1..c33e753 100644
--- a/cc/layers/layer_iterator.cc
+++ b/cc/layers/layer_iterator.cc
@@ -177,11 +177,14 @@ void LayerIteratorActions::FrontToBack::GoToHighestInSubtree(
// Declare each of the above functions for Layer and LayerImpl classes
// so that they are linked.
template CC_EXPORT void LayerIteratorActions::BackToFront::Begin(
- LayerIterator<Layer, LayerList, RenderSurface, BackToFront>* it);
+ LayerIterator<Layer, RenderSurfaceLayerList, RenderSurface, BackToFront>*
+ it);
template CC_EXPORT void LayerIteratorActions::BackToFront::End(
- LayerIterator<Layer, LayerList, RenderSurface, BackToFront>* it);
+ LayerIterator<Layer, RenderSurfaceLayerList, RenderSurface, BackToFront>*
+ it);
template CC_EXPORT void LayerIteratorActions::BackToFront::Next(
- LayerIterator<Layer, LayerList, RenderSurface, BackToFront>* it);
+ LayerIterator<Layer, RenderSurfaceLayerList, RenderSurface, BackToFront>*
+ it);
template CC_EXPORT void LayerIteratorActions::BackToFront::Begin(
LayerIterator<LayerImpl, LayerImplList, RenderSurfaceImpl, BackToFront>*
@@ -194,13 +197,17 @@ template CC_EXPORT void LayerIteratorActions::BackToFront::Next(
it);
template CC_EXPORT void LayerIteratorActions::FrontToBack::Next(
- LayerIterator<Layer, LayerList, RenderSurface, FrontToBack>* it);
+ LayerIterator<Layer, RenderSurfaceLayerList, RenderSurface, FrontToBack>*
+ it);
template CC_EXPORT void LayerIteratorActions::FrontToBack::End(
- LayerIterator<Layer, LayerList, RenderSurface, FrontToBack>* it);
+ LayerIterator<Layer, RenderSurfaceLayerList, RenderSurface, FrontToBack>*
+ it);
template CC_EXPORT void LayerIteratorActions::FrontToBack::Begin(
- LayerIterator<Layer, LayerList, RenderSurface, FrontToBack>* it);
+ LayerIterator<Layer, RenderSurfaceLayerList, RenderSurface, FrontToBack>*
+ it);
template CC_EXPORT void LayerIteratorActions::FrontToBack::GoToHighestInSubtree(
- LayerIterator<Layer, LayerList, RenderSurface, FrontToBack>* it);
+ LayerIterator<Layer, RenderSurfaceLayerList, RenderSurface, FrontToBack>*
+ it);
template CC_EXPORT void LayerIteratorActions::FrontToBack::Next(
LayerIterator<LayerImpl, LayerImplList, RenderSurfaceImpl, FrontToBack>*
diff --git a/cc/layers/layer_iterator.h b/cc/layers/layer_iterator.h
index d7b85d4..b8a02c3 100644
--- a/cc/layers/layer_iterator.h
+++ b/cc/layers/layer_iterator.h
@@ -18,9 +18,9 @@ namespace cc {
// See below for details.
//
// void DoStuffOnLayers(
-// const LayerList& render_surface_layer_list) {
+// const RenderSurfaceLayerList& render_surface_layer_list) {
// typedef LayerIterator<Layer,
-// LayerList,
+// RenderSurfaceLayerList,
// RenderSurface,
// LayerIteratorActions::FrontToBack>
// LayerIteratorType;
@@ -157,8 +157,7 @@ class LayerIterator {
}
LayerType* target_render_surface_layer() const {
- return get_raw_ptr(
- (*render_surface_layer_list_)[target_render_surface_layer_index_]);
+ return render_surface_layer_list_->at(target_render_surface_layer_index_);
}
operator const LayerIteratorPosition<LayerType>() const {
@@ -178,7 +177,7 @@ class LayerIterator {
: render_surface_layer_list_(render_surface_layer_list),
target_render_surface_layer_index_(0) {
for (size_t i = 0; i < render_surface_layer_list->size(); ++i) {
- if (!(*render_surface_layer_list)[i]->render_surface()) {
+ if (!render_surface_layer_list->at(i)->render_surface()) {
NOTREACHED();
actions_.End(this);
return;
@@ -191,16 +190,10 @@ class LayerIterator {
actions_.End(this);
}
- inline static Layer* get_raw_ptr(const scoped_refptr<Layer>& ptr) {
- return ptr.get();
- }
- inline static LayerImpl* get_raw_ptr(LayerImpl* ptr) { return ptr; }
-
inline LayerType* current_layer() const {
return current_layer_represents_target_render_surface()
? target_render_surface_layer()
- : get_raw_ptr(
- target_render_surface_children()[current_layer_index_]);
+ : target_render_surface_children().at(current_layer_index_);
}
inline bool current_layer_represents_contributing_render_surface() const {
diff --git a/cc/layers/layer_iterator_unittest.cc b/cc/layers/layer_iterator_unittest.cc
index 10526ba..ea8ec3b 100644
--- a/cc/layers/layer_iterator_unittest.cc
+++ b/cc/layers/layer_iterator_unittest.cc
@@ -50,20 +50,20 @@ class TestLayer : public Layer {
EXPECT_EQ(itself, layer->count_representing_itself_);
typedef LayerIterator<Layer,
- LayerList,
+ RenderSurfaceLayerList,
RenderSurface,
LayerIteratorActions::FrontToBack> FrontToBack;
typedef LayerIterator<Layer,
- LayerList,
+ RenderSurfaceLayerList,
RenderSurface,
LayerIteratorActions::BackToFront> BackToFront;
-void ResetCounts(LayerList* render_surface_layerList) {
+void ResetCounts(RenderSurfaceLayerList* render_surface_layer_list) {
for (unsigned surface_index = 0;
- surface_index < render_surface_layerList->size();
+ surface_index < render_surface_layer_list->size();
++surface_index) {
TestLayer* render_surface_layer = static_cast<TestLayer*>(
- (*render_surface_layerList)[surface_index].get());
+ render_surface_layer_list->at(surface_index));
RenderSurface* render_surface = render_surface_layer->render_surface();
render_surface_layer->count_representing_target_surface_ = -1;
@@ -74,7 +74,7 @@ void ResetCounts(LayerList* render_surface_layerList) {
layer_index < render_surface->layer_list().size();
++layer_index) {
TestLayer* layer = static_cast<TestLayer*>(
- render_surface->layer_list()[layer_index].get());
+ render_surface->layer_list().at(layer_index));
layer->count_representing_target_surface_ = -1;
layer->count_representing_contributing_surface_ = -1;
@@ -84,11 +84,11 @@ void ResetCounts(LayerList* render_surface_layerList) {
}
void IterateFrontToBack(
- LayerList* render_surface_layerList) {
- ResetCounts(render_surface_layerList);
+ RenderSurfaceLayerList* render_surface_layer_list) {
+ ResetCounts(render_surface_layer_list);
int count = 0;
- for (FrontToBack it = FrontToBack::Begin(render_surface_layerList);
- it != FrontToBack::End(render_surface_layerList);
+ for (FrontToBack it = FrontToBack::Begin(render_surface_layer_list);
+ it != FrontToBack::End(render_surface_layer_list);
++it, ++count) {
TestLayer* layer = static_cast<TestLayer*>(*it);
if (it.represents_target_render_surface())
@@ -101,11 +101,11 @@ void IterateFrontToBack(
}
void IterateBackToFront(
- LayerList* render_surface_layerList) {
- ResetCounts(render_surface_layerList);
+ RenderSurfaceLayerList* render_surface_layer_list) {
+ ResetCounts(render_surface_layer_list);
int count = 0;
- for (BackToFront it = BackToFront::Begin(render_surface_layerList);
- it != BackToFront::End(render_surface_layerList);
+ for (BackToFront it = BackToFront::Begin(render_surface_layer_list);
+ it != BackToFront::End(render_surface_layer_list);
++it, ++count) {
TestLayer* layer = static_cast<TestLayer*>(*it);
if (it.represents_target_render_surface())
@@ -118,10 +118,10 @@ void IterateBackToFront(
}
TEST(LayerIteratorTest, EmptyTree) {
- LayerList render_surface_layerList;
+ RenderSurfaceLayerList render_surface_layer_list;
- IterateBackToFront(&render_surface_layerList);
- IterateFrontToBack(&render_surface_layerList);
+ IterateBackToFront(&render_surface_layer_list);
+ IterateFrontToBack(&render_surface_layer_list);
}
TEST(LayerIteratorTest, SimpleTree) {
@@ -131,14 +131,12 @@ TEST(LayerIteratorTest, SimpleTree) {
scoped_refptr<TestLayer> third = TestLayer::Create();
scoped_refptr<TestLayer> fourth = TestLayer::Create();
- root_layer->CreateRenderSurface();
-
root_layer->AddChild(first);
root_layer->AddChild(second);
root_layer->AddChild(third);
root_layer->AddChild(fourth);
- LayerList render_surface_layerList;
+ RenderSurfaceLayerList render_surface_layer_list;
LayerTreeHostCommon::CalculateDrawProperties(root_layer.get(),
root_layer->bounds(),
gfx::Transform(),
@@ -148,16 +146,16 @@ TEST(LayerIteratorTest, SimpleTree) {
256,
false,
false,
- &render_surface_layerList);
+ &render_surface_layer_list);
- IterateBackToFront(&render_surface_layerList);
+ IterateBackToFront(&render_surface_layer_list);
EXPECT_COUNT(root_layer, 0, -1, 1);
EXPECT_COUNT(first, -1, -1, 2);
EXPECT_COUNT(second, -1, -1, 3);
EXPECT_COUNT(third, -1, -1, 4);
EXPECT_COUNT(fourth, -1, -1, 5);
- IterateFrontToBack(&render_surface_layerList);
+ IterateFrontToBack(&render_surface_layer_list);
EXPECT_COUNT(root_layer, 5, -1, 4);
EXPECT_COUNT(first, -1, -1, 3);
EXPECT_COUNT(second, -1, -1, 2);
@@ -176,8 +174,6 @@ TEST(LayerIteratorTest, ComplexTree) {
scoped_refptr<TestLayer> root221 = TestLayer::Create();
scoped_refptr<TestLayer> root231 = TestLayer::Create();
- root_layer->CreateRenderSurface();
-
root_layer->AddChild(root1);
root_layer->AddChild(root2);
root_layer->AddChild(root3);
@@ -187,7 +183,7 @@ TEST(LayerIteratorTest, ComplexTree) {
root22->AddChild(root221);
root23->AddChild(root231);
- LayerList render_surface_layerList;
+ RenderSurfaceLayerList render_surface_layer_list;
LayerTreeHostCommon::CalculateDrawProperties(root_layer.get(),
root_layer->bounds(),
gfx::Transform(),
@@ -197,9 +193,9 @@ TEST(LayerIteratorTest, ComplexTree) {
256,
false,
false,
- &render_surface_layerList);
+ &render_surface_layer_list);
- IterateBackToFront(&render_surface_layerList);
+ IterateBackToFront(&render_surface_layer_list);
EXPECT_COUNT(root_layer, 0, -1, 1);
EXPECT_COUNT(root1, -1, -1, 2);
EXPECT_COUNT(root2, -1, -1, 3);
@@ -210,7 +206,7 @@ TEST(LayerIteratorTest, ComplexTree) {
EXPECT_COUNT(root231, -1, -1, 8);
EXPECT_COUNT(root3, -1, -1, 9);
- IterateFrontToBack(&render_surface_layerList);
+ IterateFrontToBack(&render_surface_layer_list);
EXPECT_COUNT(root_layer, 9, -1, 8);
EXPECT_COUNT(root1, -1, -1, 7);
EXPECT_COUNT(root2, -1, -1, 6);
@@ -233,10 +229,6 @@ TEST(LayerIteratorTest, ComplexTreeMultiSurface) {
scoped_refptr<TestLayer> root221 = TestLayer::Create();
scoped_refptr<TestLayer> root231 = TestLayer::Create();
- root_layer->CreateRenderSurface();
- root_layer->render_surface()->
- SetContentRect(gfx::Rect(root_layer->bounds()));
-
root_layer->AddChild(root1);
root_layer->AddChild(root2);
root_layer->AddChild(root3);
@@ -251,7 +243,7 @@ TEST(LayerIteratorTest, ComplexTreeMultiSurface) {
root23->SetOpacity(0.5f);
root23->AddChild(root231);
- LayerList render_surface_layerList;
+ RenderSurfaceLayerList render_surface_layer_list;
LayerTreeHostCommon::CalculateDrawProperties(root_layer.get(),
root_layer->bounds(),
gfx::Transform(),
@@ -261,9 +253,9 @@ TEST(LayerIteratorTest, ComplexTreeMultiSurface) {
256,
false,
false,
- &render_surface_layerList);
+ &render_surface_layer_list);
- IterateBackToFront(&render_surface_layerList);
+ IterateBackToFront(&render_surface_layer_list);
EXPECT_COUNT(root_layer, 0, -1, 1);
EXPECT_COUNT(root1, -1, -1, 2);
EXPECT_COUNT(root2, 4, 3, -1);
@@ -274,7 +266,7 @@ TEST(LayerIteratorTest, ComplexTreeMultiSurface) {
EXPECT_COUNT(root231, -1, -1, 13);
EXPECT_COUNT(root3, -1, -1, 14);
- IterateFrontToBack(&render_surface_layerList);
+ IterateFrontToBack(&render_surface_layer_list);
EXPECT_COUNT(root_layer, 14, -1, 13);
EXPECT_COUNT(root1, -1, -1, 12);
EXPECT_COUNT(root2, 10, 11, -1);
diff --git a/cc/layers/layer_lists.cc b/cc/layers/layer_lists.cc
new file mode 100644
index 0000000..89cd498
--- /dev/null
+++ b/cc/layers/layer_lists.cc
@@ -0,0 +1,60 @@
+// Copyright 2013 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/layers/layer_lists.h"
+
+#include "cc/layers/layer.h"
+
+namespace cc {
+
+RenderSurfaceLayerList::RenderSurfaceLayerList() {}
+
+RenderSurfaceLayerList::~RenderSurfaceLayerList() {
+ for (size_t i = 0; i < size(); ++i)
+ at(size() - 1 - i)->ClearRenderSurface();
+}
+
+Layer* RenderSurfaceLayerList::at(size_t i) const {
+ return list_.at(i);
+}
+
+void RenderSurfaceLayerList::pop_back() {
+ list_.pop_back();
+}
+
+void RenderSurfaceLayerList::push_back(const scoped_refptr<Layer>& layer) {
+ list_.push_back(layer);
+}
+
+Layer* RenderSurfaceLayerList::back() {
+ return list_.back();
+}
+
+size_t RenderSurfaceLayerList::size() const {
+ return list_.size();
+}
+
+LayerList::iterator RenderSurfaceLayerList::begin() {
+ return list_.begin();
+}
+
+LayerList::iterator RenderSurfaceLayerList::end() {
+ return list_.end();
+}
+
+LayerList::const_iterator RenderSurfaceLayerList::begin() const {
+ return list_.begin();
+}
+
+LayerList::const_iterator RenderSurfaceLayerList::end() const {
+ return list_.end();
+}
+
+void RenderSurfaceLayerList::clear() {
+ for (size_t i = 0; i < list_.size(); ++i)
+ DCHECK(!list_[i]->render_surface());
+ list_.clear();
+}
+
+} // namespace cc
diff --git a/cc/layers/layer_lists.h b/cc/layers/layer_lists.h
index 83ef5fd..24a9c3c 100644
--- a/cc/layers/layer_lists.h
+++ b/cc/layers/layer_lists.h
@@ -8,6 +8,7 @@
#include <vector>
#include "base/memory/ref_counted.h"
+#include "cc/base/cc_export.h"
#include "cc/base/scoped_ptr_vector.h"
namespace cc {
@@ -19,6 +20,29 @@ typedef std::vector<scoped_refptr<Layer> > LayerList;
typedef ScopedPtrVector<LayerImpl> OwnedLayerImplList;
typedef std::vector<LayerImpl*> LayerImplList;
+class CC_EXPORT RenderSurfaceLayerList {
+ public:
+ RenderSurfaceLayerList();
+ ~RenderSurfaceLayerList();
+
+ Layer* at(size_t i) const;
+ void pop_back();
+ void push_back(const scoped_refptr<Layer>& layer);
+ Layer* back();
+ size_t size() const;
+ bool empty() const { return size() == 0u; }
+ LayerList::iterator begin();
+ LayerList::iterator end();
+ LayerList::const_iterator begin() const;
+ LayerList::const_iterator end() const;
+ void clear();
+
+ private:
+ LayerList list_;
+
+ DISALLOW_COPY_AND_ASSIGN(RenderSurfaceLayerList);
+};
+
} // namespace cc
#endif // CC_LAYERS_LAYER_LISTS_H_
diff --git a/cc/layers/render_surface.cc b/cc/layers/render_surface.cc
index 60d9cb2..a17beab 100644
--- a/cc/layers/render_surface.cc
+++ b/cc/layers/render_surface.cc
@@ -20,7 +20,16 @@ RenderSurface::RenderSurface(Layer* owning_layer)
contributes_to_drawn_surface_(false),
nearest_ancestor_that_moves_pixels_(NULL) {}
-RenderSurface::~RenderSurface() {}
+RenderSurface::~RenderSurface() {
+ for (size_t i = 0; i < layer_list_.size(); ++i) {
+ DCHECK(!layer_list_.at(i)->render_surface()) <<
+ "RenderSurfaces should be cleared from the contributing layers " <<
+ "before destroying this surface to avoid leaking a circular " <<
+ "reference on the contributing layer. Probably the " <<
+ "RenderSurfaceLayerList should just be destroyed before destroying " <<
+ "any RenderSurfaces on layers.";
+ }
+}
gfx::RectF RenderSurface::DrawableContentRect() const {
gfx::RectF drawable_content_rect =
diff --git a/cc/layers/render_surface.h b/cc/layers/render_surface.h
index 369d8c9..adce0a8 100644
--- a/cc/layers/render_surface.h
+++ b/cc/layers/render_surface.h
@@ -97,11 +97,10 @@ class CC_EXPORT RenderSurface {
contributes_to_drawn_surface_ = contributes_to_drawn_surface;
}
- LayerList& layer_list() { return layer_list_; }
+ RenderSurfaceLayerList& layer_list() { return layer_list_; }
// A no-op since DelegatedRendererLayers on the main thread don't have any
// RenderPasses so they can't contribute to a surface.
void AddContributingDelegatedRenderPassLayer(Layer* layer) {}
- void ClearLayerLists() { layer_list_.clear(); }
void SetNearestAncestorThatMovesPixels(RenderSurface* surface) {
nearest_ancestor_that_moves_pixels_ = surface;
@@ -133,7 +132,7 @@ class CC_EXPORT RenderSurface {
// Uses the space of the surface's target surface.
gfx::Rect clip_rect_;
- LayerList layer_list_;
+ RenderSurfaceLayerList layer_list_;
// The nearest ancestor target surface that will contain the contents of this
// surface, and that is going to move pixels within the surface (such as with
diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index c71731d8..eff52d2 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc
@@ -455,6 +455,8 @@ class ScrollbarLayerTestResourceCreation : public testing::Test {
EXPECT_EQ(expected_resources, queue.PartialUploadSize());
testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
+
+ scrollbar_layer->ClearRenderSurface();
}
protected:
@@ -548,6 +550,8 @@ class ScaledScrollbarLayerTestResourceCreation : public testing::Test {
}
testing::Mock::VerifyAndClearExpectations(layer_tree_host_.get());
+
+ scrollbar_layer->ClearRenderSurface();
}
protected:
diff --git a/cc/layers/solid_color_layer_impl_unittest.cc b/cc/layers/solid_color_layer_impl_unittest.cc
index 0ec7040..62729ed 100644
--- a/cc/layers/solid_color_layer_impl_unittest.cc
+++ b/cc/layers/solid_color_layer_impl_unittest.cc
@@ -109,7 +109,7 @@ TEST(SolidColorLayerImplTest, VerifyOpaqueRect) {
scoped_refptr<Layer> root = Layer::Create();
root->AddChild(layer);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
LayerTreeHostCommon::CalculateDrawProperties(root.get(),
gfx::Size(500, 500),
gfx::Transform(),
diff --git a/cc/layers/tiled_layer_unittest.cc b/cc/layers/tiled_layer_unittest.cc
index 601c59d..7eb1c8d 100644
--- a/cc/layers/tiled_layer_unittest.cc
+++ b/cc/layers/tiled_layer_unittest.cc
@@ -118,13 +118,15 @@ class TiledLayerTest : public testing::Test {
layer->Update(queue_.get(), occluded);
}
- void CalcDrawProps(const scoped_refptr<FakeTiledLayer>& layer1) {
+ void CalcDrawProps(const scoped_refptr<FakeTiledLayer>& layer1,
+ RenderSurfaceLayerList* render_surface_layer_list) {
scoped_refptr<FakeTiledLayer> layer2;
- CalcDrawProps(layer1, layer2);
+ CalcDrawProps(layer1, layer2, render_surface_layer_list);
}
void CalcDrawProps(const scoped_refptr<FakeTiledLayer>& layer1,
- const scoped_refptr<FakeTiledLayer>& layer2) {
+ const scoped_refptr<FakeTiledLayer>& layer2,
+ RenderSurfaceLayerList* render_surface_layer_list) {
if (layer1.get() && !layer1->parent())
layer_tree_host_->root_layer()->AddChild(layer1);
if (layer2.get() && !layer2->parent())
@@ -132,7 +134,6 @@ class TiledLayerTest : public testing::Test {
if (occlusion_)
occlusion_->SetRenderTarget(layer_tree_host_->root_layer());
- LayerList render_surface_layer_list;
LayerTreeHostCommon::CalculateDrawProperties(
layer_tree_host_->root_layer(),
layer_tree_host_->device_viewport_size(),
@@ -143,7 +144,7 @@ class TiledLayerTest : public testing::Test {
layer_tree_host_->GetRendererCapabilities().max_texture_size,
false, // can_use_lcd_text
true, // can_adjust_raster_scale
- &render_surface_layer_list);
+ render_surface_layer_list);
}
bool UpdateAndPush(const scoped_refptr<FakeTiledLayer>& layer1,
@@ -212,10 +213,11 @@ TEST_F(TiledLayerTest, PushDirtyTiles) {
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
scoped_ptr<FakeTiledLayerImpl> layer_impl =
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
+ RenderSurfaceLayerList render_surface_layer_list;
// The tile size is 100x100, so this invalidates and then paints two tiles.
layer->SetBounds(gfx::Size(100, 200));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
UpdateAndPush(layer, layer_impl);
// We should have both tiles on the impl side.
@@ -242,37 +244,45 @@ TEST_F(TiledLayerTest, PushOccludedDirtyTiles) {
occlusion_ = &occluded;
layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
- // The tile size is 100x100, so this invalidates and then paints two tiles.
- layer->SetBounds(gfx::Size(100, 200));
- CalcDrawProps(layer);
- UpdateAndPush(layer, layer_impl);
-
- EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
- EXPECT_NEAR(
- occluded.overdraw_metrics()->pixels_uploaded_translucent(), 20000, 1);
- EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
- // We should have both tiles on the impl side.
- EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
- EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1));
+ // The tile size is 100x100, so this invalidates and then paints two tiles.
+ layer->SetBounds(gfx::Size(100, 200));
+ CalcDrawProps(layer, &render_surface_layer_list);
+ UpdateAndPush(layer, layer_impl);
- // Invalidates part of the top tile...
- layer->InvalidateContentRect(gfx::Rect(0, 0, 50, 50));
- // ....but the area is occluded.
- occluded.SetOcclusion(gfx::Rect(0, 0, 50, 50));
- CalcDrawProps(layer);
- UpdateAndPush(layer, layer_impl);
+ EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
+ EXPECT_NEAR(
+ occluded.overdraw_metrics()->pixels_uploaded_translucent(), 20000, 1);
+ EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
- EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
- EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(),
- 20000 + 2500,
- 1);
- EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
+ // We should have both tiles on the impl side.
+ EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
+ EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1));
+ }
- // We should still have both tiles, as part of the top tile is still
- // unoccluded.
- EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
- EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1));
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+
+ // Invalidates part of the top tile...
+ layer->InvalidateContentRect(gfx::Rect(0, 0, 50, 50));
+ // ....but the area is occluded.
+ occluded.SetOcclusion(gfx::Rect(0, 0, 50, 50));
+ CalcDrawProps(layer, &render_surface_layer_list);
+ UpdateAndPush(layer, layer_impl);
+
+ EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
+ EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(),
+ 20000 + 2500,
+ 1);
+ EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
+
+ // We should still have both tiles, as part of the top tile is still
+ // unoccluded.
+ EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
+ EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1));
+ }
}
TEST_F(TiledLayerTest, PushDeletedTiles) {
@@ -280,10 +290,11 @@ TEST_F(TiledLayerTest, PushDeletedTiles) {
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
scoped_ptr<FakeTiledLayerImpl> layer_impl =
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
+ RenderSurfaceLayerList render_surface_layer_list;
// The tile size is 100x100, so this invalidates and then paints two tiles.
layer->SetBounds(gfx::Size(100, 200));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
UpdateAndPush(layer, layer_impl);
// We should have both tiles on the impl side.
@@ -316,11 +327,12 @@ TEST_F(TiledLayerTest, PushIdlePaintTiles) {
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
scoped_ptr<FakeTiledLayerImpl> layer_impl =
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
+ RenderSurfaceLayerList render_surface_layer_list;
// The tile size is 100x100. Setup 5x5 tiles with one visible tile in the
// center. This paints 1 visible of the 25 invalid tiles.
layer->SetBounds(gfx::Size(500, 500));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
layer->draw_properties().visible_content_rect = gfx::Rect(200, 200, 100, 100);
bool needs_update = UpdateAndPush(layer, layer_impl);
// We should need idle-painting for surrounding tiles.
@@ -384,7 +396,9 @@ TEST_F(TiledLayerTest, PredictivePainting) {
// Setup. Use the previous_visible_rect to setup the prediction for next
// frame.
layer->SetBounds(bounds);
- CalcDrawProps(layer);
+
+ RenderSurfaceLayerList render_surface_layer_list;
+ CalcDrawProps(layer, &render_surface_layer_list);
layer->draw_properties().visible_content_rect = previous_visible_rect;
bool needs_update = UpdateAndPush(layer, layer_impl);
@@ -432,6 +446,7 @@ TEST_F(TiledLayerTest, PushTilesAfterIdlePaintFailed) {
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
scoped_ptr<FakeTiledLayerImpl> layer_impl2 =
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 2));
+ RenderSurfaceLayerList render_surface_layer_list;
// For this test we have two layers. layer1 exhausts most texture memory,
// leaving room for 2 more tiles from layer2, but not all three tiles. First
@@ -449,7 +464,7 @@ TEST_F(TiledLayerTest, PushTilesAfterIdlePaintFailed) {
// Paint a single tile in layer2 so that it will idle paint.
layer1->SetBounds(layer1_rect.size());
layer2->SetBounds(layer2_rect.size());
- CalcDrawProps(layer1, layer2);
+ CalcDrawProps(layer1, layer2, &render_surface_layer_list);
layer1->draw_properties().visible_content_rect = layer1_rect;
layer2->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
bool needs_update = UpdateAndPush(layer1, layer_impl1, layer2, layer_impl2);
@@ -485,6 +500,7 @@ TEST_F(TiledLayerTest, PushIdlePaintedOccludedTiles) {
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
scoped_ptr<FakeTiledLayerImpl> layer_impl =
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
+ RenderSurfaceLayerList render_surface_layer_list;
TestOcclusionTracker occluded;
occlusion_ = &occluded;
@@ -493,7 +509,7 @@ TEST_F(TiledLayerTest, PushIdlePaintedOccludedTiles) {
occluded.SetOcclusion(gfx::Rect(0, 0, 100, 100));
layer->SetBounds(gfx::Size(100, 100));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
UpdateAndPush(layer, layer_impl);
@@ -508,6 +524,7 @@ TEST_F(TiledLayerTest, PushTilesMarkedDirtyDuringPaint) {
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
scoped_ptr<FakeTiledLayerImpl> layer_impl =
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
+ RenderSurfaceLayerList render_surface_layer_list;
// The tile size is 100x100, so this invalidates and then paints two tiles.
// However, during the paint, we invalidate one of the tiles. This should
@@ -515,7 +532,7 @@ TEST_F(TiledLayerTest, PushTilesMarkedDirtyDuringPaint) {
layer->fake_layer_updater()->SetRectToInvalidate(
gfx::Rect(0, 50, 100, 50), layer.get());
layer->SetBounds(gfx::Size(100, 200));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
UpdateAndPush(layer, layer_impl);
@@ -533,13 +550,14 @@ TEST_F(TiledLayerTest, PushTilesLayerMarkedDirtyDuringPaintOnNextLayer) {
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
scoped_ptr<FakeTiledLayerImpl> layer2_impl =
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 2));
+ RenderSurfaceLayerList render_surface_layer_list;
// Invalidate a tile on layer1, during update of layer 2.
layer2->fake_layer_updater()->SetRectToInvalidate(
gfx::Rect(0, 50, 100, 50), layer1.get());
layer1->SetBounds(gfx::Size(100, 200));
layer2->SetBounds(gfx::Size(100, 200));
- CalcDrawProps(layer1, layer2);
+ CalcDrawProps(layer1, layer2, &render_surface_layer_list);
layer1->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
layer2->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
UpdateAndPush(layer1, layer1_impl, layer2, layer2_impl);
@@ -560,12 +578,13 @@ TEST_F(TiledLayerTest, PushTilesLayerMarkedDirtyDuringPaintOnPreviousLayer) {
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
scoped_ptr<FakeTiledLayerImpl> layer2_impl =
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 2));
+ RenderSurfaceLayerList render_surface_layer_list;
layer1->fake_layer_updater()->SetRectToInvalidate(
gfx::Rect(0, 50, 100, 50), layer2.get());
layer1->SetBounds(gfx::Size(100, 200));
layer2->SetBounds(gfx::Size(100, 200));
- CalcDrawProps(layer1, layer2);
+ CalcDrawProps(layer1, layer2, &render_surface_layer_list);
layer1->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
layer2->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
UpdateAndPush(layer1, layer1_impl, layer2, layer2_impl);
@@ -601,11 +620,12 @@ TEST_F(TiledLayerTest, PaintSmallAnimatedLayersImmediately) {
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
scoped_ptr<FakeTiledLayerImpl> layer_impl =
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
+ RenderSurfaceLayerList render_surface_layer_list;
// Full size layer with half being visible.
layer->SetBounds(gfx::Size(layer_width, layer_height));
gfx::Rect visible_rect(0, 0, layer_width / 2, layer_height);
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
// Pretend the layer is animating.
layer->draw_properties().target_space_transform_is_animating = true;
@@ -643,6 +663,7 @@ TEST_F(TiledLayerTest, IdlePaintOutOfMemory) {
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
scoped_ptr<FakeTiledLayerImpl> layer_impl =
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
+ RenderSurfaceLayerList render_surface_layer_list;
// We have enough memory for only the visible rect, so we will run out of
// memory in first idle paint.
@@ -652,7 +673,7 @@ TEST_F(TiledLayerTest, IdlePaintOutOfMemory) {
// The tile size is 100x100, so this invalidates and then paints two tiles.
bool needs_update = false;
layer->SetBounds(gfx::Size(300, 300));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
layer->draw_properties().visible_content_rect = gfx::Rect(100, 100, 100, 100);
for (int i = 0; i < 2; i++)
needs_update = UpdateAndPush(layer, layer_impl);
@@ -678,7 +699,9 @@ TEST_F(TiledLayerTest, IdlePaintZeroSizedLayer) {
// The layer's bounds are empty.
// Empty layers don't paint or idle-paint.
layer->SetBounds(gfx::Size());
- CalcDrawProps(layer);
+
+ RenderSurfaceLayerList render_surface_layer_list;
+ CalcDrawProps(layer, &render_surface_layer_list);
layer->draw_properties().visible_content_rect = gfx::Rect();
bool needs_update = UpdateAndPush(layer, layer_impl);
@@ -713,7 +736,9 @@ TEST_F(TiledLayerTest, IdlePaintNonVisibleLayers) {
for (int i = 0; i < 10; i++) {
layer->SetBounds(gfx::Size(100, 100));
- CalcDrawProps(layer);
+
+ RenderSurfaceLayerList render_surface_layer_list;
+ CalcDrawProps(layer, &render_surface_layer_list);
layer->draw_properties().visible_content_rect = visible_rect[i];
if (invalidate[i])
@@ -732,10 +757,11 @@ TEST_F(TiledLayerTest, InvalidateFromPrepare) {
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
scoped_ptr<FakeTiledLayerImpl> layer_impl =
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
+ RenderSurfaceLayerList render_surface_layer_list;
// The tile size is 100x100, so this invalidates and then paints two tiles.
layer->SetBounds(gfx::Size(100, 200));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
UpdateAndPush(layer, layer_impl);
@@ -815,10 +841,11 @@ TEST_F(TiledLayerTest, VerifyInvalidationWhenContentsScaleChanges) {
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
scoped_ptr<FakeTiledLayerImpl> layer_impl =
make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
+ RenderSurfaceLayerList render_surface_layer_list;
// Create a layer with one tile.
layer->SetBounds(gfx::Size(100, 100));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
layer->Update(queue_.get(), NULL);
UpdateTextures();
@@ -1073,10 +1100,11 @@ TEST_F(TiledLayerPartialUpdateTest, PartialUpdates) {
TEST_F(TiledLayerTest, TilesPaintedWithoutOcclusion) {
scoped_refptr<FakeTiledLayer> layer =
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+ RenderSurfaceLayerList render_surface_layer_list;
// The tile size is 100x100, so this invalidates and then paints two tiles.
layer->SetBounds(gfx::Size(100, 200));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
layer->SetTexturePriorities(priority_calculator_);
resource_manager_->PrioritizeTextures();
@@ -1088,6 +1116,7 @@ TEST_F(TiledLayerTest, TilesPaintedWithoutOcclusion) {
TEST_F(TiledLayerTest, TilesPaintedWithOcclusion) {
scoped_refptr<FakeTiledLayer> layer =
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+ RenderSurfaceLayerList render_surface_layer_list;
TestOcclusionTracker occluded;
occlusion_ = &occluded;
@@ -1095,7 +1124,7 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusion) {
layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
layer->SetBounds(gfx::Size(600, 600));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
occluded.SetOcclusion(gfx::Rect(200, 200, 300, 100));
layer->draw_properties().drawable_content_rect =
@@ -1151,6 +1180,7 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusion) {
TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndVisiblityConstraints) {
scoped_refptr<FakeTiledLayer> layer =
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+ RenderSurfaceLayerList render_surface_layer_list;
TestOcclusionTracker occluded;
occlusion_ = &occluded;
@@ -1158,7 +1188,7 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndVisiblityConstraints) {
layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
layer->SetBounds(gfx::Size(600, 600));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
// The partially occluded tiles (by the 150 occlusion height) are visible
// beyond the occlusion, so not culled.
@@ -1222,6 +1252,7 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndVisiblityConstraints) {
TEST_F(TiledLayerTest, TilesNotPaintedWithoutInvalidation) {
scoped_refptr<FakeTiledLayer> layer =
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+ RenderSurfaceLayerList render_surface_layer_list;
TestOcclusionTracker occluded;
occlusion_ = &occluded;
@@ -1229,7 +1260,7 @@ TEST_F(TiledLayerTest, TilesNotPaintedWithoutInvalidation) {
layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
layer->SetBounds(gfx::Size(600, 600));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
occluded.SetOcclusion(gfx::Rect(200, 200, 300, 100));
layer->draw_properties().drawable_content_rect = gfx::Rect(0, 0, 600, 600);
@@ -1266,6 +1297,7 @@ TEST_F(TiledLayerTest, TilesNotPaintedWithoutInvalidation) {
TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndTransforms) {
scoped_refptr<FakeTiledLayer> layer =
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+ RenderSurfaceLayerList render_surface_layer_list;
TestOcclusionTracker occluded;
occlusion_ = &occluded;
@@ -1275,7 +1307,7 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndTransforms) {
// space) is transformed differently than the layer.
layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
layer->SetBounds(gfx::Size(600, 600));
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
gfx::Transform screen_transform;
screen_transform.Scale(0.5, 0.5);
layer->draw_properties().screen_space_transform = screen_transform;
@@ -1302,6 +1334,7 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndTransforms) {
TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndScaling) {
scoped_refptr<FakeTiledLayer> layer =
new FakeTiledLayer(resource_manager_.get());
+ RenderSurfaceLayerList render_surface_layer_list;
TestOcclusionTracker occluded;
occlusion_ = &occluded;
@@ -1319,7 +1352,7 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndScaling) {
layer->SetAnchorPoint(gfx::PointF());
layer->SetBounds(gfx::Size(300, 300));
scale_layer->AddChild(layer);
- CalcDrawProps(scale_layer);
+ CalcDrawProps(scale_layer, &render_surface_layer_list);
EXPECT_FLOAT_EQ(2.f, layer->contents_scale_x());
EXPECT_FLOAT_EQ(2.f, layer->contents_scale_y());
EXPECT_EQ(gfx::Size(600, 600).ToString(),
@@ -1406,6 +1439,7 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndScaling) {
TEST_F(TiledLayerTest, VisibleContentOpaqueRegion) {
scoped_refptr<FakeTiledLayer> layer =
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+ RenderSurfaceLayerList render_surface_layer_list;
TestOcclusionTracker occluded;
occlusion_ = &occluded;
layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
@@ -1420,7 +1454,7 @@ TEST_F(TiledLayerTest, VisibleContentOpaqueRegion) {
gfx::Rect visible_bounds = gfx::Rect(0, 0, 100, 150);
layer->SetBounds(content_bounds.size());
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
layer->draw_properties().drawable_content_rect = visible_bounds;
layer->draw_properties().visible_content_rect = visible_bounds;
@@ -1526,6 +1560,7 @@ TEST_F(TiledLayerTest, VisibleContentOpaqueRegion) {
TEST_F(TiledLayerTest, Pixels_paintedMetrics) {
scoped_refptr<FakeTiledLayer> layer =
make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
+ RenderSurfaceLayerList render_surface_layer_list;
TestOcclusionTracker occluded;
occlusion_ = &occluded;
layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
@@ -1538,7 +1573,7 @@ TEST_F(TiledLayerTest, Pixels_paintedMetrics) {
gfx::Rect content_bounds = gfx::Rect(0, 0, 100, 300);
layer->SetBounds(content_bounds.size());
- CalcDrawProps(layer);
+ CalcDrawProps(layer, &render_surface_layer_list);
// Invalidates and paints the whole layer.
layer->fake_layer_updater()->SetOpaquePaintRect(gfx::Rect());
diff --git a/cc/trees/damage_tracker_unittest.cc b/cc/trees/damage_tracker_unittest.cc
index 1ac2983..a3dd636 100644
--- a/cc/trees/damage_tracker_unittest.cc
+++ b/cc/trees/damage_tracker_unittest.cc
@@ -1301,9 +1301,10 @@ TEST_F(DamageTrackerTest, VerifyDamageForEmptyLayerList) {
ASSERT_TRUE(root == root->render_target());
RenderSurfaceImpl* target_surface = root->render_surface();
- target_surface->ClearLayerLists();
+
+ LayerImplList empty_list;
target_surface->damage_tracker()->UpdateDamageTrackingState(
- target_surface->layer_list(),
+ empty_list,
target_surface->OwningLayerId(),
false,
gfx::Rect(),
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index cf9e378..71b76fd 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -696,7 +696,7 @@ bool LayerTreeHost::UpdateLayers(Layer* root_layer,
benchmark_instrumentation::kCommitNumber,
commit_number());
- LayerList update_list;
+ RenderSurfaceLayerList update_list;
{
UpdateHudLayer();
@@ -756,9 +756,6 @@ bool LayerTreeHost::UpdateLayers(Layer* root_layer,
FROM_HERE, prepaint_callback_.callback(), prepaint_delay);
}
- for (size_t i = 0; i < update_list.size(); ++i)
- update_list[i]->ClearRenderSurface();
-
return did_paint_content;
}
@@ -794,10 +791,11 @@ void LayerTreeHost::SetPrioritiesForSurfaces(size_t surface_memory_bytes) {
surface_memory_bytes);
}
-void LayerTreeHost::SetPrioritiesForLayers(const LayerList& update_list) {
+void LayerTreeHost::SetPrioritiesForLayers(
+ const RenderSurfaceLayerList& update_list) {
// Use BackToFront since it's cheap and this isn't order-dependent.
typedef LayerIterator<Layer,
- LayerList,
+ RenderSurfaceLayerList,
RenderSurface,
LayerIteratorActions::BackToFront> LayerIteratorType;
@@ -818,7 +816,8 @@ void LayerTreeHost::SetPrioritiesForLayers(const LayerList& update_list) {
}
void LayerTreeHost::PrioritizeTextures(
- const LayerList& render_surface_layer_list, OverdrawMetrics* metrics) {
+ const RenderSurfaceLayerList& render_surface_layer_list,
+ OverdrawMetrics* metrics) {
if (!contents_texture_manager_)
return;
@@ -839,7 +838,7 @@ void LayerTreeHost::PrioritizeTextures(
}
size_t LayerTreeHost::CalculateMemoryForRenderSurfaces(
- const LayerList& update_list) {
+ const RenderSurfaceLayerList& update_list) {
size_t readback_bytes = 0;
size_t max_background_texture_bytes = 0;
size_t contents_texture_bytes = 0;
@@ -847,7 +846,7 @@ size_t LayerTreeHost::CalculateMemoryForRenderSurfaces(
// Start iteration at 1 to skip the root surface as it does not have a texture
// cost.
for (size_t i = 1; i < update_list.size(); ++i) {
- Layer* render_surface_layer = update_list[i].get();
+ Layer* render_surface_layer = update_list.at(i);
RenderSurface* render_surface = render_surface_layer->render_surface();
size_t bytes =
@@ -893,14 +892,14 @@ void LayerTreeHost::PaintMasksForRenderSurface(Layer* render_surface_layer,
}
void LayerTreeHost::PaintLayerContents(
- const LayerList& render_surface_layer_list,
+ const RenderSurfaceLayerList& render_surface_layer_list,
ResourceUpdateQueue* queue,
bool* did_paint_content,
bool* need_more_updates) {
// Use FrontToBack to allow for testing occlusion and performing culling
// during the tree walk.
typedef LayerIterator<Layer,
- LayerList,
+ RenderSurfaceLayerList,
RenderSurface,
LayerIteratorActions::FrontToBack> LayerIteratorType;
diff --git a/cc/trees/layer_tree_host.h b/cc/trees/layer_tree_host.h
index 7d8bec7..63e8aec 100644
--- a/cc/trees/layer_tree_host.h
+++ b/cc/trees/layer_tree_host.h
@@ -262,10 +262,11 @@ class CC_EXPORT LayerTreeHost : NON_EXPORTED_BASE(public RateLimiterClient) {
private:
bool InitializeProxy(scoped_ptr<Proxy> proxy);
- void PaintLayerContents(const LayerList& render_surface_layer_list,
- ResourceUpdateQueue* queue,
- bool* did_paint_content,
- bool* need_more_updates);
+ void PaintLayerContents(
+ const RenderSurfaceLayerList& render_surface_layer_list,
+ ResourceUpdateQueue* queue,
+ bool* did_paint_content,
+ bool* need_more_updates);
void PaintMasksForRenderSurface(Layer* render_surface_layer,
ResourceUpdateQueue* queue,
bool* did_paint_content,
@@ -276,11 +277,13 @@ class CC_EXPORT LayerTreeHost : NON_EXPORTED_BASE(public RateLimiterClient) {
void ReduceMemoryUsage();
- void PrioritizeTextures(const LayerList& render_surface_layer_list,
- OverdrawMetrics* metrics);
+ void PrioritizeTextures(
+ const RenderSurfaceLayerList& render_surface_layer_list,
+ OverdrawMetrics* metrics);
void SetPrioritiesForSurfaces(size_t surface_memory_bytes);
- void SetPrioritiesForLayers(const LayerList& update_list);
- size_t CalculateMemoryForRenderSurfaces(const LayerList& update_list);
+ void SetPrioritiesForLayers(const RenderSurfaceLayerList& update_list);
+ size_t CalculateMemoryForRenderSurfaces(
+ const RenderSurfaceLayerList& update_list);
bool AnimateLayersRecursive(Layer* current, base::TimeTicks time);
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index 415044a..50a2d39 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -738,6 +738,25 @@ static inline void UpdateLayerContentsScale(
animating_transform_to_screen);
}
+static inline RenderSurface* CreateOrReuseRenderSurface(Layer* layer) {
+ // The render surface should always be new on the main thread, as the
+ // RenderSurfaceLayerList should be a new empty list when given to
+ // CalculateDrawProperties.
+ DCHECK(!layer->render_surface());
+ layer->CreateRenderSurface();
+ return layer->render_surface();
+}
+
+static inline RenderSurfaceImpl* CreateOrReuseRenderSurface(LayerImpl* layer) {
+ if (!layer->render_surface()) {
+ layer->CreateRenderSurface();
+ return layer->render_surface();
+ }
+
+ layer->render_surface()->ClearLayerLists();
+ return layer->render_surface();
+}
+
template <typename LayerType, typename LayerList>
static inline void RemoveSurfaceForEarlyExit(
LayerType* layer_to_remove,
@@ -834,7 +853,9 @@ static void RoundTranslationComponents(gfx::Transform* transform) {
// Recursively walks the layer tree starting at the given node and computes all
// the necessary transformations, clip rects, render surfaces, etc.
-template <typename LayerType, typename LayerList, typename RenderSurfaceType>
+template <typename LayerType,
+ typename LayerListType,
+ typename RenderSurfaceType>
static void CalculateDrawPropertiesInternal(
LayerType* layer,
const gfx::Transform& parent_matrix,
@@ -845,8 +866,8 @@ static void CalculateDrawPropertiesInternal(
gfx::Rect clip_rect_from_ancestor_in_descendant_space,
bool ancestor_clips_subtree,
RenderSurfaceType* nearest_ancestor_that_moves_pixels,
- LayerList* render_surface_layer_list,
- LayerList* layer_list,
+ LayerListType* render_surface_layer_list,
+ LayerListType* layer_list,
LayerSorter* layer_sorter,
int max_texture_size,
float device_scale_factor,
@@ -1143,11 +1164,7 @@ static void CalculateDrawPropertiesInternal(
IsSurfaceBackFaceVisible(layer, combined_transform))
return;
- if (!layer->render_surface())
- layer->CreateRenderSurface();
-
- RenderSurfaceType* render_surface = layer->render_surface();
- render_surface->ClearLayerLists();
+ RenderSurfaceType* render_surface = CreateOrReuseRenderSurface(layer);
if (IsRootLayer(layer)) {
// The root layer's render surface size is predetermined and so the root
@@ -1355,7 +1372,7 @@ static void CalculateDrawPropertiesInternal(
-layer->anchor_point().y() * bounds.height());
}
- LayerList& descendants =
+ LayerListType& descendants =
(layer->render_surface() ? layer->render_surface()->layer_list()
: *layer_list);
@@ -1381,7 +1398,9 @@ static void CalculateDrawPropertiesInternal(
LayerTreeHostCommon::get_child_as_raw_ptr(layer->children(), i);
gfx::Rect drawable_content_rect_of_child_subtree;
gfx::Transform identity_matrix;
- CalculateDrawPropertiesInternal<LayerType, LayerList, RenderSurfaceType>(
+ CalculateDrawPropertiesInternal<LayerType,
+ LayerListType,
+ RenderSurfaceType>(
child,
sublayer_matrix,
next_hierarchy_matrix,
@@ -1485,7 +1504,6 @@ static void CalculateDrawPropertiesInternal(
std::min(clipped_content_rect.height(), max_texture_size));
if (clipped_content_rect.IsEmpty()) {
- render_surface->ClearLayerLists();
RemoveSurfaceForEarlyExit(layer, render_surface_layer_list);
return;
}
@@ -1577,12 +1595,12 @@ void LayerTreeHostCommon::CalculateDrawProperties(
int max_texture_size,
bool can_use_lcd_text,
bool can_adjust_raster_scales,
- LayerList* render_surface_layer_list) {
+ RenderSurfaceLayerList* render_surface_layer_list) {
gfx::Rect total_drawable_content_rect;
gfx::Transform identity_matrix;
gfx::Transform scaled_device_transform = device_transform;
scaled_device_transform.Scale(device_scale_factor, device_scale_factor);
- LayerList dummy_layer_list;
+ RenderSurfaceLayerList dummy_layer_list;
// The root layer's render_surface should receive the device viewport as the
// initial clip rect.
@@ -1597,7 +1615,7 @@ void LayerTreeHostCommon::CalculateDrawProperties(
PreCalculateMetaInformationRecursiveData recursive_data;
PreCalculateMetaInformation(root_layer, &recursive_data);
- CalculateDrawPropertiesInternal<Layer, LayerList, RenderSurface>(
+ CalculateDrawPropertiesInternal<Layer, RenderSurfaceLayerList, RenderSurface>(
root_layer,
scaled_device_transform,
identity_matrix,
diff --git a/cc/trees/layer_tree_host_common.h b/cc/trees/layer_tree_host_common.h
index a4f76eb..154d8a0 100644
--- a/cc/trees/layer_tree_host_common.h
+++ b/cc/trees/layer_tree_host_common.h
@@ -37,7 +37,7 @@ class CC_EXPORT LayerTreeHostCommon {
int max_texture_size,
bool can_use_lcd_text,
bool can_adjust_raster_scales,
- LayerList* render_surface_layer_list);
+ RenderSurfaceLayerList* render_surface_layer_list);
static void CalculateDrawProperties(
LayerImpl* root_layer,
gfx::Size device_viewport_size,
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 5ca0b0d..f001205 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -31,142 +31,153 @@
namespace cc {
namespace {
-template <typename LayerType>
-void SetLayerPropertiesForTestingInternal(
- LayerType* layer,
- const gfx::Transform& transform,
- const gfx::Transform& sublayer_transform,
- gfx::PointF anchor,
- gfx::PointF position,
- gfx::Size bounds,
- bool preserves3d) {
- layer->SetTransform(transform);
- layer->SetSublayerTransform(sublayer_transform);
- layer->SetAnchorPoint(anchor);
- layer->SetPosition(position);
- layer->SetBounds(bounds);
- layer->SetPreserves3d(preserves3d);
-}
+class LayerTreeHostCommonTestBase {
+ protected:
+ template <typename LayerType>
+ void SetLayerPropertiesForTestingInternal(
+ LayerType* layer,
+ const gfx::Transform& transform,
+ const gfx::Transform& sublayer_transform,
+ gfx::PointF anchor,
+ gfx::PointF position,
+ gfx::Size bounds,
+ bool preserves3d) {
+ layer->SetTransform(transform);
+ layer->SetSublayerTransform(sublayer_transform);
+ layer->SetAnchorPoint(anchor);
+ layer->SetPosition(position);
+ layer->SetBounds(bounds);
+ layer->SetPreserves3d(preserves3d);
+ }
-void SetLayerPropertiesForTesting(Layer* layer,
- const gfx::Transform& transform,
- const gfx::Transform& sublayer_transform,
- gfx::PointF anchor,
- gfx::PointF position,
- gfx::Size bounds,
- bool preserves3d) {
- SetLayerPropertiesForTestingInternal<Layer>(layer,
- transform,
- sublayer_transform,
- anchor,
- position,
- bounds,
- preserves3d);
-}
+ void SetLayerPropertiesForTesting(Layer* layer,
+ const gfx::Transform& transform,
+ const gfx::Transform& sublayer_transform,
+ gfx::PointF anchor,
+ gfx::PointF position,
+ gfx::Size bounds,
+ bool preserves3d) {
+ SetLayerPropertiesForTestingInternal<Layer>(layer,
+ transform,
+ sublayer_transform,
+ anchor,
+ position,
+ bounds,
+ preserves3d);
+ }
-void SetLayerPropertiesForTesting(LayerImpl* layer,
- const gfx::Transform& transform,
- const gfx::Transform& sublayer_transform,
- gfx::PointF anchor,
- gfx::PointF position,
- gfx::Size bounds,
- bool preserves3d) {
- SetLayerPropertiesForTestingInternal<LayerImpl>(layer,
- transform,
- sublayer_transform,
- anchor,
- position,
- bounds,
- preserves3d);
- layer->SetContentBounds(bounds);
-}
+ void SetLayerPropertiesForTesting(LayerImpl* layer,
+ const gfx::Transform& transform,
+ const gfx::Transform& sublayer_transform,
+ gfx::PointF anchor,
+ gfx::PointF position,
+ gfx::Size bounds,
+ bool preserves3d) {
+ SetLayerPropertiesForTestingInternal<LayerImpl>(layer,
+ transform,
+ sublayer_transform,
+ anchor,
+ position,
+ bounds,
+ preserves3d);
+ layer->SetContentBounds(bounds);
+ }
-void ExecuteCalculateDrawProperties(Layer* root_layer,
- float device_scale_factor,
- float page_scale_factor,
- Layer* page_scale_application_layer,
- bool can_use_lcd_text) {
- EXPECT_TRUE(page_scale_application_layer || (page_scale_factor == 1.f));
- gfx::Transform identity_matrix;
- LayerList dummy_render_surface_layer_list;
- int dummy_max_texture_size = 512;
- gfx::Size device_viewport_size =
- gfx::Size(root_layer->bounds().width() * device_scale_factor,
- root_layer->bounds().height() * device_scale_factor);
+ void ExecuteCalculateDrawProperties(Layer* root_layer,
+ float device_scale_factor,
+ float page_scale_factor,
+ Layer* page_scale_application_layer,
+ bool can_use_lcd_text) {
+ EXPECT_TRUE(page_scale_application_layer || (page_scale_factor == 1.f));
+ gfx::Transform identity_matrix;
+ int dummy_max_texture_size = 512;
+ gfx::Size device_viewport_size =
+ gfx::Size(root_layer->bounds().width() * device_scale_factor,
+ root_layer->bounds().height() * device_scale_factor);
+
+ render_surface_layer_list_.reset(new RenderSurfaceLayerList);
+
+ // We are probably not testing what is intended if the root_layer bounds are
+ // empty.
+ DCHECK(!root_layer->bounds().IsEmpty());
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root_layer,
+ device_viewport_size,
+ gfx::Transform(),
+ device_scale_factor,
+ page_scale_factor,
+ page_scale_application_layer,
+ dummy_max_texture_size,
+ can_use_lcd_text,
+ true, // can_adjust_raster_scale
+ render_surface_layer_list_.get());
+ }
- // We are probably not testing what is intended if the root_layer bounds are
- // empty.
- DCHECK(!root_layer->bounds().IsEmpty());
- LayerTreeHostCommon::CalculateDrawProperties(
- root_layer,
- device_viewport_size,
- gfx::Transform(),
- device_scale_factor,
- page_scale_factor,
- page_scale_application_layer,
- dummy_max_texture_size,
- can_use_lcd_text,
- true, // can_adjust_raster_scale
- &dummy_render_surface_layer_list);
-}
+ void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
+ float device_scale_factor,
+ float page_scale_factor,
+ LayerImpl* page_scale_application_layer,
+ bool can_use_lcd_text) {
+ gfx::Transform identity_matrix;
+ LayerImplList dummy_render_surface_layer_list;
+ int dummy_max_texture_size = 512;
+ gfx::Size device_viewport_size =
+ gfx::Size(root_layer->bounds().width() * device_scale_factor,
+ root_layer->bounds().height() * device_scale_factor);
+
+ // We are probably not testing what is intended if the root_layer bounds are
+ // empty.
+ DCHECK(!root_layer->bounds().IsEmpty());
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root_layer,
+ device_viewport_size,
+ gfx::Transform(),
+ device_scale_factor,
+ page_scale_factor,
+ page_scale_application_layer,
+ dummy_max_texture_size,
+ can_use_lcd_text,
+ true, // can_adjust_raster_scale
+ &dummy_render_surface_layer_list);
+ }
-void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
- float device_scale_factor,
- float page_scale_factor,
- LayerImpl* page_scale_application_layer,
- bool can_use_lcd_text) {
- gfx::Transform identity_matrix;
- LayerImplList dummy_render_surface_layer_list;
- int dummy_max_texture_size = 512;
- gfx::Size device_viewport_size =
- gfx::Size(root_layer->bounds().width() * device_scale_factor,
- root_layer->bounds().height() * device_scale_factor);
+ template <class LayerType>
+ void ExecuteCalculateDrawProperties(LayerType* root_layer) {
+ LayerType* page_scale_application_layer = NULL;
+ ExecuteCalculateDrawProperties(
+ root_layer, 1.f, 1.f, page_scale_application_layer, false);
+ }
- // We are probably not testing what is intended if the root_layer bounds are
- // empty.
- DCHECK(!root_layer->bounds().IsEmpty());
- LayerTreeHostCommon::CalculateDrawProperties(
- root_layer,
- device_viewport_size,
- gfx::Transform(),
- device_scale_factor,
- page_scale_factor,
- page_scale_application_layer,
- dummy_max_texture_size,
- can_use_lcd_text,
- true, // can_adjust_raster_scale
- &dummy_render_surface_layer_list);
-}
+ template <class LayerType>
+ void ExecuteCalculateDrawProperties(LayerType* root_layer,
+ float device_scale_factor) {
+ LayerType* page_scale_application_layer = NULL;
+ ExecuteCalculateDrawProperties(root_layer,
+ device_scale_factor,
+ 1.f,
+ page_scale_application_layer,
+ false);
+ }
-template <class LayerType>
-void ExecuteCalculateDrawProperties(LayerType* root_layer) {
- LayerType* page_scale_application_layer = NULL;
- ExecuteCalculateDrawProperties(
- root_layer, 1.f, 1.f, page_scale_application_layer, false);
-}
+ template <class LayerType>
+ void ExecuteCalculateDrawProperties(LayerType* root_layer,
+ float device_scale_factor,
+ float page_scale_factor,
+ LayerType* page_scale_application_layer) {
+ ExecuteCalculateDrawProperties(root_layer,
+ device_scale_factor,
+ page_scale_factor,
+ page_scale_application_layer,
+ false);
+ }
-template <class LayerType>
-void ExecuteCalculateDrawProperties(LayerType* root_layer,
- float device_scale_factor) {
- LayerType* page_scale_application_layer = NULL;
- ExecuteCalculateDrawProperties(root_layer,
- device_scale_factor,
- 1.f,
- page_scale_application_layer,
- false);
-}
+ private:
+ scoped_ptr<RenderSurfaceLayerList> render_surface_layer_list_;
+};
-template <class LayerType>
-void ExecuteCalculateDrawProperties(LayerType* root_layer,
- float device_scale_factor,
- float page_scale_factor,
- LayerType* page_scale_application_layer) {
- ExecuteCalculateDrawProperties(root_layer,
- device_scale_factor,
- page_scale_factor,
- page_scale_application_layer,
- false);
-}
+class LayerTreeHostCommonTest : public LayerTreeHostCommonTestBase,
+ public testing::Test {
+};
class LayerWithForcedDrawsContent : public Layer {
public:
@@ -212,13 +223,13 @@ scoped_refptr<ContentLayer> CreateDrawableContentLayer(
return to_return;
}
-#define EXPECT_CONTENTS_SCALE_EQ(expected, layer) \
- do { \
- EXPECT_FLOAT_EQ(expected, layer->contents_scale_x()); \
- EXPECT_FLOAT_EQ(expected, layer->contents_scale_y()); \
+#define EXPECT_CONTENTS_SCALE_EQ(expected, layer) \
+ do { \
+ EXPECT_FLOAT_EQ(expected, layer->contents_scale_x()); \
+ EXPECT_FLOAT_EQ(expected, layer->contents_scale_y()); \
} while (false)
-TEST(LayerTreeHostCommonTest, TransformsForNoOpLayer) {
+TEST_F(LayerTreeHostCommonTest, TransformsForNoOpLayer) {
// Sanity check: For layers positioned at zero, with zero size,
// and with identity transforms, then the draw transform,
// screen space transform, and the hierarchy passed on to children
@@ -264,7 +275,7 @@ TEST(LayerTreeHostCommonTest, TransformsForNoOpLayer) {
grand_child->screen_space_transform());
}
-TEST(LayerTreeHostCommonTest, TransformsForSingleLayer) {
+TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) {
gfx::Transform identity_matrix;
scoped_refptr<Layer> layer = Layer::Create();
@@ -394,7 +405,7 @@ TEST(LayerTreeHostCommonTest, TransformsForSingleLayer) {
layer->screen_space_transform());
}
-TEST(LayerTreeHostCommonTest, TransformsAboutScrollOffset) {
+TEST_F(LayerTreeHostCommonTest, TransformsAboutScrollOffset) {
const gfx::Vector2d kScrollOffset(50, 100);
const gfx::Vector2dF kScrollDelta(2.34f, 5.67f);
const gfx::PointF kScrollLayerPosition(-kScrollOffset.x(),
@@ -480,7 +491,7 @@ TEST(LayerTreeHostCommonTest, TransformsAboutScrollOffset) {
sublayer->draw_transform());
}
-TEST(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) {
+TEST_F(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) {
gfx::Transform identity_matrix;
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<Layer> parent = Layer::Create();
@@ -683,7 +694,7 @@ TEST(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) {
grand_child->screen_space_transform());
}
-TEST(LayerTreeHostCommonTest, TransformsForSingleRenderSurface) {
+TEST_F(LayerTreeHostCommonTest, TransformsForSingleRenderSurface) {
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<Layer> parent = Layer::Create();
scoped_refptr<Layer> child = Layer::Create();
@@ -778,7 +789,7 @@ TEST(LayerTreeHostCommonTest, TransformsForSingleRenderSurface) {
child->render_target()->render_surface()->screen_space_transform());
}
-TEST(LayerTreeHostCommonTest, SublayerTransformWithAnchorPoint) {
+TEST_F(LayerTreeHostCommonTest, SublayerTransformWithAnchorPoint) {
// crbug.com/157961 - we were always applying the sublayer transform about
// the center of the layer, rather than the anchor point.
@@ -825,7 +836,7 @@ TEST(LayerTreeHostCommonTest, SublayerTransformWithAnchorPoint) {
child->draw_transform());
}
-TEST(LayerTreeHostCommonTest, SeparateRenderTargetRequirementWithClipping) {
+TEST_F(LayerTreeHostCommonTest, SeparateRenderTargetRequirementWithClipping) {
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<Layer> parent = Layer::Create();
scoped_refptr<Layer> child = Layer::Create();
@@ -891,7 +902,8 @@ TEST(LayerTreeHostCommonTest, SeparateRenderTargetRequirementWithClipping) {
EXPECT_FALSE(grand_child->render_surface());
}
-TEST(LayerTreeHostCommonTest, SeparateRenderTargetRequirementWithoutClipping) {
+TEST_F(LayerTreeHostCommonTest,
+ SeparateRenderTargetRequirementWithoutClipping) {
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<Layer> parent = Layer::Create();
scoped_refptr<Layer> child = Layer::Create();
@@ -959,7 +971,7 @@ TEST(LayerTreeHostCommonTest, SeparateRenderTargetRequirementWithoutClipping) {
EXPECT_FALSE(grand_child->render_surface());
}
-TEST(LayerTreeHostCommonTest, TransformsForReplica) {
+TEST_F(LayerTreeHostCommonTest, TransformsForReplica) {
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<Layer> parent = Layer::Create();
scoped_refptr<Layer> child = Layer::Create();
@@ -1051,7 +1063,7 @@ TEST(LayerTreeHostCommonTest, TransformsForReplica) {
->replica_screen_space_transform());
}
-TEST(LayerTreeHostCommonTest, TransformsForRenderSurfaceHierarchy) {
+TEST_F(LayerTreeHostCommonTest, TransformsForRenderSurfaceHierarchy) {
// This test creates a more complex tree and verifies it all at once. This
// covers the following cases:
// - layers that are described w.r.t. a render surface: should have draw
@@ -1359,7 +1371,7 @@ TEST(LayerTreeHostCommonTest, TransformsForRenderSurfaceHierarchy) {
grand_child_of_rs2->screen_space_transform().matrix().getDouble(1, 3));
}
-TEST(LayerTreeHostCommonTest, TransformsForFlatteningLayer) {
+TEST_F(LayerTreeHostCommonTest, TransformsForFlatteningLayer) {
// For layers that flatten their subtree, there should be an orthographic
// projection (for x and y values) in the middle of the transform sequence.
// Note that the way the code is currently implemented, it is not expected to
@@ -1432,7 +1444,7 @@ TEST(LayerTreeHostCommonTest, TransformsForFlatteningLayer) {
grand_child->screen_space_transform());
}
-TEST(LayerTreeHostCommonTest, TransformsForDegenerateIntermediateLayer) {
+TEST_F(LayerTreeHostCommonTest, TransformsForDegenerateIntermediateLayer) {
// A layer that is empty in one axis, but not the other, was accidentally
// skipping a necessary translation. Without that translation, the coordinate
// space of the layer's draw transform is incorrect.
@@ -1487,7 +1499,7 @@ TEST(LayerTreeHostCommonTest, TransformsForDegenerateIntermediateLayer) {
grand_child->draw_transform());
}
-TEST(LayerTreeHostCommonTest, TransformAboveRootLayer) {
+TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
// Transformations applied at the root of the tree should be forwarded
// to child layers instead of applied to the root RenderSurface.
const gfx::Transform identity_matrix;
@@ -1511,138 +1523,168 @@ TEST(LayerTreeHostCommonTest, TransformAboveRootLayer) {
gfx::Size(20, 20),
false);
- LayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
gfx::Transform translate;
translate.Translate(50, 50);
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- translate,
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
- EXPECT_EQ(translate, root->draw_properties().target_space_transform);
- EXPECT_EQ(translate, child->draw_properties().target_space_transform);
- EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ translate,
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+ EXPECT_EQ(translate, root->draw_properties().target_space_transform);
+ EXPECT_EQ(translate, child->draw_properties().target_space_transform);
+ EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+ }
gfx::Transform scale;
scale.Scale(2, 2);
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- scale,
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
- EXPECT_EQ(scale, root->draw_properties().target_space_transform);
- EXPECT_EQ(scale, child->draw_properties().target_space_transform);
- EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ scale,
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+ EXPECT_EQ(scale, root->draw_properties().target_space_transform);
+ EXPECT_EQ(scale, child->draw_properties().target_space_transform);
+ EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+ }
gfx::Transform rotate;
rotate.Rotate(2);
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- rotate,
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
- EXPECT_EQ(rotate, root->draw_properties().target_space_transform);
- EXPECT_EQ(rotate, child->draw_properties().target_space_transform);
- EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ rotate,
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+ EXPECT_EQ(rotate, root->draw_properties().target_space_transform);
+ EXPECT_EQ(rotate, child->draw_properties().target_space_transform);
+ EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+ }
gfx::Transform composite;
composite.ConcatTransform(translate);
composite.ConcatTransform(scale);
composite.ConcatTransform(rotate);
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- composite,
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
- EXPECT_EQ(composite, root->draw_properties().target_space_transform);
- EXPECT_EQ(composite, child->draw_properties().target_space_transform);
- EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ composite,
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+ EXPECT_EQ(composite, root->draw_properties().target_space_transform);
+ EXPECT_EQ(composite, child->draw_properties().target_space_transform);
+ EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+ }
// Verify it composes correctly with device scale.
float device_scale_factor = 1.5f;
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- translate,
- device_scale_factor,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
- gfx::Transform device_scaled_translate = translate;
- device_scaled_translate.Scale(device_scale_factor, device_scale_factor);
- EXPECT_EQ(device_scaled_translate,
- root->draw_properties().target_space_transform);
- EXPECT_EQ(device_scaled_translate,
- child->draw_properties().target_space_transform);
- EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ translate,
+ device_scale_factor,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+ gfx::Transform device_scaled_translate = translate;
+ device_scaled_translate.Scale(device_scale_factor, device_scale_factor);
+ EXPECT_EQ(device_scaled_translate,
+ root->draw_properties().target_space_transform);
+ EXPECT_EQ(device_scaled_translate,
+ child->draw_properties().target_space_transform);
+ EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+ }
// Verify it composes correctly with page scale.
float page_scale_factor = 2.f;
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- translate,
- 1.f,
- page_scale_factor,
- root.get(),
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
- gfx::Transform page_scaled_translate = translate;
- page_scaled_translate.Scale(page_scale_factor, page_scale_factor);
- EXPECT_EQ(translate, root->draw_properties().target_space_transform);
- EXPECT_EQ(page_scaled_translate,
- child->draw_properties().target_space_transform);
- EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ translate,
+ 1.f,
+ page_scale_factor,
+ root.get(),
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+ gfx::Transform page_scaled_translate = translate;
+ page_scaled_translate.Scale(page_scale_factor, page_scale_factor);
+ EXPECT_EQ(translate, root->draw_properties().target_space_transform);
+ EXPECT_EQ(page_scaled_translate,
+ child->draw_properties().target_space_transform);
+ EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+ }
// Verify that it composes correctly with transforms directly on root layer.
root->SetTransform(composite);
root->SetSublayerTransform(composite);
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- composite,
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
- gfx::Transform compositeSquared = composite;
- compositeSquared.ConcatTransform(composite);
- gfx::Transform compositeCubed = compositeSquared;
- compositeCubed.ConcatTransform(composite);
- EXPECT_EQ(compositeSquared, root->draw_properties().target_space_transform);
- EXPECT_EQ(compositeCubed, child->draw_properties().target_space_transform);
- EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ composite,
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+ gfx::Transform compositeSquared = composite;
+ compositeSquared.ConcatTransform(composite);
+ gfx::Transform compositeCubed = compositeSquared;
+ compositeCubed.ConcatTransform(composite);
+ EXPECT_EQ(compositeSquared, root->draw_properties().target_space_transform);
+ EXPECT_EQ(compositeCubed, child->draw_properties().target_space_transform);
+ EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
+ }
}
-TEST(LayerTreeHostCommonTest,
- RenderSurfaceListForRenderSurfaceWithClippedLayer) {
+TEST_F(LayerTreeHostCommonTest,
+ RenderSurfaceListForRenderSurfaceWithClippedLayer) {
scoped_refptr<Layer> parent = Layer::Create();
scoped_refptr<Layer> render_surface1 = Layer::Create();
scoped_refptr<LayerWithForcedDrawsContent> child =
@@ -1676,7 +1718,7 @@ TEST(LayerTreeHostCommonTest,
render_surface1->AddChild(child);
render_surface1->SetForceRenderSurface(true);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
parent->bounds(),
@@ -1699,7 +1741,7 @@ TEST(LayerTreeHostCommonTest,
EXPECT_EQ(1U, render_surface_layer_list.size());
}
-TEST(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
+TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
scoped_refptr<Layer> parent = Layer::Create();
scoped_refptr<Layer> render_surface1 = Layer::Create();
scoped_refptr<LayerWithForcedDrawsContent> child =
@@ -1726,7 +1768,7 @@ TEST(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
render_surface1->SetForceRenderSurface(true);
render_surface1->SetOpacity(0.f);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
parent->bounds(),
@@ -1745,11 +1787,11 @@ TEST(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
ASSERT_TRUE(parent->render_surface());
EXPECT_EQ(0U, parent->render_surface()->layer_list().size());
EXPECT_EQ(1U, render_surface_layer_list.size());
- EXPECT_EQ(parent->id(), render_surface_layer_list[0]->id());
+ EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
EXPECT_EQ(gfx::Rect(), parent->drawable_content_rect());
}
-TEST(LayerTreeHostCommonTest, ForceRenderSurface) {
+TEST_F(LayerTreeHostCommonTest, ForceRenderSurface) {
scoped_refptr<Layer> parent = Layer::Create();
scoped_refptr<Layer> render_surface1 = Layer::Create();
scoped_refptr<LayerWithForcedDrawsContent> child =
@@ -1786,42 +1828,48 @@ TEST(LayerTreeHostCommonTest, ForceRenderSurface) {
EXPECT_FALSE(parent->render_surface());
EXPECT_FALSE(render_surface1->render_surface());
- LayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
- LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
- parent->bounds(),
- gfx::Transform(),
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- // The root layer always creates a render surface
- EXPECT_TRUE(parent->render_surface());
- EXPECT_TRUE(render_surface1->render_surface());
- EXPECT_EQ(2U, render_surface_layer_list.size());
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ parent.get(),
+ parent->bounds(),
+ gfx::Transform(),
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ // The root layer always creates a render surface
+ EXPECT_TRUE(parent->render_surface());
+ EXPECT_TRUE(render_surface1->render_surface());
+ EXPECT_EQ(2U, render_surface_layer_list.size());
+ }
- render_surface_layer_list.clear();
- render_surface1->SetForceRenderSurface(false);
- LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
- parent->bounds(),
- gfx::Transform(),
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
- EXPECT_TRUE(parent->render_surface());
- EXPECT_FALSE(render_surface1->render_surface());
- EXPECT_EQ(1U, render_surface_layer_list.size());
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ render_surface1->SetForceRenderSurface(false);
+ LayerTreeHostCommon::CalculateDrawProperties(
+ parent.get(),
+ parent->bounds(),
+ gfx::Transform(),
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+ EXPECT_TRUE(parent->render_surface());
+ EXPECT_FALSE(render_surface1->render_surface());
+ EXPECT_EQ(1U, render_surface_layer_list.size());
+ }
}
-TEST(LayerTreeHostCommonTest, ClipRectCullsRenderSurfaces) {
+TEST_F(LayerTreeHostCommonTest, ClipRectCullsRenderSurfaces) {
// The entire subtree of layers that are outside the clip rect should be
// culled away, and should not affect the render_surface_layer_list.
//
@@ -1906,7 +1954,7 @@ TEST(LayerTreeHostCommonTest, ClipRectCullsRenderSurfaces) {
grand_child->SetOpacity(0.5f);
great_grand_child->SetOpacity(0.4f);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
parent->bounds(),
@@ -1920,11 +1968,11 @@ TEST(LayerTreeHostCommonTest, ClipRectCullsRenderSurfaces) {
&render_surface_layer_list);
ASSERT_EQ(2U, render_surface_layer_list.size());
- EXPECT_EQ(parent->id(), render_surface_layer_list[0]->id());
- EXPECT_EQ(child->id(), render_surface_layer_list[1]->id());
+ EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
+ EXPECT_EQ(child->id(), render_surface_layer_list.at(1)->id());
}
-TEST(LayerTreeHostCommonTest, ClipRectCullsSurfaceWithoutVisibleContent) {
+TEST_F(LayerTreeHostCommonTest, ClipRectCullsSurfaceWithoutVisibleContent) {
// When a render surface has a clip rect, it is used to clip the content rect
// of the surface. When the render surface is animating its transforms, then
// the content rect's position in the clip rect is not defined on the main
@@ -1988,53 +2036,56 @@ TEST(LayerTreeHostCommonTest, ClipRectCullsSurfaceWithoutVisibleContent) {
grand_child->SetOpacity(0.4f);
grand_child->SetForceRenderSurface(true);
- LayerList render_surface_layer_list;
- int dummy_max_texture_size = 512;
- LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
- parent->bounds(),
- gfx::Transform(),
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- // Without an animation, we should cull child and grand_child from the
- // render_surface_layer_list.
- ASSERT_EQ(1U, render_surface_layer_list.size());
- EXPECT_EQ(parent->id(), render_surface_layer_list[0]->id());
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ int dummy_max_texture_size = 512;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ parent.get(),
+ parent->bounds(),
+ gfx::Transform(),
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ // Without an animation, we should cull child and grand_child from the
+ // render_surface_layer_list.
+ ASSERT_EQ(1U, render_surface_layer_list.size());
+ EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
+ }
// Now put an animating transform on child.
AddAnimatedTransformToController(
child->layer_animation_controller(), 10.0, 30, 0);
- parent->ClearRenderSurface();
- child->ClearRenderSurface();
- grand_child->ClearRenderSurface();
- render_surface_layer_list.clear();
-
- LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
- parent->bounds(),
- gfx::Transform(),
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- // With an animating transform, we should keep child and grand_child in the
- // render_surface_layer_list.
- ASSERT_EQ(3U, render_surface_layer_list.size());
- EXPECT_EQ(parent->id(), render_surface_layer_list[0]->id());
- EXPECT_EQ(child->id(), render_surface_layer_list[1]->id());
- EXPECT_EQ(grand_child->id(), render_surface_layer_list[2]->id());
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ int dummy_max_texture_size = 512;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ parent.get(),
+ parent->bounds(),
+ gfx::Transform(),
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ // With an animating transform, we should keep child and grand_child in the
+ // render_surface_layer_list.
+ ASSERT_EQ(3U, render_surface_layer_list.size());
+ EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
+ EXPECT_EQ(child->id(), render_surface_layer_list.at(1)->id());
+ EXPECT_EQ(grand_child->id(), render_surface_layer_list.at(2)->id());
+ }
}
-TEST(LayerTreeHostCommonTest, IsClippedIsSetCorrectly) {
+TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectly) {
// Layer's IsClipped() property is set to true when:
// - the layer clips its subtree, e.g. masks to bounds,
// - the layer is clipped by an ancestor that contributes to the same
@@ -2117,94 +2168,104 @@ TEST(LayerTreeHostCommonTest, IsClippedIsSetCorrectly) {
gfx::Size(100, 100),
false);
- // Case 1: nothing is clipped except the root render surface.
- LayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- parent->bounds(),
- gfx::Transform(),
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- ASSERT_TRUE(root->render_surface());
- ASSERT_TRUE(child2->render_surface());
- EXPECT_FALSE(root->is_clipped());
- EXPECT_TRUE(root->render_surface()->is_clipped());
- EXPECT_FALSE(parent->is_clipped());
- EXPECT_FALSE(child1->is_clipped());
- EXPECT_FALSE(child2->is_clipped());
- EXPECT_FALSE(child2->render_surface()->is_clipped());
- EXPECT_FALSE(grand_child->is_clipped());
- EXPECT_FALSE(leaf_node1->is_clipped());
- EXPECT_FALSE(leaf_node2->is_clipped());
+ // Case 1: nothing is clipped except the root render surface.
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ parent->bounds(),
+ gfx::Transform(),
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ ASSERT_TRUE(root->render_surface());
+ ASSERT_TRUE(child2->render_surface());
+
+ EXPECT_FALSE(root->is_clipped());
+ EXPECT_TRUE(root->render_surface()->is_clipped());
+ EXPECT_FALSE(parent->is_clipped());
+ EXPECT_FALSE(child1->is_clipped());
+ EXPECT_FALSE(child2->is_clipped());
+ EXPECT_FALSE(child2->render_surface()->is_clipped());
+ EXPECT_FALSE(grand_child->is_clipped());
+ EXPECT_FALSE(leaf_node1->is_clipped());
+ EXPECT_FALSE(leaf_node2->is_clipped());
+ }
// Case 2: parent masksToBounds, so the parent, child1, and child2's
// surface are clipped. But layers that contribute to child2's surface are
// not clipped explicitly because child2's surface already accounts for
// that clip.
- render_surface_layer_list.clear();
- parent->SetMasksToBounds(true);
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- parent->bounds(),
- gfx::Transform(),
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- ASSERT_TRUE(root->render_surface());
- ASSERT_TRUE(child2->render_surface());
-
- EXPECT_FALSE(root->is_clipped());
- EXPECT_TRUE(root->render_surface()->is_clipped());
- EXPECT_TRUE(parent->is_clipped());
- EXPECT_TRUE(child1->is_clipped());
- EXPECT_FALSE(child2->is_clipped());
- EXPECT_TRUE(child2->render_surface()->is_clipped());
- EXPECT_TRUE(grand_child->is_clipped());
- EXPECT_TRUE(leaf_node1->is_clipped());
- EXPECT_FALSE(leaf_node2->is_clipped());
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ parent->SetMasksToBounds(true);
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ parent->bounds(),
+ gfx::Transform(),
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ ASSERT_TRUE(root->render_surface());
+ ASSERT_TRUE(child2->render_surface());
+
+ EXPECT_FALSE(root->is_clipped());
+ EXPECT_TRUE(root->render_surface()->is_clipped());
+ EXPECT_TRUE(parent->is_clipped());
+ EXPECT_TRUE(child1->is_clipped());
+ EXPECT_FALSE(child2->is_clipped());
+ EXPECT_TRUE(child2->render_surface()->is_clipped());
+ EXPECT_TRUE(grand_child->is_clipped());
+ EXPECT_TRUE(leaf_node1->is_clipped());
+ EXPECT_FALSE(leaf_node2->is_clipped());
+ }
// Case 3: child2 masksToBounds. The layer and subtree are clipped, and
// child2's render surface is not clipped.
- render_surface_layer_list.clear();
- parent->SetMasksToBounds(false);
- child2->SetMasksToBounds(true);
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- parent->bounds(),
- gfx::Transform(),
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- ASSERT_TRUE(root->render_surface());
- ASSERT_TRUE(child2->render_surface());
-
- EXPECT_FALSE(root->is_clipped());
- EXPECT_TRUE(root->render_surface()->is_clipped());
- EXPECT_FALSE(parent->is_clipped());
- EXPECT_FALSE(child1->is_clipped());
- EXPECT_TRUE(child2->is_clipped());
- EXPECT_FALSE(child2->render_surface()->is_clipped());
- EXPECT_FALSE(grand_child->is_clipped());
- EXPECT_FALSE(leaf_node1->is_clipped());
- EXPECT_TRUE(leaf_node2->is_clipped());
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ parent->SetMasksToBounds(false);
+ child2->SetMasksToBounds(true);
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ parent->bounds(),
+ gfx::Transform(),
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ ASSERT_TRUE(root->render_surface());
+ ASSERT_TRUE(child2->render_surface());
+
+ EXPECT_FALSE(root->is_clipped());
+ EXPECT_TRUE(root->render_surface()->is_clipped());
+ EXPECT_FALSE(parent->is_clipped());
+ EXPECT_FALSE(child1->is_clipped());
+ EXPECT_TRUE(child2->is_clipped());
+ EXPECT_FALSE(child2->render_surface()->is_clipped());
+ EXPECT_FALSE(grand_child->is_clipped());
+ EXPECT_FALSE(leaf_node1->is_clipped());
+ EXPECT_TRUE(leaf_node2->is_clipped());
+ }
}
-TEST(LayerTreeHostCommonTest, drawable_content_rectForLayers) {
+TEST_F(LayerTreeHostCommonTest, drawable_content_rectForLayers) {
// Verify that layers get the appropriate DrawableContentRect when their
// parent masksToBounds is true.
//
@@ -2286,7 +2347,7 @@ TEST(LayerTreeHostCommonTest, drawable_content_rectForLayers) {
grand_child3->SetOpacity(0.5f);
grand_child4->SetOpacity(0.5f);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
parent->bounds(),
@@ -2308,7 +2369,7 @@ TEST(LayerTreeHostCommonTest, drawable_content_rectForLayers) {
EXPECT_TRUE(grand_child4->drawable_content_rect().IsEmpty());
}
-TEST(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
+TEST_F(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
// Verify that render surfaces (and their layers) get the appropriate
// clip rects when their parent masksToBounds is true.
//
@@ -2432,7 +2493,7 @@ TEST(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
grand_child4->SetOpacity(0.5f);
grand_child4->SetForceRenderSurface(true);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
parent->bounds(),
@@ -2462,7 +2523,7 @@ TEST(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
grand_child3->render_surface()->clip_rect());
}
-TEST(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) {
+TEST_F(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) {
scoped_refptr<Layer> parent = Layer::Create();
scoped_refptr<Layer> render_surface1 = Layer::Create();
scoped_refptr<Layer> render_surface2 = Layer::Create();
@@ -2675,7 +2736,7 @@ TEST(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) {
grand_child_of_rs2->screen_space_transform().matrix().getDouble(1, 3));
}
-TEST(LayerTreeHostCommonTest, VisibleRectForIdentityTransform) {
+TEST_F(LayerTreeHostCommonTest, VisibleRectForIdentityTransform) {
// Test the calculateVisibleRect() function works correctly for identity
// transforms.
@@ -2683,8 +2744,7 @@ TEST(LayerTreeHostCommonTest, VisibleRectForIdentityTransform) {
gfx::Transform layer_to_surface_transform;
// Case 1: Layer is contained within the surface.
- gfx::Rect layer_content_rect =
- gfx::Rect(10, 10, 30, 30);
+ gfx::Rect layer_content_rect = gfx::Rect(10, 10, 30, 30);
gfx::Rect expected = gfx::Rect(10, 10, 30, 30);
gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
target_surface_rect, layer_content_rect, layer_to_surface_transform);
@@ -2704,7 +2764,7 @@ TEST(LayerTreeHostCommonTest, VisibleRectForIdentityTransform) {
EXPECT_RECT_EQ(expected, actual);
}
-TEST(LayerTreeHostCommonTest, VisibleRectForTranslations) {
+TEST_F(LayerTreeHostCommonTest, VisibleRectForTranslations) {
// Test the calculateVisibleRect() function works correctly for scaling
// transforms.
@@ -2736,7 +2796,7 @@ TEST(LayerTreeHostCommonTest, VisibleRectForTranslations) {
EXPECT_RECT_EQ(expected, actual);
}
-TEST(LayerTreeHostCommonTest, VisibleRectFor2DRotations) {
+TEST_F(LayerTreeHostCommonTest, VisibleRectFor2DRotations) {
// Test the calculateVisibleRect() function works correctly for rotations
// about z-axis (i.e. 2D rotations). Remember that calculateVisibleRect()
// should return the g in the layer's space.
@@ -2788,7 +2848,7 @@ TEST(LayerTreeHostCommonTest, VisibleRectFor2DRotations) {
EXPECT_RECT_EQ(expected, actual);
}
-TEST(LayerTreeHostCommonTest, VisibleRectFor3dOrthographicTransform) {
+TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dOrthographicTransform) {
// Test that the calculateVisibleRect() function works correctly for 3d
// transforms.
@@ -2812,15 +2872,15 @@ TEST(LayerTreeHostCommonTest, VisibleRectFor3dOrthographicTransform) {
double half_width_of_rotated_layer = (100.0 / sqrt(2.0)) * 0.5;
layer_to_surface_transform.MakeIdentity();
layer_to_surface_transform.Translate(-half_width_of_rotated_layer, 0.0);
- layer_to_surface_transform.RotateAboutYAxis(
- 45.0); // Rotates about the left edge of the layer.
+ layer_to_surface_transform.RotateAboutYAxis(45.0); // Rotates about the left
+ // edge of the layer.
expected = gfx::Rect(50, 0, 50, 100); // Tight half of the layer.
actual = LayerTreeHostCommon::CalculateVisibleRect(
target_surface_rect, layer_content_rect, layer_to_surface_transform);
EXPECT_RECT_EQ(expected, actual);
}
-TEST(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveTransform) {
+TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveTransform) {
// Test the calculateVisibleRect() function works correctly when the layer has
// a perspective projection onto the target surface.
@@ -2857,16 +2917,16 @@ TEST(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveTransform) {
// only half of it is visible), then we would need to translate by (-36 / 9) *
// -50 == -200 in the layer's units.
layer_to_surface_transform.Translate3d(-200.0, 0.0, 0.0);
- expected = gfx::Rect(
- gfx::Point(50, -50),
- gfx::Size(100, 200)); // The right half of the layer's bounding rect.
+ expected = gfx::Rect(gfx::Point(50, -50),
+ gfx::Size(100, 200)); // The right half of the layer's
+ // bounding rect.
actual = LayerTreeHostCommon::CalculateVisibleRect(
target_surface_rect, layer_content_rect, layer_to_surface_transform);
EXPECT_RECT_EQ(expected, actual);
}
-TEST(LayerTreeHostCommonTest,
- VisibleRectFor3dOrthographicIsNotClippedBehindSurface) {
+TEST_F(LayerTreeHostCommonTest,
+ VisibleRectFor3dOrthographicIsNotClippedBehindSurface) {
// There is currently no explicit concept of an orthographic projection plane
// in our code (nor in the CSS spec to my knowledge). Therefore, layers that
// are technically behind the surface in an orthographic world should not be
@@ -2889,7 +2949,7 @@ TEST(LayerTreeHostCommonTest,
EXPECT_RECT_EQ(expected, actual);
}
-TEST(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveWhenClippedByW) {
+TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveWhenClippedByW) {
// Test the calculateVisibleRect() function works correctly when projecting a
// surface onto a layer, but the layer is partially behind the camera (not
// just behind the projection plane). In this case, the cartesian coordinates
@@ -2898,8 +2958,7 @@ TEST(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveWhenClippedByW) {
// converting to cartesian coordinates.
gfx::Rect target_surface_rect = gfx::Rect(-50, -50, 100, 100);
- gfx::Rect layer_content_rect =
- gfx::Rect(-10, -1, 20, 2);
+ gfx::Rect layer_content_rect = gfx::Rect(-10, -1, 20, 2);
gfx::Transform layer_to_surface_transform;
// The layer is positioned so that the right half of the layer should be in
@@ -2927,7 +2986,7 @@ TEST(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveWhenClippedByW) {
EXPECT_EQ(expected_width, actual.width());
}
-TEST(LayerTreeHostCommonTest, VisibleRectForPerspectiveUnprojection) {
+TEST_F(LayerTreeHostCommonTest, VisibleRectForPerspectiveUnprojection) {
// To determine visible rect in layer space, there needs to be an
// un-projection from surface space to layer space. When the original
// transform was a perspective projection that was clipped, it returns a rect
@@ -2936,10 +2995,8 @@ TEST(LayerTreeHostCommonTest, VisibleRectForPerspectiveUnprojection) {
// This sequence of transforms causes one corner of the layer to protrude
// across the w = 0 plane, and should be clipped.
- gfx::Rect target_surface_rect =
- gfx::Rect(-50, -50, 100, 100);
- gfx::Rect layer_content_rect =
- gfx::Rect(-10, -10, 20, 20);
+ gfx::Rect target_surface_rect = gfx::Rect(-50, -50, 100, 100);
+ gfx::Rect layer_content_rect = gfx::Rect(-10, -10, 20, 20);
gfx::Transform layer_to_surface_transform;
layer_to_surface_transform.MakeIdentity();
layer_to_surface_transform.ApplyPerspectiveDepth(1.0);
@@ -2965,7 +3022,7 @@ TEST(LayerTreeHostCommonTest, VisibleRectForPerspectiveUnprojection) {
EXPECT_RECT_EQ(expected, actual);
}
-TEST(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsForSimpleLayers) {
+TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsForSimpleLayers) {
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<LayerWithForcedDrawsContent> child1 =
make_scoped_refptr(new LayerWithForcedDrawsContent());
@@ -3027,8 +3084,8 @@ TEST(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsForSimpleLayers) {
EXPECT_RECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
}
-TEST(LayerTreeHostCommonTest,
- DrawableAndVisibleContentRectsForLayersClippedByLayer) {
+TEST_F(LayerTreeHostCommonTest,
+ DrawableAndVisibleContentRectsForLayersClippedByLayer) {
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<Layer> child = Layer::Create();
scoped_refptr<LayerWithForcedDrawsContent> grand_child1 =
@@ -3105,8 +3162,8 @@ TEST(LayerTreeHostCommonTest,
EXPECT_TRUE(grand_child3->drawable_content_rect().IsEmpty());
}
-TEST(LayerTreeHostCommonTest,
- DrawableAndVisibleContentRectsForLayersInUnclippedRenderSurface) {
+TEST_F(LayerTreeHostCommonTest,
+ DrawableAndVisibleContentRectsForLayersInUnclippedRenderSurface) {
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<Layer> render_surface1 = Layer::Create();
scoped_refptr<LayerWithForcedDrawsContent> child1 =
@@ -3186,8 +3243,8 @@ TEST(LayerTreeHostCommonTest,
EXPECT_RECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
}
-TEST(LayerTreeHostCommonTest,
- DrawableAndVisibleContentRectsForLayersWithUninvertibleTransform) {
+TEST_F(LayerTreeHostCommonTest,
+ DrawableAndVisibleContentRectsForLayersWithUninvertibleTransform) {
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<LayerWithForcedDrawsContent> child =
make_scoped_refptr(new LayerWithForcedDrawsContent());
@@ -3217,8 +3274,8 @@ TEST(LayerTreeHostCommonTest,
EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
}
-TEST(LayerTreeHostCommonTest,
- DrawableAndVisibleContentRectsForLayersInClippedRenderSurface) {
+TEST_F(LayerTreeHostCommonTest,
+ DrawableAndVisibleContentRectsForLayersInClippedRenderSurface) {
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<Layer> render_surface1 = Layer::Create();
scoped_refptr<LayerWithForcedDrawsContent> child1 =
@@ -3301,8 +3358,8 @@ TEST(LayerTreeHostCommonTest,
EXPECT_RECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
}
-TEST(LayerTreeHostCommonTest,
- DrawableAndVisibleContentRectsForSurfaceHierarchy) {
+TEST_F(LayerTreeHostCommonTest,
+ DrawableAndVisibleContentRectsForSurfaceHierarchy) {
// Check that clipping does not propagate down surfaces.
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<Layer> render_surface1 = Layer::Create();
@@ -3404,8 +3461,8 @@ TEST(LayerTreeHostCommonTest,
EXPECT_RECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
}
-TEST(LayerTreeHostCommonTest,
- DrawableAndVisibleContentRectsWithTransformOnUnclippedSurface) {
+TEST_F(LayerTreeHostCommonTest,
+ DrawableAndVisibleContentRectsWithTransformOnUnclippedSurface) {
// Layers that have non-axis aligned bounds (due to transforms) have an
// expanded, axis-aligned DrawableContentRect and visible content rect.
@@ -3472,8 +3529,8 @@ TEST(LayerTreeHostCommonTest,
child1->drawable_content_rect());
}
-TEST(LayerTreeHostCommonTest,
- DrawableAndVisibleContentRectsWithTransformOnClippedSurface) {
+TEST_F(LayerTreeHostCommonTest,
+ DrawableAndVisibleContentRectsWithTransformOnClippedSurface) {
// Layers that have non-axis aligned bounds (due to transforms) have an
// expanded, axis-aligned DrawableContentRect and visible content rect.
@@ -3536,7 +3593,7 @@ TEST(LayerTreeHostCommonTest,
EXPECT_RECT_EQ(unclipped_surface_content, child1->drawable_content_rect());
}
-TEST(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsInHighDPI) {
+TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsInHighDPI) {
MockContentLayerClient client;
scoped_refptr<Layer> root = Layer::Create();
@@ -3640,7 +3697,7 @@ TEST(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsInHighDPI) {
EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), child3->visible_content_rect());
}
-TEST(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
+TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
// Verify the behavior of back-face culling when there are no preserve-3d
// layers. Note that 3d transforms still apply in this case, but they are
// "flattened" to each parent layer according to current W3C spec.
@@ -3656,17 +3713,17 @@ TEST(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
scoped_refptr<LayerWithForcedDrawsContent> back_facing_surface =
make_scoped_refptr(new LayerWithForcedDrawsContent());
scoped_refptr<LayerWithForcedDrawsContent>
- front_facing_child_of_front_facing_surface =
- make_scoped_refptr(new LayerWithForcedDrawsContent());
+ front_facing_child_of_front_facing_surface =
+ make_scoped_refptr(new LayerWithForcedDrawsContent());
scoped_refptr<LayerWithForcedDrawsContent>
- back_facing_child_of_front_facing_surface =
- make_scoped_refptr(new LayerWithForcedDrawsContent());
+ back_facing_child_of_front_facing_surface =
+ make_scoped_refptr(new LayerWithForcedDrawsContent());
scoped_refptr<LayerWithForcedDrawsContent>
- front_facing_child_of_back_facing_surface =
- make_scoped_refptr(new LayerWithForcedDrawsContent());
+ front_facing_child_of_back_facing_surface =
+ make_scoped_refptr(new LayerWithForcedDrawsContent());
scoped_refptr<LayerWithForcedDrawsContent>
- back_facing_child_of_back_facing_surface =
- make_scoped_refptr(new LayerWithForcedDrawsContent());
+ back_facing_child_of_back_facing_surface =
+ make_scoped_refptr(new LayerWithForcedDrawsContent());
parent->AddChild(front_facing_child);
parent->AddChild(back_facing_child);
@@ -3763,7 +3820,7 @@ TEST(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
gfx::Size(100, 100),
false);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
parent->bounds(),
@@ -3788,45 +3845,48 @@ TEST(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
// Verify the render_surface_layer_list.
ASSERT_EQ(3u, render_surface_layer_list.size());
- EXPECT_EQ(parent->id(), render_surface_layer_list[0]->id());
- EXPECT_EQ(front_facing_surface->id(), render_surface_layer_list[1]->id());
+ EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
+ EXPECT_EQ(front_facing_surface->id(), render_surface_layer_list.at(1)->id());
// Even though the back facing surface LAYER gets culled, the other
// descendants should still be added, so the SURFACE should not be culled.
- EXPECT_EQ(back_facing_surface->id(), render_surface_layer_list[2]->id());
+ EXPECT_EQ(back_facing_surface->id(), render_surface_layer_list.at(2)->id());
// Verify root surface's layer list.
ASSERT_EQ(
- 3u, render_surface_layer_list[0]->render_surface()->layer_list().size());
- EXPECT_EQ(
- front_facing_child->id(),
- render_surface_layer_list[0]->render_surface()->layer_list()[0]->id());
- EXPECT_EQ(
- front_facing_surface->id(),
- render_surface_layer_list[0]->render_surface()->layer_list()[1]->id());
- EXPECT_EQ(
- back_facing_surface->id(),
- render_surface_layer_list[0]->render_surface()->layer_list()[2]->id());
+ 3u,
+ render_surface_layer_list.at(0)->render_surface()->layer_list().size());
+ EXPECT_EQ(front_facing_child->id(),
+ render_surface_layer_list.at(0)
+ ->render_surface()->layer_list().at(0)->id());
+ EXPECT_EQ(front_facing_surface->id(),
+ render_surface_layer_list.at(0)
+ ->render_surface()->layer_list().at(1)->id());
+ EXPECT_EQ(back_facing_surface->id(),
+ render_surface_layer_list.at(0)
+ ->render_surface()->layer_list().at(2)->id());
// Verify front_facing_surface's layer list.
ASSERT_EQ(
- 2u, render_surface_layer_list[1]->render_surface()->layer_list().size());
- EXPECT_EQ(
- front_facing_surface->id(),
- render_surface_layer_list[1]->render_surface()->layer_list()[0]->id());
- EXPECT_EQ(
- front_facing_child_of_front_facing_surface->id(),
- render_surface_layer_list[1]->render_surface()->layer_list()[1]->id());
+ 2u,
+ render_surface_layer_list.at(1)->render_surface()->layer_list().size());
+ EXPECT_EQ(front_facing_surface->id(),
+ render_surface_layer_list.at(1)
+ ->render_surface()->layer_list().at(0)->id());
+ EXPECT_EQ(front_facing_child_of_front_facing_surface->id(),
+ render_surface_layer_list.at(1)
+ ->render_surface()->layer_list().at(1)->id());
// Verify back_facing_surface's layer list; its own layer should be culled
// from the surface list.
ASSERT_EQ(
- 1u, render_surface_layer_list[2]->render_surface()->layer_list().size());
- EXPECT_EQ(
- front_facing_child_of_back_facing_surface->id(),
- render_surface_layer_list[2]->render_surface()->layer_list()[0]->id());
+ 1u,
+ render_surface_layer_list.at(2)->render_surface()->layer_list().size());
+ EXPECT_EQ(front_facing_child_of_back_facing_surface->id(),
+ render_surface_layer_list.at(2)
+ ->render_surface()->layer_list().at(0)->id());
}
-TEST(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
+TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
// Verify the behavior of back-face culling when preserves-3d transform style
// is used.
@@ -3958,7 +4018,7 @@ TEST(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
gfx::Size(100, 100),
false);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
parent->bounds(),
@@ -3984,31 +4044,33 @@ TEST(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
// Verify the render_surface_layer_list. The back-facing surface should be
// culled.
ASSERT_EQ(2u, render_surface_layer_list.size());
- EXPECT_EQ(parent->id(), render_surface_layer_list[0]->id());
- EXPECT_EQ(front_facing_surface->id(), render_surface_layer_list[1]->id());
+ EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
+ EXPECT_EQ(front_facing_surface->id(), render_surface_layer_list.at(1)->id());
// Verify root surface's layer list.
ASSERT_EQ(
- 2u, render_surface_layer_list[0]->render_surface()->layer_list().size());
- EXPECT_EQ(
- front_facing_child->id(),
- render_surface_layer_list[0]->render_surface()->layer_list()[0]->id());
- EXPECT_EQ(
- front_facing_surface->id(),
- render_surface_layer_list[0]->render_surface()->layer_list()[1]->id());
+ 2u,
+ render_surface_layer_list.at(0)->render_surface()->layer_list().size());
+ EXPECT_EQ(front_facing_child->id(),
+ render_surface_layer_list.at(0)
+ ->render_surface()->layer_list().at(0)->id());
+ EXPECT_EQ(front_facing_surface->id(),
+ render_surface_layer_list.at(0)
+ ->render_surface()->layer_list().at(1)->id());
// Verify front_facing_surface's layer list.
ASSERT_EQ(
- 2u, render_surface_layer_list[1]->render_surface()->layer_list().size());
- EXPECT_EQ(
- front_facing_surface->id(),
- render_surface_layer_list[1]->render_surface()->layer_list()[0]->id());
- EXPECT_EQ(
- front_facing_child_of_front_facing_surface->id(),
- render_surface_layer_list[1]->render_surface()->layer_list()[1]->id());
+ 2u,
+ render_surface_layer_list.at(1)->render_surface()->layer_list().size());
+ EXPECT_EQ(front_facing_surface->id(),
+ render_surface_layer_list.at(1)
+ ->render_surface()->layer_list().at(0)->id());
+ EXPECT_EQ(front_facing_child_of_front_facing_surface->id(),
+ render_surface_layer_list.at(1)
+ ->render_surface()->layer_list().at(1)->id());
}
-TEST(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
+TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
// Verify that layers are appropriately culled when their back face is showing
// and they are not double sided, while animations are going on.
//
@@ -4099,7 +4161,7 @@ TEST(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
gfx::Size(100, 100),
false);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
parent->bounds(),
@@ -4121,31 +4183,33 @@ TEST(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
// Verify that the animating_child and child_of_animating_surface were not
// culled, but that child was.
ASSERT_EQ(2u, render_surface_layer_list.size());
- EXPECT_EQ(parent->id(), render_surface_layer_list[0]->id());
- EXPECT_EQ(animating_surface->id(), render_surface_layer_list[1]->id());
+ EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
+ EXPECT_EQ(animating_surface->id(), render_surface_layer_list.at(1)->id());
// The non-animating child be culled from the layer list for the parent render
// surface.
ASSERT_EQ(
- 3u, render_surface_layer_list[0]->render_surface()->layer_list().size());
- EXPECT_EQ(
- animating_surface->id(),
- render_surface_layer_list[0]->render_surface()->layer_list()[0]->id());
- EXPECT_EQ(
- animating_child->id(),
- render_surface_layer_list[0]->render_surface()->layer_list()[1]->id());
- EXPECT_EQ(
- child2->id(),
- render_surface_layer_list[0]->render_surface()->layer_list()[2]->id());
+ 3u,
+ render_surface_layer_list.at(0)->render_surface()->layer_list().size());
+ EXPECT_EQ(animating_surface->id(),
+ render_surface_layer_list.at(0)
+ ->render_surface()->layer_list().at(0)->id());
+ EXPECT_EQ(animating_child->id(),
+ render_surface_layer_list.at(0)
+ ->render_surface()->layer_list().at(1)->id());
+ EXPECT_EQ(child2->id(),
+ render_surface_layer_list.at(0)
+ ->render_surface()->layer_list().at(2)->id());
ASSERT_EQ(
- 2u, render_surface_layer_list[1]->render_surface()->layer_list().size());
- EXPECT_EQ(
- animating_surface->id(),
- render_surface_layer_list[1]->render_surface()->layer_list()[0]->id());
- EXPECT_EQ(
- child_of_animating_surface->id(),
- render_surface_layer_list[1]->render_surface()->layer_list()[1]->id());
+ 2u,
+ render_surface_layer_list.at(1)->render_surface()->layer_list().size());
+ EXPECT_EQ(animating_surface->id(),
+ render_surface_layer_list.at(1)
+ ->render_surface()->layer_list().at(0)->id());
+ EXPECT_EQ(child_of_animating_surface->id(),
+ render_surface_layer_list.at(1)
+ ->render_surface()->layer_list().at(1)->id());
EXPECT_FALSE(child2->visible_content_rect().IsEmpty());
@@ -4157,12 +4221,11 @@ TEST(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
gfx::Rect(animating_surface->content_bounds()));
// And layers in the subtree of the animating layer should have valid visible
// content rects also.
- EXPECT_EQ(
- child_of_animating_surface->visible_content_rect(),
- gfx::Rect(child_of_animating_surface->content_bounds()));
+ EXPECT_EQ(child_of_animating_surface->visible_content_rect(),
+ gfx::Rect(child_of_animating_surface->content_bounds()));
}
-TEST(LayerTreeHostCommonTest,
+TEST_F(LayerTreeHostCommonTest,
BackFaceCullingWithPreserves3dForFlatteningSurface) {
// Verify the behavior of back-face culling for a render surface that is
// created when it flattens its subtree, and its parent has preserves-3d.
@@ -4228,7 +4291,7 @@ TEST(LayerTreeHostCommonTest,
gfx::Size(100, 100),
false);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
parent->bounds(),
@@ -4251,28 +4314,31 @@ TEST(LayerTreeHostCommonTest,
// Verify the render_surface_layer_list. The back-facing surface should be
// culled.
ASSERT_EQ(2u, render_surface_layer_list.size());
- EXPECT_EQ(parent->id(), render_surface_layer_list[0]->id());
- EXPECT_EQ(front_facing_surface->id(), render_surface_layer_list[1]->id());
+ EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
+ EXPECT_EQ(front_facing_surface->id(), render_surface_layer_list.at(1)->id());
// Verify root surface's layer list.
ASSERT_EQ(
- 1u, render_surface_layer_list[0]->render_surface()->layer_list().size());
- EXPECT_EQ(
- front_facing_surface->id(),
- render_surface_layer_list[0]->render_surface()->layer_list()[0]->id());
+ 1u,
+ render_surface_layer_list.at(0)->render_surface()->layer_list().size());
+ EXPECT_EQ(front_facing_surface->id(),
+ render_surface_layer_list.at(0)
+ ->render_surface()->layer_list().at(0)->id());
// Verify front_facing_surface's layer list.
ASSERT_EQ(
- 2u, render_surface_layer_list[1]->render_surface()->layer_list().size());
- EXPECT_EQ(
- front_facing_surface->id(),
- render_surface_layer_list[1]->render_surface()->layer_list()[0]->id());
- EXPECT_EQ(
- child1->id(),
- render_surface_layer_list[1]->render_surface()->layer_list()[1]->id());
+ 2u,
+ render_surface_layer_list.at(1)->render_surface()->layer_list().size());
+ EXPECT_EQ(front_facing_surface->id(),
+ render_surface_layer_list.at(1)
+ ->render_surface()->layer_list().at(0)->id());
+ EXPECT_EQ(child1->id(),
+ render_surface_layer_list.at(1)
+ ->render_surface()->layer_list().at(1)->id());
}
-TEST(LayerTreeHostCommonTest, HitTestingForEmptyLayerList) {
+
+TEST_F(LayerTreeHostCommonTest, HitTestingForEmptyLayerList) {
// Hit testing on an empty render_surface_layer_list should return a null
// pointer.
LayerImplList render_surface_layer_list;
@@ -4288,7 +4354,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForEmptyLayerList) {
EXPECT_FALSE(result_layer);
}
-TEST(LayerTreeHostCommonTest, HitTestingForSingleLayer) {
+TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayer) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
scoped_ptr<LayerImpl> root =
@@ -4349,7 +4415,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSingleLayer) {
EXPECT_EQ(12345, result_layer->id());
}
-TEST(LayerTreeHostCommonTest, HitTestingForSingleLayerAndHud) {
+TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayerAndHud) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
scoped_ptr<LayerImpl> root =
@@ -4427,7 +4493,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSingleLayerAndHud) {
EXPECT_EQ(12345, result_layer->id());
}
-TEST(LayerTreeHostCommonTest, HitTestingForUninvertibleTransform) {
+TEST_F(LayerTreeHostCommonTest, HitTestingForUninvertibleTransform) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
scoped_ptr<LayerImpl> root =
@@ -4510,7 +4576,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForUninvertibleTransform) {
EXPECT_FALSE(result_layer);
}
-TEST(LayerTreeHostCommonTest, HitTestingForSinglePositionedLayer) {
+TEST_F(LayerTreeHostCommonTest, HitTestingForSinglePositionedLayer) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
scoped_ptr<LayerImpl> root =
@@ -4575,7 +4641,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSinglePositionedLayer) {
EXPECT_EQ(12345, result_layer->id());
}
-TEST(LayerTreeHostCommonTest, HitTestingForSingleRotatedLayer) {
+TEST_F(LayerTreeHostCommonTest, HitTestingForSingleRotatedLayer) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
scoped_ptr<LayerImpl> root =
@@ -4648,7 +4714,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSingleRotatedLayer) {
ASSERT_FALSE(result_layer);
}
-TEST(LayerTreeHostCommonTest, HitTestingForSinglePerspectiveLayer) {
+TEST_F(LayerTreeHostCommonTest, HitTestingForSinglePerspectiveLayer) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
scoped_ptr<LayerImpl> root =
@@ -4722,7 +4788,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSinglePerspectiveLayer) {
EXPECT_EQ(12345, result_layer->id());
}
-TEST(LayerTreeHostCommonTest, HitTestingForSingleLayerWithScaledContents) {
+TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayerWithScaledContents) {
// A layer's visible content rect is actually in the layer's content space.
// The screen space transform converts from the layer's origin space to screen
// space. This test makes sure that hit testing works correctly accounts for
@@ -4822,7 +4888,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSingleLayerWithScaledContents) {
EXPECT_EQ(12345, result_layer->id());
}
-TEST(LayerTreeHostCommonTest, HitTestingForSimpleClippedLayer) {
+TEST_F(LayerTreeHostCommonTest, HitTestingForSimpleClippedLayer) {
// Test that hit-testing will only work for the visible portion of a layer,
// and not the entire layer bounds. Here we just test the simple axis-aligned
// case.
@@ -4887,7 +4953,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSimpleClippedLayer) {
// Sanity check the scenario we just created.
ASSERT_EQ(1u, render_surface_layer_list.size());
ASSERT_EQ(1u, root->render_surface()->layer_list().size());
- ASSERT_EQ(456, root->render_surface()->layer_list()[0]->id());
+ ASSERT_EQ(456, root->render_surface()->layer_list().at(0)->id());
// Hit testing for a point outside the layer should return a null pointer.
// Despite the child layer being very large, it should be clipped to the root
@@ -4918,7 +4984,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForSimpleClippedLayer) {
EXPECT_EQ(456, result_layer->id());
}
-TEST(LayerTreeHostCommonTest, HitTestingForMultiClippedRotatedLayer) {
+TEST_F(LayerTreeHostCommonTest, HitTestingForMultiClippedRotatedLayer) {
// This test checks whether hit testing correctly avoids hit testing with
// multiple ancestors that clip in non axis-aligned ways. To pass this test,
// the hit testing algorithm needs to recognize that multiple parent layers
@@ -5021,18 +5087,20 @@ TEST(LayerTreeHostCommonTest, HitTestingForMultiClippedRotatedLayer) {
// Sanity check the scenario we just created.
// The grand_child is expected to create a render surface because it
- // masksToBounds and is not axis aligned.
+ // MasksToBounds and is not axis aligned.
ASSERT_EQ(2u, render_surface_layer_list.size());
ASSERT_EQ(
- 1u, render_surface_layer_list[0]->render_surface()->layer_list().size());
+ 1u,
+ render_surface_layer_list.at(0)->render_surface()->layer_list().size());
ASSERT_EQ(789,
- render_surface_layer_list[0]->render_surface()->layer_list()[0]
- ->id()); // grand_child's surface.
+ render_surface_layer_list.at(0)->render_surface()->layer_list().at(
+ 0)->id()); // grand_child's surface.
ASSERT_EQ(
- 1u, render_surface_layer_list[1]->render_surface()->layer_list().size());
+ 1u,
+ render_surface_layer_list.at(1)->render_surface()->layer_list().size());
ASSERT_EQ(
2468,
- render_surface_layer_list[1]->render_surface()->layer_list()[0]->id());
+ render_surface_layer_list[1]->render_surface()->layer_list().at(0)->id());
// (11, 89) is close to the the bottom left corner within the clip, but it is
// not inside the layer.
@@ -5081,7 +5149,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForMultiClippedRotatedLayer) {
EXPECT_EQ(2468, result_layer->id());
}
-TEST(LayerTreeHostCommonTest, HitTestingForNonClippingIntermediateLayer) {
+TEST_F(LayerTreeHostCommonTest, HitTestingForNonClippingIntermediateLayer) {
// This test checks that hit testing code does not accidentally clip to layer
// bounds for a layer that actually does not clip.
gfx::Transform identity_matrix;
@@ -5150,7 +5218,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForNonClippingIntermediateLayer) {
// Sanity check the scenario we just created.
ASSERT_EQ(1u, render_surface_layer_list.size());
ASSERT_EQ(1u, root->render_surface()->layer_list().size());
- ASSERT_EQ(456, root->render_surface()->layer_list()[0]->id());
+ ASSERT_EQ(456, root->render_surface()->layer_list().at(0)->id());
// Hit testing for a point outside the layer should return a null pointer.
gfx::Point test_point(69, 69);
@@ -5177,7 +5245,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForNonClippingIntermediateLayer) {
EXPECT_EQ(456, result_layer->id());
}
-TEST(LayerTreeHostCommonTest, HitTestingForMultipleLayers) {
+TEST_F(LayerTreeHostCommonTest, HitTestingForMultipleLayers) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
@@ -5271,11 +5339,13 @@ TEST(LayerTreeHostCommonTest, HitTestingForMultipleLayers) {
ASSERT_TRUE(child2);
ASSERT_TRUE(grand_child1);
ASSERT_EQ(1u, render_surface_layer_list.size());
- ASSERT_EQ(4u, root->render_surface()->layer_list().size());
- ASSERT_EQ(1, root->render_surface()->layer_list()[0]->id()); // root layer
- ASSERT_EQ(2, root->render_surface()->layer_list()[1]->id()); // child1
- ASSERT_EQ(4, root->render_surface()->layer_list()[2]->id()); // grand_child1
- ASSERT_EQ(3, root->render_surface()->layer_list()[3]->id()); // child2
+
+ RenderSurfaceImpl* root_render_surface = root->render_surface();
+ ASSERT_EQ(4u, root_render_surface->layer_list().size());
+ ASSERT_EQ(1, root_render_surface->layer_list().at(0)->id()); // root layer
+ ASSERT_EQ(2, root_render_surface->layer_list().at(1)->id()); // child1
+ ASSERT_EQ(4, root_render_surface->layer_list().at(2)->id()); // grand_child1
+ ASSERT_EQ(3, root_render_surface->layer_list().at(3)->id()); // child2
// Nothing overlaps the root_layer at (1, 1), so hit testing there should find
// the root layer.
@@ -5325,7 +5395,7 @@ TEST(LayerTreeHostCommonTest, HitTestingForMultipleLayers) {
EXPECT_EQ(4, result_layer->id());
}
-TEST(LayerTreeHostCommonTest, HitTestingForMultipleLayerLists) {
+TEST_F(LayerTreeHostCommonTest, HitTestingForMultipleLayerLists) {
//
// The geometry is set up similarly to the previous case, but
// all layers are forced to be render surfaces now.
@@ -5436,9 +5506,9 @@ TEST(LayerTreeHostCommonTest, HitTestingForMultipleLayerLists) {
ASSERT_EQ(2u, child1->render_surface()->layer_list().size());
ASSERT_EQ(1u, child2->render_surface()->layer_list().size());
ASSERT_EQ(1u, grand_child1->render_surface()->layer_list().size());
- ASSERT_EQ(1, render_surface_layer_list[0]->id()); // root layer
+ ASSERT_EQ(1, render_surface_layer_list.at(0)->id()); // root layer
ASSERT_EQ(2, render_surface_layer_list[1]->id()); // child1
- ASSERT_EQ(4, render_surface_layer_list[2]->id()); // grand_child1
+ ASSERT_EQ(4, render_surface_layer_list.at(2)->id()); // grand_child1
ASSERT_EQ(3, render_surface_layer_list[3]->id()); // child2
// Nothing overlaps the root_layer at (1, 1), so hit testing there should find
@@ -5489,7 +5559,8 @@ TEST(LayerTreeHostCommonTest, HitTestingForMultipleLayerLists) {
EXPECT_EQ(4, result_layer->id());
}
-TEST(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForEmptyLayerList) {
+TEST_F(LayerTreeHostCommonTest,
+ HitCheckingTouchHandlerRegionsForEmptyLayerList) {
// Hit checking on an empty render_surface_layer_list should return a null
// pointer.
LayerImplList render_surface_layer_list;
@@ -5507,7 +5578,7 @@ TEST(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForEmptyLayerList) {
EXPECT_FALSE(result_layer);
}
-TEST(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
+TEST_F(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
scoped_ptr<LayerImpl> root =
@@ -5597,7 +5668,7 @@ TEST(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
EXPECT_EQ(12345, result_layer->id());
}
-TEST(LayerTreeHostCommonTest,
+TEST_F(LayerTreeHostCommonTest,
HitCheckingTouchHandlerRegionsForUninvertibleTransform) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
@@ -5691,7 +5762,7 @@ TEST(LayerTreeHostCommonTest,
EXPECT_FALSE(result_layer);
}
-TEST(LayerTreeHostCommonTest,
+TEST_F(LayerTreeHostCommonTest,
HitCheckingTouchHandlerRegionsForSinglePositionedLayer) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
@@ -5772,7 +5843,7 @@ TEST(LayerTreeHostCommonTest,
EXPECT_EQ(12345, result_layer->id());
}
-TEST(LayerTreeHostCommonTest,
+TEST_F(LayerTreeHostCommonTest,
HitCheckingTouchHandlerRegionsForSingleLayerWithScaledContents) {
// A layer's visible content rect is actually in the layer's content space.
// The screen space transform converts from the layer's origin space to screen
@@ -5894,7 +5965,7 @@ TEST(LayerTreeHostCommonTest,
EXPECT_EQ(12345, result_layer->id());
}
-TEST(LayerTreeHostCommonTest,
+TEST_F(LayerTreeHostCommonTest,
HitCheckingTouchHandlerRegionsForSingleLayerWithDeviceScale) {
// The layer's device_scale_factor and page_scale_factor should scale the
// content rect and we should be able to hit the touch handler region by
@@ -6025,7 +6096,7 @@ TEST(LayerTreeHostCommonTest,
EXPECT_EQ(12345, result_layer->id());
}
-TEST(LayerTreeHostCommonTest,
+TEST_F(LayerTreeHostCommonTest,
HitCheckingTouchHandlerRegionsForSimpleClippedLayer) {
// Test that hit-checking will only work for the visible portion of a layer,
// and not the entire layer bounds. Here we just test the simple axis-aligned
@@ -6093,7 +6164,7 @@ TEST(LayerTreeHostCommonTest,
// Sanity check the scenario we just created.
ASSERT_EQ(1u, render_surface_layer_list.size());
ASSERT_EQ(1u, root->render_surface()->layer_list().size());
- ASSERT_EQ(456, root->render_surface()->layer_list()[0]->id());
+ ASSERT_EQ(456, root->render_surface()->layer_list().at(0)->id());
// Hit checking for a point outside the layer should return a null pointer.
// Despite the child layer being very large, it should be clipped to the root
@@ -6172,7 +6243,7 @@ scoped_refptr<NoScaleContentLayer> CreateNoScaleDrawableContentLayer(
return to_return;
}
-TEST(LayerTreeHostCommonTest, LayerTransformsInHighDPI) {
+TEST_F(LayerTreeHostCommonTest, LayerTransformsInHighDPI) {
// Verify draw and screen space transforms of layers not in a surface.
MockContentLayerClient delegate;
gfx::Transform identity_matrix;
@@ -6219,7 +6290,7 @@ TEST(LayerTreeHostCommonTest, LayerTransformsInHighDPI) {
parent->AddChild(child_empty);
parent->AddChild(child_no_scale);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
float device_scale_factor = 2.5f;
@@ -6311,7 +6382,7 @@ TEST(LayerTreeHostCommonTest, LayerTransformsInHighDPI) {
child_no_scale->screen_space_transform());
}
-TEST(LayerTreeHostCommonTest, SurfaceLayerTransformsInHighDPI) {
+TEST_F(LayerTreeHostCommonTest, SurfaceLayerTransformsInHighDPI) {
// Verify draw and screen space transforms of layers in a surface.
MockContentLayerClient delegate;
gfx::Transform identity_matrix;
@@ -6360,7 +6431,7 @@ TEST(LayerTreeHostCommonTest, SurfaceLayerTransformsInHighDPI) {
parent->AddChild(scale_surface);
root->AddChild(parent);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
float device_scale_factor = 2.5f;
@@ -6424,7 +6495,7 @@ TEST(LayerTreeHostCommonTest, SurfaceLayerTransformsInHighDPI) {
perspective_surface->draw_transform());
}
-TEST(LayerTreeHostCommonTest,
+TEST_F(LayerTreeHostCommonTest,
LayerTransformsInHighDPIAccurateScaleZeroChildPosition) {
// Verify draw and screen space transforms of layers not in a surface.
MockContentLayerClient delegate;
@@ -6461,7 +6532,7 @@ TEST(LayerTreeHostCommonTest,
parent->AddChild(child);
parent->AddChild(child_no_scale);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
float device_scale_factor = 1.7f;
@@ -6541,7 +6612,7 @@ TEST(LayerTreeHostCommonTest,
child_no_scale->screen_space_transform());
}
-TEST(LayerTreeHostCommonTest, ContentsScale) {
+TEST_F(LayerTreeHostCommonTest, ContentsScale) {
MockContentLayerClient delegate;
gfx::Transform identity_matrix;
@@ -6601,75 +6672,86 @@ TEST(LayerTreeHostCommonTest, ContentsScale) {
parent->AddChild(child_empty);
parent->AddChild(child_no_scale);
- LayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
float device_scale_factor = 2.5f;
float page_scale_factor = 1.f;
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- gfx::Transform(),
- device_scale_factor,
- page_scale_factor,
- root.get(),
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale, parent);
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale * initial_child_scale,
- child_scale);
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale * initial_child_scale,
- child_empty);
- EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
-
- // The parent is scaled up and shouldn't need to scale during draw. The child
- // that can scale its contents should also not need to scale during draw. This
- // shouldn't change if the child has empty bounds. The other children should.
- EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().getDouble(0, 0));
- EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().getDouble(1, 1));
- EXPECT_FLOAT_EQ(1.0, child_scale->draw_transform().matrix().getDouble(0, 0));
- EXPECT_FLOAT_EQ(1.0, child_scale->draw_transform().matrix().getDouble(1, 1));
- EXPECT_FLOAT_EQ(1.0, child_empty->draw_transform().matrix().getDouble(0, 0));
- EXPECT_FLOAT_EQ(1.0, child_empty->draw_transform().matrix().getDouble(1, 1));
- EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale * initial_child_scale,
- child_no_scale->draw_transform().matrix().getDouble(0, 0));
- EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale * initial_child_scale,
- child_no_scale->draw_transform().matrix().getDouble(1, 1));
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ gfx::Transform(),
+ device_scale_factor,
+ page_scale_factor,
+ root.get(),
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale, parent);
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale * initial_child_scale,
+ child_scale);
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale * initial_child_scale,
+ child_empty);
+ EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
+
+ // The parent is scaled up and shouldn't need to scale during draw. The
+ // child that can scale its contents should also not need to scale during
+ // draw. This shouldn't change if the child has empty bounds. The other
+ // children should.
+ EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().getDouble(0, 0));
+ EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().getDouble(1, 1));
+ EXPECT_FLOAT_EQ(1.0,
+ child_scale->draw_transform().matrix().getDouble(0, 0));
+ EXPECT_FLOAT_EQ(1.0,
+ child_scale->draw_transform().matrix().getDouble(1, 1));
+ EXPECT_FLOAT_EQ(1.0,
+ child_empty->draw_transform().matrix().getDouble(0, 0));
+ EXPECT_FLOAT_EQ(1.0,
+ child_empty->draw_transform().matrix().getDouble(1, 1));
+ EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale * initial_child_scale,
+ child_no_scale->draw_transform().matrix().getDouble(0, 0));
+ EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale * initial_child_scale,
+ child_no_scale->draw_transform().matrix().getDouble(1, 1));
+ }
// If the device_scale_factor or page_scale_factor changes, then it should be
// updated using the initial transform as the raster scale.
device_scale_factor = 2.25f;
page_scale_factor = 1.25f;
- render_surface_layer_list.clear();
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- gfx::Transform(),
- device_scale_factor,
- page_scale_factor,
- root.get(),
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale,
- parent);
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale * initial_child_scale,
- child_scale);
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale * initial_child_scale,
- child_empty);
- EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ gfx::Transform(),
+ device_scale_factor,
+ page_scale_factor,
+ root.get(),
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale,
+ parent);
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale * initial_child_scale,
+ child_scale);
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale * initial_child_scale,
+ child_empty);
+ EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
+ }
// If the transform changes, we expect the raster scale to be reset to 1.0.
double second_child_scale = 1.75;
@@ -6678,55 +6760,61 @@ TEST(LayerTreeHostCommonTest, ContentsScale) {
child_scale->SetTransform(child_scale_matrix);
child_empty->SetTransform(child_scale_matrix);
- render_surface_layer_list.clear();
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- gfx::Transform(),
- device_scale_factor,
- page_scale_factor,
- root.get(),
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale,
- parent);
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
- child_scale);
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
- child_empty);
- EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ gfx::Transform(),
+ device_scale_factor,
+ page_scale_factor,
+ root.get(),
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale,
+ parent);
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
+ child_scale);
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
+ child_empty);
+ EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
+ }
// If the device_scale_factor or page_scale_factor changes, then it should be
// updated, but still using 1.0 as the raster scale.
device_scale_factor = 2.75f;
page_scale_factor = 1.75f;
- render_surface_layer_list.clear();
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- gfx::Transform(),
- device_scale_factor,
- page_scale_factor,
- root.get(),
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale,
- parent);
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
- child_scale);
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
- child_empty);
- EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ gfx::Transform(),
+ device_scale_factor,
+ page_scale_factor,
+ root.get(),
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale,
+ parent);
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
+ child_scale);
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
+ child_empty);
+ EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
+ }
}
-TEST(LayerTreeHostCommonTest,
+TEST_F(LayerTreeHostCommonTest,
ContentsScale_LayerTransformsDontAffectContentsScale) {
MockContentLayerClient delegate;
gfx::Transform identity_matrix;
@@ -6787,7 +6875,7 @@ TEST(LayerTreeHostCommonTest,
parent->AddChild(child_empty);
parent->AddChild(child_no_scale);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
float device_scale_factor = 2.5f;
@@ -6834,7 +6922,7 @@ TEST(LayerTreeHostCommonTest,
child_no_scale->draw_transform().matrix().getDouble(1, 1));
}
-TEST(LayerTreeHostCommonTest, SmallContentsScale) {
+TEST_F(LayerTreeHostCommonTest, SmallContentsScale) {
MockContentLayerClient delegate;
gfx::Transform identity_matrix;
@@ -6872,29 +6960,33 @@ TEST(LayerTreeHostCommonTest, SmallContentsScale) {
parent->AddChild(child_scale);
- LayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
float device_scale_factor = 2.5f;
float page_scale_factor = 0.01f;
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- gfx::Transform(),
- device_scale_factor,
- page_scale_factor,
- root.get(),
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale,
- parent);
- // The child's scale is < 1, so we should not save and use that scale factor.
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor * 1,
- child_scale);
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ gfx::Transform(),
+ device_scale_factor,
+ page_scale_factor,
+ root.get(),
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale,
+ parent);
+ // The child's scale is < 1, so we should not save and use that scale
+ // factor.
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor * 1,
+ child_scale);
+ }
// When chilld's total scale becomes >= 1, we should save and use that scale
// factor.
@@ -6903,27 +6995,30 @@ TEST(LayerTreeHostCommonTest, SmallContentsScale) {
child_scale_matrix.Scale(final_child_scale, final_child_scale);
child_scale->SetTransform(child_scale_matrix);
- render_surface_layer_list.clear();
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- gfx::Transform(),
- device_scale_factor,
- page_scale_factor,
- root.get(),
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale,
- parent);
- EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
- initial_parent_scale * final_child_scale,
- child_scale);
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ gfx::Transform(),
+ device_scale_factor,
+ page_scale_factor,
+ root.get(),
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale,
+ parent);
+ EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
+ initial_parent_scale * final_child_scale,
+ child_scale);
+ }
}
-TEST(LayerTreeHostCommonTest, ContentsScaleForSurfaces) {
+TEST_F(LayerTreeHostCommonTest, ContentsScaleForSurfaces) {
MockContentLayerClient delegate;
gfx::Transform identity_matrix;
@@ -7020,7 +7115,7 @@ TEST(LayerTreeHostCommonTest, ContentsScaleForSurfaces) {
surface_no_scale->AddChild(surface_no_scale_child_scale);
surface_no_scale->AddChild(surface_no_scale_child_no_scale);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
double device_scale_factor = 5;
@@ -7137,7 +7232,7 @@ TEST(LayerTreeHostCommonTest, ContentsScaleForSurfaces) {
1));
}
-TEST(LayerTreeHostCommonTest,
+TEST_F(LayerTreeHostCommonTest,
ContentsScaleForSurfaces_LayerTransformsDontAffectContentsScale) {
MockContentLayerClient delegate;
gfx::Transform identity_matrix;
@@ -7235,7 +7330,7 @@ TEST(LayerTreeHostCommonTest,
surface_no_scale->AddChild(surface_no_scale_child_scale);
surface_no_scale->AddChild(surface_no_scale_child_no_scale);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
double device_scale_factor = 5;
@@ -7351,7 +7446,7 @@ TEST(LayerTreeHostCommonTest,
1));
}
-TEST(LayerTreeHostCommonTest, ContentsScaleForAnimatingLayer) {
+TEST_F(LayerTreeHostCommonTest, ContentsScaleForAnimatingLayer) {
MockContentLayerClient delegate;
gfx::Transform identity_matrix;
@@ -7393,47 +7488,54 @@ TEST(LayerTreeHostCommonTest, ContentsScaleForAnimatingLayer) {
int animation_id = AddAnimatedTransformToController(
child_scale->layer_animation_controller(), 10.0, 30, 0);
- LayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- gfx::Transform(),
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale, parent);
- // The layers with animating transforms should not compute a contents scale
- // other than 1 until they finish animating.
- EXPECT_CONTENTS_SCALE_EQ(1, child_scale);
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ gfx::Transform(),
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale, parent);
+ // The layers with animating transforms should not compute a contents scale
+ // other than 1 until they finish animating.
+ EXPECT_CONTENTS_SCALE_EQ(1, child_scale);
+ }
// Remove the animation, now it can save a raster scale.
child_scale->layer_animation_controller()->RemoveAnimation(animation_id);
- LayerTreeHostCommon::CalculateDrawProperties(root.get(),
- root->bounds(),
- gfx::Transform(),
- 1.f,
- 1.f,
- NULL,
- dummy_max_texture_size,
- false,
- true, // can_adjust_raster_scale
- &render_surface_layer_list);
-
- EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale, parent);
- // The layers with animating transforms should not compute a contents scale
- // other than 1 until they finish animating.
- EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale * initial_child_scale,
- child_scale);
+ {
+ RenderSurfaceLayerList render_surface_layer_list;
+ LayerTreeHostCommon::CalculateDrawProperties(
+ root.get(),
+ root->bounds(),
+ gfx::Transform(),
+ 1.f,
+ 1.f,
+ NULL,
+ dummy_max_texture_size,
+ false,
+ true, // can_adjust_raster_scale
+ &render_surface_layer_list);
+
+ EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale, parent);
+ // The layers with animating transforms should not compute a contents scale
+ // other than 1 until they finish animating.
+ EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale * initial_child_scale,
+ child_scale);
+ }
}
-TEST(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) {
+TEST_F(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) {
MockContentLayerClient delegate;
gfx::Transform identity_matrix;
@@ -7482,7 +7584,7 @@ TEST(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) {
child->AddChild(duplicate_child_non_owner);
child->SetReplicaLayer(replica.get());
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
float device_scale_factor = 1.5f;
@@ -7570,7 +7672,7 @@ TEST(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) {
child->render_surface()->replica_screen_space_transform());
}
-TEST(LayerTreeHostCommonTest,
+TEST_F(LayerTreeHostCommonTest,
RenderSurfaceTransformsInHighDPIAccurateScaleZeroPosition) {
MockContentLayerClient delegate;
gfx::Transform identity_matrix;
@@ -7620,7 +7722,7 @@ TEST(LayerTreeHostCommonTest,
child->AddChild(duplicate_child_non_owner);
child->SetReplicaLayer(replica.get());
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
float device_scale_factor = 1.7f;
@@ -7676,7 +7778,7 @@ TEST(LayerTreeHostCommonTest,
child->render_surface()->replica_screen_space_transform());
}
-TEST(LayerTreeHostCommonTest, SubtreeSearch) {
+TEST_F(LayerTreeHostCommonTest, SubtreeSearch) {
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<Layer> child = Layer::Create();
scoped_refptr<Layer> grand_child = Layer::Create();
@@ -7706,7 +7808,7 @@ TEST(LayerTreeHostCommonTest, SubtreeSearch) {
0, LayerTreeHostCommon::FindLayerInSubtree(root.get(), nonexistent_id));
}
-TEST(LayerTreeHostCommonTest, TransparentChildRenderSurfaceCreation) {
+TEST_F(LayerTreeHostCommonTest, TransparentChildRenderSurfaceCreation) {
scoped_refptr<Layer> root = Layer::Create();
scoped_refptr<Layer> child = Layer::Create();
scoped_refptr<LayerWithForcedDrawsContent> grand_child =
@@ -7744,7 +7846,7 @@ TEST(LayerTreeHostCommonTest, TransparentChildRenderSurfaceCreation) {
EXPECT_FALSE(child->render_surface());
}
-TEST(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
+TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
host_impl.CreatePendingTree();
@@ -7797,7 +7899,9 @@ TEST(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
}
typedef std::tr1::tuple<bool, bool> LCDTextTestParam;
-class LCDTextTest : public testing::TestWithParam<LCDTextTestParam> {
+class LCDTextTest
+ : public LayerTreeHostCommonTestBase,
+ public testing::TestWithParam<LCDTextTestParam> {
protected:
virtual void SetUp() {
can_use_lcd_text_ = std::tr1::get<0>(GetParam());
@@ -7944,7 +8048,7 @@ INSTANTIATE_TEST_CASE_P(LayerTreeHostCommonTest,
LCDTextTest,
testing::Combine(testing::Bool(), testing::Bool()));
-TEST(LayerTreeHostCommonTest, SubtreeHidden_SingleLayer) {
+TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayer) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
host_impl.CreatePendingTree();
@@ -7984,7 +8088,7 @@ TEST(LayerTreeHostCommonTest, SubtreeHidden_SingleLayer) {
child->AddChild(grand_child);
root->AddChild(child);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(root.get(),
root->bounds(),
@@ -8001,11 +8105,11 @@ TEST(LayerTreeHostCommonTest, SubtreeHidden_SingleLayer) {
// hidden itself.
ASSERT_EQ(1u, render_surface_layer_list.size());
ASSERT_EQ(2u, root->render_surface()->layer_list().size());
- EXPECT_EQ(root->id(), root->render_surface()->layer_list()[0]->id());
- EXPECT_EQ(child->id(), root->render_surface()->layer_list()[1]->id());
+ EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
+ EXPECT_EQ(child->id(), root->render_surface()->layer_list().at(1)->id());
}
-TEST(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) {
+TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
host_impl.CreatePendingTree();
@@ -8063,11 +8167,11 @@ TEST(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) {
// hidden itself.
ASSERT_EQ(1u, render_surface_layer_list.size());
ASSERT_EQ(2u, root->render_surface()->layer_list().size());
- EXPECT_EQ(1, root->render_surface()->layer_list()[0]->id());
- EXPECT_EQ(2, root->render_surface()->layer_list()[1]->id());
+ EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id());
+ EXPECT_EQ(2, root->render_surface()->layer_list().at(1)->id());
}
-TEST(LayerTreeHostCommonTest, SubtreeHidden_TwoLayers) {
+TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayers) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
host_impl.CreatePendingTree();
@@ -8107,7 +8211,7 @@ TEST(LayerTreeHostCommonTest, SubtreeHidden_TwoLayers) {
child->AddChild(grand_child);
root->AddChild(child);
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(root.get(),
root->bounds(),
@@ -8124,10 +8228,10 @@ TEST(LayerTreeHostCommonTest, SubtreeHidden_TwoLayers) {
// hidden itself and the grand child.
ASSERT_EQ(1u, render_surface_layer_list.size());
ASSERT_EQ(1u, root->render_surface()->layer_list().size());
- EXPECT_EQ(root->id(), root->render_surface()->layer_list()[0]->id());
+ EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
}
-TEST(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {
+TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
host_impl.CreatePendingTree();
@@ -8185,12 +8289,12 @@ TEST(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {
// hidden itself and the grand child.
ASSERT_EQ(1u, render_surface_layer_list.size());
ASSERT_EQ(1u, root->render_surface()->layer_list().size());
- EXPECT_EQ(1, root->render_surface()->layer_list()[0]->id());
+ EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id());
}
void EmptyCopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
-TEST(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
+TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
host_impl.CreatePendingTree();
@@ -8283,7 +8387,7 @@ TEST(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
base::Bind(&EmptyCopyOutputCallback)));
EXPECT_TRUE(copy_layer->HasCopyRequest());
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(root.get(),
root->bounds(),
@@ -8313,33 +8417,34 @@ TEST(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
// We should have three render surfaces, one for the root, one for the parent
// since it owns a surface, and one for the copy_layer.
ASSERT_EQ(3u, render_surface_layer_list.size());
- EXPECT_EQ(root->id(), render_surface_layer_list[0]->id());
- EXPECT_EQ(copy_parent->id(), render_surface_layer_list[1]->id());
- EXPECT_EQ(copy_layer->id(), render_surface_layer_list[2]->id());
+ EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id());
+ EXPECT_EQ(copy_parent->id(), render_surface_layer_list.at(1)->id());
+ EXPECT_EQ(copy_layer->id(), render_surface_layer_list.at(2)->id());
// The root render surface should have 2 contributing layers. The
// copy_grand_parent is hidden along with its siblings, but the copy_parent
// will appear since something in its subtree needs to be drawn for a copy
// request.
ASSERT_EQ(2u, root->render_surface()->layer_list().size());
- EXPECT_EQ(root->id(), root->render_surface()->layer_list()[0]->id());
- EXPECT_EQ(copy_parent->id(), root->render_surface()->layer_list()[1]->id());
+ EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
+ EXPECT_EQ(copy_parent->id(),
+ root->render_surface()->layer_list().at(1)->id());
// Nothing actually drawns into the copy parent, so only the copy_layer will
// appear in its list, since it needs to be drawn for the copy request.
ASSERT_EQ(1u, copy_parent->render_surface()->layer_list().size());
EXPECT_EQ(copy_layer->id(),
- copy_parent->render_surface()->layer_list()[0]->id());
+ copy_parent->render_surface()->layer_list().at(0)->id());
// The copy_layer's render surface should have two contributing layers.
ASSERT_EQ(2u, copy_layer->render_surface()->layer_list().size());
EXPECT_EQ(copy_layer->id(),
- copy_layer->render_surface()->layer_list()[0]->id());
+ copy_layer->render_surface()->layer_list().at(0)->id());
EXPECT_EQ(copy_child->id(),
- copy_layer->render_surface()->layer_list()[1]->id());
+ copy_layer->render_surface()->layer_list().at(1)->id());
}
-TEST(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
+TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
host_impl.CreatePendingTree();
@@ -8394,7 +8499,7 @@ TEST(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
base::Bind(&EmptyCopyOutputCallback)));
EXPECT_TRUE(copy_layer->HasCopyRequest());
- LayerList render_surface_layer_list;
+ RenderSurfaceLayerList render_surface_layer_list;
int dummy_max_texture_size = 512;
LayerTreeHostCommon::CalculateDrawProperties(root.get(),
root->bounds(),
@@ -8409,12 +8514,12 @@ TEST(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
// We should have one render surface, as the others are clipped out.
ASSERT_EQ(1u, render_surface_layer_list.size());
- EXPECT_EQ(root->id(), render_surface_layer_list[0]->id());
+ EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id());
// The root render surface should only have 1 contributing layer, since the
// other layers are empty/clipped away.
ASSERT_EQ(1u, root->render_surface()->layer_list().size());
- EXPECT_EQ(root->id(), root->render_surface()->layer_list()[0]->id());
+ EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
}
} // namespace
diff --git a/cc/trees/layer_tree_host_unittest_occlusion.cc b/cc/trees/layer_tree_host_unittest_occlusion.cc
index fa9b6fb..155b842 100644
--- a/cc/trees/layer_tree_host_unittest_occlusion.cc
+++ b/cc/trees/layer_tree_host_unittest_occlusion.cc
@@ -439,12 +439,11 @@ class LayerTreeHostOcclusionTestManySurfaces
for (int i = 0; i < num_surfaces; ++i) {
layers.push_back(TestLayer::Create());
- if (!i) {
+ if (i == 0) {
SetLayerPropertiesForTesting(
layers.back().get(), NULL, identity_matrix_,
gfx::PointF(0.f, 0.f),
gfx::Size(root_width, root_height), true);
- layers.back()->CreateRenderSurface();
} else {
SetLayerPropertiesForTesting(
layers.back().get(), layers[layers.size() - 2].get(),
diff --git a/cc/trees/occlusion_tracker_unittest.cc b/cc/trees/occlusion_tracker_unittest.cc
index 9a5f839..5a1aae1 100644
--- a/cc/trees/occlusion_tracker_unittest.cc
+++ b/cc/trees/occlusion_tracker_unittest.cc
@@ -136,7 +136,7 @@ struct OcclusionTrackerTestMainThreadTypes {
typedef scoped_refptr<Layer> LayerPtrType;
typedef scoped_refptr<ContentLayerType> ContentLayerPtrType;
typedef LayerIterator<Layer,
- LayerList,
+ RenderSurfaceLayerList,
RenderSurface,
LayerIteratorActions::FrontToBack> TestLayerIterator;
typedef OcclusionTracker OcclusionTrackerType;
@@ -204,7 +204,7 @@ template <typename Types> class OcclusionTrackerTest : public testing::Test {
virtual void TearDown() {
Types::DestroyLayer(&root_);
- render_surface_layer_list_.clear();
+ render_surface_layer_list_.reset();
render_surface_layer_list_impl_.clear();
replica_layers_.clear();
mask_layers_.clear();
@@ -335,6 +335,7 @@ template <typename Types> class OcclusionTrackerTest : public testing::Test {
DCHECK(!root->render_surface());
+ render_surface_layer_list_.reset(new RenderSurfaceLayerList);
LayerTreeHostCommon::CalculateDrawProperties(
root,
root->bounds(),
@@ -345,10 +346,10 @@ template <typename Types> class OcclusionTrackerTest : public testing::Test {
dummy_max_texture_size,
false, // can_use_lcd_text
true, // can_adjust_raster_scales
- &render_surface_layer_list_);
+ render_surface_layer_list_.get());
layer_iterator_ = layer_iterator_begin_ =
- Types::TestLayerIterator::Begin(&render_surface_layer_list_);
+ Types::TestLayerIterator::Begin(render_surface_layer_list_.get());
}
void EnterLayer(typename Types::LayerType* layer,
@@ -457,7 +458,7 @@ template <typename Types> class OcclusionTrackerTest : public testing::Test {
bool opaque_layers_;
// These hold ownership of the layers for the duration of the test.
typename Types::LayerPtrType root_;
- LayerList render_surface_layer_list_;
+ scoped_ptr<RenderSurfaceLayerList> render_surface_layer_list_;
LayerImplList render_surface_layer_list_impl_;
typename Types::TestLayerIterator layer_iterator_begin_;
typename Types::TestLayerIterator layer_iterator_;
diff --git a/webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc b/webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc
index 7099d7f..1ae67d4 100644
--- a/webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc
+++ b/webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc
@@ -127,41 +127,47 @@ void CompareFixedBoundsLayerAndNormalLayer(
normal_layer->setPosition(position);
root_layer->addChild(normal_layer);
- std::vector<scoped_refptr<cc::Layer> > render_surface_layer_list;
- cc::LayerTreeHostCommon::CalculateDrawProperties(
- root_layer->layer(),
- kDeviceViewportSize,
- gfx::Transform(),
- kDeviceScaleFactor,
- kPageScaleFactor,
- root_layer->layer(),
- kMaxTextureSize,
- false, // can_use_lcd_text
- false, // can_adjust_raster_scales
- &render_surface_layer_list);
- ExpectEqualLayerRectsInTarget(normal_layer->layer(),
- fixed_bounds_layer->layer());
- ExpectEqualLayerRectsInTarget(sublayer_under_normal_layer->layer(),
- sublayer_under_fixed_bounds_layer->layer());
+ {
+ cc::RenderSurfaceLayerList render_surface_layer_list;
+ cc::LayerTreeHostCommon::CalculateDrawProperties(
+ root_layer->layer(),
+ kDeviceViewportSize,
+ gfx::Transform(),
+ kDeviceScaleFactor,
+ kPageScaleFactor,
+ root_layer->layer(),
+ kMaxTextureSize,
+ false, // can_use_lcd_text
+ false, // can_adjust_raster_scales
+ &render_surface_layer_list);
+ ExpectEqualLayerRectsInTarget(normal_layer->layer(),
+ fixed_bounds_layer->layer());
+ ExpectEqualLayerRectsInTarget(sublayer_under_normal_layer->layer(),
+ sublayer_under_fixed_bounds_layer->layer());
+ }
// Change of fixed bounds should not affect the target geometries.
fixed_bounds_layer->SetFixedBounds(gfx::Size(fixed_bounds.width() / 2,
fixed_bounds.height() * 2));
- cc::LayerTreeHostCommon::CalculateDrawProperties(
- root_layer->layer(),
- kDeviceViewportSize,
- gfx::Transform(),
- kDeviceScaleFactor,
- kPageScaleFactor,
- root_layer->layer(),
- kMaxTextureSize,
- false, // can_use_lcd_text
- false, // can_adjust_raster_scales
- &render_surface_layer_list);
- ExpectEqualLayerRectsInTarget(normal_layer->layer(),
- fixed_bounds_layer->layer());
- ExpectEqualLayerRectsInTarget(sublayer_under_normal_layer->layer(),
- sublayer_under_fixed_bounds_layer->layer());
+
+ {
+ cc::RenderSurfaceLayerList render_surface_layer_list;
+ cc::LayerTreeHostCommon::CalculateDrawProperties(
+ root_layer->layer(),
+ kDeviceViewportSize,
+ gfx::Transform(),
+ kDeviceScaleFactor,
+ kPageScaleFactor,
+ root_layer->layer(),
+ kMaxTextureSize,
+ false, // can_use_lcd_text
+ false, // can_adjust_raster_scales
+ &render_surface_layer_list);
+ ExpectEqualLayerRectsInTarget(normal_layer->layer(),
+ fixed_bounds_layer->layer());
+ ExpectEqualLayerRectsInTarget(sublayer_under_normal_layer->layer(),
+ sublayer_under_fixed_bounds_layer->layer());
+ }
}
// A black box test that ensures WebLayerImplFixedBounds won't change target
generated by cgit v1.1 at 2025-02-14 15:05:34 +0000