cc: Chromify the LayerTreeHostImpl class.
Style-only change. Make the LayerTreeHostImpl and InputHandlerClient classes
follow chromium style.
Review URL: https://codereview.chromium.org/12648005
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@187908 0039d316-1c4b-4281-b951-d872f2087c98
diff --git a/cc/damage_tracker_unittest.cc b/cc/damage_tracker_unittest.cc
index e15a22c7..abf8da4 100644
--- a/cc/damage_tracker_unittest.cc
+++ b/cc/damage_tracker_unittest.cc
@@ -73,8 +73,8 @@
scoped_ptr<LayerImpl> createTestTreeWithOneSurface()
{
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl.activeTree(), 1);
- scoped_ptr<LayerImpl> child = LayerImpl::Create(m_hostImpl.activeTree(), 2);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl.active_tree(), 1);
+ scoped_ptr<LayerImpl> child = LayerImpl::Create(m_hostImpl.active_tree(), 2);
root->SetPosition(gfx::PointF());
root->SetAnchorPoint(gfx::PointF());
@@ -100,11 +100,11 @@
// child1. Additionally, the root has a second child layer, and child1 has two
// children of its own.
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl.activeTree(), 1);
- scoped_ptr<LayerImpl> child1 = LayerImpl::Create(m_hostImpl.activeTree(), 2);
- scoped_ptr<LayerImpl> child2 = LayerImpl::Create(m_hostImpl.activeTree(), 3);
- scoped_ptr<LayerImpl> grandChild1 = LayerImpl::Create(m_hostImpl.activeTree(), 4);
- scoped_ptr<LayerImpl> grandChild2 = LayerImpl::Create(m_hostImpl.activeTree(), 5);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl.active_tree(), 1);
+ scoped_ptr<LayerImpl> child1 = LayerImpl::Create(m_hostImpl.active_tree(), 2);
+ scoped_ptr<LayerImpl> child2 = LayerImpl::Create(m_hostImpl.active_tree(), 3);
+ scoped_ptr<LayerImpl> grandChild1 = LayerImpl::Create(m_hostImpl.active_tree(), 4);
+ scoped_ptr<LayerImpl> grandChild2 = LayerImpl::Create(m_hostImpl.active_tree(), 5);
root->SetPosition(gfx::PointF());
root->SetAnchorPoint(gfx::PointF());
@@ -535,7 +535,7 @@
//
clearDamageForAllSurfaces(root.get());
{
- scoped_ptr<LayerImpl> child2 = LayerImpl::Create(m_hostImpl.activeTree(), 3);
+ scoped_ptr<LayerImpl> child2 = LayerImpl::Create(m_hostImpl.active_tree(), 3);
child2->SetPosition(gfx::PointF(400, 380));
child2->SetAnchorPoint(gfx::PointF());
child2->SetBounds(gfx::Size(6, 8));
@@ -576,7 +576,7 @@
clearDamageForAllSurfaces(root.get());
{
- scoped_ptr<LayerImpl> child2 = LayerImpl::Create(m_hostImpl.activeTree(), 3);
+ scoped_ptr<LayerImpl> child2 = LayerImpl::Create(m_hostImpl.active_tree(), 3);
child2->SetPosition(gfx::PointF(400, 380));
child2->SetAnchorPoint(gfx::PointF());
child2->SetBounds(gfx::Size(6, 8));
@@ -606,7 +606,7 @@
// In this test we don't want the above tree manipulation to be considered part of the same frame.
clearDamageForAllSurfaces(root.get());
{
- scoped_ptr<LayerImpl> child2 = LayerImpl::Create(m_hostImpl.activeTree(), 3);
+ scoped_ptr<LayerImpl> child2 = LayerImpl::Create(m_hostImpl.active_tree(), 3);
child2->SetPosition(gfx::PointF(400, 380));
child2->SetAnchorPoint(gfx::PointF());
child2->SetBounds(gfx::Size(6, 8));
@@ -827,7 +827,7 @@
// contentBounds of the surface.
grandChild2->SetPosition(gfx::PointF(180, 180));
{
- scoped_ptr<LayerImpl> grandChild3 = LayerImpl::Create(m_hostImpl.activeTree(), 6);
+ scoped_ptr<LayerImpl> grandChild3 = LayerImpl::Create(m_hostImpl.active_tree(), 6);
grandChild3->SetPosition(gfx::PointF(240, 240));
grandChild3->SetAnchorPoint(gfx::PointF());
grandChild3->SetBounds(gfx::Size(10, 10));
@@ -842,7 +842,7 @@
//
clearDamageForAllSurfaces(root.get());
{
- scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::Create(m_hostImpl.activeTree(), 7);
+ scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::Create(m_hostImpl.active_tree(), 7);
grandChild1Replica->SetPosition(gfx::PointF());
grandChild1Replica->SetAnchorPoint(gfx::PointF());
gfx::Transform reflection;
@@ -910,7 +910,7 @@
// Set up the mask layer.
{
- scoped_ptr<LayerImpl> maskLayer = LayerImpl::Create(m_hostImpl.activeTree(), 3);
+ scoped_ptr<LayerImpl> maskLayer = LayerImpl::Create(m_hostImpl.active_tree(), 3);
maskLayer->SetPosition(child->position());
maskLayer->SetAnchorPoint(gfx::PointF());
maskLayer->SetBounds(child->bounds());
@@ -922,7 +922,7 @@
// Add opacity and a grandChild so that the render surface persists even after we remove the mask.
child->SetOpacity(0.5);
{
- scoped_ptr<LayerImpl> grandChild = LayerImpl::Create(m_hostImpl.activeTree(), 4);
+ scoped_ptr<LayerImpl> grandChild = LayerImpl::Create(m_hostImpl.active_tree(), 4);
grandChild->SetPosition(gfx::PointF(2, 2));
grandChild->SetAnchorPoint(gfx::PointF());
grandChild->SetBounds(gfx::Size(2, 2));
@@ -995,7 +995,7 @@
// Create a reflection about the left edge of grandChild1.
{
- scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::Create(m_hostImpl.activeTree(), 6);
+ scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::Create(m_hostImpl.active_tree(), 6);
grandChild1Replica->SetPosition(gfx::PointF());
grandChild1Replica->SetAnchorPoint(gfx::PointF());
gfx::Transform reflection;
@@ -1007,7 +1007,7 @@
// Set up the mask layer on the replica layer
{
- scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::Create(m_hostImpl.activeTree(), 7);
+ scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::Create(m_hostImpl.active_tree(), 7);
replicaMaskLayer->SetPosition(gfx::PointF());
replicaMaskLayer->SetAnchorPoint(gfx::PointF());
replicaMaskLayer->SetBounds(grandChild1->bounds());
@@ -1057,7 +1057,7 @@
grandChild1->SetAnchorPoint(gfx::PointF(1, 0)); // This is not exactly the anchor being tested, but by convention its expected to be the same as the replica's anchor point.
{
- scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::Create(m_hostImpl.activeTree(), 6);
+ scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::Create(m_hostImpl.active_tree(), 6);
grandChild1Replica->SetPosition(gfx::PointF());
grandChild1Replica->SetAnchorPoint(gfx::PointF(1, 0)); // This is the anchor being tested.
gfx::Transform reflection;
@@ -1069,7 +1069,7 @@
// Set up the mask layer on the replica layer
{
- scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::Create(m_hostImpl.activeTree(), 7);
+ scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::Create(m_hostImpl.active_tree(), 7);
replicaMaskLayer->SetPosition(gfx::PointF());
replicaMaskLayer->SetAnchorPoint(gfx::PointF()); // note, this is not the anchor being tested.
replicaMaskLayer->SetBounds(grandChild1->bounds());
@@ -1123,7 +1123,7 @@
// Though it should never happen, its a good idea to verify that the damage tracker
// does not crash when it receives an empty layerList.
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl.active_tree(), 1);
root->CreateRenderSurface();
ASSERT_TRUE(root == root->render_target());
diff --git a/cc/delegated_renderer_layer_impl.cc b/cc/delegated_renderer_layer_impl.cc
index dc9b720..f77a417 100644
--- a/cc/delegated_renderer_layer_impl.cc
+++ b/cc/delegated_renderer_layer_impl.cc
@@ -211,7 +211,7 @@
// Don't clash with the RenderPass we generate if we own a RenderSurface.
DCHECK(output_render_pass_id.index > 0);
- render_pass_sink->appendRenderPass(
+ render_pass_sink->AppendRenderPass(
render_passes_in_draw_order_[i]->Copy(output_render_pass_id));
}
}
diff --git a/cc/delegated_renderer_layer_impl_unittest.cc b/cc/delegated_renderer_layer_impl_unittest.cc
index 7ab8b5a..def29c1 100644
--- a/cc/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/delegated_renderer_layer_impl_unittest.cc
@@ -37,9 +37,9 @@
LayerTreeSettings settings;
settings.minimumOcclusionTrackingSize = gfx::Size();
- host_impl_ = LayerTreeHostImpl::create(settings, &client_, &proxy_);
- host_impl_->initializeRenderer(createFakeOutputSurface());
- host_impl_->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+ host_impl_ = LayerTreeHostImpl::Create(settings, &client_, &proxy_);
+ host_impl_->InitializeRenderer(createFakeOutputSurface());
+ host_impl_->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
}
protected:
@@ -56,15 +56,15 @@
DelegatedRendererLayerImplTestSimple()
: DelegatedRendererLayerImplTest() {
scoped_ptr<LayerImpl> root_layer = SolidColorLayerImpl::Create(
- host_impl_->activeTree(), 1).PassAs<LayerImpl>();
+ host_impl_->active_tree(), 1).PassAs<LayerImpl>();
scoped_ptr<LayerImpl> layer_before = SolidColorLayerImpl::Create(
- host_impl_->activeTree(), 2).PassAs<LayerImpl>();
+ host_impl_->active_tree(), 2).PassAs<LayerImpl>();
scoped_ptr<LayerImpl> layer_after = SolidColorLayerImpl::Create(
- host_impl_->activeTree(), 3).PassAs<LayerImpl>();
+ host_impl_->active_tree(), 3).PassAs<LayerImpl>();
scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
- FakeDelegatedRendererLayerImpl::Create(host_impl_->activeTree(), 4);
+ FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4);
- host_impl_->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+ host_impl_->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
root_layer->SetBounds(gfx::Size(100, 100));
layer_before->SetPosition(gfx::Point(20, 20));
@@ -126,7 +126,7 @@
// Get the RenderPass generated by layer_before to come before the delegated
// RenderPasses.
root_layer->AddChild(layer_before.Pass());
- host_impl_->activeTree()->SetRootLayer(root_layer.Pass());
+ host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
}
protected:
@@ -138,108 +138,108 @@
TEST_F(DelegatedRendererLayerImplTestSimple, AddsContributingRenderPasses) {
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
// Each non-DelegatedRendererLayer added one RenderPass. The
// DelegatedRendererLayer added two contributing passes.
- ASSERT_EQ(5u, frame.renderPasses.size());
+ ASSERT_EQ(5u, frame.render_passes.size());
// The DelegatedRendererLayer should have added its contributing RenderPasses
// to the frame.
- EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
- EXPECT_EQ(1, frame.renderPasses[1]->id.index);
- EXPECT_EQ(4, frame.renderPasses[2]->id.layer_id);
- EXPECT_EQ(2, frame.renderPasses[2]->id.index);
+ EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
+ EXPECT_EQ(1, frame.render_passes[1]->id.index);
+ EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
+ EXPECT_EQ(2, frame.render_passes[2]->id.index);
// And all other RenderPasses should be non-delegated.
- EXPECT_NE(4, frame.renderPasses[0]->id.layer_id);
- EXPECT_EQ(0, frame.renderPasses[0]->id.index);
- EXPECT_NE(4, frame.renderPasses[3]->id.layer_id);
- EXPECT_EQ(0, frame.renderPasses[3]->id.index);
- EXPECT_NE(4, frame.renderPasses[4]->id.layer_id);
- EXPECT_EQ(0, frame.renderPasses[4]->id.index);
+ EXPECT_NE(4, frame.render_passes[0]->id.layer_id);
+ EXPECT_EQ(0, frame.render_passes[0]->id.index);
+ EXPECT_NE(4, frame.render_passes[3]->id.layer_id);
+ EXPECT_EQ(0, frame.render_passes[3]->id.index);
+ EXPECT_NE(4, frame.render_passes[4]->id.layer_id);
+ EXPECT_EQ(0, frame.render_passes[4]->id.index);
// The DelegatedRendererLayer should have added its RenderPasses to the frame
// in order.
EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
- frame.renderPasses[1]->output_rect.ToString());
+ frame.render_passes[1]->output_rect.ToString());
EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
- frame.renderPasses[2]->output_rect.ToString());
+ frame.render_passes[2]->output_rect.ToString());
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestSimple,
AddsQuadsToContributingRenderPasses) {
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
// Each non-DelegatedRendererLayer added one RenderPass. The
// DelegatedRendererLayer added two contributing passes.
- ASSERT_EQ(5u, frame.renderPasses.size());
+ ASSERT_EQ(5u, frame.render_passes.size());
// The DelegatedRendererLayer should have added its contributing RenderPasses
// to the frame.
- EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
- EXPECT_EQ(1, frame.renderPasses[1]->id.index);
- EXPECT_EQ(4, frame.renderPasses[2]->id.layer_id);
- EXPECT_EQ(2, frame.renderPasses[2]->id.index);
+ EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
+ EXPECT_EQ(1, frame.render_passes[1]->id.index);
+ EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
+ EXPECT_EQ(2, frame.render_passes[2]->id.index);
// The DelegatedRendererLayer should have added copies of its quads to
// contributing RenderPasses.
- ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
+ ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
- frame.renderPasses[1]->quad_list[0]->rect.ToString());
+ frame.render_passes[1]->quad_list[0]->rect.ToString());
// Verify it added the right quads.
- ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
+ ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(),
- frame.renderPasses[2]->quad_list[0]->rect.ToString());
+ frame.render_passes[2]->quad_list[0]->rect.ToString());
EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
- frame.renderPasses[2]->quad_list[1]->rect.ToString());
- ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
+ frame.render_passes[2]->quad_list[1]->rect.ToString());
+ ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
- frame.renderPasses[1]->quad_list[0]->rect.ToString());
+ frame.render_passes[1]->quad_list[0]->rect.ToString());
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestSimple, AddsQuadsToTargetRenderPass) {
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
// Each non-DelegatedRendererLayer added one RenderPass. The
// DelegatedRendererLayer added two contributing passes.
- ASSERT_EQ(5u, frame.renderPasses.size());
+ ASSERT_EQ(5u, frame.render_passes.size());
// The layer's target is the RenderPass from m_layer_after.
- EXPECT_EQ(RenderPass::Id(3, 0), frame.renderPasses[3]->id);
+ EXPECT_EQ(RenderPass::Id(3, 0), frame.render_passes[3]->id);
// The DelegatedRendererLayer should have added copies of quads in its root
// RenderPass to its target RenderPass. The m_layer_after also adds one quad.
- ASSERT_EQ(2u, frame.renderPasses[3]->quad_list.size());
+ ASSERT_EQ(2u, frame.render_passes[3]->quad_list.size());
// Verify it added the right quads.
EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
- frame.renderPasses[3]->quad_list[0]->rect.ToString());
+ frame.render_passes[3]->quad_list[0]->rect.ToString());
// Its target layer should have a quad as well.
EXPECT_EQ(gfx::Rect(0, 0, 15, 15).ToString(),
- frame.renderPasses[3]->quad_list[1]->rect.ToString());
+ frame.render_passes[3]->quad_list[1]->rect.ToString());
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestSimple,
QuadsFromRootRenderPassAreModifiedForTheTarget) {
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
// Each non-DelegatedRendererLayer added one RenderPass. The
// DelegatedRendererLayer added two contributing passes.
- ASSERT_EQ(5u, frame.renderPasses.size());
+ ASSERT_EQ(5u, frame.render_passes.size());
// The DelegatedRendererLayer is at position 3,3 compared to its target, and
// has a translation transform of 1,1. So its root RenderPass' quads should
@@ -250,47 +250,47 @@
transform.Translate(4.0, 4.0);
transform.Scale(10.0 / 8.0, 10.0 / 8.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- transform, frame.renderPasses[3]->quad_list[0]->quadTransform());
+ transform, frame.render_passes[3]->quad_list[0]->quadTransform());
// Quads from non-root RenderPasses should not be shifted though.
- ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
+ ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(), frame.renderPasses[2]->quad_list[0]->quadTransform());
+ gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform());
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(), frame.renderPasses[2]->quad_list[1]->quadTransform());
- ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
+ gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform());
+ ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(), frame.renderPasses[1]->quad_list[0]->quadTransform());
+ gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform());
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestSimple, DoesNotOwnARenderSurface) {
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
// If the DelegatedRendererLayer is axis aligned and has opacity 1, then it
// has no need to be a renderSurface for the quads it carries.
EXPECT_FALSE(delegated_renderer_layer_->render_surface());
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestSimple, DoesOwnARenderSurfaceForOpacity) {
delegated_renderer_layer_->SetOpacity(0.5f);
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
// This test case has quads from multiple layers in the delegated renderer, so
// if the DelegatedRendererLayer has opacity < 1, it should end up with a
// render surface.
EXPECT_TRUE(delegated_renderer_layer_->render_surface());
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestSimple,
@@ -300,15 +300,15 @@
delegated_renderer_layer_->SetTransform(rotation);
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
// This test case has quads from multiple layers in the delegated renderer, so
// if the DelegatedRendererLayer has opacity < 1, it should end up with a
// render surface.
EXPECT_TRUE(delegated_renderer_layer_->render_surface());
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
class DelegatedRendererLayerImplTestOwnSurface
@@ -322,113 +322,113 @@
TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses) {
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
// Each non-DelegatedRendererLayer added one RenderPass. The
// DelegatedRendererLayer added two contributing passes and its owned surface
// added one pass.
- ASSERT_EQ(6u, frame.renderPasses.size());
+ ASSERT_EQ(6u, frame.render_passes.size());
// The DelegatedRendererLayer should have added its contributing RenderPasses
// to the frame.
- EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
- EXPECT_EQ(1, frame.renderPasses[1]->id.index);
- EXPECT_EQ(4, frame.renderPasses[2]->id.layer_id);
- EXPECT_EQ(2, frame.renderPasses[2]->id.index);
+ EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
+ EXPECT_EQ(1, frame.render_passes[1]->id.index);
+ EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
+ EXPECT_EQ(2, frame.render_passes[2]->id.index);
// The DelegatedRendererLayer should have added a RenderPass for its surface
// to the frame.
- EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
- EXPECT_EQ(0, frame.renderPasses[3]->id.index);
+ EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
+ EXPECT_EQ(0, frame.render_passes[3]->id.index);
// And all other RenderPasses should be non-delegated.
- EXPECT_NE(4, frame.renderPasses[0]->id.layer_id);
- EXPECT_EQ(0, frame.renderPasses[0]->id.index);
- EXPECT_NE(4, frame.renderPasses[4]->id.layer_id);
- EXPECT_EQ(0, frame.renderPasses[4]->id.index);
- EXPECT_NE(4, frame.renderPasses[5]->id.layer_id);
- EXPECT_EQ(0, frame.renderPasses[5]->id.index);
+ EXPECT_NE(4, frame.render_passes[0]->id.layer_id);
+ EXPECT_EQ(0, frame.render_passes[0]->id.index);
+ EXPECT_NE(4, frame.render_passes[4]->id.layer_id);
+ EXPECT_EQ(0, frame.render_passes[4]->id.index);
+ EXPECT_NE(4, frame.render_passes[5]->id.layer_id);
+ EXPECT_EQ(0, frame.render_passes[5]->id.index);
// The DelegatedRendererLayer should have added its RenderPasses to the frame
// in order.
EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
- frame.renderPasses[1]->output_rect.ToString());
+ frame.render_passes[1]->output_rect.ToString());
EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
- frame.renderPasses[2]->output_rect.ToString());
+ frame.render_passes[2]->output_rect.ToString());
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestOwnSurface,
AddsQuadsToContributingRenderPasses) {
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
// Each non-DelegatedRendererLayer added one RenderPass. The
// DelegatedRendererLayer added two contributing passes and its owned surface
// added one pass.
- ASSERT_EQ(6u, frame.renderPasses.size());
+ ASSERT_EQ(6u, frame.render_passes.size());
// The DelegatedRendererLayer should have added its contributing RenderPasses
// to the frame.
- EXPECT_EQ(4, frame.renderPasses[1]->id.layer_id);
- EXPECT_EQ(1, frame.renderPasses[1]->id.index);
- EXPECT_EQ(4, frame.renderPasses[2]->id.layer_id);
- EXPECT_EQ(2, frame.renderPasses[2]->id.index);
+ EXPECT_EQ(4, frame.render_passes[1]->id.layer_id);
+ EXPECT_EQ(1, frame.render_passes[1]->id.index);
+ EXPECT_EQ(4, frame.render_passes[2]->id.layer_id);
+ EXPECT_EQ(2, frame.render_passes[2]->id.index);
// The DelegatedRendererLayer should have added copies of its quads to
// contributing RenderPasses.
- ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
+ ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
- frame.renderPasses[1]->quad_list[0]->rect.ToString());
+ frame.render_passes[1]->quad_list[0]->rect.ToString());
// Verify it added the right quads.
- ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
+ ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
EXPECT_EQ(gfx::Rect(0, 0, 7, 7).ToString(),
- frame.renderPasses[2]->quad_list[0]->rect.ToString());
+ frame.render_passes[2]->quad_list[0]->rect.ToString());
EXPECT_EQ(gfx::Rect(6, 6, 6, 6).ToString(),
- frame.renderPasses[2]->quad_list[1]->rect.ToString());
- ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
+ frame.render_passes[2]->quad_list[1]->rect.ToString());
+ ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
EXPECT_EQ(gfx::Rect(0, 0, 6, 6).ToString(),
- frame.renderPasses[1]->quad_list[0]->rect.ToString());
+ frame.render_passes[1]->quad_list[0]->rect.ToString());
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsQuadsToTargetRenderPass) {
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
// Each non-DelegatedRendererLayer added one RenderPass. The
// DelegatedRendererLayer added two contributing passes and its owned surface
// added one pass.
- ASSERT_EQ(6u, frame.renderPasses.size());
+ ASSERT_EQ(6u, frame.render_passes.size());
// The layer's target is the RenderPass owned by itself.
- EXPECT_EQ(RenderPass::Id(4, 0), frame.renderPasses[3]->id);
+ EXPECT_EQ(RenderPass::Id(4, 0), frame.render_passes[3]->id);
// The DelegatedRendererLayer should have added copies of quads in its root
// RenderPass to its target RenderPass.
// The m_layer_after also adds one quad.
- ASSERT_EQ(1u, frame.renderPasses[3]->quad_list.size());
+ ASSERT_EQ(1u, frame.render_passes[3]->quad_list.size());
// Verify it added the right quads.
EXPECT_EQ(gfx::Rect(7, 7, 7, 7).ToString(),
- frame.renderPasses[3]->quad_list[0]->rect.ToString());
+ frame.render_passes[3]->quad_list[0]->rect.ToString());
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestOwnSurface,
QuadsFromRootRenderPassAreNotModifiedForTheTarget) {
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
// Each non-DelegatedRendererLayer added one RenderPass. The
// DelegatedRendererLayer added two contributing passes and its owned surface
// added one pass.
- ASSERT_EQ(6u, frame.renderPasses.size());
+ ASSERT_EQ(6u, frame.render_passes.size());
// Because the DelegatedRendererLayer owns a RenderSurfaceImpl, its root
// RenderPass' quads do not need to be translated at all. However, they are
@@ -436,20 +436,20 @@
gfx::Transform transform;
transform.Scale(10.0 / 8.0, 10.0 / 8.0);
EXPECT_TRANSFORMATION_MATRIX_EQ(
- transform, frame.renderPasses[3]->quad_list[0]->quadTransform());
+ transform, frame.render_passes[3]->quad_list[0]->quadTransform());
// Quads from non-root RenderPasses should not be shifted either.
- ASSERT_EQ(2u, frame.renderPasses[2]->quad_list.size());
+ ASSERT_EQ(2u, frame.render_passes[2]->quad_list.size());
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(), frame.renderPasses[2]->quad_list[0]->quadTransform());
+ gfx::Transform(), frame.render_passes[2]->quad_list[0]->quadTransform());
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(), frame.renderPasses[2]->quad_list[1]->quadTransform());
- ASSERT_EQ(1u, frame.renderPasses[1]->quad_list.size());
+ gfx::Transform(), frame.render_passes[2]->quad_list[1]->quadTransform());
+ ASSERT_EQ(1u, frame.render_passes[1]->quad_list.size());
EXPECT_TRANSFORMATION_MATRIX_EQ(
- gfx::Transform(), frame.renderPasses[1]->quad_list[0]->quadTransform());
+ gfx::Transform(), frame.render_passes[1]->quad_list[0]->quadTransform());
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
class DelegatedRendererLayerImplTestTransform
@@ -457,11 +457,11 @@
public:
void SetUpTest() {
scoped_ptr<LayerImpl> root_layer = LayerImpl::Create(
- host_impl_->activeTree(), 1);
+ host_impl_->active_tree(), 1);
scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
- FakeDelegatedRendererLayerImpl::Create(host_impl_->activeTree(), 2);
+ FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
- host_impl_->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+ host_impl_->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
root_layer->SetBounds(gfx::Size(100, 100));
delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
@@ -526,7 +526,8 @@
gfx::Transform());
MockQuadCuller quad_sink(pass->quad_list, pass->shared_quad_state_list);
AppendQuadsData data(pass->id);
- SharedQuadState* shared_quad_state = quad_sink.useSharedQuadState(SharedQuadState::Create());
+ SharedQuadState* shared_quad_state =
+ quad_sink.useSharedQuadState(SharedQuadState::Create());
shared_quad_state->SetAll(
root_pass_transform,
root_pass_content_bounds,
@@ -577,7 +578,7 @@
delegated_renderer_layer_ = delegated_renderer_layer.get();
root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
- host_impl_->activeTree()->SetRootLayer(root_layer.Pass());
+ host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
}
void VerifyRenderPasses(
@@ -585,19 +586,20 @@
size_t num_render_passes,
const SharedQuadState** root_delegated_shared_quad_state,
const SharedQuadState** contrib_delegated_shared_quad_state) {
- ASSERT_EQ(num_render_passes, frame.renderPasses.size());
+ ASSERT_EQ(num_render_passes, frame.render_passes.size());
// The contributing render pass in the DelegatedRendererLayer.
- EXPECT_EQ(2, frame.renderPasses[0]->id.layer_id);
- EXPECT_EQ(1, frame.renderPasses[0]->id.index);
+ EXPECT_EQ(2, frame.render_passes[0]->id.layer_id);
+ EXPECT_EQ(1, frame.render_passes[0]->id.index);
// The root render pass.
- EXPECT_EQ(1, frame.renderPasses.back()->id.layer_id);
- EXPECT_EQ(0, frame.renderPasses.back()->id.index);
+ EXPECT_EQ(1, frame.render_passes.back()->id.layer_id);
+ EXPECT_EQ(0, frame.render_passes.back()->id.index);
const QuadList& contrib_delegated_quad_list =
- frame.renderPasses[0]->quad_list;
+ frame.render_passes[0]->quad_list;
ASSERT_EQ(2u, contrib_delegated_quad_list.size());
- const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+ const QuadList& root_delegated_quad_list =
+ frame.render_passes[1]->quad_list;
ASSERT_EQ(5u, root_delegated_quad_list.size());
// All quads in a render pass should share the same state.
@@ -632,7 +634,7 @@
SetUpTest();
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
const SharedQuadState* root_delegated_shared_quad_state = NULL;
const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
@@ -677,8 +679,8 @@
expected,
contrib_delegated_shared_quad_state->content_to_target_transform);
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) {
@@ -686,7 +688,7 @@
SetUpTest();
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
const SharedQuadState* root_delegated_shared_quad_state = NULL;
const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
@@ -736,8 +738,8 @@
expected,
contrib_delegated_shared_quad_state->content_to_target_transform);
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) {
@@ -747,7 +749,7 @@
delegated_renderer_layer_->SetForceRenderSurface(true);
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
const SharedQuadState* root_delegated_shared_quad_state = NULL;
const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
@@ -791,8 +793,8 @@
expected,
contrib_delegated_shared_quad_state->content_to_target_transform);
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) {
@@ -802,7 +804,7 @@
delegated_renderer_layer_->SetForceRenderSurface(true);
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
const SharedQuadState* root_delegated_shared_quad_state = NULL;
const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
@@ -845,8 +847,8 @@
expected,
contrib_delegated_shared_quad_state->content_to_target_transform);
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
class DelegatedRendererLayerImplTestClip
@@ -854,15 +856,15 @@
public:
void SetUpTest() {
scoped_ptr<LayerImpl> root_layer =
- LayerImpl::Create(host_impl_->activeTree(), 1);
+ LayerImpl::Create(host_impl_->active_tree(), 1);
scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
- FakeDelegatedRendererLayerImpl::Create(host_impl_->activeTree(), 2);
+ FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
scoped_ptr<LayerImpl> clip_layer =
- LayerImpl::Create(host_impl_->activeTree(), 3);
+ LayerImpl::Create(host_impl_->active_tree(), 3);
scoped_ptr<LayerImpl> origin_layer =
- LayerImpl::Create(host_impl_->activeTree(), 4);
+ LayerImpl::Create(host_impl_->active_tree(), 4);
- host_impl_->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+ host_impl_->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
root_layer->SetBounds(gfx::Size(100, 100));
delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
@@ -987,7 +989,7 @@
root_layer->AddChild(delegated_renderer_layer.PassAs<LayerImpl>());
}
- host_impl_->activeTree()->SetRootLayer(root_layer.Pass());
+ host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
}
protected:
@@ -1004,13 +1006,13 @@
SetUpTest();
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
- ASSERT_EQ(2u, frame.renderPasses.size());
+ ASSERT_EQ(2u, frame.render_passes.size());
const QuadList& contrib_delegated_quad_list =
- frame.renderPasses[0]->quad_list;
+ frame.render_passes[0]->quad_list;
ASSERT_EQ(2u, contrib_delegated_quad_list.size());
- const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+ const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
ASSERT_EQ(5u, root_delegated_quad_list.size());
const SharedQuadState* root_delegated_shared_quad_state =
root_delegated_quad_list[0]->shared_quad_state;
@@ -1024,8 +1026,8 @@
// Quads are clipped to the delegated renderer layer.
EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestClip,
@@ -1035,14 +1037,14 @@
SetUpTest();
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
- ASSERT_EQ(2u, frame.renderPasses.size());
+ ASSERT_EQ(2u, frame.render_passes.size());
const QuadList& contrib_delegated_quad_list =
- frame.renderPasses[0]->quad_list;
+ frame.render_passes[0]->quad_list;
ASSERT_EQ(2u, contrib_delegated_quad_list.size());
const QuadList& root_delegated_quad_list =
- frame.renderPasses[1]->quad_list;
+ frame.render_passes[1]->quad_list;
ASSERT_EQ(5u, root_delegated_quad_list.size());
const SharedQuadState* root_delegated_shared_quad_state =
root_delegated_quad_list[0]->shared_quad_state;
@@ -1055,8 +1057,8 @@
// Quads came with a clip rect.
EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestClip,
@@ -1066,13 +1068,13 @@
SetUpTest();
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
- ASSERT_EQ(2u, frame.renderPasses.size());
+ ASSERT_EQ(2u, frame.render_passes.size());
const QuadList& contrib_delegated_quad_list =
- frame.renderPasses[0]->quad_list;
+ frame.render_passes[0]->quad_list;
ASSERT_EQ(2u, contrib_delegated_quad_list.size());
- const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+ const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
ASSERT_EQ(5u, root_delegated_quad_list.size());
const SharedQuadState* root_delegated_shared_quad_state =
root_delegated_quad_list[0]->shared_quad_state;
@@ -1087,8 +1089,8 @@
// Quads are clipped to the delegated renderer layer.
EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestClip,
@@ -1098,13 +1100,13 @@
SetUpTest();
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
- ASSERT_EQ(2u, frame.renderPasses.size());
+ ASSERT_EQ(2u, frame.render_passes.size());
const QuadList& contrib_delegated_quad_list =
- frame.renderPasses[0]->quad_list;
+ frame.render_passes[0]->quad_list;
ASSERT_EQ(2u, contrib_delegated_quad_list.size());
- const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+ const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
ASSERT_EQ(5u, root_delegated_quad_list.size());
const SharedQuadState* root_delegated_shared_quad_state =
root_delegated_quad_list[0]->shared_quad_state;
@@ -1118,8 +1120,8 @@
// Quads came with a clip rect.
EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestClip,
@@ -1131,13 +1133,13 @@
delegated_renderer_layer_->SetForceRenderSurface(true);
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
- ASSERT_EQ(3u, frame.renderPasses.size());
+ ASSERT_EQ(3u, frame.render_passes.size());
const QuadList& contrib_delegated_quad_list =
- frame.renderPasses[0]->quad_list;
+ frame.render_passes[0]->quad_list;
ASSERT_EQ(2u, contrib_delegated_quad_list.size());
- const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+ const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
ASSERT_EQ(5u, root_delegated_quad_list.size());
const SharedQuadState* root_delegated_shared_quad_state =
root_delegated_quad_list[0]->shared_quad_state;
@@ -1149,8 +1151,8 @@
// clip rect is ignored, and they are not set as clipped.
EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestClip,
@@ -1162,14 +1164,16 @@
delegated_renderer_layer_->SetForceRenderSurface(true);
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
- ASSERT_EQ(3u, frame.renderPasses.size());
- const QuadList& contrib_delegated_quad_list = frame.renderPasses[0]->quad_list;
+ ASSERT_EQ(3u, frame.render_passes.size());
+ const QuadList& contrib_delegated_quad_list =
+ frame.render_passes[0]->quad_list;
ASSERT_EQ(2u, contrib_delegated_quad_list.size());
- const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+ const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
ASSERT_EQ(5u, root_delegated_quad_list.size());
- const SharedQuadState* root_delegated_shared_quad_state = root_delegated_quad_list[0]->shared_quad_state;
+ const SharedQuadState* root_delegated_shared_quad_state =
+ root_delegated_quad_list[0]->shared_quad_state;
const SharedQuadState* contrib_delegated_shared_quad_state =
contrib_delegated_quad_list[0]->shared_quad_state;
@@ -1179,8 +1183,8 @@
// Quads came with a clip rect.
EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestClip,
@@ -1192,13 +1196,13 @@
delegated_renderer_layer_->SetForceRenderSurface(true);
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
- ASSERT_EQ(3u, frame.renderPasses.size());
+ ASSERT_EQ(3u, frame.render_passes.size());
const QuadList& contrib_delegated_quad_list =
- frame.renderPasses[0]->quad_list;
+ frame.render_passes[0]->quad_list;
ASSERT_EQ(2u, contrib_delegated_quad_list.size());
- const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+ const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
ASSERT_EQ(5u, root_delegated_quad_list.size());
const SharedQuadState* root_delegated_shared_quad_state =
root_delegated_quad_list[0]->shared_quad_state;
@@ -1210,8 +1214,8 @@
// clip rect is ignored, and they are not set as clipped.
EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
TEST_F(DelegatedRendererLayerImplTestClip, QuadsClipped_LayerClipped_Surface) {
@@ -1222,13 +1226,13 @@
delegated_renderer_layer_->SetForceRenderSurface(true);
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(host_impl_->prepareToDraw(frame));
+ EXPECT_TRUE(host_impl_->PrepareToDraw(&frame));
- ASSERT_EQ(3u, frame.renderPasses.size());
+ ASSERT_EQ(3u, frame.render_passes.size());
const QuadList& contrib_delegated_quad_list =
- frame.renderPasses[0]->quad_list;
+ frame.render_passes[0]->quad_list;
ASSERT_EQ(2u, contrib_delegated_quad_list.size());
- const QuadList& root_delegated_quad_list = frame.renderPasses[1]->quad_list;
+ const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
ASSERT_EQ(5u, root_delegated_quad_list.size());
const SharedQuadState* root_delegated_shared_quad_state =
root_delegated_quad_list[0]->shared_quad_state;
@@ -1243,8 +1247,8 @@
// Quads came with a clip rect.
EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
- host_impl_->drawLayers(frame);
- host_impl_->didDrawAllLayers(frame);
+ host_impl_->DrawLayers(&frame);
+ host_impl_->DidDrawAllLayers(frame);
}
} // namespace
diff --git a/cc/delegating_renderer_unittest.cc b/cc/delegating_renderer_unittest.cc
index 59d633f..69e5a46 100644
--- a/cc/delegating_renderer_unittest.cc
+++ b/cc/delegating_renderer_unittest.cc
@@ -44,7 +44,7 @@
virtual void afterTest() OVERRIDE {}
virtual bool prepareToDrawOnThread(
- LayerTreeHostImpl*, LayerTreeHostImpl::FrameData& frame, bool result)
+ LayerTreeHostImpl*, LayerTreeHostImpl::FrameData* frame, bool result)
OVERRIDE {
EXPECT_EQ(0u, output_surface_->num_sent_frames());
@@ -64,7 +64,7 @@
ASSERT_TRUE(last_frame.delegated_frame_data);
EXPECT_FALSE(last_frame.gl_frame_data);
EXPECT_EQ(
- gfx::Rect(host_impl->DeviceViewportSize()).ToString(),
+ gfx::Rect(host_impl->device_viewport_size()).ToString(),
last_frame_data->render_pass_list.back()->output_rect.ToString());
EXPECT_EQ(0.5f, last_frame.metadata.min_page_scale_factor);
EXPECT_EQ(4.f, last_frame.metadata.max_page_scale_factor);
@@ -89,27 +89,27 @@
virtual bool prepareToDrawOnThread(
LayerTreeHostImpl* host_impl,
- LayerTreeHostImpl::FrameData& frame,
+ LayerTreeHostImpl::FrameData* frame,
bool result) OVERRIDE {
- frame.renderPasses.clear();
- frame.renderPassesById.clear();
+ frame->render_passes.clear();
+ frame->render_passes_by_id.clear();
TestRenderPass* child_pass = addRenderPass(
- frame.renderPasses,
+ frame->render_passes,
RenderPass::Id(2, 1),
gfx::Rect(3, 3, 10, 10),
gfx::Transform());
child_pass->AppendOneOfEveryQuadType(
- host_impl->resourceProvider(), RenderPass::Id(0, 0));
+ host_impl->resource_provider(), RenderPass::Id(0, 0));
TestRenderPass* pass = addRenderPass(
- frame.renderPasses,
+ frame->render_passes,
RenderPass::Id(1, 1),
gfx::Rect(3, 3, 10, 10),
gfx::Transform());
pass->AppendOneOfEveryQuadType(
- host_impl->resourceProvider(), child_pass->id);
+ host_impl->resource_provider(), child_pass->id);
return true;
}
diff --git a/cc/gl_renderer_unittest.cc b/cc/gl_renderer_unittest.cc
index b844690..f9c24ba 100644
--- a/cc/gl_renderer_unittest.cc
+++ b/cc/gl_renderer_unittest.cc
@@ -67,7 +67,7 @@
: m_hostImpl(&m_proxy)
, m_setFullRootLayerDamageCount(0)
, m_lastCallWasSetVisibility(0)
- , m_rootLayer(LayerImpl::Create(m_hostImpl.activeTree(), 1))
+ , m_rootLayer(LayerImpl::Create(m_hostImpl.active_tree(), 1))
, m_memoryAllocationLimitBytes(PrioritizedResourceManager::defaultMemoryAllocationLimit())
{
m_rootLayer->CreateRenderSurface();
diff --git a/cc/input_handler.h b/cc/input_handler.h
index 712fa608..e6314b5 100644
--- a/cc/input_handler.h
+++ b/cc/input_handler.h
@@ -27,70 +27,72 @@
// The InputHandler is constructed with a InputHandlerClient, which is the
// interface by which the handler can manipulate the LayerTree.
class CC_EXPORT InputHandlerClient {
-public:
- enum ScrollStatus { ScrollOnMainThread, ScrollStarted, ScrollIgnored };
- enum ScrollInputType { Gesture, Wheel, NonBubblingGesture };
+ public:
+ enum ScrollStatus { ScrollOnMainThread, ScrollStarted, ScrollIgnored };
+ enum ScrollInputType { Gesture, Wheel, NonBubblingGesture };
- // Selects a layer to be scrolled at a given point in viewport (logical
- // pixel) coordinates. Returns ScrollStarted if the layer at the coordinates
- // can be scrolled, ScrollOnMainThread if the scroll event should instead be
- // delegated to the main thread, or ScrollIgnored if there is nothing to be
- // scrolled at the given coordinates.
- virtual ScrollStatus scrollBegin(gfx::Point, ScrollInputType) = 0;
+ // Selects a layer to be scrolled at a given point in viewport (logical
+ // pixel) coordinates. Returns ScrollStarted if the layer at the coordinates
+ // can be scrolled, ScrollOnMainThread if the scroll event should instead be
+ // delegated to the main thread, or ScrollIgnored if there is nothing to be
+ // scrolled at the given coordinates.
+ virtual ScrollStatus ScrollBegin(gfx::Point viewport_point,
+ ScrollInputType type) = 0;
- // Scroll the selected layer starting at the given position. If the scroll
- // type given to scrollBegin was a gesture, then the scroll point and delta
- // should be in viewport (logical pixel) coordinates. Otherwise they are in
- // scrolling layer's (logical pixel) space. If there is no room to move the
- // layer in the requested direction, its first ancestor layer that can be
- // scrolled will be moved instead. If no layer can be moved in the requested
- // direction at all, then false is returned. If any layer is moved, then
- // true is returned.
- // Should only be called if scrollBegin() returned ScrollStarted.
- virtual bool scrollBy(const gfx::Point&, const gfx::Vector2dF&) = 0;
+ // Scroll the selected layer starting at the given position. If the scroll
+ // type given to scrollBegin was a gesture, then the scroll point and delta
+ // should be in viewport (logical pixel) coordinates. Otherwise they are in
+ // scrolling layer's (logical pixel) space. If there is no room to move the
+ // layer in the requested direction, its first ancestor layer that can be
+ // scrolled will be moved instead. If no layer can be moved in the requested
+ // direction at all, then false is returned. If any layer is moved, then
+ // true is returned.
+ // Should only be called if ScrollBegin() returned ScrollStarted.
+ virtual bool ScrollBy(gfx::Point viewport_point,
+ gfx::Vector2dF scroll_delta) = 0;
- // Stop scrolling the selected layer. Should only be called if scrollBegin()
- // returned ScrollStarted.
- virtual void scrollEnd() = 0;
+ // Stop scrolling the selected layer. Should only be called if ScrollBegin()
+ // returned ScrollStarted.
+ virtual void ScrollEnd() = 0;
- virtual void pinchGestureBegin() = 0;
- virtual void pinchGestureUpdate(float magnifyDelta, gfx::Point anchor) = 0;
- virtual void pinchGestureEnd() = 0;
+ virtual void PinchGestureBegin() = 0;
+ virtual void PinchGestureUpdate(float magnify_delta, gfx::Point anchor) = 0;
+ virtual void PinchGestureEnd() = 0;
- virtual void startPageScaleAnimation(gfx::Vector2d targetOffset,
- bool anchorPoint,
- float pageScale,
- base::TimeTicks startTime,
- base::TimeDelta duration) = 0;
+ virtual void StartPageScaleAnimation(gfx::Vector2d target_offset,
+ bool anchor_point,
+ float page_scale,
+ base::TimeTicks start_time,
+ base::TimeDelta duration) = 0;
- // Request another callback to InputHandler::animate().
- virtual void scheduleAnimation() = 0;
+ // Request another callback to InputHandler::Animate().
+ virtual void ScheduleAnimation() = 0;
- virtual bool haveTouchEventHandlersAt(const gfx::Point&) = 0;
+ virtual bool HaveTouchEventHandlersAt(gfx::Point viewport_point) = 0;
-protected:
- InputHandlerClient() { }
- virtual ~InputHandlerClient() { }
+ protected:
+ InputHandlerClient() {}
+ virtual ~InputHandlerClient() {}
-private:
- DISALLOW_COPY_AND_ASSIGN(InputHandlerClient);
+ private:
+ DISALLOW_COPY_AND_ASSIGN(InputHandlerClient);
};
class CC_EXPORT InputHandler {
-public:
- virtual ~InputHandler() { }
+ public:
+ virtual ~InputHandler() {}
- virtual void bindToClient(InputHandlerClient*) = 0;
- virtual void animate(base::TimeTicks time) = 0;
- virtual void mainThreadHasStoppedFlinging() = 0;
+ virtual void BindToClient(InputHandlerClient* client) = 0;
+ virtual void Animate(base::TimeTicks time) = 0;
+ virtual void MainThreadHasStoppedFlinging() = 0;
-protected:
- InputHandler() { }
+ protected:
+ InputHandler() {}
-private:
- DISALLOW_COPY_AND_ASSIGN(InputHandler);
+ private:
+ DISALLOW_COPY_AND_ASSIGN(InputHandler);
};
-}
+} // namespace cc
#endif // CC_INPUT_HANDLER_H_
diff --git a/cc/layer_impl_unittest.cc b/cc/layer_impl_unittest.cc
index 56e4163..fbca63b 100644
--- a/cc/layer_impl_unittest.cc
+++ b/cc/layer_impl_unittest.cc
@@ -53,19 +53,19 @@
EXPECT_FALSE(grandChild->LayerPropertyChanged()); \
EXPECT_TRUE(root->LayerSurfacePropertyChanged())
-#define VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(codeToTest) \
- root->ResetAllChangeTrackingForSubtree(); \
- hostImpl.forcePrepareToDraw(); \
- EXPECT_FALSE(hostImpl.activeTree()->needs_update_draw_properties());\
- codeToTest; \
- EXPECT_TRUE(hostImpl.activeTree()->needs_update_draw_properties());
+#define VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(codeToTest) \
+ root->ResetAllChangeTrackingForSubtree(); \
+ hostImpl.ForcePrepareToDraw(); \
+ EXPECT_FALSE(hostImpl.active_tree()->needs_update_draw_properties()); \
+ codeToTest; \
+ EXPECT_TRUE(hostImpl.active_tree()->needs_update_draw_properties());
-#define VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(codeToTest) \
- root->ResetAllChangeTrackingForSubtree(); \
- hostImpl.forcePrepareToDraw(); \
- EXPECT_FALSE(hostImpl.activeTree()->needs_update_draw_properties());\
- codeToTest; \
- EXPECT_FALSE(hostImpl.activeTree()->needs_update_draw_properties());
+#define VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(codeToTest) \
+ root->ResetAllChangeTrackingForSubtree(); \
+ hostImpl.ForcePrepareToDraw(); \
+ EXPECT_FALSE(hostImpl.active_tree()->needs_update_draw_properties()); \
+ codeToTest; \
+ EXPECT_FALSE(hostImpl.active_tree()->needs_update_draw_properties());
TEST(LayerImplTest, verifyLayerChangesAreTrackedProperly)
{
@@ -77,11 +77,11 @@
// Create a simple LayerImpl tree:
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- EXPECT_TRUE(hostImpl.initializeRenderer(createFakeOutputSurface()));
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
- root->AddChild(LayerImpl::Create(hostImpl.activeTree(), 2));
+ EXPECT_TRUE(hostImpl.InitializeRenderer(createFakeOutputSurface()));
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
+ root->AddChild(LayerImpl::Create(hostImpl.active_tree(), 2));
LayerImpl* child = root->children()[0];
- child->AddChild(LayerImpl::Create(hostImpl.activeTree(), 3));
+ child->AddChild(LayerImpl::Create(hostImpl.active_tree(), 3));
LayerImpl* grandChild = child->children()[0];
// Adding children is an internal operation and should not mark layers as changed.
@@ -113,10 +113,10 @@
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitraryFilters));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(WebFilterOperations()));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilter(arbitraryFilter));
- EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMaskLayer(LayerImpl::Create(hostImpl.activeTree(), 4)));
+ EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMaskLayer(LayerImpl::Create(hostImpl.active_tree(), 4)));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMasksToBounds(true));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetContentsOpaque(true));
- EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetReplicaLayer(LayerImpl::Create(hostImpl.activeTree(), 5)));
+ EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetReplicaLayer(LayerImpl::Create(hostImpl.active_tree(), 5)));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPosition(arbitraryPointF));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPreserves3d(true));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetDoubleSided(false)); // constructor initializes it to "true".
@@ -174,8 +174,8 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- EXPECT_TRUE(hostImpl.initializeRenderer(createFakeOutputSurface()));
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+ EXPECT_TRUE(hostImpl.InitializeRenderer(createFakeOutputSurface()));
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
gfx::PointF arbitraryPointF = gfx::PointF(0.125f, 0.25f);
float arbitraryNumber = 0.352f;
@@ -205,7 +205,7 @@
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(arbitraryVector2d));
VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(gfx::Vector2d()));
root->SetScrollDelta(gfx::Vector2d(0, 0));
- hostImpl.forcePrepareToDraw();
+ hostImpl.ForcePrepareToDraw();
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetScrollDelta(arbitraryVector2d));
VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetScrollDelta(arbitraryVector2d));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetScrollOffset(arbitraryVector2d));
@@ -213,10 +213,10 @@
// Unrelated functions, always set to new values, always set needs update.
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetAnchorPointZ(arbitraryNumber));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMaskLayer(LayerImpl::Create(hostImpl.activeTree(), 4)));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMaskLayer(LayerImpl::Create(hostImpl.active_tree(), 4)));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMasksToBounds(true));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentsOpaque(true));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetReplicaLayer(LayerImpl::Create(hostImpl.activeTree(), 5)));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetReplicaLayer(LayerImpl::Create(hostImpl.active_tree(), 5)));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPosition(arbitraryPointF));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPreserves3d(true));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetDoubleSided(false)); // constructor initializes it to "true".
diff --git a/cc/layer_sorter_unittest.cc b/cc/layer_sorter_unittest.cc
index 3a492b9..58f653b 100644
--- a/cc/layer_sorter_unittest.cc
+++ b/cc/layer_sorter_unittest.cc
@@ -212,11 +212,11 @@
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
- scoped_ptr<LayerImpl> layer1 = LayerImpl::Create(host_impl.activeTree(), 1);
- scoped_ptr<LayerImpl> layer2 = LayerImpl::Create(host_impl.activeTree(), 2);
- scoped_ptr<LayerImpl> layer3 = LayerImpl::Create(host_impl.activeTree(), 3);
- scoped_ptr<LayerImpl> layer4 = LayerImpl::Create(host_impl.activeTree(), 4);
- scoped_ptr<LayerImpl> layer5 = LayerImpl::Create(host_impl.activeTree(), 5);
+ scoped_ptr<LayerImpl> layer1 = LayerImpl::Create(host_impl.active_tree(), 1);
+ scoped_ptr<LayerImpl> layer2 = LayerImpl::Create(host_impl.active_tree(), 2);
+ scoped_ptr<LayerImpl> layer3 = LayerImpl::Create(host_impl.active_tree(), 3);
+ scoped_ptr<LayerImpl> layer4 = LayerImpl::Create(host_impl.active_tree(), 4);
+ scoped_ptr<LayerImpl> layer5 = LayerImpl::Create(host_impl.active_tree(), 5);
gfx::Transform BehindMatrix;
BehindMatrix.Translate3d(0.0, 0.0, 2.0);
@@ -277,8 +277,8 @@
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
- scoped_ptr<LayerImpl> layer1 = LayerImpl::Create(host_impl.activeTree(), 1);
- scoped_ptr<LayerImpl> layer2 = LayerImpl::Create(host_impl.activeTree(), 2);
+ scoped_ptr<LayerImpl> layer1 = LayerImpl::Create(host_impl.active_tree(), 1);
+ scoped_ptr<LayerImpl> layer2 = LayerImpl::Create(host_impl.active_tree(), 2);
// Layer 1 should occur before layer 2 in paint. However, due to numeric
// issues in the sorter, it will put the layers in the wrong order
diff --git a/cc/layer_tree_host.cc b/cc/layer_tree_host.cc
index 8bee454..b56bdde 100644
--- a/cc/layer_tree_host.cc
+++ b/cc/layer_tree_host.cc
@@ -266,19 +266,19 @@
LayerTreeImpl* sync_tree;
if (settings_.implSidePainting) {
// Commits should not occur while there is already a pending tree.
- DCHECK(!host_impl->pendingTree());
- host_impl->createPendingTree();
- sync_tree = host_impl->pendingTree();
+ DCHECK(!host_impl->pending_tree());
+ host_impl->CreatePendingTree();
+ sync_tree = host_impl->pending_tree();
} else {
- contents_texture_manager_->reduceMemory(host_impl->resourceProvider());
- sync_tree = host_impl->activeTree();
+ contents_texture_manager_->reduceMemory(host_impl->resource_provider());
+ sync_tree = host_impl->active_tree();
}
if (needs_full_tree_sync_)
sync_tree->SetRootLayer(TreeSynchronizer::synchronizeTrees(
root_layer(), sync_tree->DetachLayerTree(), sync_tree)); {
TRACE_EVENT0("cc", "LayerTreeHost::PushProperties");
- TreeSynchronizer::pushProperties(root_layer(), sync_tree->RootLayer());
+ TreeSynchronizer::pushProperties(root_layer(), sync_tree->root_layer());
}
sync_tree->set_needs_full_tree_sync(needs_full_tree_sync_);
@@ -286,7 +286,7 @@
if (root_layer_ && hud_layer_) {
LayerImpl* hud_impl = LayerTreeHostCommon::findLayerInSubtree(
- sync_tree->RootLayer(), hud_layer_->id());
+ sync_tree->root_layer(), hud_layer_->id());
sync_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(hud_impl));
} else {
sync_tree->set_hud_layer(NULL);
@@ -304,8 +304,8 @@
// adjusted its delta prior to the pending tree being created.
// This code is equivalent to that in LayerTreeImpl::SetPageScaleDelta.
DCHECK_EQ(1.f, sync_tree->sent_page_scale_delta());
- page_scale_delta = host_impl->activeTree()->page_scale_delta();
- sent_page_scale_delta = host_impl->activeTree()->sent_page_scale_delta();
+ page_scale_delta = host_impl->active_tree()->page_scale_delta();
+ sent_page_scale_delta = host_impl->active_tree()->sent_page_scale_delta();
} else {
page_scale_delta = sync_tree->page_scale_delta();
sent_page_scale_delta = sync_tree->sent_page_scale_delta();
@@ -317,9 +317,9 @@
max_page_scale_factor_);
sync_tree->SetPageScaleDelta(page_scale_delta / sent_page_scale_delta);
- host_impl->setViewportSize(layout_viewport_size_, device_viewport_size_);
- host_impl->setDeviceScaleFactor(device_scale_factor_);
- host_impl->setDebugState(debug_state_);
+ host_impl->SetViewportSize(layout_viewport_size_, device_viewport_size_);
+ host_impl->SetDeviceScaleFactor(device_scale_factor_);
+ host_impl->SetDebugState(debug_state_);
DCHECK(!sync_tree->ViewportSizeInvalid());
@@ -335,7 +335,7 @@
}
if (debug_state_.continuousPainting)
- host_impl->savePaintTime(rendering_stats_.totalPaintTime, commit_number());
+ host_impl->SavePaintTime(rendering_stats_.totalPaintTime, commit_number());
commit_number_++;
}
@@ -373,11 +373,11 @@
LayerTreeHostImplClient* client) {
DCHECK(proxy_->IsImplThread());
scoped_ptr<LayerTreeHostImpl> host_impl =
- LayerTreeHostImpl::create(settings_, client, proxy_.get());
+ LayerTreeHostImpl::Create(settings_, client, proxy_.get());
if (settings_.calculateTopControlsPosition &&
- host_impl->topControlsManager()) {
+ host_impl->top_controls_manager()) {
top_controls_manager_weak_ptr_ =
- host_impl->topControlsManager()->AsWeakPtr();
+ host_impl->top_controls_manager()->AsWeakPtr();
}
return host_impl.Pass();
}
diff --git a/cc/layer_tree_host_common_unittest.cc b/cc/layer_tree_host_common_unittest.cc
index 1228d63..f690047 100644
--- a/cc/layer_tree_host_common_unittest.cc
+++ b/cc/layer_tree_host_common_unittest.cc
@@ -77,10 +77,10 @@
scoped_ptr<LayerImpl> createTreeForFixedPositionTests(LayerTreeHostImpl* hostImpl)
{
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl->activeTree(), 1);
- scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl->activeTree(), 2);
- scoped_ptr<LayerImpl> grandChild = LayerImpl::Create(hostImpl->activeTree(), 3);
- scoped_ptr<LayerImpl> greatGrandChild = LayerImpl::Create(hostImpl->activeTree(), 4);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl->active_tree(), 1);
+ scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl->active_tree(), 2);
+ scoped_ptr<LayerImpl> grandChild = LayerImpl::Create(hostImpl->active_tree(), 3);
+ scoped_ptr<LayerImpl> greatGrandChild = LayerImpl::Create(hostImpl->active_tree(), 4);
gfx::Transform IdentityMatrix;
gfx::PointF anchor(0, 0);
@@ -270,12 +270,12 @@
FakeLayerTreeHostImpl hostImpl(&proxy);
gfx::Transform identityMatrix;
- scoped_ptr<LayerImpl> sublayerScopedPtr(LayerImpl::Create(hostImpl.activeTree(), 1));
+ scoped_ptr<LayerImpl> sublayerScopedPtr(LayerImpl::Create(hostImpl.active_tree(), 1));
LayerImpl* sublayer = sublayerScopedPtr.get();
sublayer->SetContentsScale(kPageScale * kDeviceScale, kPageScale * kDeviceScale);
setLayerPropertiesForTesting(sublayer, identityMatrix, identityMatrix, gfx::Point(0, 0), gfx::PointF(0, 0), gfx::Size(500, 500), false);
- scoped_ptr<LayerImpl> scrollLayerScopedPtr(LayerImpl::Create(hostImpl.activeTree(), 2));
+ scoped_ptr<LayerImpl> scrollLayerScopedPtr(LayerImpl::Create(hostImpl.active_tree(), 2));
LayerImpl* scrollLayer = scrollLayerScopedPtr.get();
setLayerPropertiesForTesting(scrollLayer, identityMatrix, identityMatrix, gfx::PointF(0, 0), kScrollLayerPosition, gfx::Size(10, 20), false);
scrollLayer->SetScrollable(true);
@@ -286,7 +286,7 @@
scrollLayer->SetImplTransform(implTransform);
scrollLayer->AddChild(sublayerScopedPtr.Pass());
- scoped_ptr<LayerImpl> root(LayerImpl::Create(hostImpl.activeTree(), 3));
+ scoped_ptr<LayerImpl> root(LayerImpl::Create(hostImpl.active_tree(), 3));
setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(3, 4), false);
root->AddChild(scrollLayerScopedPtr.Pass());
@@ -1303,7 +1303,7 @@
// Add one more layer to the test tree for this scenario.
{
gfx::Transform identity;
- scoped_ptr<LayerImpl> fixedPositionChild = LayerImpl::Create(hostImpl.activeTree(), 5);
+ scoped_ptr<LayerImpl> fixedPositionChild = LayerImpl::Create(hostImpl.active_tree(), 5);
setLayerPropertiesForTesting(fixedPositionChild.get(), identity, identity, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
greatGrandChild->AddChild(fixedPositionChild.Pass());
}
@@ -2978,7 +2978,7 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
gfx::Transform identityMatrix;
gfx::PointF anchor(0, 0);
@@ -3020,8 +3020,8 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
- scoped_ptr<HeadsUpDisplayLayerImpl> hud = HeadsUpDisplayLayerImpl::Create(hostImpl.activeTree(), 11111);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
+ scoped_ptr<HeadsUpDisplayLayerImpl> hud = HeadsUpDisplayLayerImpl::Create(hostImpl.active_tree(), 11111);
gfx::Transform identityMatrix;
gfx::PointF anchor(0.f, 0.f);
@@ -3035,7 +3035,7 @@
setLayerPropertiesForTesting(hud.get(), identityMatrix, identityMatrix, anchor, position, hudBounds, false);
hud->SetDrawsContent(true);
- hostImpl.activeTree()->set_hud_layer(hud.get());
+ hostImpl.active_tree()->set_hud_layer(hud.get());
root->AddChild(hud.PassAs<LayerImpl>());
std::vector<LayerImpl*> renderSurfaceLayerList;
@@ -3071,7 +3071,7 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
gfx::Transform uninvertibleTransform;
uninvertibleTransform.matrix().setDouble(0, 0, 0);
@@ -3132,7 +3132,7 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
gfx::Transform identityMatrix;
gfx::PointF anchor(0, 0);
@@ -3175,7 +3175,7 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
gfx::Transform identityMatrix;
gfx::Transform rotation45DegreesAboutCenter;
@@ -3226,7 +3226,7 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
gfx::Transform identityMatrix;
@@ -3288,7 +3288,7 @@
//
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
gfx::Transform identityMatrix;
gfx::PointF anchor(0, 0);
@@ -3298,7 +3298,7 @@
{
gfx::PointF position(25, 25);
gfx::Size bounds(50, 50);
- scoped_ptr<LayerImpl> testLayer = LayerImpl::Create(hostImpl.activeTree(), 12345);
+ scoped_ptr<LayerImpl> testLayer = LayerImpl::Create(hostImpl.active_tree(), 12345);
setLayerPropertiesForTesting(testLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
// override contentBounds and contentsScale
@@ -3354,17 +3354,17 @@
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
{
- scoped_ptr<LayerImpl> clippingLayer = LayerImpl::Create(hostImpl.activeTree(), 123);
+ scoped_ptr<LayerImpl> clippingLayer = LayerImpl::Create(hostImpl.active_tree(), 123);
gfx::PointF position(25, 25); // this layer is positioned, and hit testing should correctly know where the layer is located.
gfx::Size bounds(50, 50);
setLayerPropertiesForTesting(clippingLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
clippingLayer->SetMasksToBounds(true);
- scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.activeTree(), 456);
+ scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.active_tree(), 456);
position = gfx::PointF(-50, -50);
bounds = gfx::Size(300, 300);
setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
@@ -3419,7 +3419,7 @@
//
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 123);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 123);
gfx::Transform identityMatrix;
gfx::PointF anchor(0, 0);
@@ -3429,9 +3429,9 @@
root->SetMasksToBounds(true);
{
- scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.activeTree(), 456);
- scoped_ptr<LayerImpl> grandChild = LayerImpl::Create(hostImpl.activeTree(), 789);
- scoped_ptr<LayerImpl> rotatedLeaf = LayerImpl::Create(hostImpl.activeTree(), 2468);
+ scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.active_tree(), 456);
+ scoped_ptr<LayerImpl> grandChild = LayerImpl::Create(hostImpl.active_tree(), 789);
+ scoped_ptr<LayerImpl> rotatedLeaf = LayerImpl::Create(hostImpl.active_tree(), 2468);
position = gfx::PointF(10, 10);
bounds = gfx::Size(80, 80);
@@ -3522,11 +3522,11 @@
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
{
- scoped_ptr<LayerImpl> intermediateLayer = LayerImpl::Create(hostImpl.activeTree(), 123);
+ scoped_ptr<LayerImpl> intermediateLayer = LayerImpl::Create(hostImpl.active_tree(), 123);
gfx::PointF position(10, 10); // this layer is positioned, and hit testing should correctly know where the layer is located.
gfx::Size bounds(50, 50);
setLayerPropertiesForTesting(intermediateLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
@@ -3536,7 +3536,7 @@
// The child of the intermediateLayer is translated so that it does not overlap intermediateLayer at all.
// If child is incorrectly clipped, we would not be able to hit it successfully.
- scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.activeTree(), 456);
+ scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.active_tree(), 456);
position = gfx::PointF(60, 60); // 70, 70 in screen space
bounds = gfx::Size(20, 20);
setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
@@ -3580,7 +3580,7 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
gfx::Transform identityMatrix;
gfx::PointF anchor(0, 0);
@@ -3595,9 +3595,9 @@
// The expected stacking order is:
// (front) child2, (second) grandChild, (third) child1, and (back) the root layer behind all other layers.
- scoped_ptr<LayerImpl> child1 = LayerImpl::Create(hostImpl.activeTree(), 2);
- scoped_ptr<LayerImpl> child2 = LayerImpl::Create(hostImpl.activeTree(), 3);
- scoped_ptr<LayerImpl> grandChild1 = LayerImpl::Create(hostImpl.activeTree(), 4);
+ scoped_ptr<LayerImpl> child1 = LayerImpl::Create(hostImpl.active_tree(), 2);
+ scoped_ptr<LayerImpl> child2 = LayerImpl::Create(hostImpl.active_tree(), 3);
+ scoped_ptr<LayerImpl> grandChild1 = LayerImpl::Create(hostImpl.active_tree(), 4);
position = gfx::PointF(10, 10);
bounds = gfx::Size(50, 50);
@@ -3685,7 +3685,7 @@
//
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
gfx::Transform identityMatrix;
gfx::PointF anchor(0, 0);
@@ -3700,9 +3700,9 @@
// The expected stacking order is:
// (front) child2, (second) grandChild, (third) child1, and (back) the root layer behind all other layers.
- scoped_ptr<LayerImpl> child1 = LayerImpl::Create(hostImpl.activeTree(), 2);
- scoped_ptr<LayerImpl> child2 = LayerImpl::Create(hostImpl.activeTree(), 3);
- scoped_ptr<LayerImpl> grandChild1 = LayerImpl::Create(hostImpl.activeTree(), 4);
+ scoped_ptr<LayerImpl> child1 = LayerImpl::Create(hostImpl.active_tree(), 2);
+ scoped_ptr<LayerImpl> child2 = LayerImpl::Create(hostImpl.active_tree(), 3);
+ scoped_ptr<LayerImpl> grandChild1 = LayerImpl::Create(hostImpl.active_tree(), 4);
position = gfx::PointF(10, 10);
bounds = gfx::Size(50, 50);
@@ -3809,7 +3809,7 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
gfx::Transform identityMatrix;
Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
@@ -3867,7 +3867,7 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
gfx::Transform uninvertibleTransform;
uninvertibleTransform.matrix().setDouble(0, 0, 0);
@@ -3930,7 +3930,7 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
gfx::Transform identityMatrix;
Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
@@ -3990,7 +3990,7 @@
//
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
gfx::Transform identityMatrix;
gfx::PointF anchor(0, 0);
@@ -4001,7 +4001,7 @@
Region touchHandlerRegion(gfx::Rect(10, 10, 30, 30));
gfx::PointF position(25, 25);
gfx::Size bounds(50, 50);
- scoped_ptr<LayerImpl> testLayer = LayerImpl::Create(hostImpl.activeTree(), 12345);
+ scoped_ptr<LayerImpl> testLayer = LayerImpl::Create(hostImpl.active_tree(), 12345);
setLayerPropertiesForTesting(testLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
// override contentBounds and contentsScale
@@ -4064,7 +4064,7 @@
// be able to hit the touch handler region by scaling the points accordingly.
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
gfx::Transform identityMatrix;
gfx::PointF anchor(0, 0);
@@ -4075,7 +4075,7 @@
Region touchHandlerRegion(gfx::Rect(10, 10, 30, 30));
gfx::PointF position(25, 25);
gfx::Size bounds(50, 50);
- scoped_ptr<LayerImpl> testLayer = LayerImpl::Create(hostImpl.activeTree(), 12345);
+ scoped_ptr<LayerImpl> testLayer = LayerImpl::Create(hostImpl.active_tree(), 12345);
setLayerPropertiesForTesting(testLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
testLayer->SetDrawsContent(true);
@@ -4152,17 +4152,17 @@
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
{
- scoped_ptr<LayerImpl> clippingLayer = LayerImpl::Create(hostImpl.activeTree(), 123);
+ scoped_ptr<LayerImpl> clippingLayer = LayerImpl::Create(hostImpl.active_tree(), 123);
gfx::PointF position(25, 25); // this layer is positioned, and hit testing should correctly know where the layer is located.
gfx::Size bounds(50, 50);
setLayerPropertiesForTesting(clippingLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
clippingLayer->SetMasksToBounds(true);
- scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.activeTree(), 456);
+ scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.active_tree(), 456);
Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
position = gfx::PointF(-50, -50);
bounds = gfx::Size(300, 300);
diff --git a/cc/layer_tree_host_impl.cc b/cc/layer_tree_host_impl.cc
index 3e20336b..3c13252 100644
--- a/cc/layer_tree_host_impl.cc
+++ b/cc/layer_tree_host_impl.cc
@@ -50,1691 +50,1882 @@
namespace {
-void didVisibilityChange(cc::LayerTreeHostImpl* id, bool visible)
-{
- if (visible) {
- TRACE_EVENT_ASYNC_BEGIN1("webkit", "LayerTreeHostImpl::setVisible", id, "LayerTreeHostImpl", id);
- return;
- }
+void DidVisibilityChange(cc::LayerTreeHostImpl* id, bool visible) {
+ if (visible) {
+ TRACE_EVENT_ASYNC_BEGIN1("webkit",
+ "LayerTreeHostImpl::SetVisible",
+ id,
+ "LayerTreeHostImpl",
+ id);
+ return;
+ }
- TRACE_EVENT_ASYNC_END0("webkit", "LayerTreeHostImpl::setVisible", id);
+ TRACE_EVENT_ASYNC_END0("webkit", "LayerTreeHostImpl::SetVisible", id);
}
-std::string ValueToString(scoped_ptr<base::Value> value)
-{
- std::string str;
- base::JSONWriter::Write(value.get(), &str);
- return str;
+std::string ValueToString(scoped_ptr<base::Value> value) {
+ std::string str;
+ base::JSONWriter::Write(value.get(), &str);
+ return str;
}
-} // namespace
+} // namespace
namespace cc {
class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
-public:
- static scoped_ptr<LayerTreeHostImplTimeSourceAdapter> Create(LayerTreeHostImpl* layerTreeHostImpl, scoped_refptr<DelayBasedTimeSource> timeSource)
- {
- return make_scoped_ptr(new LayerTreeHostImplTimeSourceAdapter(layerTreeHostImpl, timeSource));
- }
- virtual ~LayerTreeHostImplTimeSourceAdapter()
- {
- m_timeSource->setClient(0);
- m_timeSource->setActive(false);
+ public:
+ static scoped_ptr<LayerTreeHostImplTimeSourceAdapter> Create(
+ LayerTreeHostImpl* layer_tree_host_impl,
+ scoped_refptr<DelayBasedTimeSource> time_source) {
+ return make_scoped_ptr(
+ new LayerTreeHostImplTimeSourceAdapter(layer_tree_host_impl,
+ time_source));
+ }
+ virtual ~LayerTreeHostImplTimeSourceAdapter() {
+ time_source_->setClient(NULL);
+ time_source_->setActive(false);
+ }
+
+ virtual void onTimerTick() OVERRIDE {
+ // In single threaded mode we attempt to simulate changing the current
+ // thread by maintaining a fake thread id. When we switch from one
+ // thread to another, we construct DebugScopedSetXXXThread objects that
+ // update the thread id. This lets DCHECKS that ensure we're on the
+ // right thread to work correctly in single threaded mode. The problem
+ // here is that the timer tasks are run via the message loop, and when
+ // they run, we've had no chance to construct a DebugScopedSetXXXThread
+ // object. The result is that we report that we're running on the main
+ // thread. In multi-threaded mode, this timer is run on the compositor
+ // thread, so to keep this consistent in single-threaded mode, we'll
+ // construct a DebugScopedSetImplThread object. There is no need to do
+ // this in multi-threaded mode since the real thread id's will be
+ // correct. In fact, setting fake thread id's interferes with the real
+ // thread id's and causes breakage.
+ scoped_ptr<DebugScopedSetImplThread> set_impl_thread;
+ if (!layer_tree_host_impl_->proxy()->HasImplThread()) {
+ set_impl_thread.reset(
+ new DebugScopedSetImplThread(layer_tree_host_impl_->proxy()));
}
- virtual void onTimerTick() OVERRIDE
- {
- // In single threaded mode we attempt to simulate changing the current
- // thread by maintaining a fake thread id. When we switch from one
- // thread to another, we construct DebugScopedSetXXXThread objects that
- // update the thread id. This lets DCHECKS that ensure we're on the
- // right thread to work correctly in single threaded mode. The problem
- // here is that the timer tasks are run via the message loop, and when
- // they run, we've had no chance to construct a DebugScopedSetXXXThread
- // object. The result is that we report that we're running on the main
- // thread. In multi-threaded mode, this timer is run on the compositor
- // thread, so to keep this consistent in single-threaded mode, we'll
- // construct a DebugScopedSetImplThread object. There is no need to do
- // this in multi-threaded mode since the real thread id's will be
- // correct. In fact, setting fake thread id's interferes with the real
- // thread id's and causes breakage.
- scoped_ptr<DebugScopedSetImplThread> setImplThread;
- if (!m_layerTreeHostImpl->proxy()->HasImplThread())
- setImplThread.reset(new DebugScopedSetImplThread(m_layerTreeHostImpl->proxy()));
+ layer_tree_host_impl_->ActivatePendingTreeIfNeeded();
+ layer_tree_host_impl_->Animate(base::TimeTicks::Now(), base::Time::Now());
+ layer_tree_host_impl_->BeginNextFrame();
+ }
- m_layerTreeHostImpl->activatePendingTreeIfNeeded();
- m_layerTreeHostImpl->animate(base::TimeTicks::Now(), base::Time::Now());
- m_layerTreeHostImpl->beginNextFrame();
- }
+ void SetActive(bool active) {
+ if (active != time_source_->active())
+ time_source_->setActive(active);
+ }
- void setActive(bool active)
- {
- if (active != m_timeSource->active())
- m_timeSource->setActive(active);
- }
+ private:
+ LayerTreeHostImplTimeSourceAdapter(
+ LayerTreeHostImpl* layer_tree_host_impl,
+ scoped_refptr<DelayBasedTimeSource> time_source)
+ : layer_tree_host_impl_(layer_tree_host_impl),
+ time_source_(time_source) {
+ time_source_->setClient(this);
+ }
-private:
- LayerTreeHostImplTimeSourceAdapter(LayerTreeHostImpl* layerTreeHostImpl, scoped_refptr<DelayBasedTimeSource> timeSource)
- : m_layerTreeHostImpl(layerTreeHostImpl)
- , m_timeSource(timeSource)
- {
- m_timeSource->setClient(this);
- }
+ LayerTreeHostImpl* layer_tree_host_impl_;
+ scoped_refptr<DelayBasedTimeSource> time_source_;
- LayerTreeHostImpl* m_layerTreeHostImpl;
- scoped_refptr<DelayBasedTimeSource> m_timeSource;
-
- DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImplTimeSourceAdapter);
+ DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImplTimeSourceAdapter);
};
LayerTreeHostImpl::FrameData::FrameData()
- : containsIncompleteTile(false)
-{
+ : contains_incomplete_tile(false) {}
+
+LayerTreeHostImpl::FrameData::~FrameData() {}
+
+scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::Create(
+ const LayerTreeSettings& settings,
+ LayerTreeHostImplClient* client,
+ Proxy* proxy) {
+ return make_scoped_ptr(new LayerTreeHostImpl(settings, client, proxy));
}
-LayerTreeHostImpl::FrameData::~FrameData()
-{
+LayerTreeHostImpl::LayerTreeHostImpl(const LayerTreeSettings& settings,
+ LayerTreeHostImplClient* client,
+ Proxy* proxy)
+ : client_(client),
+ proxy_(proxy),
+ did_lock_scrolling_layer_(false),
+ should_bubble_scrolls_(false),
+ wheel_scrolling_(false),
+ settings_(settings),
+ device_scale_factor_(1.f),
+ visible_(true),
+ managed_memory_policy_(
+ PrioritizedResourceManager::defaultMemoryAllocationLimit(),
+ ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING,
+ 0,
+ ManagedMemoryPolicy::CUTOFF_ALLOW_NOTHING),
+ pinch_gesture_active_(false),
+ fps_counter_(FrameRateCounter::create(proxy_->HasImplThread())),
+ paint_time_counter_(PaintTimeCounter::create()),
+ memory_history_(MemoryHistory::Create()),
+ debug_rect_history_(DebugRectHistory::create()),
+ num_impl_thread_scrolls_(0),
+ num_main_thread_scrolls_(0),
+ cumulative_num_layers_drawn_(0),
+ cumulative_num_missing_tiles_(0),
+ last_sent_memory_visible_bytes_(0),
+ last_sent_memory_visible_and_nearby_bytes_(0),
+ last_sent_memory_use_bytes_(0),
+ animation_registrar_(AnimationRegistrar::create()) {
+ DCHECK(proxy_->IsImplThread());
+ DidVisibilityChange(this, visible_);
+
+ SetDebugState(settings.initialDebugState);
+
+ if (settings.calculateTopControlsPosition) {
+ top_controls_manager_ =
+ TopControlsManager::Create(this,
+ settings.topControlsHeight,
+ settings.topControlsShowThreshold,
+ settings.topControlsHideThreshold);
+ }
+
+ SetDebugState(settings.initialDebugState);
+
+ // LTHI always has an active tree.
+ active_tree_ = LayerTreeImpl::create(this);
}
-scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::create(const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
-{
- return make_scoped_ptr(new LayerTreeHostImpl(settings, client, proxy));
+LayerTreeHostImpl::~LayerTreeHostImpl() {
+ DCHECK(proxy_->IsImplThread());
+ TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
+
+ if (active_tree_->root_layer()) {
+ ClearRenderSurfaces();
+ // The layer trees must be destroyed before the layer tree host. We've
+ // made a contract with our animation controllers that the registrar
+ // will outlive them, and we must make good.
+ recycle_tree_.reset();
+ pending_tree_.reset();
+ active_tree_.reset();
+ }
}
-LayerTreeHostImpl::LayerTreeHostImpl(const LayerTreeSettings& settings, LayerTreeHostImplClient* client, Proxy* proxy)
- : m_client(client)
- , m_proxy(proxy)
- , m_didLockScrollingLayer(false)
- , m_shouldBubbleScrolls(false)
- , m_wheelScrolling(false)
- , m_settings(settings)
- , m_deviceScaleFactor(1)
- , m_visible(true)
- , m_managedMemoryPolicy(PrioritizedResourceManager::defaultMemoryAllocationLimit(),
- ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING,
- 0,
- ManagedMemoryPolicy::CUTOFF_ALLOW_NOTHING)
- , m_pinchGestureActive(false)
- , m_fpsCounter(FrameRateCounter::create(m_proxy->HasImplThread()))
- , m_paintTimeCounter(PaintTimeCounter::create())
- , m_memoryHistory(MemoryHistory::Create())
- , m_debugRectHistory(DebugRectHistory::create())
- , m_numImplThreadScrolls(0)
- , m_numMainThreadScrolls(0)
- , m_cumulativeNumLayersDrawn(0)
- , m_cumulativeNumMissingTiles(0)
- , m_lastSentMemoryVisibleBytes(0)
- , m_lastSentMemoryVisibleAndNearbyBytes(0)
- , m_lastSentMemoryUseBytes(0)
- , m_animationRegistrar(AnimationRegistrar::create())
-{
- DCHECK(m_proxy->IsImplThread());
- didVisibilityChange(this, m_visible);
+void LayerTreeHostImpl::BeginCommit() {}
- setDebugState(settings.initialDebugState);
+void LayerTreeHostImpl::CommitComplete() {
+ TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
- if (settings.calculateTopControlsPosition) {
- m_topControlsManager = TopControlsManager::Create(this,
- settings.topControlsHeight,
- settings.topControlsShowThreshold,
- settings.topControlsHideThreshold);
- }
+ // Impl-side painting needs an update immediately post-commit to have the
+ // opportunity to create tilings. Other paths can call UpdateDrawProperties
+ // more lazily when needed prior to drawing.
+ if (settings_.implSidePainting) {
+ pending_tree_->set_needs_update_draw_properties();
+ pending_tree_->UpdateDrawProperties(LayerTreeImpl::UPDATE_PENDING_TREE);
+ } else {
+ active_tree_->set_needs_update_draw_properties();
+ }
- setDebugState(settings.initialDebugState);
-
- // LTHI always has an active tree.
- m_activeTree = LayerTreeImpl::create(this);
+ client_->SendManagedMemoryStats();
}
-LayerTreeHostImpl::~LayerTreeHostImpl()
-{
- DCHECK(m_proxy->IsImplThread());
- TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
+bool LayerTreeHostImpl::CanDraw() {
+ // Note: If you are changing this function or any other function that might
+ // affect the result of CanDraw, make sure to call
+ // client_->OnCanDrawStateChanged in the proper places and update the
+ // NotifyIfCanDrawChanged test.
- if (rootLayer()) {
- clearRenderSurfaces();
- // The layer trees must be destroyed before the layer tree host. We've
- // made a contract with our animation controllers that the registrar
- // will outlive them, and we must make good.
- m_recycleTree.reset();
- m_pendingTree.reset();
- m_activeTree.reset();
- }
-}
-
-void LayerTreeHostImpl::beginCommit()
-{
-}
-
-void LayerTreeHostImpl::commitComplete()
-{
- TRACE_EVENT0("cc", "LayerTreeHostImpl::commitComplete");
-
- // Impl-side painting needs an update immediately post-commit to have the
- // opportunity to create tilings. Other paths can call updateDrawProperties
- // more lazily when needed prior to drawing.
- if (m_settings.implSidePainting) {
- pendingTree()->set_needs_update_draw_properties();
- pendingTree()->UpdateDrawProperties(LayerTreeImpl::UPDATE_PENDING_TREE);
- } else {
- activeTree()->set_needs_update_draw_properties();
- }
-
- m_client->sendManagedMemoryStats();
-}
-
-bool LayerTreeHostImpl::canDraw()
-{
- // Note: If you are changing this function or any other function that might
- // affect the result of canDraw, make sure to call m_client->onCanDrawStateChanged
- // in the proper places and update the notifyIfCanDrawChanged test.
-
- if (!rootLayer()) {
- TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw no root layer");
- return false;
- }
- if (DeviceViewportSize().IsEmpty()) {
- TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw empty viewport");
- return false;
- }
- if (m_activeTree->ViewportSizeInvalid()) {
- TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw viewport size recently changed");
- return false;
- }
- if (!m_renderer) {
- TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw no renderer");
- return false;
- }
- if (m_activeTree->ContentsTexturesPurged()) {
- TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw contents textures purged");
- return false;
- }
- return true;
-}
-
-OutputSurface* LayerTreeHostImpl::outputSurface() const
-{
- return m_outputSurface.get();
-}
-
-void LayerTreeHostImpl::animate(base::TimeTicks monotonicTime, base::Time wallClockTime)
-{
- animatePageScale(monotonicTime);
- animateLayers(monotonicTime, wallClockTime);
- animateScrollbars(monotonicTime);
- if (m_topControlsManager)
- m_topControlsManager->Animate(monotonicTime);
-}
-
-void LayerTreeHostImpl::manageTiles()
-{
- DCHECK(m_tileManager);
- m_tileManager->ManageTiles();
-
- size_t memoryRequiredBytes;
- size_t memoryNiceToHaveBytes;
- size_t memoryUsedBytes;
- m_tileManager->GetMemoryStats(&memoryRequiredBytes,
- &memoryNiceToHaveBytes,
- &memoryUsedBytes);
- sendManagedMemoryStats(memoryRequiredBytes,
- memoryNiceToHaveBytes,
- memoryUsedBytes);
-}
-
-void LayerTreeHostImpl::startPageScaleAnimation(gfx::Vector2d targetOffset, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)
-{
- if (!rootScrollLayer())
- return;
-
- gfx::Vector2dF scrollTotal = rootScrollLayer()->scroll_offset() + rootScrollLayer()->scroll_delta();
- gfx::SizeF scaledScrollableSize = activeTree()->ScrollableSize();
- gfx::SizeF viewportSize = gfx::ScaleSize(m_deviceViewportSize, 1 / m_deviceScaleFactor);
-
- double startTimeSeconds = (startTime - base::TimeTicks()).InSecondsF();
- m_pageScaleAnimation = PageScaleAnimation::Create(scrollTotal, activeTree()->total_page_scale_factor(), viewportSize, scaledScrollableSize, startTimeSeconds);
-
- if (anchorPoint) {
- gfx::Vector2dF anchor(targetOffset);
- m_pageScaleAnimation->ZoomWithAnchor(anchor, pageScale, duration.InSecondsF());
- } else {
- gfx::Vector2dF scaledTargetOffset = targetOffset;
- m_pageScaleAnimation->ZoomTo(scaledTargetOffset, pageScale, duration.InSecondsF());
- }
-
- m_client->setNeedsRedrawOnImplThread();
- m_client->setNeedsCommitOnImplThread();
- m_client->renewTreePriority();
-}
-
-void LayerTreeHostImpl::scheduleAnimation()
-{
- m_client->setNeedsRedrawOnImplThread();
-}
-
-bool LayerTreeHostImpl::haveTouchEventHandlersAt(const gfx::Point& viewportPoint)
-{
- if (!ensureRenderSurfaceLayerList())
- return false;
-
- gfx::PointF deviceViewportPoint = gfx::ScalePoint(viewportPoint, m_deviceScaleFactor);
-
- // First find out which layer was hit from the saved list of visible layers
- // in the most recent frame.
- LayerImpl* layerImpl = LayerTreeHostCommon::findLayerThatIsHitByPoint(deviceViewportPoint, activeTree()->RenderSurfaceLayerList());
-
- // Walk up the hierarchy and look for a layer with a touch event handler region that the given point hits.
- for (; layerImpl; layerImpl = layerImpl->parent()) {
- if (LayerTreeHostCommon::layerHasTouchEventHandlersAt(deviceViewportPoint,layerImpl))
- return true;
- }
-
+ if (!active_tree_->root_layer()) {
+ TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no root layer");
return false;
+ }
+ if (device_viewport_size_.IsEmpty()) {
+ TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw empty viewport");
+ return false;
+ }
+ if (active_tree_->ViewportSizeInvalid()) {
+ TRACE_EVENT_INSTANT0(
+ "cc", "LayerTreeHostImpl::CanDraw viewport size recently changed");
+ return false;
+ }
+ if (!renderer_) {
+ TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::CanDraw no renderer");
+ return false;
+ }
+ if (active_tree_->ContentsTexturesPurged()) {
+ TRACE_EVENT_INSTANT0(
+ "cc", "LayerTreeHostImpl::CanDraw contents textures purged");
+ return false;
+ }
+ return true;
}
-void LayerTreeHostImpl::trackDamageForAllSurfaces(LayerImpl* rootDrawLayer, const LayerList& renderSurfaceLayerList)
-{
- // For now, we use damage tracking to compute a global scissor. To do this, we must
- // compute all damage tracking before drawing anything, so that we know the root
- // damage rect. The root damage rect is then used to scissor each surface.
-
- for (int surfaceIndex = renderSurfaceLayerList.size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
- LayerImpl* renderSurfaceLayer = renderSurfaceLayerList[surfaceIndex];
- RenderSurfaceImpl* renderSurface = renderSurfaceLayer->render_surface();
- DCHECK(renderSurface);
- renderSurface->damage_tracker()->UpdateDamageTrackingState(renderSurface->layer_list(), renderSurfaceLayer->id(), renderSurface->SurfacePropertyChangedOnlyFromDescendant(), renderSurface->content_rect(), renderSurfaceLayer->mask_layer(), renderSurfaceLayer->filters(), renderSurfaceLayer->filter().get());
- }
+void LayerTreeHostImpl::Animate(base::TimeTicks monotonic_time,
+ base::Time wall_clock_time) {
+ AnimatePageScale(monotonic_time);
+ AnimateLayers(monotonic_time, wall_clock_time);
+ AnimateScrollbars(monotonic_time);
+ if (top_controls_manager_)
+ top_controls_manager_->Animate(monotonic_time);
}
-void LayerTreeHostImpl::FrameData::appendRenderPass(scoped_ptr<RenderPass> renderPass)
-{
- renderPassesById[renderPass->id] = renderPass.get();
- renderPasses.push_back(renderPass.Pass());
+void LayerTreeHostImpl::ManageTiles() {
+ DCHECK(tile_manager_);
+ tile_manager_->ManageTiles();
+
+ size_t memory_required_bytes;
+ size_t memory_nice_to_have_bytes;
+ size_t memory_used_bytes;
+ tile_manager_->GetMemoryStats(&memory_required_bytes,
+ &memory_nice_to_have_bytes,
+ &memory_used_bytes);
+ SendManagedMemoryStats(memory_required_bytes,
+ memory_nice_to_have_bytes,
+ memory_used_bytes);
}
-static void appendQuadsForLayer(RenderPass* targetRenderPass, LayerImpl* layer, OcclusionTrackerImpl& occlusionTracker, AppendQuadsData& appendQuadsData)
-{
- bool forSurface = false;
- QuadCuller quadCuller(targetRenderPass->quad_list,
- targetRenderPass->shared_quad_state_list,
- layer,
- occlusionTracker,
- layer->ShowDebugBorders(),
- forSurface);
- layer->AppendQuads(&quadCuller, &appendQuadsData);
+void LayerTreeHostImpl::StartPageScaleAnimation(gfx::Vector2d target_offset,
+ bool anchor_point,
+ float page_scale,
+ base::TimeTicks start_time,
+ base::TimeDelta duration) {
+ if (!RootScrollLayer())
+ return;
+
+ gfx::Vector2dF scroll_total =
+ RootScrollLayer()->scroll_offset() + RootScrollLayer()->scroll_delta();
+ gfx::SizeF scaled_scrollable_size = active_tree_->ScrollableSize();
+ gfx::SizeF viewport_size =
+ gfx::ScaleSize(device_viewport_size_, 1.f / device_scale_factor_);
+
+ double start_time_seconds = (start_time - base::TimeTicks()).InSecondsF();
+ page_scale_animation_ =
+ PageScaleAnimation::Create(scroll_total,
+ active_tree_->total_page_scale_factor(),
+ viewport_size,
+ scaled_scrollable_size,
+ start_time_seconds);
+
+ if (anchor_point) {
+ gfx::Vector2dF anchor(target_offset);
+ page_scale_animation_->ZoomWithAnchor(anchor,
+ page_scale,
+ duration.InSecondsF());
+ } else {
+ gfx::Vector2dF scaled_target_offset = target_offset;
+ page_scale_animation_->ZoomTo(scaled_target_offset,
+ page_scale,
+ duration.InSecondsF());
+ }
+
+ client_->SetNeedsRedrawOnImplThread();
+ client_->SetNeedsCommitOnImplThread();
+ client_->RenewTreePriority();
}
-static void appendQuadsForRenderSurfaceLayer(RenderPass* targetRenderPass, LayerImpl* layer, const RenderPass* contributingRenderPass, OcclusionTrackerImpl& occlusionTracker, AppendQuadsData& appendQuadsData)
-{
- bool forSurface = true;
- QuadCuller quadCuller(targetRenderPass->quad_list,
- targetRenderPass->shared_quad_state_list,
- layer,
- occlusionTracker,
- layer->ShowDebugBorders(),
- forSurface);
-
- bool isReplica = false;
- layer->render_surface()->AppendQuads(&quadCuller,
- &appendQuadsData,
- isReplica,
- contributingRenderPass->id);
-
- // Add replica after the surface so that it appears below the surface.
- if (layer->has_replica()) {
- isReplica = true;
- layer->render_surface()->AppendQuads(&quadCuller,
- &appendQuadsData,
- isReplica,
- contributingRenderPass->id);
- }
+void LayerTreeHostImpl::ScheduleAnimation() {
+ client_->SetNeedsRedrawOnImplThread();
}
-static void appendQuadsToFillScreen(RenderPass* targetRenderPass, LayerImpl* rootLayer, SkColor screenBackgroundColor, const OcclusionTrackerImpl& occlusionTracker)
-{
- if (!rootLayer || !SkColorGetA(screenBackgroundColor))
- return;
+bool LayerTreeHostImpl::HaveTouchEventHandlersAt(gfx::Point viewport_point) {
+ if (!EnsureRenderSurfaceLayerList())
+ return false;
- Region fillRegion = occlusionTracker.ComputeVisibleRegionInScreen();
- if (fillRegion.IsEmpty())
- return;
+ gfx::PointF device_viewport_point =
+ gfx::ScalePoint(viewport_point, device_scale_factor_);
- bool forSurface = false;
- QuadCuller quadCuller(targetRenderPass->quad_list,
- targetRenderPass->shared_quad_state_list,
- rootLayer,
- occlusionTracker,
- rootLayer->ShowDebugBorders(),
- forSurface);
+ // First find out which layer was hit from the saved list of visible layers
+ // in the most recent frame.
+ LayerImpl* layer_impl = LayerTreeHostCommon::findLayerThatIsHitByPoint(
+ device_viewport_point,
+ active_tree_->RenderSurfaceLayerList());
- // Manually create the quad state for the gutter quads, as the root layer
- // doesn't have any bounds and so can't generate this itself.
- // FIXME: Make the gutter quads generated by the solid color layer (make it smarter about generating quads to fill unoccluded areas).
+ // Walk up the hierarchy and look for a layer with a touch event handler
+ // region that the given point hits.
+ for (; layer_impl; layer_impl = layer_impl->parent()) {
+ if (LayerTreeHostCommon::layerHasTouchEventHandlersAt(device_viewport_point,
+ layer_impl))
+ return true;
+ }
- gfx::Rect rootTargetRect = rootLayer->render_surface()->content_rect();
- float opacity = 1;
- SharedQuadState* sharedQuadState = quadCuller.useSharedQuadState(SharedQuadState::Create());
- sharedQuadState->SetAll(rootLayer->draw_transform(),
- rootTargetRect.size(),
- rootTargetRect,
- rootTargetRect,
+ return false;
+}
+
+void LayerTreeHostImpl::TrackDamageForAllSurfaces(
+ LayerImpl* root_draw_layer,
+ const LayerList& render_surface_layer_list) {
+ // For now, we use damage tracking to compute a global scissor. To do this, we
+ // must compute all damage tracking before drawing anything, so that we know
+ // the root damage rect. The root damage rect is then used to scissor each
+ // surface.
+
+ for (int surface_index = render_surface_layer_list.size() - 1;
+ surface_index >= 0 ;
+ --surface_index) {
+ LayerImpl* render_surface_layer = render_surface_layer_list[surface_index];
+ RenderSurfaceImpl* render_surface = render_surface_layer->render_surface();
+ DCHECK(render_surface);
+ render_surface->damage_tracker()->UpdateDamageTrackingState(
+ render_surface->layer_list(),
+ render_surface_layer->id(),
+ render_surface->SurfacePropertyChangedOnlyFromDescendant(),
+ render_surface->content_rect(),
+ render_surface_layer->mask_layer(),
+ render_surface_layer->filters(),
+ render_surface_layer->filter().get());
+ }
+}
+
+void LayerTreeHostImpl::FrameData::AppendRenderPass(
+ scoped_ptr<RenderPass> render_pass) {
+ render_passes_by_id[render_pass->id] = render_pass.get();
+ render_passes.push_back(render_pass.Pass());
+}
+
+static void AppendQuadsForLayer(RenderPass* target_render_pass,
+ LayerImpl* layer,
+ const OcclusionTrackerImpl& occlusion_tracker,
+ AppendQuadsData* append_quads_data) {
+ bool for_surface = false;
+ QuadCuller quad_culler(target_render_pass->quad_list,
+ target_render_pass->shared_quad_state_list,
+ layer,
+ occlusion_tracker,
+ layer->ShowDebugBorders(),
+ for_surface);
+ layer->AppendQuads(&quad_culler, append_quads_data);
+}
+
+static void AppendQuadsForRenderSurfaceLayer(
+ RenderPass* target_render_pass,
+ LayerImpl* layer,
+ const RenderPass* contributing_render_pass,
+ const OcclusionTrackerImpl& occlusion_tracker,
+ AppendQuadsData* append_quads_data) {
+ bool for_surface = true;
+ QuadCuller quad_culler(target_render_pass->quad_list,
+ target_render_pass->shared_quad_state_list,
+ layer,
+ occlusion_tracker,
+ layer->ShowDebugBorders(),
+ for_surface);
+
+ bool is_replica = false;
+ layer->render_surface()->AppendQuads(&quad_culler,
+ append_quads_data,
+ is_replica,
+ contributing_render_pass->id);
+
+ // Add replica after the surface so that it appears below the surface.
+ if (layer->has_replica()) {
+ is_replica = true;
+ layer->render_surface()->AppendQuads(&quad_culler,
+ append_quads_data,
+ is_replica,
+ contributing_render_pass->id);
+ }
+}
+
+static void AppendQuadsToFillScreen(
+ RenderPass* target_render_pass,
+ LayerImpl* root_layer,
+ SkColor screen_background_color,
+ const OcclusionTrackerImpl& occlusion_tracker) {
+ if (!root_layer || !SkColorGetA(screen_background_color))
+ return;
+
+ Region fill_region = occlusion_tracker.ComputeVisibleRegionInScreen();
+ if (fill_region.IsEmpty())
+ return;
+
+ bool for_surface = false;
+ QuadCuller quad_culler(target_render_pass->quad_list,
+ target_render_pass->shared_quad_state_list,
+ root_layer,
+ occlusion_tracker,
+ root_layer->ShowDebugBorders(),
+ for_surface);
+
+ // Manually create the quad state for the gutter quads, as the root layer
+ // doesn't have any bounds and so can't generate this itself.
+ // TODO(danakj): Make the gutter quads generated by the solid color layer
+ // (make it smarter about generating quads to fill unoccluded areas).
+
+ gfx::Rect root_target_rect = root_layer->render_surface()->content_rect();
+ float opacity = 1.f;
+ SharedQuadState* shared_quad_state =
+ quad_culler.useSharedQuadState(SharedQuadState::Create());
+ shared_quad_state->SetAll(root_layer->draw_transform(),
+ root_target_rect.size(),
+ root_target_rect,
+ root_target_rect,
false,
opacity);
- AppendQuadsData appendQuadsData;
+ AppendQuadsData append_quads_data;
- gfx::Transform transformToLayerSpace(gfx::Transform::kSkipInitialization);
- bool didInvert = rootLayer->screen_space_transform().GetInverse(&transformToLayerSpace);
- DCHECK(didInvert);
- for (Region::Iterator fillRects(fillRegion); fillRects.has_rect(); fillRects.next()) {
- // The root layer transform is composed of translations and scales only,
- // no perspective, so mapping is sufficient (as opposed to projecting).
- gfx::Rect layerRect = MathUtil::mapClippedRect(transformToLayerSpace, fillRects.rect());
- // Skip the quad culler and just append the quads directly to avoid
- // occlusion checks.
- scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
- quad->SetNew(sharedQuadState, layerRect, screenBackgroundColor);
- quadCuller.append(quad.PassAs<DrawQuad>(), &appendQuadsData);
- }
+ gfx::Transform transform_to_layer_space(gfx::Transform::kSkipInitialization);
+ bool did_invert = root_layer->screen_space_transform().GetInverse(
+ &transform_to_layer_space);
+ DCHECK(did_invert);
+ for (Region::Iterator fill_rects(fill_region);
+ fill_rects.has_rect();
+ fill_rects.next()) {
+ // The root layer transform is composed of translations and scales only,
+ // no perspective, so mapping is sufficient (as opposed to projecting).
+ gfx::Rect layer_rect =
+ MathUtil::mapClippedRect(transform_to_layer_space, fill_rects.rect());
+ // Skip the quad culler and just append the quads directly to avoid
+ // occlusion checks.
+ scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+ quad->SetNew(shared_quad_state, layer_rect, screen_background_color);
+ quad_culler.append(quad.PassAs<DrawQuad>(), &append_quads_data);
+ }
}
-bool LayerTreeHostImpl::calculateRenderPasses(FrameData& frame)
-{
- DCHECK(frame.renderPasses.empty());
+bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
+ DCHECK(frame->render_passes.empty());
- if (!canDraw() || !rootLayer())
- return false;
+ if (!CanDraw() || !active_tree_->root_layer())
+ return false;
- trackDamageForAllSurfaces(rootLayer(), *frame.renderSurfaceLayerList);
+ TrackDamageForAllSurfaces(active_tree_->root_layer(),
+ *frame->render_surface_layer_list);
- TRACE_EVENT1("cc", "LayerTreeHostImpl::calculateRenderPasses", "renderSurfaceLayerList.size()", static_cast<long long unsigned>(frame.renderSurfaceLayerList->size()));
+ TRACE_EVENT1("cc",
+ "LayerTreeHostImpl::CalculateRenderPasses",
+ "render_surface_layer_list.size()",
+ static_cast<long long unsigned>(
+ frame->render_surface_layer_list->size()));
- // Create the render passes in dependency order.
- for (int surfaceIndex = frame.renderSurfaceLayerList->size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
- LayerImpl* renderSurfaceLayer = (*frame.renderSurfaceLayerList)[surfaceIndex];
- renderSurfaceLayer->render_surface()->AppendRenderPasses(&frame);
- }
+ // Create the render passes in dependency order.
+ for (int surface_index = frame->render_surface_layer_list->size() - 1;
+ surface_index >= 0 ;
+ --surface_index) {
+ LayerImpl* render_surface_layer =
+ (*frame->render_surface_layer_list)[surface_index];
+ render_surface_layer->render_surface()->AppendRenderPasses(frame);
+ }
- bool recordMetricsForFrame = m_settings.showOverdrawInTracing && base::debug::TraceLog::GetInstance() && base::debug::TraceLog::GetInstance()->IsEnabled();
- OcclusionTrackerImpl occlusionTracker(rootLayer()->render_surface()->content_rect(), recordMetricsForFrame);
- occlusionTracker.set_minimum_tracking_size(m_settings.minimumOcclusionTrackingSize);
+ bool record_metrics_for_frame =
+ settings_.showOverdrawInTracing &&
+ base::debug::TraceLog::GetInstance() &&
+ base::debug::TraceLog::GetInstance()->IsEnabled();
+ OcclusionTrackerImpl occlusion_tracker(
+ active_tree_->root_layer()->render_surface()->content_rect(),
+ record_metrics_for_frame);
+ occlusion_tracker.set_minimum_tracking_size(
+ settings_.minimumOcclusionTrackingSize);
- if (m_debugState.showOccludingRects)
- occlusionTracker.set_occluding_screen_space_rects_container(&frame.occludingScreenSpaceRects);
- if (m_debugState.showNonOccludingRects)
- occlusionTracker.set_non_occluding_screen_space_rects_container(&frame.nonOccludingScreenSpaceRects);
+ if (debug_state_.showOccludingRects) {
+ occlusion_tracker.set_occluding_screen_space_rects_container(
+ &frame->occluding_screen_space_rects);
+ }
+ if (debug_state_.showNonOccludingRects) {
+ occlusion_tracker.set_non_occluding_screen_space_rects_container(
+ &frame->non_occluding_screen_space_rects);
+ }
- // Add quads to the Render passes in FrontToBack order to allow for testing occlusion and performing culling during the tree walk.
- typedef LayerIterator<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerIteratorActions::FrontToBack> LayerIteratorType;
+ // Add quads to the Render passes in FrontToBack order to allow for testing
+ // occlusion and performing culling during the tree walk.
+ typedef LayerIterator<LayerImpl,
+ std::vector<LayerImpl*>,
+ RenderSurfaceImpl,
+ LayerIteratorActions::FrontToBack> LayerIteratorType;
- // Typically when we are missing a texture and use a checkerboard quad, we still draw the frame. However when the layer being
- // checkerboarded is moving due to an impl-animation, we drop the frame to avoid flashing due to the texture suddenly appearing
- // in the future.
- bool drawFrame = true;
+ // Typically when we are missing a texture and use a checkerboard quad, we
+ // still draw the frame. However when the layer being checkerboarded is moving
+ // due to an impl-animation, we drop the frame to avoid flashing due to the
+ // texture suddenly appearing in the future.
+ bool draw_frame = true;
- LayerIteratorType end = LayerIteratorType::end(frame.renderSurfaceLayerList);
- for (LayerIteratorType it = LayerIteratorType::begin(frame.renderSurfaceLayerList); it != end; ++it) {
- RenderPass::Id targetRenderPassId = it.targetRenderSurfaceLayer()->render_surface()->RenderPassId();
- RenderPass* targetRenderPass = frame.renderPassesById[targetRenderPassId];
+ LayerIteratorType end =
+ LayerIteratorType::end(frame->render_surface_layer_list);
+ for (LayerIteratorType it =
+ LayerIteratorType::begin(frame->render_surface_layer_list);
+ it != end;
+ ++it) {
+ RenderPass::Id target_render_pass_id =
+ it.targetRenderSurfaceLayer()->render_surface()->RenderPassId();
+ RenderPass* target_render_pass =
+ frame->render_passes_by_id[target_render_pass_id];
- occlusionTracker.EnterLayer(it);
+ occlusion_tracker.EnterLayer(it);
- AppendQuadsData appendQuadsData(targetRenderPass->id);
+ AppendQuadsData append_quads_data(target_render_pass->id);
- if (it.representsContributingRenderSurface()) {
- RenderPass::Id contributingRenderPassId = it->render_surface()->RenderPassId();
- RenderPass* contributingRenderPass = frame.renderPassesById[contributingRenderPassId];
- appendQuadsForRenderSurfaceLayer(targetRenderPass, *it, contributingRenderPass, occlusionTracker, appendQuadsData);
- } else if (it.representsItself() && !it->visible_content_rect().IsEmpty()) {
- bool hasOcclusionFromOutsideTargetSurface;
- bool implDrawTransformIsUnknown = false;
- if (occlusionTracker.Occluded(it->render_target(), it->visible_content_rect(), it->draw_transform(), implDrawTransformIsUnknown, it->is_clipped(), it->clip_rect(), &hasOcclusionFromOutsideTargetSurface))
- appendQuadsData.hadOcclusionFromOutsideTargetSurface |= hasOcclusionFromOutsideTargetSurface;
- else {
- DCHECK_EQ(activeTree(), it->layer_tree_impl());
- it->WillDraw(m_resourceProvider.get());
- frame.willDrawLayers.push_back(*it);
+ if (it.representsContributingRenderSurface()) {
+ RenderPass::Id contributing_render_pass_id =
+ it->render_surface()->RenderPassId();
+ RenderPass* contributing_render_pass =
+ frame->render_passes_by_id[contributing_render_pass_id];
+ AppendQuadsForRenderSurfaceLayer(target_render_pass,
+ *it,
+ contributing_render_pass,
+ occlusion_tracker,
+ &append_quads_data);
+ } else if (it.representsItself() && !it->visible_content_rect().IsEmpty()) {
+ bool has_occlusion_from_outside_target_surface;
+ bool impl_draw_transform_is_unknown = false;
+ if (occlusion_tracker.Occluded(
+ it->render_target(),
+ it->visible_content_rect(),
+ it->draw_transform(),
+ impl_draw_transform_is_unknown,
+ it->is_clipped(),
+ it->clip_rect(),
+ &has_occlusion_from_outside_target_surface)) {
+ append_quads_data.hadOcclusionFromOutsideTargetSurface |=
+ has_occlusion_from_outside_target_surface;
+ } else {
+ DCHECK_EQ(active_tree_, it->layer_tree_impl());
+ it->WillDraw(resource_provider_.get());
+ frame->will_draw_layers.push_back(*it);
- if (it->HasContributingDelegatedRenderPasses()) {
- RenderPass::Id contributingRenderPassId = it->FirstContributingRenderPassId();
- while (frame.renderPassesById.find(contributingRenderPassId) != frame.renderPassesById.end()) {
- RenderPass* renderPass = frame.renderPassesById[contributingRenderPassId];
+ if (it->HasContributingDelegatedRenderPasses()) {
+ RenderPass::Id contributing_render_pass_id =
+ it->FirstContributingRenderPassId();
+ while (frame->render_passes_by_id.find(contributing_render_pass_id) !=
+ frame->render_passes_by_id.end()) {
+ RenderPass* render_pass =
+ frame->render_passes_by_id[contributing_render_pass_id];
- AppendQuadsData appendQuadsData(renderPass->id);
- appendQuadsForLayer(renderPass, *it, occlusionTracker, appendQuadsData);
+ AppendQuadsData append_quads_data(render_pass->id);
+ AppendQuadsForLayer(render_pass,
+ *it,
+ occlusion_tracker,
+ &append_quads_data);
- contributingRenderPassId = it->NextContributingRenderPassId(contributingRenderPassId);
- }
- }
-
- appendQuadsForLayer(targetRenderPass, *it, occlusionTracker, appendQuadsData);
- }
-
- ++m_cumulativeNumLayersDrawn;
+ contributing_render_pass_id =
+ it->NextContributingRenderPassId(contributing_render_pass_id);
+ }
}
- if (appendQuadsData.hadOcclusionFromOutsideTargetSurface)
- targetRenderPass->has_occlusion_from_outside_target_surface = true;
+ AppendQuadsForLayer(target_render_pass,
+ *it,
+ occlusion_tracker,
+ &append_quads_data);
+ }
- if (appendQuadsData.numMissingTiles) {
- m_cumulativeNumMissingTiles += appendQuadsData.numMissingTiles;
- bool layerHasAnimatingTransform = it->screen_space_transform_is_animating() || it->draw_transform_is_animating();
- if (layerHasAnimatingTransform)
- drawFrame = false;
- }
-
- if (appendQuadsData.hadIncompleteTile)
- frame.containsIncompleteTile = true;
-
- occlusionTracker.LeaveLayer(it);
+ ++cumulative_num_layers_drawn_;
}
+ if (append_quads_data.hadOcclusionFromOutsideTargetSurface)
+ target_render_pass->has_occlusion_from_outside_target_surface = true;
+
+ if (append_quads_data.numMissingTiles) {
+ cumulative_num_missing_tiles_ += append_quads_data.numMissingTiles;
+ bool layer_has_animating_transform =
+ it->screen_space_transform_is_animating() ||
+ it->draw_transform_is_animating();
+ if (layer_has_animating_transform)
+ draw_frame = false;
+ }
+
+ if (append_quads_data.hadIncompleteTile)
+ frame->contains_incomplete_tile = true;
+
+ occlusion_tracker.LeaveLayer(it);
+ }
+
#ifndef NDEBUG
- for (size_t i = 0; i < frame.renderPasses.size(); ++i) {
- for (size_t j = 0; j < frame.renderPasses[i]->quad_list.size(); ++j)
- DCHECK(frame.renderPasses[i]->quad_list[j]->shared_quad_state);
- DCHECK(frame.renderPassesById.find(frame.renderPasses[i]->id)
- != frame.renderPassesById.end());
- }
+ for (size_t i = 0; i < frame->render_passes.size(); ++i) {
+ for (size_t j = 0; j < frame->render_passes[i]->quad_list.size(); ++j)
+ DCHECK(frame->render_passes[i]->quad_list[j]->shared_quad_state);
+ DCHECK(frame->render_passes_by_id.find(frame->render_passes[i]->id)
+ != frame->render_passes_by_id.end());
+ }
#endif
- DCHECK(frame.renderPasses.back()->output_rect.origin().IsOrigin());
+ DCHECK(frame->render_passes.back()->output_rect.origin().IsOrigin());
- if (!activeTree()->has_transparent_background()) {
- frame.renderPasses.back()->has_transparent_background = false;
- appendQuadsToFillScreen(frame.renderPasses.back(), rootLayer(), activeTree()->background_color(), occlusionTracker);
- }
+ if (!active_tree_->has_transparent_background()) {
+ frame->render_passes.back()->has_transparent_background = false;
+ AppendQuadsToFillScreen(frame->render_passes.back(),
+ active_tree_->root_layer(),
+ active_tree_->background_color(),
+ occlusion_tracker);
+ }
- if (drawFrame)
- occlusionTracker.overdraw_metrics()->RecordMetrics(this);
+ if (draw_frame)
+ occlusion_tracker.overdraw_metrics()->RecordMetrics(this);
- removeRenderPasses(CullRenderPassesWithNoQuads(), frame);
- m_renderer->DecideRenderPassAllocationsForFrame(frame.renderPasses);
- removeRenderPasses(CullRenderPassesWithCachedTextures(*m_renderer), frame);
+ RemoveRenderPasses(CullRenderPassesWithNoQuads(), frame);
+ renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
+ RemoveRenderPasses(CullRenderPassesWithCachedTextures(*renderer_), frame);
- return drawFrame;
+ return draw_frame;
}
-void LayerTreeHostImpl::setBackgroundTickingEnabled(bool enabled)
-{
- // Lazily create the timeSource adapter so that we can vary the interval for testing.
- if (!m_timeSourceClientAdapter)
- m_timeSourceClientAdapter = LayerTreeHostImplTimeSourceAdapter::Create(this, DelayBasedTimeSource::create(lowFrequencyAnimationInterval(), m_proxy->CurrentThread()));
+void LayerTreeHostImpl::SetBackgroundTickingEnabled(bool enabled) {
+ // Lazily create the time_source adapter so that we can vary the interval for
+ // testing.
+ if (!time_source_client_adapter_) {
+ time_source_client_adapter_ = LayerTreeHostImplTimeSourceAdapter::Create(
+ this,
+ DelayBasedTimeSource::create(LowFrequencyAnimationInterval(),
+ proxy_->CurrentThread()));
+ }
- m_timeSourceClientAdapter->setActive(enabled);
+ time_source_client_adapter_->SetActive(enabled);
}
-static inline RenderPass* findRenderPassById(RenderPass::Id renderPassId, const LayerTreeHostImpl::FrameData& frame)
-{
- RenderPassIdHashMap::const_iterator it = frame.renderPassesById.find(renderPassId);
- return it != frame.renderPassesById.end() ? it->second : NULL;
+static inline RenderPass* FindRenderPassById(
+ RenderPass::Id render_pass_id,
+ const LayerTreeHostImpl::FrameData& frame) {
+ RenderPassIdHashMap::const_iterator it =
+ frame.render_passes_by_id.find(render_pass_id);
+ return it != frame.render_passes_by_id.end() ? it->second : NULL;
}
-static void removeRenderPassesRecursive(RenderPass::Id removeRenderPassId, LayerTreeHostImpl::FrameData& frame)
-{
- RenderPass* removeRenderPass = findRenderPassById(removeRenderPassId, frame);
- // The pass was already removed by another quad - probably the original, and we are the replica.
- if (!removeRenderPass)
- return;
- RenderPassList& renderPasses = frame.renderPasses;
- RenderPassList::iterator toRemove = std::find(renderPasses.begin(), renderPasses.end(), removeRenderPass);
+static void RemoveRenderPassesRecursive(RenderPass::Id remove_render_pass_id,
+ LayerTreeHostImpl::FrameData* frame) {
+ RenderPass* remove_render_pass =
+ FindRenderPassById(remove_render_pass_id, *frame);
+ // The pass was already removed by another quad - probably the original, and
+ // we are the replica.
+ if (!remove_render_pass)
+ return;
+ RenderPassList& render_passes = frame->render_passes;
+ RenderPassList::iterator to_remove = std::find(render_passes.begin(),
+ render_passes.end(),
+ remove_render_pass);
- DCHECK(toRemove != renderPasses.end());
+ DCHECK(to_remove != render_passes.end());
- scoped_ptr<RenderPass> removedPass = renderPasses.take(toRemove);
- frame.renderPasses.erase(toRemove);
- frame.renderPassesById.erase(removeRenderPassId);
+ scoped_ptr<RenderPass> removed_pass = render_passes.take(to_remove);
+ frame->render_passes.erase(to_remove);
+ frame->render_passes_by_id.erase(remove_render_pass_id);
- // Now follow up for all RenderPass quads and remove their RenderPasses recursively.
- const QuadList& quadList = removedPass->quad_list;
- QuadList::constBackToFrontIterator quadListIterator = quadList.backToFrontBegin();
- for (; quadListIterator != quadList.backToFrontEnd(); ++quadListIterator) {
- DrawQuad* currentQuad = (*quadListIterator);
- if (currentQuad->material != DrawQuad::RENDER_PASS)
- continue;
+ // Now follow up for all RenderPass quads and remove their RenderPasses
+ // recursively.
+ const QuadList& quad_list = removed_pass->quad_list;
+ QuadList::constBackToFrontIterator quad_list_iterator =
+ quad_list.backToFrontBegin();
+ for (; quad_list_iterator != quad_list.backToFrontEnd();
+ ++quad_list_iterator) {
+ DrawQuad* current_quad = (*quad_list_iterator);
+ if (current_quad->material != DrawQuad::RENDER_PASS)
+ continue;
- RenderPass::Id nextRemoveRenderPassId = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id;
- removeRenderPassesRecursive(nextRemoveRenderPassId, frame);
- }
+ RenderPass::Id next_remove_render_pass_id =
+ RenderPassDrawQuad::MaterialCast(current_quad)->render_pass_id;
+ RemoveRenderPassesRecursive(next_remove_render_pass_id, frame);
+ }
}
-bool LayerTreeHostImpl::CullRenderPassesWithCachedTextures::shouldRemoveRenderPass(const RenderPassDrawQuad& quad, const FrameData&) const
-{
- if (!quad.contents_changed_since_last_frame.IsEmpty()) {
- TRACE_EVENT0("cc", "CullRenderPassesWithCachedTextures have damage");
- return false;
- } else if (!m_renderer.HaveCachedResourcesForRenderPassId(quad.render_pass_id)) {
- TRACE_EVENT0("cc", "CullRenderPassesWithCachedTextures have no texture");
- return false;
- }
- TRACE_EVENT0("cc", "CullRenderPassesWithCachedTextures dropped!");
- return true;
+bool LayerTreeHostImpl::CullRenderPassesWithCachedTextures::
+ ShouldRemoveRenderPass(const RenderPassDrawQuad& quad,
+ const FrameData& frame) const {
+ bool quad_has_damage = !quad.contents_changed_since_last_frame.IsEmpty();
+ bool quad_has_cached_resource =
+ renderer_.HaveCachedResourcesForRenderPassId(quad.render_pass_id);
+ if (quad_has_damage) {
+ TRACE_EVENT0("cc", "CullRenderPassesWithCachedTextures have damage");
+ return false;
+ } else if (!quad_has_cached_resource) {
+ TRACE_EVENT0("cc", "CullRenderPassesWithCachedTextures have no texture");
+ return false;
+ }
+ TRACE_EVENT0("cc", "CullRenderPassesWithCachedTextures dropped!");
+ return true;
}
-bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::shouldRemoveRenderPass(const RenderPassDrawQuad& quad, const FrameData& frame) const
-{
- const RenderPass* renderPass = findRenderPassById(quad.render_pass_id, frame);
- if (!renderPass)
- return false;
+bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::ShouldRemoveRenderPass(
+ const RenderPassDrawQuad& quad, const FrameData& frame) const {
+ const RenderPass* render_pass =
+ FindRenderPassById(quad.render_pass_id, frame);
+ if (!render_pass)
+ return false;
- // If any quad or RenderPass draws into this RenderPass, then keep it.
- const QuadList& quadList = renderPass->quad_list;
- for (QuadList::constBackToFrontIterator quadListIterator = quadList.backToFrontBegin(); quadListIterator != quadList.backToFrontEnd(); ++quadListIterator) {
- DrawQuad* currentQuad = *quadListIterator;
+ // If any quad or RenderPass draws into this RenderPass, then keep it.
+ const QuadList& quad_list = render_pass->quad_list;
+ for (QuadList::constBackToFrontIterator quad_list_iterator =
+ quad_list.backToFrontBegin();
+ quad_list_iterator != quad_list.backToFrontEnd();
+ ++quad_list_iterator) {
+ DrawQuad* current_quad = *quad_list_iterator;
- if (currentQuad->material != DrawQuad::RENDER_PASS)
- return false;
+ if (current_quad->material != DrawQuad::RENDER_PASS)
+ return false;
- const RenderPass* contributingPass = findRenderPassById(RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id, frame);
- if (contributingPass)
- return false;
- }
- return true;
+ const RenderPass* contributing_pass = FindRenderPassById(
+ RenderPassDrawQuad::MaterialCast(current_quad)->render_pass_id, frame);
+ if (contributing_pass)
+ return false;
+ }
+ return true;
}
// Defined for linking tests.
-template CC_EXPORT void LayerTreeHostImpl::removeRenderPasses<LayerTreeHostImpl::CullRenderPassesWithCachedTextures>(CullRenderPassesWithCachedTextures, FrameData&);
-template CC_EXPORT void LayerTreeHostImpl::removeRenderPasses<LayerTreeHostImpl::CullRenderPassesWithNoQuads>(CullRenderPassesWithNoQuads, FrameData&);
+template CC_EXPORT void LayerTreeHostImpl::RemoveRenderPasses<
+ LayerTreeHostImpl::CullRenderPassesWithCachedTextures>(
+ CullRenderPassesWithCachedTextures culler, FrameData* frame);
+template CC_EXPORT void LayerTreeHostImpl::RemoveRenderPasses<
+ LayerTreeHostImpl::CullRenderPassesWithNoQuads>(
+ CullRenderPassesWithNoQuads culler, FrameData*);
// static
-template<typename RenderPassCuller>
-void LayerTreeHostImpl::removeRenderPasses(RenderPassCuller culler, FrameData& frame)
-{
- for (size_t it = culler.renderPassListBegin(frame.renderPasses); it != culler.renderPassListEnd(frame.renderPasses); it = culler.renderPassListNext(it)) {
- const RenderPass* currentPass = frame.renderPasses[it];
- const QuadList& quadList = currentPass->quad_list;
- QuadList::constBackToFrontIterator quadListIterator = quadList.backToFrontBegin();
+template <typename RenderPassCuller>
+void LayerTreeHostImpl::RemoveRenderPasses(RenderPassCuller culler,
+ FrameData* frame) {
+ for (size_t it = culler.RenderPassListBegin(frame->render_passes);
+ it != culler.RenderPassListEnd(frame->render_passes);
+ it = culler.RenderPassListNext(it)) {
+ const RenderPass* current_pass = frame->render_passes[it];
+ const QuadList& quad_list = current_pass->quad_list;
+ QuadList::constBackToFrontIterator quad_list_iterator =
+ quad_list.backToFrontBegin();
- for (; quadListIterator != quadList.backToFrontEnd(); ++quadListIterator) {
- DrawQuad* currentQuad = *quadListIterator;
+ for (; quad_list_iterator != quad_list.backToFrontEnd();
+ ++quad_list_iterator) {
+ DrawQuad* current_quad = *quad_list_iterator;
- if (currentQuad->material != DrawQuad::RENDER_PASS)
- continue;
+ if (current_quad->material != DrawQuad::RENDER_PASS)
+ continue;
- RenderPassDrawQuad* renderPassQuad = static_cast<RenderPassDrawQuad*>(currentQuad);
- if (!culler.shouldRemoveRenderPass(*renderPassQuad, frame))
- continue;
+ const RenderPassDrawQuad* render_pass_quad =
+ RenderPassDrawQuad::MaterialCast(current_quad);
+ if (!culler.ShouldRemoveRenderPass(*render_pass_quad, *frame))
+ continue;
- // We are changing the vector in the middle of iteration. Because we
- // delete render passes that draw into the current pass, we are
- // guaranteed that any data from the iterator to the end will not
- // change. So, capture the iterator position from the end of the
- // list, and restore it after the change.
- int positionFromEnd = frame.renderPasses.size() - it;
- removeRenderPassesRecursive(renderPassQuad->render_pass_id, frame);
- it = frame.renderPasses.size() - positionFromEnd;
- DCHECK(frame.renderPasses.size() >= static_cast<size_t>(positionFromEnd));
- }
+ // We are changing the vector in the middle of iteration. Because we
+ // delete render passes that draw into the current pass, we are
+ // guaranteed that any data from the iterator to the end will not
+ // change. So, capture the iterator position from the end of the
+ // list, and restore it after the change.
+ size_t position_from_end = frame->render_passes.size() - it;
+ RemoveRenderPassesRecursive(render_pass_quad->render_pass_id, frame);
+ it = frame->render_passes.size() - position_from_end;
+ DCHECK_GE(frame->render_passes.size(), position_from_end);
}
+ }
}
-bool LayerTreeHostImpl::prepareToDraw(FrameData& frame)
-{
- TRACE_EVENT0("cc", "LayerTreeHostImpl::prepareToDraw");
+bool LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
+ TRACE_EVENT0("cc", "LayerTreeHostImpl::PrepareToDraw");
- activeTree()->UpdateDrawProperties(LayerTreeImpl::UPDATE_ACTIVE_TREE_FOR_DRAW);
+ active_tree_->UpdateDrawProperties(
+ LayerTreeImpl::UPDATE_ACTIVE_TREE_FOR_DRAW);
- frame.renderSurfaceLayerList = &activeTree()->RenderSurfaceLayerList();
- frame.renderPasses.clear();
- frame.renderPassesById.clear();
- frame.willDrawLayers.clear();
+ frame->render_surface_layer_list = &active_tree_->RenderSurfaceLayerList();
+ frame->render_passes.clear();
+ frame->render_passes_by_id.clear();
+ frame->will_draw_layers.clear();
- if (!calculateRenderPasses(frame))
- return false;
+ if (!CalculateRenderPasses(frame))
+ return false;
- // If we return true, then we expect drawLayers() to be called before this function is called again.
- return true;
+ // If we return true, then we expect DrawLayers() to be called before this
+ // function is called again.
+ return true;
}
-void LayerTreeHostImpl::EnforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy)
-{
- bool evictedResources = m_client->reduceContentsTextureMemoryOnImplThread(
- m_visible ? policy.bytesLimitWhenVisible : policy.bytesLimitWhenNotVisible,
- ManagedMemoryPolicy::priorityCutoffToValue(
- m_visible ? policy.priorityCutoffWhenVisible : policy.priorityCutoffWhenNotVisible));
- if (evictedResources) {
- activeTree()->SetContentsTexturesPurged();
- if (pendingTree())
- pendingTree()->SetContentsTexturesPurged();
- m_client->setNeedsCommitOnImplThread();
- m_client->onCanDrawStateChanged(canDraw());
- m_client->renewTreePriority();
- }
- m_client->sendManagedMemoryStats();
+void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
+ const ManagedMemoryPolicy& policy) {
+ bool evicted_resources = client_->ReduceContentsTextureMemoryOnImplThread(
+ visible_ ? policy.bytesLimitWhenVisible : policy.bytesLimitWhenNotVisible,
+ ManagedMemoryPolicy::priorityCutoffToValue(
+ visible_ ?
+ policy.priorityCutoffWhenVisible :
+ policy.priorityCutoffWhenNotVisible));
+ if (evicted_resources) {
+ active_tree_->SetContentsTexturesPurged();
+ if (pending_tree_)
+ pending_tree_->SetContentsTexturesPurged();
+ client_->SetNeedsCommitOnImplThread();
+ client_->OnCanDrawStateChanged(CanDraw());
+ client_->RenewTreePriority();
+ }
+ client_->SendManagedMemoryStats();
- if (m_tileManager) {
- GlobalStateThatImpactsTilePriority new_state(m_tileManager->GlobalState());
- new_state.memory_limit_in_bytes = m_visible ? policy.bytesLimitWhenVisible : policy.bytesLimitWhenNotVisible;
- new_state.memory_limit_policy = ManagedMemoryPolicy::priorityCutoffToTileMemoryLimitPolicy(
- m_visible ? policy.priorityCutoffWhenVisible : policy.priorityCutoffWhenNotVisible);
- m_tileManager->SetGlobalState(new_state);
- }
+ if (tile_manager_) {
+ GlobalStateThatImpactsTilePriority new_state(tile_manager_->GlobalState());
+ new_state.memory_limit_in_bytes = visible_ ?
+ policy.bytesLimitWhenVisible :
+ policy.bytesLimitWhenNotVisible;
+ new_state.memory_limit_policy =
+ ManagedMemoryPolicy::priorityCutoffToTileMemoryLimitPolicy(
+ visible_ ?
+ policy.priorityCutoffWhenVisible :
+ policy.priorityCutoffWhenNotVisible);
+ tile_manager_->SetGlobalState(new_state);
+ }
}
-bool LayerTreeHostImpl::HasImplThread() const
-{
- return m_proxy->HasImplThread();
+bool LayerTreeHostImpl::HasImplThread() const {
+ return proxy_->HasImplThread();
}
-void LayerTreeHostImpl::ScheduleManageTiles()
-{
- if (m_client)
- m_client->setNeedsManageTilesOnImplThread();
+void LayerTreeHostImpl::ScheduleManageTiles() {
+ if (client_)
+ client_->SetNeedsManageTilesOnImplThread();
}
-void LayerTreeHostImpl::DidUploadVisibleHighResolutionTile()
-{
- if (m_client)
- m_client->didUploadVisibleHighResolutionTileOnImplThread();
+void LayerTreeHostImpl::DidUploadVisibleHighResolutionTile() {
+ if (client_)
+ client_->DidUploadVisibleHighResolutionTileOnImplThread();
}
-bool LayerTreeHostImpl::ShouldClearRootRenderPass() const
-{
- return m_settings.shouldClearRootRenderPass;
+bool LayerTreeHostImpl::ShouldClearRootRenderPass() const {
+ return settings_.shouldClearRootRenderPass;
}
-void LayerTreeHostImpl::SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy)
-{
- if (m_managedMemoryPolicy == policy)
- return;
+void LayerTreeHostImpl::SetManagedMemoryPolicy(
+ const ManagedMemoryPolicy& policy) {
+ if (managed_memory_policy_ == policy)
+ return;
- m_managedMemoryPolicy = policy;
- if (!m_proxy->HasImplThread()) {
- // FIXME: In single-thread mode, this can be called on the main thread
- // by GLRenderer::onMemoryAllocationChanged.
- DebugScopedSetImplThread implThread(m_proxy);
- EnforceManagedMemoryPolicy(m_managedMemoryPolicy);
- } else {
- DCHECK(m_proxy->IsImplThread());
- EnforceManagedMemoryPolicy(m_managedMemoryPolicy);
- }
- // We always need to commit after changing the memory policy because the new
- // limit can result in more or less content having texture allocated for it.
- m_client->setNeedsCommitOnImplThread();
+ managed_memory_policy_ = policy;
+ if (!proxy_->HasImplThread()) {
+ // TODO(ccameron): In single-thread mode, this can be called on the main
+ // thread by GLRenderer::OnMemoryAllocationChanged.
+ DebugScopedSetImplThread impl_thread(proxy_);
+ EnforceManagedMemoryPolicy(managed_memory_policy_);
+ } else {
+ DCHECK(proxy_->IsImplThread());
+ EnforceManagedMemoryPolicy(managed_memory_policy_);
+ }
+ // We always need to commit after changing the memory policy because the new
+ // limit can result in more or less content having texture allocated for it.
+ client_->SetNeedsCommitOnImplThread();
}
-void LayerTreeHostImpl::OnVSyncParametersChanged(base::TimeTicks timebase, base::TimeDelta interval)
-{
- m_client->onVSyncParametersChanged(timebase, interval);
+void LayerTreeHostImpl::OnVSyncParametersChanged(base::TimeTicks timebase,
+ base::TimeDelta interval) {
+ client_->OnVSyncParametersChanged(timebase, interval);
}
-void LayerTreeHostImpl::OnSendFrameToParentCompositorAck(const CompositorFrameAck& ack)
-{
- if (!m_renderer)
- return;
+void LayerTreeHostImpl::OnSendFrameToParentCompositorAck(
+ const CompositorFrameAck& ack) {
+ if (!renderer_)
+ return;
- // TODO(piman): We may need to do some validation on this ack before processing it.
- m_renderer->ReceiveCompositorFrameAck(ack);
+ // TODO(piman): We may need to do some validation on this ack before
+ // processing it.
+ renderer_->ReceiveCompositorFrameAck(ack);
}
-void LayerTreeHostImpl::OnCanDrawStateChangedForTree(LayerTreeImpl*)
-{
- m_client->onCanDrawStateChanged(canDraw());
+void LayerTreeHostImpl::OnCanDrawStateChangedForTree() {
+ client_->OnCanDrawStateChanged(CanDraw());
}
-CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const
-{
- CompositorFrameMetadata metadata;
- metadata.device_scale_factor = m_deviceScaleFactor;
- metadata.page_scale_factor = activeTree()->total_page_scale_factor();
- metadata.viewport_size = activeTree()->ScrollableViewportSize();
- metadata.root_layer_size = activeTree()->ScrollableSize();
- metadata.min_page_scale_factor = activeTree()->min_page_scale_factor();
- metadata.max_page_scale_factor = activeTree()->max_page_scale_factor();
- if (m_topControlsManager) {
- metadata.location_bar_offset = gfx::Vector2dF(0.f, m_topControlsManager->controls_top_offset());
- metadata.location_bar_content_translation = gfx::Vector2dF(0.f, m_topControlsManager->content_top_offset());
- }
+CompositorFrameMetadata LayerTreeHostImpl::MakeCompositorFrameMetadata() const {
+ CompositorFrameMetadata metadata;
+ metadata.device_scale_factor = device_scale_factor_;
+ metadata.page_scale_factor = active_tree_->total_page_scale_factor();
+ metadata.viewport_size = active_tree_->ScrollableViewportSize();
+ metadata.root_layer_size = active_tree_->ScrollableSize();
+ metadata.min_page_scale_factor = active_tree_->min_page_scale_factor();
+ metadata.max_page_scale_factor = active_tree_->max_page_scale_factor();
+ if (top_controls_manager_) {
+ metadata.location_bar_offset =
+ gfx::Vector2dF(0.f, top_controls_manager_->controls_top_offset());
+ metadata.location_bar_content_translation =
+ gfx::Vector2dF(0.f, top_controls_manager_->content_top_offset());
+ }
- if (!rootScrollLayer())
- return metadata;
-
- metadata.root_scroll_offset = rootScrollLayer()->scroll_offset() + rootScrollLayer()->scroll_delta();
-
+ if (!RootScrollLayer())
return metadata;
+
+ metadata.root_scroll_offset = RootScrollLayer()->scroll_offset() +
+ RootScrollLayer()->scroll_delta();
+
+ return metadata;
}
-void LayerTreeHostImpl::drawLayers(FrameData& frame)
-{
- TRACE_EVENT0("cc", "LayerTreeHostImpl::drawLayers");
- DCHECK(canDraw());
- DCHECK(!frame.renderPasses.empty());
+void LayerTreeHostImpl::DrawLayers(FrameData* frame) {
+ TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
+ DCHECK(CanDraw());
+ DCHECK(!frame->render_passes.empty());
- // FIXME: use the frame begin time from the overall compositor scheduler.
- // This value is currently inaccessible because it is up in Chromium's
- // RenderWidget.
- m_fpsCounter->saveTimeStamp(base::TimeTicks::Now());
+ // FIXME: use the frame begin time from the overall compositor scheduler.
+ // This value is currently inaccessible because it is up in Chromium's
+ // RenderWidget.
+ fps_counter_->saveTimeStamp(base::TimeTicks::Now());
- if (m_tileManager) {
- m_memoryHistory->SaveEntry(
- m_tileManager->memory_stats_from_last_assign());
- }
+ if (tile_manager_) {
+ memory_history_->SaveEntry(
+ tile_manager_->memory_stats_from_last_assign());
+ }
- if (m_debugState.showHudRects())
- m_debugRectHistory->saveDebugRectsForCurrentFrame(rootLayer(), *frame.renderSurfaceLayerList, frame.occludingScreenSpaceRects, frame.nonOccludingScreenSpaceRects, m_debugState);
+ if (debug_state_.showHudRects()) {
+ debug_rect_history_->saveDebugRectsForCurrentFrame(
+ active_tree_->root_layer(),
+ *frame->render_surface_layer_list,
+ frame->occluding_screen_space_rects,
+ frame->non_occluding_screen_space_rects,
+ debug_state_);
+ }
- if (m_debugState.traceAllRenderedFrames) {
- TRACE_EVENT_INSTANT1("cc.debug", "Frame",
- "frame", ValueToString(frameStateAsValue()));
- }
+ if (debug_state_.traceAllRenderedFrames) {
+ TRACE_EVENT_INSTANT1("cc.debug", "Frame",
+ "frame", ValueToString(FrameStateAsValue()));
+ }
- // Because the contents of the HUD depend on everything else in the frame, the contents
- // of its texture are updated as the last thing before the frame is drawn.
- if (m_activeTree->hud_layer())
- m_activeTree->hud_layer()->updateHudTexture(m_resourceProvider.get());
+ // Because the contents of the HUD depend on everything else in the frame, the
+ // contents of its texture are updated as the last thing before the frame is
+ // drawn.
+ if (active_tree_->hud_layer())
+ active_tree_->hud_layer()->updateHudTexture(resource_provider_.get());
- m_renderer->DrawFrame(frame.renderPasses);
- // The render passes should be consumed by the renderer.
- DCHECK(frame.renderPasses.empty());
- frame.renderPassesById.clear();
+ renderer_->DrawFrame(frame->render_passes);
+ // The render passes should be consumed by the renderer.
+ DCHECK(frame->render_passes.empty());
+ frame->render_passes_by_id.clear();
- // The next frame should start by assuming nothing has changed, and changes are noted as they occur.
- for (unsigned int i = 0; i < frame.renderSurfaceLayerList->size(); i++)
- (*frame.renderSurfaceLayerList)[i]->render_surface()->damage_tracker()->DidDrawDamagedArea();
- rootLayer()->ResetAllChangeTrackingForSubtree();
- updateAnimationState();
+ // The next frame should start by assuming nothing has changed, and changes
+ // are noted as they occur.
+ for (unsigned int i = 0; i < frame->render_surface_layer_list->size(); i++) {
+ (*frame->render_surface_layer_list)[i]->render_surface()->damage_tracker()->
+ DidDrawDamagedArea();
+ }
+ active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
+ UpdateAnimationState();
}
-void LayerTreeHostImpl::didDrawAllLayers(const FrameData& frame)
-{
- for (size_t i = 0; i < frame.willDrawLayers.size(); ++i)
- frame.willDrawLayers[i]->DidDraw(m_resourceProvider.get());
+void LayerTreeHostImpl::DidDrawAllLayers(const FrameData& frame) {
+ for (size_t i = 0; i < frame.will_draw_layers.size(); ++i)
+ frame.will_draw_layers[i]->DidDraw(resource_provider_.get());
- // Once all layers have been drawn, pending texture uploads should no
- // longer block future uploads.
- m_resourceProvider->MarkPendingUploadsAsNonBlocking();
+ // Once all layers have been drawn, pending texture uploads should no
+ // longer block future uploads.
+ resource_provider_->MarkPendingUploadsAsNonBlocking();
}
-void LayerTreeHostImpl::finishAllRendering()
-{
- if (m_renderer)
- m_renderer->Finish();
+void LayerTreeHostImpl::FinishAllRendering() {
+ if (renderer_)
+ renderer_->Finish();
}
-bool LayerTreeHostImpl::isContextLost()
-{
- DCHECK(m_proxy->IsImplThread());
- return m_renderer && m_renderer->IsContextLost();
+bool LayerTreeHostImpl::IsContextLost() {
+ DCHECK(proxy_->IsImplThread());
+ return renderer_ && renderer_->IsContextLost();
}
-const RendererCapabilities& LayerTreeHostImpl::rendererCapabilities() const
-{
- return m_renderer->Capabilities();
+const RendererCapabilities& LayerTreeHostImpl::GetRendererCapabilities() const {
+ return renderer_->Capabilities();
}
-bool LayerTreeHostImpl::swapBuffers()
-{
- if (m_tileManager)
- m_tileManager->DidCompleteFrame();
- return m_renderer->SwapBuffers();
+bool LayerTreeHostImpl::SwapBuffers() {
+ if (tile_manager_)
+ tile_manager_->DidCompleteFrame();
+ return renderer_->SwapBuffers();
}
-gfx::Size LayerTreeHostImpl::DeviceViewportSize() const
-{
- return m_deviceViewportSize;
+gfx::Size LayerTreeHostImpl::DeviceViewportSize() const {
+ return device_viewport_size();
}
-const LayerTreeSettings& LayerTreeHostImpl::Settings() const
-{
- return m_settings;
+const LayerTreeSettings& LayerTreeHostImpl::Settings() const {
+ return settings();
}
-void LayerTreeHostImpl::DidLoseOutputSurface()
-{
- m_client->didLoseOutputSurfaceOnImplThread();
+void LayerTreeHostImpl::DidLoseOutputSurface() {
+ client_->DidLoseOutputSurfaceOnImplThread();
}
-void LayerTreeHostImpl::OnSwapBuffersComplete()
-{
- m_client->onSwapBuffersCompleteOnImplThread();
+void LayerTreeHostImpl::OnSwapBuffersComplete() {
+ client_->OnSwapBuffersCompleteOnImplThread();
}
-void LayerTreeHostImpl::readback(void* pixels,
- gfx::Rect rect_in_device_viewport)
-{
- DCHECK(m_renderer);
- m_renderer->GetFramebufferPixels(pixels, rect_in_device_viewport);
+void LayerTreeHostImpl::Readback(void* pixels,
+ gfx::Rect rect_in_device_viewport) {
+ DCHECK(renderer_);
+ renderer_->GetFramebufferPixels(pixels, rect_in_device_viewport);
}
bool LayerTreeHostImpl::haveRootScrollLayer() const {
- return rootScrollLayer();
+ return RootScrollLayer();
}
float LayerTreeHostImpl::rootScrollLayerTotalScrollY() const {
- if (LayerImpl* layer = rootScrollLayer())
+ if (LayerImpl* layer = RootScrollLayer())
return layer->scroll_offset().y() + layer->scroll_delta().y();
return 0.0f;
}
-LayerImpl* LayerTreeHostImpl::rootLayer() const
-{
- return m_activeTree->RootLayer();
+LayerImpl* LayerTreeHostImpl::RootLayer() const {
+ return active_tree_->root_layer();
}
-LayerImpl* LayerTreeHostImpl::rootScrollLayer() const
-{
- return m_activeTree->RootScrollLayer();
+LayerImpl* LayerTreeHostImpl::RootScrollLayer() const {
+ return active_tree_->RootScrollLayer();
}
-LayerImpl* LayerTreeHostImpl::currentlyScrollingLayer() const
-{
- return m_activeTree->CurrentlyScrollingLayer();
+LayerImpl* LayerTreeHostImpl::CurrentlyScrollingLayer() const {
+ return active_tree_->CurrentlyScrollingLayer();
}
// Content layers can be either directly scrollable or contained in an outer
// scrolling layer which applies the scroll transform. Given a content layer,
// this function returns the associated scroll layer if any.
-static LayerImpl* findScrollLayerForContentLayer(LayerImpl* layerImpl)
-{
- if (!layerImpl)
- return 0;
-
- if (layerImpl->scrollable())
- return layerImpl;
-
- if (layerImpl->DrawsContent() && layerImpl->parent() && layerImpl->parent()->scrollable())
- return layerImpl->parent();
-
+static LayerImpl* FindScrollLayerForContentLayer(LayerImpl* layer_impl) {
+ if (!layer_impl)
return 0;
+
+ if (layer_impl->scrollable())
+ return layer_impl;
+
+ if (layer_impl->DrawsContent() &&
+ layer_impl->parent() &&
+ layer_impl->parent()->scrollable())
+ return layer_impl->parent();
+
+ return 0;
}
-void LayerTreeHostImpl::createPendingTree()
-{
- CHECK(!m_pendingTree);
- if (m_recycleTree)
- m_recycleTree.swap(m_pendingTree);
- else
- m_pendingTree = LayerTreeImpl::create(this);
- m_client->onCanDrawStateChanged(canDraw());
- m_client->onHasPendingTreeStateChanged(pendingTree());
- TRACE_EVENT_ASYNC_BEGIN0("cc", "PendingTree", m_pendingTree.get());
- TRACE_EVENT_ASYNC_STEP0("cc",
- "PendingTree", m_pendingTree.get(), "waiting");
+void LayerTreeHostImpl::CreatePendingTree() {
+ CHECK(!pending_tree_);
+ if (recycle_tree_)
+ recycle_tree_.swap(pending_tree_);
+ else
+ pending_tree_ = LayerTreeImpl::create(this);
+ client_->OnCanDrawStateChanged(CanDraw());
+ client_->OnHasPendingTreeStateChanged(pending_tree_);
+ TRACE_EVENT_ASYNC_BEGIN0("cc", "PendingTree", pending_tree_.get());
+ TRACE_EVENT_ASYNC_STEP0("cc",
+ "PendingTree", pending_tree_.get(), "waiting");
}
-void LayerTreeHostImpl::checkForCompletedTileUploads()
-{
- DCHECK(!m_client->isInsideDraw()) << "Checking for completed uploads within a draw may trigger spurious redraws.";
- if (m_tileManager)
- m_tileManager->CheckForCompletedTileUploads();
+void LayerTreeHostImpl::CheckForCompletedTileUploads() {
+ DCHECK(!client_->IsInsideDraw()) <<
+ "Checking for completed uploads within a draw may trigger "
+ "spurious redraws.";
+ if (tile_manager_)
+ tile_manager_->CheckForCompletedTileUploads();
}
-bool LayerTreeHostImpl::activatePendingTreeIfNeeded()
-{
- if (!pendingTree())
- return false;
+bool LayerTreeHostImpl::ActivatePendingTreeIfNeeded() {
+ if (!pending_tree_)
+ return false;
- CHECK(m_tileManager);
+ CHECK(tile_manager_);
- pendingTree()->UpdateDrawProperties(LayerTreeImpl::UPDATE_PENDING_TREE);
+ pending_tree_->UpdateDrawProperties(LayerTreeImpl::UPDATE_PENDING_TREE);
- TRACE_EVENT_ASYNC_STEP1("cc",
- "PendingTree", m_pendingTree.get(), "activate",
- "state", ValueToString(activationStateAsValue()));
+ TRACE_EVENT_ASYNC_STEP1("cc",
+ "PendingTree", pending_tree_.get(), "activate",
+ "state", ValueToString(ActivationStateAsValue()));
- // It's always fine to activate to an empty tree. Otherwise, only
- // activate once all visible resources in pending tree are ready
- // or tile manager has no work scheduled for pending tree.
- if (activeTree()->RootLayer() &&
- !pendingTree()->AreVisibleResourcesReady()) {
- // In smoothness takes priority mode, the pending tree's priorities are
- // ignored, so the tile manager may not have work for it even though it
- // is simultaneously not ready to be activated.
- if (m_tileManager->GlobalState().tree_priority ==
- SMOOTHNESS_TAKES_PRIORITY ||
- m_tileManager->HasPendingWorkScheduled(PENDING_TREE)) {
- TRACE_EVENT_ASYNC_STEP0("cc",
- "PendingTree",
- m_pendingTree.get(),
- "waiting");
- return false;
- }
+ // It's always fine to activate to an empty tree. Otherwise, only
+ // activate once all visible resources in pending tree are ready
+ // or tile manager has no work scheduled for pending tree.
+ if (active_tree_->root_layer() &&
+ !pending_tree_->AreVisibleResourcesReady()) {
+ // In smoothness takes priority mode, the pending tree's priorities are
+ // ignored, so the tile manager may not have work for it even though it
+ // is simultaneously not ready to be activated.
+ if (tile_manager_->GlobalState().tree_priority ==
+ SMOOTHNESS_TAKES_PRIORITY ||
+ tile_manager_->HasPendingWorkScheduled(PENDING_TREE)) {
+ TRACE_EVENT_ASYNC_STEP0("cc",
+ "PendingTree",
+ pending_tree_.get(),
+ "waiting");
+ return false;
}
+ }
- activatePendingTree();
- return true;
+ ActivatePendingTree();
+ return true;
}
-void LayerTreeHostImpl::activatePendingTree()
-{
- CHECK(m_pendingTree);
- TRACE_EVENT_ASYNC_END0("cc", "PendingTree", m_pendingTree.get());
+void LayerTreeHostImpl::ActivatePendingTree() {
+ CHECK(pending_tree_);
+ TRACE_EVENT_ASYNC_END0("cc", "PendingTree", pending_tree_.get());
- m_activeTree->PushPersistedState(m_pendingTree.get());
- if (m_pendingTree->needs_full_tree_sync())
- m_activeTree->SetRootLayer(TreeSynchronizer::synchronizeTrees(m_pendingTree->RootLayer(), m_activeTree->DetachLayerTree(), m_activeTree.get()));
- TreeSynchronizer::pushProperties(m_pendingTree->RootLayer(), m_activeTree->RootLayer());
- DCHECK(!m_recycleTree);
+ active_tree_->PushPersistedState(pending_tree_.get());
+ if (pending_tree_->needs_full_tree_sync()) {
+ active_tree_->SetRootLayer(
+ TreeSynchronizer::synchronizeTrees(pending_tree_->root_layer(),
+ active_tree_->DetachLayerTree(),
+ active_tree_.get()));
+ }
+ TreeSynchronizer::pushProperties(pending_tree_->root_layer(),
+ active_tree_->root_layer());
+ DCHECK(!recycle_tree_);
- m_pendingTree->PushPropertiesTo(m_activeTree.get());
+ pending_tree_->PushPropertiesTo(active_tree_.get());
- // Now that we've synced everything from the pending tree to the active
- // tree, rename the pending tree the recycle tree so we can reuse it on the
- // next sync.
- m_pendingTree.swap(m_recycleTree);
- m_recycleTree->ClearRenderSurfaces();
+ // Now that we've synced everything from the pending tree to the active
+ // tree, rename the pending tree the recycle tree so we can reuse it on the
+ // next sync.
+ pending_tree_.swap(recycle_tree_);
+ recycle_tree_->ClearRenderSurfaces();
- m_activeTree->DidBecomeActive();
+ active_tree_->DidBecomeActive();
- // Reduce wasted memory now that unlinked resources are guaranteed not
- // to be used.
- m_client->reduceWastedContentsTextureMemoryOnImplThread();
+ // Reduce wasted memory now that unlinked resources are guaranteed not
+ // to be used.
+ client_->ReduceWastedContentsTextureMemoryOnImplThread();
- m_client->onCanDrawStateChanged(canDraw());
- m_client->onHasPendingTreeStateChanged(pendingTree());
- m_client->setNeedsRedrawOnImplThread();
- m_client->renewTreePriority();
+ client_->OnCanDrawStateChanged(CanDraw());
+ client_->OnHasPendingTreeStateChanged(pending_tree_);
+ client_->SetNeedsRedrawOnImplThread();
+ client_->RenewTreePriority();
- if (m_tileManager && m_debugState.continuousPainting) {
- RenderingStats stats;
- m_tileManager->GetRenderingStats(&stats);
- m_paintTimeCounter->SaveRasterizeTime(stats.totalRasterizeTimeForNowBinsOnPendingTree, m_activeTree->source_frame_number());
- }
+ if (tile_manager_ && debug_state_.continuousPainting) {
+ RenderingStats stats;
+ tile_manager_->GetRenderingStats(&stats);
+ paint_time_counter_->SaveRasterizeTime(
+ stats.totalRasterizeTimeForNowBinsOnPendingTree,
+ active_tree_->source_frame_number());
+ }
}
-void LayerTreeHostImpl::setVisible(bool visible)
-{
- DCHECK(m_proxy->IsImplThread());
+void LayerTreeHostImpl::SetVisible(bool visible) {
+ DCHECK(proxy_->IsImplThread());
- if (m_visible == visible)
- return;
- m_visible = visible;
- didVisibilityChange(this, m_visible);
- EnforceManagedMemoryPolicy(m_managedMemoryPolicy);
+ if (visible_ == visible)
+ return;
+ visible_ = visible;
+ DidVisibilityChange(this, visible_);
+ EnforceManagedMemoryPolicy(managed_memory_policy_);
- if (!m_renderer)
- return;
+ if (!renderer_)
+ return;
- m_renderer->SetVisible(visible);
+ renderer_->SetVisible(visible);
- setBackgroundTickingEnabled(!m_visible && !m_animationRegistrar->active_animation_controllers().empty());
+ SetBackgroundTickingEnabled(
+ !visible_ &&
+ !animation_registrar_->active_animation_controllers().empty());
}
-bool LayerTreeHostImpl::initializeRenderer(scoped_ptr<OutputSurface> outputSurface)
-{
- // Since we will create a new resource provider, we cannot continue to use
- // the old resources (i.e. renderSurfaces and texture IDs). Clear them
- // before we destroy the old resource provider.
- if (rootLayer())
- clearRenderSurfaces();
- if (activeTree()->RootLayer())
- sendDidLoseOutputSurfaceRecursive(activeTree()->RootLayer());
- if (pendingTree() && pendingTree()->RootLayer())
- sendDidLoseOutputSurfaceRecursive(pendingTree()->RootLayer());
- if (m_recycleTree && m_recycleTree->RootLayer())
- sendDidLoseOutputSurfaceRecursive(m_recycleTree->RootLayer());
+bool LayerTreeHostImpl::InitializeRenderer(
+ scoped_ptr<OutputSurface> output_surface) {
+ // Since we will create a new resource provider, we cannot continue to use
+ // the old resources (i.e. render_surfaces and texture IDs). Clear them
+ // before we destroy the old resource provider.
+ if (active_tree_->root_layer())
+ ClearRenderSurfaces();
+ if (active_tree_->root_layer())
+ SendDidLoseOutputSurfaceRecursive(active_tree_->root_layer());
+ if (pending_tree_ && pending_tree_->root_layer())
+ SendDidLoseOutputSurfaceRecursive(pending_tree_->root_layer());
+ if (recycle_tree_ && recycle_tree_->root_layer())
+ SendDidLoseOutputSurfaceRecursive(recycle_tree_->root_layer());
- // Note: order is important here.
- m_renderer.reset();
- m_tileManager.reset();
- m_resourceProvider.reset();
- m_outputSurface.reset();
+ // Note: order is important here.
+ renderer_.reset();
+ tile_manager_.reset();
+ resource_provider_.reset();
+ output_surface_.reset();
- if (!outputSurface->BindToClient(this))
- return false;
+ if (!output_surface->BindToClient(this))
+ return false;
- scoped_ptr<ResourceProvider> resourceProvider = ResourceProvider::Create(outputSurface.get());
- if (!resourceProvider)
- return false;
+ scoped_ptr<ResourceProvider> resource_provider =
+ ResourceProvider::Create(output_surface.get());
+ if (!resource_provider)
+ return false;
- if (m_settings.implSidePainting) {
- m_tileManager.reset(new TileManager(this,
- resourceProvider.get(),
- m_settings.numRasterThreads,
- m_settings.useCheapnessEstimator,
- m_settings.useColorEstimator,
- m_settings.predictionBenchmarking));
- m_tileManager->SetRecordRenderingStats(m_debugState.recordRenderingStats());
- }
+ if (settings_.implSidePainting) {
+ tile_manager_.reset(new TileManager(this,
+ resource_provider.get(),
+ settings_.numRasterThreads,
+ settings_.useCheapnessEstimator,
+ settings_.useColorEstimator,
+ settings_.predictionBenchmarking));
+ tile_manager_->SetRecordRenderingStats(debug_state_.recordRenderingStats());
+ }
- if (outputSurface->capabilities().has_parent_compositor)
- m_renderer = DelegatingRenderer::Create(this, outputSurface.get(), resourceProvider.get());
- else if (outputSurface->context3d())
- m_renderer = GLRenderer::Create(this, outputSurface.get(), resourceProvider.get());
- else if (outputSurface->software_device())
- m_renderer = SoftwareRenderer::Create(this, outputSurface.get(), resourceProvider.get());
- if (!m_renderer)
- return false;
+ if (output_surface->capabilities().has_parent_compositor) {
+ renderer_ = DelegatingRenderer::Create(this, output_surface.get(),
+ resource_provider.get());
+ } else if (output_surface->context3d()) {
+ renderer_ = GLRenderer::Create(this,
+ output_surface.get(),
+ resource_provider.get());
+ } else if (output_surface->software_device()) {
+ renderer_ = SoftwareRenderer::Create(this,
+ output_surface.get(),
+ resource_provider.get());
+ }
+ if (!renderer_)
+ return false;
- m_resourceProvider = resourceProvider.Pass();
- m_outputSurface = outputSurface.Pass();
+ resource_provider_ = resource_provider.Pass();
+ output_surface_ = output_surface.Pass();
- if (!m_visible)
- m_renderer->SetVisible(m_visible);
+ if (!visible_)
+ renderer_->SetVisible(visible_);
- m_client->onCanDrawStateChanged(canDraw());
+ client_->OnCanDrawStateChanged(CanDraw());
- // See note in LayerTreeImpl::UpdateDrawProperties. Renderer needs
- // to be initialized to get max texture size.
- activeTree()->set_needs_update_draw_properties();
- if (pendingTree())
- pendingTree()->set_needs_update_draw_properties();
+ // See note in LayerTreeImpl::UpdateDrawProperties. Renderer needs
+ // to be initialized to get max texture size.
+ active_tree_->set_needs_update_draw_properties();
+ if (pending_tree_)
+ pending_tree_->set_needs_update_draw_properties();
- return true;
+ return true;
}
-void LayerTreeHostImpl::setViewportSize(const gfx::Size& layoutViewportSize, const gfx::Size& deviceViewportSize)
-{
- if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_deviceViewportSize)
- return;
+void LayerTreeHostImpl::SetViewportSize(gfx::Size layout_viewport_size,
+ gfx::Size device_viewport_size) {
+ if (layout_viewport_size == layout_viewport_size_ &&
+ device_viewport_size == device_viewport_size_)
+ return;
- if (pendingTree() && m_deviceViewportSize != deviceViewportSize)
- activeTree()->SetViewportSizeInvalid();
+ if (pending_tree_ && device_viewport_size_ != device_viewport_size)
+ active_tree_->SetViewportSizeInvalid();
- m_layoutViewportSize = layoutViewportSize;
- m_deviceViewportSize = deviceViewportSize;
+ layout_viewport_size_ = layout_viewport_size;
+ device_viewport_size_ = device_viewport_size;
- updateMaxScrollOffset();
+ UpdateMaxScrollOffset();
- if (m_renderer)
- m_renderer->ViewportChanged();
+ if (renderer_)
+ renderer_->ViewportChanged();
- m_client->onCanDrawStateChanged(canDraw());
+ client_->OnCanDrawStateChanged(CanDraw());
}
-static void adjustScrollsForPageScaleChange(LayerImpl* layerImpl, float pageScaleChange)
-{
- if (!layerImpl)
- return;
+static void AdjustScrollsForPageScaleChange(LayerImpl* layer_impl,
+ float page_scale_change) {
+ if (!layer_impl)
+ return;
- if (layerImpl->scrollable()) {
- // We need to convert impl-side scroll deltas to pageScale space.
- gfx::Vector2dF scrollDelta = layerImpl->scroll_delta();
- scrollDelta.Scale(pageScaleChange);
- layerImpl->SetScrollDelta(scrollDelta);
- }
+ if (layer_impl->scrollable()) {
+ // We need to convert impl-side scroll deltas to page_scale space.
+ gfx::Vector2dF scroll_delta = layer_impl->scroll_delta();
+ scroll_delta.Scale(page_scale_change);
+ layer_impl->SetScrollDelta(scroll_delta);
+ }
- for (size_t i = 0; i < layerImpl->children().size(); ++i)
- adjustScrollsForPageScaleChange(layerImpl->children()[i], pageScaleChange);
+ for (size_t i = 0; i < layer_impl->children().size(); ++i)
+ AdjustScrollsForPageScaleChange(layer_impl->children()[i],
+ page_scale_change);
}
-void LayerTreeHostImpl::setDeviceScaleFactor(float deviceScaleFactor)
-{
- if (deviceScaleFactor == m_deviceScaleFactor)
- return;
- m_deviceScaleFactor = deviceScaleFactor;
+void LayerTreeHostImpl::SetDeviceScaleFactor(float device_scale_factor) {
+ if (device_scale_factor == device_scale_factor_)
+ return;
+ device_scale_factor_ = device_scale_factor;
- updateMaxScrollOffset();
+ UpdateMaxScrollOffset();
}
-void LayerTreeHostImpl::updateMaxScrollOffset()
-{
- activeTree()->UpdateMaxScrollOffset();
+void LayerTreeHostImpl::UpdateMaxScrollOffset() {
+ active_tree_->UpdateMaxScrollOffset();
}
-void LayerTreeHostImpl::setActiveTreeNeedsUpdateDrawProperties()
-{
- activeTree()->set_needs_update_draw_properties();
+void LayerTreeHostImpl::setActiveTreeNeedsUpdateDrawProperties() {
+ active_tree_->set_needs_update_draw_properties();
}
-void LayerTreeHostImpl::setNeedsRedraw()
-{
- m_client->setNeedsRedrawOnImplThread();
+void LayerTreeHostImpl::setNeedsRedraw() {
+ client_->SetNeedsRedrawOnImplThread();
}
-bool LayerTreeHostImpl::ensureRenderSurfaceLayerList()
-{
- activeTree()->UpdateDrawProperties(LayerTreeImpl::UPDATE_ACTIVE_TREE);
- return activeTree()->RenderSurfaceLayerList().size();
+bool LayerTreeHostImpl::EnsureRenderSurfaceLayerList() {
+ active_tree_->UpdateDrawProperties(LayerTreeImpl::UPDATE_ACTIVE_TREE);
+ return active_tree_->RenderSurfaceLayerList().size();
}
-InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(gfx::Point viewportPoint, InputHandlerClient::ScrollInputType type)
-{
- TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBegin");
+InputHandlerClient::ScrollStatus LayerTreeHostImpl::ScrollBegin(
+ gfx::Point viewport_point, InputHandlerClient::ScrollInputType type) {
+ TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBegin");
- if (m_topControlsManager)
- m_topControlsManager->ScrollBegin();
+ if (top_controls_manager_)
+ top_controls_manager_->ScrollBegin();
- DCHECK(!currentlyScrollingLayer());
- clearCurrentlyScrollingLayer();
+ DCHECK(!CurrentlyScrollingLayer());
+ ClearCurrentlyScrollingLayer();
- if (!ensureRenderSurfaceLayerList())
- return ScrollIgnored;
-
- gfx::PointF deviceViewportPoint = gfx::ScalePoint(viewportPoint, m_deviceScaleFactor);
-
- // First find out which layer was hit from the saved list of visible layers
- // in the most recent frame.
- LayerImpl* layerImpl = LayerTreeHostCommon::findLayerThatIsHitByPoint(deviceViewportPoint, activeTree()->RenderSurfaceLayerList());
-
- // Walk up the hierarchy and look for a scrollable layer.
- LayerImpl* potentiallyScrollingLayerImpl = 0;
- for (; layerImpl; layerImpl = layerImpl->parent()) {
- // The content layer can also block attempts to scroll outside the main thread.
- if (layerImpl->TryScroll(deviceViewportPoint, type) == ScrollOnMainThread) {
- m_numMainThreadScrolls++;
- UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
- return ScrollOnMainThread;
- }
-
- LayerImpl* scrollLayerImpl = findScrollLayerForContentLayer(layerImpl);
- if (!scrollLayerImpl)
- continue;
-
- ScrollStatus status = scrollLayerImpl->TryScroll(deviceViewportPoint, type);
-
- // If any layer wants to divert the scroll event to the main thread, abort.
- if (status == ScrollOnMainThread) {
- m_numMainThreadScrolls++;
- UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
- return ScrollOnMainThread;
- }
-
- if (status == ScrollStarted && !potentiallyScrollingLayerImpl)
- potentiallyScrollingLayerImpl = scrollLayerImpl;
- }
-
- // When hiding top controls is enabled and the controls are hidden or
- // overlaying the content, force scrolls to be enabled on the root layer to
- // allow bringing the top controls back into view.
- if (!potentiallyScrollingLayerImpl && m_topControlsManager &&
- m_topControlsManager->content_top_offset() != m_settings.topControlsHeight) {
- potentiallyScrollingLayerImpl = rootScrollLayer();
- }
-
- if (potentiallyScrollingLayerImpl) {
- m_activeTree->set_currently_scrolling_layer(potentiallyScrollingLayerImpl);
- m_shouldBubbleScrolls = (type != NonBubblingGesture);
- m_wheelScrolling = (type == Wheel);
- m_numImplThreadScrolls++;
- m_client->renewTreePriority();
- UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
- return ScrollStarted;
- }
+ if (!EnsureRenderSurfaceLayerList())
return ScrollIgnored;
-}
-gfx::Vector2dF LayerTreeHostImpl::scrollLayerWithViewportSpaceDelta(LayerImpl* layerImpl, float scaleFromViewportToScreenSpace, gfx::PointF viewportPoint, gfx::Vector2dF viewportDelta)
-{
- // Layers with non-invertible screen space transforms should not have passed the scroll hit
- // test in the first place.
- DCHECK(layerImpl->screen_space_transform().IsInvertible());
- gfx::Transform inverseScreenSpaceTransform(gfx::Transform::kSkipInitialization);
- bool didInvert = layerImpl->screen_space_transform().GetInverse(&inverseScreenSpaceTransform);
- // TODO: With the advent of impl-side crolling for non-root layers, we may
- // need to explicitly handle uninvertible transforms here.
- DCHECK(didInvert);
+ gfx::PointF device_viewport_point = gfx::ScalePoint(viewport_point,
+ device_scale_factor_);
- gfx::PointF screenSpacePoint = gfx::ScalePoint(viewportPoint, scaleFromViewportToScreenSpace);
+ // First find out which layer was hit from the saved list of visible layers
+ // in the most recent frame.
+ LayerImpl* layer_impl = LayerTreeHostCommon::findLayerThatIsHitByPoint(
+ device_viewport_point, active_tree_->RenderSurfaceLayerList());
- gfx::Vector2dF screenSpaceDelta = viewportDelta;
- screenSpaceDelta.Scale(scaleFromViewportToScreenSpace);
-
- // First project the scroll start and end points to local layer space to find the scroll delta
- // in layer coordinates.
- bool startClipped, endClipped;
- gfx::PointF screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta;
- gfx::PointF localStartPoint = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpacePoint, startClipped);
- gfx::PointF localEndPoint = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpaceEndPoint, endClipped);
-
- // In general scroll point coordinates should not get clipped.
- DCHECK(!startClipped);
- DCHECK(!endClipped);
- if (startClipped || endClipped)
- return gfx::Vector2dF();
-
- // localStartPoint and localEndPoint are in content space but we want to move them to layer space for scrolling.
- float widthScale = 1.f / layerImpl->contents_scale_x();
- float heightScale = 1.f / layerImpl->contents_scale_y();
- localStartPoint.Scale(widthScale, heightScale);
- localEndPoint.Scale(widthScale, heightScale);
-
- // Apply the scroll delta.
- gfx::Vector2dF previousDelta = layerImpl->scroll_delta();
- layerImpl->ScrollBy(localEndPoint - localStartPoint);
-
- // Get the end point in the layer's content space so we can apply its screenSpaceTransform.
- gfx::PointF actualLocalEndPoint = localStartPoint + layerImpl->scroll_delta() - previousDelta;
- gfx::PointF actualLocalContentEndPoint = gfx::ScalePoint(actualLocalEndPoint, 1 / widthScale, 1 / heightScale);
-
- // Calculate the applied scroll delta in viewport space coordinates.
- gfx::PointF actualScreenSpaceEndPoint = MathUtil::mapPoint(layerImpl->screen_space_transform(), actualLocalContentEndPoint, endClipped);
- DCHECK(!endClipped);
- if (endClipped)
- return gfx::Vector2dF();
- gfx::PointF actualViewportEndPoint = gfx::ScalePoint(actualScreenSpaceEndPoint, 1 / scaleFromViewportToScreenSpace);
- return actualViewportEndPoint - viewportPoint;
-}
-
-static gfx::Vector2dF scrollLayerWithLocalDelta(LayerImpl& layerImpl, gfx::Vector2dF localDelta)
-{
- gfx::Vector2dF previousDelta(layerImpl.scroll_delta());
- layerImpl.ScrollBy(localDelta);
- return layerImpl.scroll_delta() - previousDelta;
-}
-
-bool LayerTreeHostImpl::scrollBy(const gfx::Point& viewportPoint,
- const gfx::Vector2dF& scrollDelta)
-{
- TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBy");
- if (!currentlyScrollingLayer())
- return false;
-
- gfx::Vector2dF pendingDelta = scrollDelta;
- bool didScroll = false;
-
- for (LayerImpl* layerImpl = currentlyScrollingLayer(); layerImpl; layerImpl = layerImpl->parent()) {
- if (!layerImpl->scrollable())
- continue;
-
- gfx::Vector2dF appliedDelta;
- if (m_topControlsManager && layerImpl == rootScrollLayer())
- pendingDelta = m_topControlsManager->ScrollBy(pendingDelta);
-
- // Gesture events need to be transformed from viewport coordinates to local layer coordinates
- // so that the scrolling contents exactly follow the user's finger. In contrast, wheel
- // events represent a fixed amount of scrolling so we can just apply them directly.
- if (!m_wheelScrolling) {
- float scaleFromViewportToScreenSpace = m_deviceScaleFactor;
- appliedDelta = scrollLayerWithViewportSpaceDelta(layerImpl, scaleFromViewportToScreenSpace, viewportPoint, pendingDelta);
- } else
- appliedDelta = scrollLayerWithLocalDelta(*layerImpl, pendingDelta);
-
- // If the layer wasn't able to move, try the next one in the hierarchy.
- float moveThresholdSquared = 0.1f * 0.1f;
- if (appliedDelta.LengthSquared() < moveThresholdSquared) {
- if (m_shouldBubbleScrolls || !m_didLockScrollingLayer)
- continue;
- else
- break;
- }
- didScroll = true;
- m_didLockScrollingLayer = true;
- if (!m_shouldBubbleScrolls) {
- m_activeTree->set_currently_scrolling_layer(layerImpl);
- break;
- }
-
- // If the applied delta is within 45 degrees of the input delta, bail out to make it easier
- // to scroll just one layer in one direction without affecting any of its parents.
- float angleThreshold = 45;
- if (MathUtil::smallestAngleBetweenVectors(appliedDelta, pendingDelta) < angleThreshold) {
- pendingDelta = gfx::Vector2d();
- break;
- }
-
- // Allow further movement only on an axis perpendicular to the direction in which the layer
- // moved.
- gfx::Vector2dF perpendicularAxis(-appliedDelta.y(), appliedDelta.x());
- pendingDelta = MathUtil::projectVector(pendingDelta, perpendicularAxis);
-
- if (gfx::ToFlooredVector2d(pendingDelta).IsZero())
- break;
+ // Walk up the hierarchy and look for a scrollable layer.
+ LayerImpl* potentially_scrolling_layer_impl = 0;
+ for (; layer_impl; layer_impl = layer_impl->parent()) {
+ // The content layer can also block attempts to scroll outside the main
+ // thread.
+ ScrollStatus status = layer_impl->TryScroll(device_viewport_point, type);
+ if (status == ScrollOnMainThread) {
+ num_main_thread_scrolls_++;
+ UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
+ return ScrollOnMainThread;
}
- if (didScroll) {
- m_client->setNeedsCommitOnImplThread();
- m_client->setNeedsRedrawOnImplThread();
- m_client->renewTreePriority();
- }
- return didScroll;
-}
+ LayerImpl* scroll_layer_impl = FindScrollLayerForContentLayer(layer_impl);
+ if (!scroll_layer_impl)
+ continue;
-void LayerTreeHostImpl::clearCurrentlyScrollingLayer()
-{
- m_activeTree->ClearCurrentlyScrollingLayer();
- m_didLockScrollingLayer = false;
-}
+ status = scroll_layer_impl->TryScroll(device_viewport_point, type);
-void LayerTreeHostImpl::scrollEnd()
-{
- if (m_topControlsManager)
- m_topControlsManager->ScrollEnd();
- clearCurrentlyScrollingLayer();
-}
-
-void LayerTreeHostImpl::pinchGestureBegin()
-{
- m_pinchGestureActive = true;
- m_previousPinchAnchor = gfx::Point();
- m_client->renewTreePriority();
-}
-
-void LayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta, gfx::Point anchor)
-{
- TRACE_EVENT0("cc", "LayerTreeHostImpl::pinchGestureUpdate");
-
- if (!rootScrollLayer())
- return;
-
- // Keep the center-of-pinch anchor specified by (x, y) in a stable
- // position over the course of the magnify.
- float pageScaleDelta = activeTree()->page_scale_delta();
- gfx::PointF previousScaleAnchor = gfx::ScalePoint(anchor, 1 / pageScaleDelta);
- activeTree()->SetPageScaleDelta(pageScaleDelta * magnifyDelta);
- pageScaleDelta = activeTree()->page_scale_delta();
- gfx::PointF newScaleAnchor = gfx::ScalePoint(anchor, 1 / pageScaleDelta);
- gfx::Vector2dF move = previousScaleAnchor - newScaleAnchor;
-
- m_previousPinchAnchor = anchor;
-
- move.Scale(1 / activeTree()->page_scale_factor());
-
- rootScrollLayer()->ScrollBy(move);
-
- if (rootScrollLayer()->scrollbar_animation_controller())
- rootScrollLayer()->scrollbar_animation_controller()->didPinchGestureUpdate(base::TimeTicks::Now());
-
- m_client->setNeedsCommitOnImplThread();
- m_client->setNeedsRedrawOnImplThread();
- m_client->renewTreePriority();
-}
-
-void LayerTreeHostImpl::pinchGestureEnd()
-{
- m_pinchGestureActive = false;
-
- if (rootScrollLayer() && rootScrollLayer()->scrollbar_animation_controller())
- rootScrollLayer()->scrollbar_animation_controller()->didPinchGestureEnd(base::TimeTicks::Now());
-
- m_client->setNeedsCommitOnImplThread();
-}
-
-static void collectScrollDeltas(ScrollAndScaleSet* scrollInfo, LayerImpl* layerImpl)
-{
- if (!layerImpl)
- return;
-
- gfx::Vector2d scrollDelta = gfx::ToFlooredVector2d(layerImpl->scroll_delta());
- if (!scrollDelta.IsZero()) {
- LayerTreeHostCommon::ScrollUpdateInfo scroll;
- scroll.layerId = layerImpl->id();
- scroll.scrollDelta = scrollDelta;
- scrollInfo->scrolls.push_back(scroll);
- layerImpl->SetSentScrollDelta(scrollDelta);
+ // If any layer wants to divert the scroll event to the main thread, abort.
+ if (status == ScrollOnMainThread) {
+ num_main_thread_scrolls_++;
+ UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", true);
+ return ScrollOnMainThread;
}
- for (size_t i = 0; i < layerImpl->children().size(); ++i)
- collectScrollDeltas(scrollInfo, layerImpl->children()[i]);
+ if (status == ScrollStarted && !potentially_scrolling_layer_impl)
+ potentially_scrolling_layer_impl = scroll_layer_impl;
+ }
+
+ // When hiding top controls is enabled and the controls are hidden or
+ // overlaying the content, force scrolls to be enabled on the root layer to
+ // allow bringing the top controls back into view.
+ if (!potentially_scrolling_layer_impl && top_controls_manager_ &&
+ top_controls_manager_->content_top_offset() !=
+ settings_.topControlsHeight) {
+ potentially_scrolling_layer_impl = RootScrollLayer();
+ }
+
+ if (potentially_scrolling_layer_impl) {
+ active_tree_->set_currently_scrolling_layer(
+ potentially_scrolling_layer_impl);
+ should_bubble_scrolls_ = (type != NonBubblingGesture);
+ wheel_scrolling_ = (type == Wheel);
+ num_impl_thread_scrolls_++;
+ client_->RenewTreePriority();
+ UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
+ return ScrollStarted;
+ }
+ return ScrollIgnored;
}
-scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::processScrollDeltas()
-{
- scoped_ptr<ScrollAndScaleSet> scrollInfo(new ScrollAndScaleSet());
+gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
+ LayerImpl* layer_impl,
+ float scale_from_viewport_to_screen_space,
+ gfx::PointF viewport_point,
+ gfx::Vector2dF viewport_delta) {
+ // Layers with non-invertible screen space transforms should not have passed
+ // the scroll hit test in the first place.
+ DCHECK(layer_impl->screen_space_transform().IsInvertible());
+ gfx::Transform inverse_screen_space_transform(
+ gfx::Transform::kSkipInitialization);
+ bool did_invert = layer_impl->screen_space_transform().GetInverse(
+ &inverse_screen_space_transform);
+ // TODO: With the advent of impl-side crolling for non-root layers, we may
+ // need to explicitly handle uninvertible transforms here.
+ DCHECK(did_invert);
- collectScrollDeltas(scrollInfo.get(), rootLayer());
- scrollInfo->pageScaleDelta = activeTree()->page_scale_delta();
- activeTree()->set_sent_page_scale_delta(scrollInfo->pageScaleDelta);
+ gfx::PointF screen_space_point =
+ gfx::ScalePoint(viewport_point, scale_from_viewport_to_screen_space);
- return scrollInfo.Pass();
+ gfx::Vector2dF screen_space_delta = viewport_delta;
+ screen_space_delta.Scale(scale_from_viewport_to_screen_space);
+
+ // First project the scroll start and end points to local layer space to find
+ // the scroll delta in layer coordinates.
+ bool start_clipped, end_clipped;
+ gfx::PointF screen_space_end_point = screen_space_point + screen_space_delta;
+ gfx::PointF local_start_point =
+ MathUtil::projectPoint(inverse_screen_space_transform,
+ screen_space_point,
+ start_clipped);
+ gfx::PointF local_end_point =
+ MathUtil::projectPoint(inverse_screen_space_transform,
+ screen_space_end_point,
+ end_clipped);
+
+ // In general scroll point coordinates should not get clipped.
+ DCHECK(!start_clipped);
+ DCHECK(!end_clipped);
+ if (start_clipped || end_clipped)
+ return gfx::Vector2dF();
+
+ // local_start_point and local_end_point are in content space but we want to
+ // move them to layer space for scrolling.
+ float width_scale = 1.f / layer_impl->contents_scale_x();
+ float height_scale = 1.f / layer_impl->contents_scale_y();
+ local_start_point.Scale(width_scale, height_scale);
+ local_end_point.Scale(width_scale, height_scale);
+
+ // Apply the scroll delta.
+ gfx::Vector2dF previous_delta = layer_impl->scroll_delta();
+ layer_impl->ScrollBy(local_end_point - local_start_point);
+
+ // Get the end point in the layer's content space so we can apply its
+ // ScreenSpaceTransform.
+ gfx::PointF actual_local_end_point = local_start_point +
+ layer_impl->scroll_delta() -
+ previous_delta;
+ gfx::PointF actual_local_content_end_point =
+ gfx::ScalePoint(actual_local_end_point,
+ 1.f / width_scale,
+ 1.f / height_scale);
+
+ // Calculate the applied scroll delta in viewport space coordinates.
+ gfx::PointF actual_screen_space_end_point =
+ MathUtil::mapPoint(layer_impl->screen_space_transform(),
+ actual_local_content_end_point,
+ end_clipped);
+ DCHECK(!end_clipped);
+ if (end_clipped)
+ return gfx::Vector2dF();
+ gfx::PointF actual_viewport_end_point =
+ gfx::ScalePoint(actual_screen_space_end_point,
+ 1.f / scale_from_viewport_to_screen_space);
+ return actual_viewport_end_point - viewport_point;
}
-void LayerTreeHostImpl::SetFullRootLayerDamage()
-{
- if (rootLayer()) {
- RenderSurfaceImpl* renderSurface = rootLayer()->render_surface();
- if (renderSurface)
- renderSurface->damage_tracker()->ForceFullDamageNextUpdate();
+static gfx::Vector2dF ScrollLayerWithLocalDelta(LayerImpl* layer_impl,
+ gfx::Vector2dF local_delta) {
+ gfx::Vector2dF previous_delta(layer_impl->scroll_delta());
+ layer_impl->ScrollBy(local_delta);
+ return layer_impl->scroll_delta() - previous_delta;
+}
+
+bool LayerTreeHostImpl::ScrollBy(gfx::Point viewport_point,
+ gfx::Vector2dF scroll_delta) {
+ TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
+ if (!CurrentlyScrollingLayer())
+ return false;
+
+ gfx::Vector2dF pending_delta = scroll_delta;
+ bool did_scroll = false;
+
+ for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
+ layer_impl;
+ layer_impl = layer_impl->parent()) {
+ if (!layer_impl->scrollable())
+ continue;
+
+ gfx::Vector2dF applied_delta;
+ if (top_controls_manager_ && layer_impl == RootScrollLayer())
+ pending_delta = top_controls_manager_->ScrollBy(pending_delta);
+
+ // Gesture events need to be transformed from viewport coordinates to local
+ // layer coordinates so that the scrolling contents exactly follow the
+ // user's finger. In contrast, wheel events represent a fixed amount of
+ // scrolling so we can just apply them directly.
+ if (!wheel_scrolling_) {
+ float scale_from_viewport_to_screen_space = device_scale_factor_;
+ applied_delta =
+ ScrollLayerWithViewportSpaceDelta(layer_impl,
+ scale_from_viewport_to_screen_space,
+ viewport_point, pending_delta);
+ } else {
+ applied_delta = ScrollLayerWithLocalDelta(layer_impl, pending_delta);
}
-}
-void LayerTreeHostImpl::animatePageScale(base::TimeTicks time)
-{
- if (!m_pageScaleAnimation || !rootScrollLayer())
- return;
-
- double monotonicTime = (time - base::TimeTicks()).InSecondsF();
- gfx::Vector2dF scrollTotal = rootScrollLayer()->scroll_offset() + rootScrollLayer()->scroll_delta();
-
- activeTree()->SetPageScaleDelta(m_pageScaleAnimation->PageScaleFactorAtTime(monotonicTime) / activeTree()->page_scale_factor());
- gfx::Vector2dF nextScroll = m_pageScaleAnimation->ScrollOffsetAtTime(monotonicTime);
-
- rootScrollLayer()->ScrollBy(nextScroll - scrollTotal);
- m_client->setNeedsRedrawOnImplThread();
-
- if (m_pageScaleAnimation->IsAnimationCompleteAtTime(monotonicTime)) {
- m_pageScaleAnimation.reset();
- m_client->setNeedsCommitOnImplThread();
- m_client->renewTreePriority();
+ // If the layer wasn't able to move, try the next one in the hierarchy.
+ float move_threshold_squared = 0.1f * 0.1f;
+ if (applied_delta.LengthSquared() < move_threshold_squared) {
+ if (should_bubble_scrolls_ || !did_lock_scrolling_layer_)
+ continue;
+ else
+ break;
}
-}
-
-void LayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
-{
- if (!m_settings.acceleratedAnimationEnabled || m_animationRegistrar->active_animation_controllers().empty() || !rootLayer())
- return;
-
- TRACE_EVENT0("cc", "LayerTreeHostImpl::animateLayers");
-
- m_lastAnimationTime = wallClockTime;
- double monotonicSeconds = (monotonicTime - base::TimeTicks()).InSecondsF();
-
- AnimationRegistrar::AnimationControllerMap copy = m_animationRegistrar->active_animation_controllers();
- for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin(); iter != copy.end(); ++iter)
- (*iter).second->Animate(monotonicSeconds);
-
- m_client->setNeedsRedrawOnImplThread();
- setBackgroundTickingEnabled(!m_visible && !m_animationRegistrar->active_animation_controllers().empty());
-}
-
-void LayerTreeHostImpl::updateAnimationState()
-{
- if (!m_settings.acceleratedAnimationEnabled || m_animationRegistrar->active_animation_controllers().empty() || !rootLayer())
- return;
-
- TRACE_EVENT0("cc", "LayerTreeHostImpl::updateAnimationState");
- scoped_ptr<AnimationEventsVector> events(make_scoped_ptr(new AnimationEventsVector));
- AnimationRegistrar::AnimationControllerMap copy = m_animationRegistrar->active_animation_controllers();
- for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin(); iter != copy.end(); ++iter)
- (*iter).second->UpdateState(events.get());
-
- if (!events->empty())
- m_client->postAnimationEventsToMainThreadOnImplThread(events.Pass(), m_lastAnimationTime);
-}
-
-base::TimeDelta LayerTreeHostImpl::lowFrequencyAnimationInterval() const
-{
- return base::TimeDelta::FromSeconds(1);
-}
-
-void LayerTreeHostImpl::sendDidLoseOutputSurfaceRecursive(LayerImpl* current)
-{
- DCHECK(current);
- current->DidLoseOutputSurface();
- if (current->mask_layer())
- sendDidLoseOutputSurfaceRecursive(current->mask_layer());
- if (current->replica_layer())
- sendDidLoseOutputSurfaceRecursive(current->replica_layer());
- for (size_t i = 0; i < current->children().size(); ++i)
- sendDidLoseOutputSurfaceRecursive(current->children()[i]);
-}
-
-void LayerTreeHostImpl::clearRenderSurfaces()
-{
- activeTree()->ClearRenderSurfaces();
- if (pendingTree())
- pendingTree()->ClearRenderSurfaces();
-}
-
-std::string LayerTreeHostImpl::layerTreeAsText() const
-{
- std::string str;
- if (rootLayer()) {
- str = rootLayer()->LayerTreeAsText();
- str += "RenderSurfaces:\n";
- dumpRenderSurfaces(&str, 1, rootLayer());
+ did_scroll = true;
+ did_lock_scrolling_layer_ = true;
+ if (!should_bubble_scrolls_) {
+ active_tree_->set_currently_scrolling_layer(layer_impl);
+ break;
}
- return str;
-}
-std::string LayerTreeHostImpl::layerTreeAsJson() const
-{
- std::string str;
- if (rootLayer()) {
- scoped_ptr<base::Value> json(rootLayer()->LayerTreeAsJson());
- base::JSONWriter::WriteWithOptions(
- json.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &str);
+ // If the applied delta is within 45 degrees of the input delta, bail out to
+ // make it easier to scroll just one layer in one direction without
+ // affecting any of its parents.
+ float angle_threshold = 45;
+ if (MathUtil::smallestAngleBetweenVectors(
+ applied_delta, pending_delta) < angle_threshold) {
+ pending_delta = gfx::Vector2d();
+ break;
}
- return str;
+
+ // Allow further movement only on an axis perpendicular to the direction in
+ // which the layer moved.
+ gfx::Vector2dF perpendicular_axis(-applied_delta.y(), applied_delta.x());
+ pending_delta = MathUtil::projectVector(pending_delta, perpendicular_axis);
+
+ if (gfx::ToFlooredVector2d(pending_delta).IsZero())
+ break;
+ }
+
+ if (did_scroll) {
+ client_->SetNeedsCommitOnImplThread();
+ client_->SetNeedsRedrawOnImplThread();
+ client_->RenewTreePriority();
+ }
+ return did_scroll;
}
-void LayerTreeHostImpl::dumpRenderSurfaces(std::string* str, int indent, const LayerImpl* layer) const
-{
- if (layer->render_surface())
- layer->render_surface()->DumpSurface(str, indent);
-
- for (size_t i = 0; i < layer->children().size(); ++i)
- dumpRenderSurfaces(str, indent, layer->children()[i]);
+void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
+ active_tree_->ClearCurrentlyScrollingLayer();
+ did_lock_scrolling_layer_ = false;
}
-int LayerTreeHostImpl::sourceAnimationFrameNumber() const
-{
- return fpsCounter()->currentFrameNumber();
+void LayerTreeHostImpl::ScrollEnd() {
+ if (top_controls_manager_)
+ top_controls_manager_->ScrollEnd();
+ ClearCurrentlyScrollingLayer();
}
-void LayerTreeHostImpl::renderingStats(RenderingStats* stats) const
-{
- stats->numFramesSentToScreen = fpsCounter()->currentFrameNumber();
- stats->droppedFrameCount = fpsCounter()->droppedFrameCount();
- stats->numImplThreadScrolls = m_numImplThreadScrolls;
- stats->numMainThreadScrolls = m_numMainThreadScrolls;
- stats->numLayersDrawn = m_cumulativeNumLayersDrawn;
- stats->numMissingTiles = m_cumulativeNumMissingTiles;
-
- if (m_tileManager)
- m_tileManager->GetRenderingStats(stats);
+void LayerTreeHostImpl::PinchGestureBegin() {
+ pinch_gesture_active_ = true;
+ previous_pinch_anchor_ = gfx::Point();
+ client_->RenewTreePriority();
}
-void LayerTreeHostImpl::sendManagedMemoryStats(
- size_t memoryVisibleBytes,
- size_t memoryVisibleAndNearbyBytes,
- size_t memoryUseBytes)
-{
- if (!renderer())
- return;
+void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta,
+ gfx::Point anchor) {
+ TRACE_EVENT0("cc", "LayerTreeHostImpl::PinchGestureUpdate");
- // Round the numbers being sent up to the next 8MB, to throttle the rate
- // at which we spam the GPU process.
- static const size_t roundingStep = 8 * 1024 * 1024;
- memoryVisibleBytes = RoundUp(memoryVisibleBytes, roundingStep);
- memoryVisibleAndNearbyBytes = RoundUp(memoryVisibleAndNearbyBytes, roundingStep);
- memoryUseBytes = RoundUp(memoryUseBytes, roundingStep);
- if (m_lastSentMemoryVisibleBytes == memoryVisibleBytes &&
- m_lastSentMemoryVisibleAndNearbyBytes == memoryVisibleAndNearbyBytes &&
- m_lastSentMemoryUseBytes == memoryUseBytes) {
- return;
- }
- m_lastSentMemoryVisibleBytes = memoryVisibleBytes;
- m_lastSentMemoryVisibleAndNearbyBytes = memoryVisibleAndNearbyBytes;
- m_lastSentMemoryUseBytes = memoryUseBytes;
+ if (!RootScrollLayer())
+ return;
- renderer()->SendManagedMemoryStats(m_lastSentMemoryVisibleBytes,
- m_lastSentMemoryVisibleAndNearbyBytes,
- m_lastSentMemoryUseBytes);
+ // Keep the center-of-pinch anchor specified by (x, y) in a stable
+ // position over the course of the magnify.
+ float page_scale_delta = active_tree_->page_scale_delta();
+ gfx::PointF previous_scale_anchor =
+ gfx::ScalePoint(anchor, 1.f / page_scale_delta);
+ active_tree_->SetPageScaleDelta(page_scale_delta * magnify_delta);
+ page_scale_delta = active_tree_->page_scale_delta();
+ gfx::PointF new_scale_anchor =
+ gfx::ScalePoint(anchor, 1.f / page_scale_delta);
+ gfx::Vector2dF move = previous_scale_anchor - new_scale_anchor;
+
+ previous_pinch_anchor_ = anchor;
+
+ move.Scale(1 / active_tree_->page_scale_factor());
+
+ RootScrollLayer()->ScrollBy(move);
+
+ if (RootScrollLayer()->scrollbar_animation_controller()) {
+ RootScrollLayer()->scrollbar_animation_controller()->
+ didPinchGestureUpdate(base::TimeTicks::Now());
+ }
+
+ client_->SetNeedsCommitOnImplThread();
+ client_->SetNeedsRedrawOnImplThread();
+ client_->RenewTreePriority();
}
-void LayerTreeHostImpl::animateScrollbars(base::TimeTicks time)
-{
- animateScrollbarsRecursive(rootLayer(), time);
+void LayerTreeHostImpl::PinchGestureEnd() {
+ pinch_gesture_active_ = false;
+
+ if (RootScrollLayer() &&
+ RootScrollLayer()->scrollbar_animation_controller()) {
+ RootScrollLayer()->scrollbar_animation_controller()->
+ didPinchGestureEnd(base::TimeTicks::Now());
+ }
+
+ client_->SetNeedsCommitOnImplThread();
}
-void LayerTreeHostImpl::animateScrollbarsRecursive(LayerImpl* layer, base::TimeTicks time)
-{
- if (!layer)
- return;
+static void CollectScrollDeltas(ScrollAndScaleSet* scroll_info,
+ LayerImpl* layer_impl) {
+ if (!layer_impl)
+ return;
- ScrollbarAnimationController* scrollbarController = layer->scrollbar_animation_controller();
- if (scrollbarController && scrollbarController->animate(time))
- m_client->setNeedsRedrawOnImplThread();
+ gfx::Vector2d scroll_delta =
+ gfx::ToFlooredVector2d(layer_impl->scroll_delta());
+ if (!scroll_delta.IsZero()) {
+ LayerTreeHostCommon::ScrollUpdateInfo scroll;
+ scroll.layerId = layer_impl->id();
+ scroll.scrollDelta = scroll_delta;
+ scroll_info->scrolls.push_back(scroll);
+ layer_impl->SetSentScrollDelta(scroll_delta);
+ }
- for (size_t i = 0; i < layer->children().size(); ++i)
- animateScrollbarsRecursive(layer->children()[i], time);
+ for (size_t i = 0; i < layer_impl->children().size(); ++i)
+ CollectScrollDeltas(scroll_info, layer_impl->children()[i]);
}
-void LayerTreeHostImpl::setTreePriority(TreePriority priority)
-{
- if (!m_tileManager)
- return;
+scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() {
+ scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
- GlobalStateThatImpactsTilePriority new_state(m_tileManager->GlobalState());
- if (new_state.tree_priority == priority)
- return;
+ CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
+ scroll_info->pageScaleDelta = active_tree_->page_scale_delta();
+ active_tree_->set_sent_page_scale_delta(scroll_info->pageScaleDelta);
- new_state.tree_priority = priority;
- m_tileManager->SetGlobalState(new_state);
+ return scroll_info.Pass();
}
-void LayerTreeHostImpl::beginNextFrame()
-{
- m_currentFrameTime = base::TimeTicks();
+void LayerTreeHostImpl::SetFullRootLayerDamage() {
+ if (active_tree_->root_layer()) {
+ RenderSurfaceImpl* render_surface =
+ active_tree_->root_layer()->render_surface();
+ if (render_surface)
+ render_surface->damage_tracker()->ForceFullDamageNextUpdate();
+ }
}
-base::TimeTicks LayerTreeHostImpl::currentFrameTime()
-{
- if (m_currentFrameTime.is_null())
- m_currentFrameTime = base::TimeTicks::Now();
- return m_currentFrameTime;
+void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks time) {
+ if (!page_scale_animation_ || !RootScrollLayer())
+ return;
+
+ double monotonic_time = (time - base::TimeTicks()).InSecondsF();
+ gfx::Vector2dF scroll_total = RootScrollLayer()->scroll_offset() +
+ RootScrollLayer()->scroll_delta();
+
+ active_tree_->SetPageScaleDelta(
+ page_scale_animation_->PageScaleFactorAtTime(monotonic_time) /
+ active_tree_->page_scale_factor());
+ gfx::Vector2dF next_scroll =
+ page_scale_animation_->ScrollOffsetAtTime(monotonic_time);
+
+ RootScrollLayer()->ScrollBy(next_scroll - scroll_total);
+ client_->SetNeedsRedrawOnImplThread();
+
+ if (page_scale_animation_->IsAnimationCompleteAtTime(monotonic_time)) {
+ page_scale_animation_.reset();
+ client_->SetNeedsCommitOnImplThread();
+ client_->RenewTreePriority();
+ }
}
-scoped_ptr<base::Value> LayerTreeHostImpl::asValue() const
-{
- scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
- state->Set("activation_state", activationStateAsValue().release());
- state->Set("frame_state", frameStateAsValue().release());
- return state.PassAs<base::Value>();
+void LayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonic_time,
+ base::Time wall_clock_time) {
+ if (!settings_.acceleratedAnimationEnabled ||
+ animation_registrar_->active_animation_controllers().empty() ||
+ !active_tree_->root_layer())
+ return;
+
+ TRACE_EVENT0("cc", "LayerTreeHostImpl::AnimateLayers");
+
+ last_animation_time_ = wall_clock_time;
+ double monotonic_seconds = (monotonic_time - base::TimeTicks()).InSecondsF();
+
+ AnimationRegistrar::AnimationControllerMap copy =
+ animation_registrar_->active_animation_controllers();
+ for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
+ iter != copy.end();
+ ++iter)
+ (*iter).second->Animate(monotonic_seconds);
+
+ client_->SetNeedsRedrawOnImplThread();
+ SetBackgroundTickingEnabled(
+ !visible_ &&
+ !animation_registrar_->active_animation_controllers().empty());
}
-scoped_ptr<base::Value> LayerTreeHostImpl::activationStateAsValue() const
-{
- scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
- state->SetString("lthi_id", StringPrintf("%p", this));
- state->SetBoolean("visible_resources_ready", pendingTree()->AreVisibleResourcesReady());
- state->Set("tile_manager", m_tileManager->BasicStateAsValue().release());
- return state.PassAs<base::Value>();
+void LayerTreeHostImpl::UpdateAnimationState() {
+ if (!settings_.acceleratedAnimationEnabled ||
+ animation_registrar_->active_animation_controllers().empty() ||
+ !active_tree_->root_layer())
+ return;
+
+ TRACE_EVENT0("cc", "LayerTreeHostImpl::UpdateAnimationState");
+ scoped_ptr<AnimationEventsVector> events =
+ make_scoped_ptr(new AnimationEventsVector);
+ AnimationRegistrar::AnimationControllerMap copy =
+ animation_registrar_->active_animation_controllers();
+ for (AnimationRegistrar::AnimationControllerMap::iterator iter = copy.begin();
+ iter != copy.end();
+ ++iter)
+ (*iter).second->UpdateState(events.get());
+
+ if (!events->empty()) {
+ client_->PostAnimationEventsToMainThreadOnImplThread(events.Pass(),
+ last_animation_time_);
+ }
}
-scoped_ptr<base::Value> LayerTreeHostImpl::frameStateAsValue() const
-{
- scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
- state->SetString("lthi_id", StringPrintf("%p", this));
- state->Set("device_viewport_size", MathUtil::asValue(m_deviceViewportSize).release());
- if (m_tileManager)
- state->Set("tiles", m_tileManager->AllTilesAsValue().release());
- state->Set("active_tree", activeTree()->AsValue().release());
- return state.PassAs<base::Value>();
+base::TimeDelta LayerTreeHostImpl::LowFrequencyAnimationInterval() const {
+ return base::TimeDelta::FromSeconds(1);
+}
+
+void LayerTreeHostImpl::SendDidLoseOutputSurfaceRecursive(LayerImpl* current) {
+ DCHECK(current);
+ current->DidLoseOutputSurface();
+ if (current->mask_layer())
+ SendDidLoseOutputSurfaceRecursive(current->mask_layer());
+ if (current->replica_layer())
+ SendDidLoseOutputSurfaceRecursive(current->replica_layer());
+ for (size_t i = 0; i < current->children().size(); ++i)
+ SendDidLoseOutputSurfaceRecursive(current->children()[i]);
+}
+
+void LayerTreeHostImpl::ClearRenderSurfaces() {
+ active_tree_->ClearRenderSurfaces();
+ if (pending_tree_)
+ pending_tree_->ClearRenderSurfaces();
+}
+
+std::string LayerTreeHostImpl::LayerTreeAsText() const {
+ std::string str;
+ if (active_tree_->root_layer()) {
+ str = active_tree_->root_layer()->LayerTreeAsText();
+ str += "RenderSurfaces:\n";
+ DumpRenderSurfaces(&str, 1, active_tree_->root_layer());
+ }
+ return str;
+}
+
+std::string LayerTreeHostImpl::LayerTreeAsJson() const {
+ std::string str;
+ if (active_tree_->root_layer()) {
+ scoped_ptr<base::Value> json(active_tree_->root_layer()->LayerTreeAsJson());
+ base::JSONWriter::WriteWithOptions(
+ json.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &str);
+ }
+ return str;
+}
+
+void LayerTreeHostImpl::DumpRenderSurfaces(std::string* str,
+ int indent,
+ const LayerImpl* layer) const {
+ if (layer->render_surface())
+ layer->render_surface()->DumpSurface(str, indent);
+
+ for (size_t i = 0; i < layer->children().size(); ++i)
+ DumpRenderSurfaces(str, indent, layer->children()[i]);
+}
+
+int LayerTreeHostImpl::SourceAnimationFrameNumber() const {
+ return fps_counter_->currentFrameNumber();
+}
+
+void LayerTreeHostImpl::CollectRenderingStats(RenderingStats* stats) const {
+ stats->numFramesSentToScreen = fps_counter_->currentFrameNumber();
+ stats->droppedFrameCount = fps_counter_->droppedFrameCount();
+ stats->numImplThreadScrolls = num_impl_thread_scrolls_;
+ stats->numMainThreadScrolls = num_main_thread_scrolls_;
+ stats->numLayersDrawn = cumulative_num_layers_drawn_;
+ stats->numMissingTiles = cumulative_num_missing_tiles_;
+
+ if (tile_manager_)
+ tile_manager_->GetRenderingStats(stats);
+}
+
+void LayerTreeHostImpl::SendManagedMemoryStats(
+ size_t memory_visible_bytes,
+ size_t memory_visible_and_nearby_bytes,
+ size_t memory_use_bytes) {
+ if (!renderer_)
+ return;
+
+ // Round the numbers being sent up to the next 8MB, to throttle the rate
+ // at which we spam the GPU process.
+ static const size_t rounding_step = 8 * 1024 * 1024;
+ memory_visible_bytes = RoundUp(memory_visible_bytes, rounding_step);
+ memory_visible_and_nearby_bytes = RoundUp(memory_visible_and_nearby_bytes,
+ rounding_step);
+ memory_use_bytes = RoundUp(memory_use_bytes, rounding_step);
+ if (last_sent_memory_visible_bytes_ == memory_visible_bytes &&
+ last_sent_memory_visible_and_nearby_bytes_ ==
+ memory_visible_and_nearby_bytes &&
+ last_sent_memory_use_bytes_ == memory_use_bytes) {
+ return;
+ }
+ last_sent_memory_visible_bytes_ = memory_visible_bytes;
+ last_sent_memory_visible_and_nearby_bytes_ = memory_visible_and_nearby_bytes;
+ last_sent_memory_use_bytes_ = memory_use_bytes;
+
+ renderer_->SendManagedMemoryStats(last_sent_memory_visible_bytes_,
+ last_sent_memory_visible_and_nearby_bytes_,
+ last_sent_memory_use_bytes_);
+}
+
+void LayerTreeHostImpl::AnimateScrollbars(base::TimeTicks time) {
+ AnimateScrollbarsRecursive(active_tree_->root_layer(), time);
+}
+
+void LayerTreeHostImpl::AnimateScrollbarsRecursive(LayerImpl* layer,
+ base::TimeTicks time) {
+ if (!layer)
+ return;
+
+ ScrollbarAnimationController* scrollbar_controller =
+ layer->scrollbar_animation_controller();
+ if (scrollbar_controller && scrollbar_controller->animate(time))
+ client_->SetNeedsRedrawOnImplThread();
+
+ for (size_t i = 0; i < layer->children().size(); ++i)
+ AnimateScrollbarsRecursive(layer->children()[i], time);
+}
+
+void LayerTreeHostImpl::SetTreePriority(TreePriority priority) {
+ if (!tile_manager_)
+ return;
+
+ GlobalStateThatImpactsTilePriority new_state(tile_manager_->GlobalState());
+ if (new_state.tree_priority == priority)
+ return;
+
+ new_state.tree_priority = priority;
+ tile_manager_->SetGlobalState(new_state);
+}
+
+void LayerTreeHostImpl::BeginNextFrame() {
+ current_frame_time_ = base::TimeTicks();
+}
+
+base::TimeTicks LayerTreeHostImpl::CurrentFrameTime() {
+ if (current_frame_time_.is_null())
+ current_frame_time_ = base::TimeTicks::Now();
+ return current_frame_time_;
+}
+
+scoped_ptr<base::Value> LayerTreeHostImpl::AsValue() const {
+ scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
+ state->Set("activation_state", ActivationStateAsValue().release());
+ state->Set("frame_state", FrameStateAsValue().release());
+ return state.PassAs<base::Value>();
+}
+
+scoped_ptr<base::Value> LayerTreeHostImpl::ActivationStateAsValue() const {
+ scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
+ state->SetString("lthi_id", StringPrintf("%p", this));
+ state->SetBoolean("visible_resources_ready",
+ pending_tree_->AreVisibleResourcesReady());
+ state->Set("tile_manager", tile_manager_->BasicStateAsValue().release());
+ return state.PassAs<base::Value>();
+}
+
+scoped_ptr<base::Value> LayerTreeHostImpl::FrameStateAsValue() const {
+ scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
+ state->SetString("lthi_id", StringPrintf("%p", this));
+ state->Set("device_viewport_size",
+ MathUtil::asValue(device_viewport_size_).release());
+ if (tile_manager_)
+ state->Set("tiles", tile_manager_->AllTilesAsValue().release());
+ state->Set("active_tree", active_tree_->AsValue().release());
+ return state.PassAs<base::Value>();
}
// static
-LayerImpl* LayerTreeHostImpl::getNonCompositedContentLayerRecursive(LayerImpl* layer)
-{
- if (!layer)
- return NULL;
-
- if (layer->DrawsContent())
- return layer;
-
- for (LayerImpl::LayerList::const_iterator it = layer->children().begin();
- it != layer->children().end(); ++it) {
- LayerImpl* nccr = getNonCompositedContentLayerRecursive(*it);
- if (nccr)
- return nccr;
- }
-
+LayerImpl* LayerTreeHostImpl::GetNonCompositedContentLayerRecursive(
+ LayerImpl* layer) {
+ if (!layer)
return NULL;
+
+ if (layer->DrawsContent())
+ return layer;
+
+ for (LayerImpl::LayerList::const_iterator it = layer->children().begin();
+ it != layer->children().end(); ++it) {
+ LayerImpl* nccr = GetNonCompositedContentLayerRecursive(*it);
+ if (nccr)
+ return nccr;
+ }
+
+ return NULL;
}
-skia::RefPtr<SkPicture> LayerTreeHostImpl::capturePicture()
-{
- LayerTreeImpl* tree = pendingTree() ? pendingTree() : activeTree();
- LayerImpl* layer = getNonCompositedContentLayerRecursive(tree->RootLayer());
- return layer ? layer->GetPicture() : skia::RefPtr<SkPicture>();
+skia::RefPtr<SkPicture> LayerTreeHostImpl::CapturePicture() {
+ LayerTreeImpl* tree =
+ pending_tree_ ? pending_tree_.get() : active_tree_.get();
+ LayerImpl* layer = GetNonCompositedContentLayerRecursive(tree->root_layer());
+ return layer ? layer->GetPicture() : skia::RefPtr<SkPicture>();
}
-void LayerTreeHostImpl::setDebugState(const LayerTreeDebugState& debugState)
-{
- if (m_debugState.continuousPainting != debugState.continuousPainting)
- m_paintTimeCounter->ClearHistory();
+void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
+ if (debug_state_.continuousPainting != debug_state.continuousPainting)
+ paint_time_counter_->ClearHistory();
- m_debugState = debugState;
+ debug_state_ = debug_state;
- if (m_tileManager)
- m_tileManager->SetRecordRenderingStats(m_debugState.recordRenderingStats());
+ if (tile_manager_)
+ tile_manager_->SetRecordRenderingStats(debug_state_.recordRenderingStats());
}
-void LayerTreeHostImpl::savePaintTime(const base::TimeDelta& totalPaintTime, int commitNumber)
-{
- DCHECK(m_debugState.continuousPainting);
- m_paintTimeCounter->SavePaintTime(totalPaintTime, commitNumber);
+void LayerTreeHostImpl::SavePaintTime(const base::TimeDelta& total_paint_time,
+ int commit_number) {
+ DCHECK(debug_state_.continuousPainting);
+ paint_time_counter_->SavePaintTime(total_paint_time, commit_number);
}
} // namespace cc
diff --git a/cc/layer_tree_host_impl.h b/cc/layer_tree_host_impl.h
index 23bf1add..6e90e93 100644
--- a/cc/layer_tree_host_impl.h
+++ b/cc/layer_tree_host_impl.h
@@ -43,334 +43,402 @@
// LayerTreeHost->Proxy callback interface.
class LayerTreeHostImplClient {
-public:
- virtual void didLoseOutputSurfaceOnImplThread() = 0;
- virtual void onSwapBuffersCompleteOnImplThread() = 0;
- virtual void onVSyncParametersChanged(base::TimeTicks timebase, base::TimeDelta interval) = 0;
- virtual void onCanDrawStateChanged(bool canDraw) = 0;
- virtual void onHasPendingTreeStateChanged(bool hasPendingTree) = 0;
- virtual void setNeedsRedrawOnImplThread() = 0;
- virtual void didUploadVisibleHighResolutionTileOnImplThread() = 0;
- virtual void setNeedsCommitOnImplThread() = 0;
- virtual void setNeedsManageTilesOnImplThread() = 0;
- virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector>, base::Time wallClockTime) = 0;
- // Returns true if resources were deleted by this call.
- virtual bool reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff) = 0;
- virtual void reduceWastedContentsTextureMemoryOnImplThread() = 0;
- virtual void sendManagedMemoryStats() = 0;
- virtual bool isInsideDraw() = 0;
- virtual void renewTreePriority() = 0;
+ public:
+ virtual void DidLoseOutputSurfaceOnImplThread() = 0;
+ virtual void OnSwapBuffersCompleteOnImplThread() = 0;
+ virtual void OnVSyncParametersChanged(base::TimeTicks timebase,
+ base::TimeDelta interval) = 0;
+ virtual void OnCanDrawStateChanged(bool can_draw) = 0;
+ virtual void OnHasPendingTreeStateChanged(bool has_pending_tree) = 0;
+ virtual void SetNeedsRedrawOnImplThread() = 0;
+ virtual void DidUploadVisibleHighResolutionTileOnImplThread() = 0;
+ virtual void SetNeedsCommitOnImplThread() = 0;
+ virtual void SetNeedsManageTilesOnImplThread() = 0;
+ virtual void PostAnimationEventsToMainThreadOnImplThread(
+ scoped_ptr<AnimationEventsVector> events,
+ base::Time wall_clock_time) = 0;
+ // Returns true if resources were deleted by this call.
+ virtual bool ReduceContentsTextureMemoryOnImplThread(
+ size_t limit_bytes,
+ int priority_cutoff) = 0;
+ virtual void ReduceWastedContentsTextureMemoryOnImplThread() = 0;
+ virtual void SendManagedMemoryStats() = 0;
+ virtual bool IsInsideDraw() = 0;
+ virtual void RenewTreePriority() = 0;
};
-// LayerTreeHostImpl owns the LayerImpl tree as well as associated rendering state
+// LayerTreeHostImpl owns the LayerImpl trees as well as associated rendering
+// state.
class CC_EXPORT LayerTreeHostImpl : public InputHandlerClient,
public RendererClient,
public TileManagerClient,
public OutputSurfaceClient,
public TopControlsManagerClient {
- typedef std::vector<LayerImpl*> LayerList;
+ typedef std::vector<LayerImpl*> LayerList;
-public:
- static scoped_ptr<LayerTreeHostImpl> create(const LayerTreeSettings&, LayerTreeHostImplClient*, Proxy*);
- virtual ~LayerTreeHostImpl();
+ public:
+ static scoped_ptr<LayerTreeHostImpl> Create(
+ const LayerTreeSettings& settings,
+ LayerTreeHostImplClient* client,
+ Proxy* proxy);
+ virtual ~LayerTreeHostImpl();
- // InputHandlerClient implementation
- virtual InputHandlerClient::ScrollStatus scrollBegin(gfx::Point, InputHandlerClient::ScrollInputType) OVERRIDE;
- virtual bool scrollBy(const gfx::Point&, const gfx::Vector2dF&) OVERRIDE;
- virtual void scrollEnd() OVERRIDE;
- virtual void pinchGestureBegin() OVERRIDE;
- virtual void pinchGestureUpdate(float, gfx::Point) OVERRIDE;
- virtual void pinchGestureEnd() OVERRIDE;
- virtual void startPageScaleAnimation(gfx::Vector2d targetOffset, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration) OVERRIDE;
- virtual void scheduleAnimation() OVERRIDE;
- virtual bool haveTouchEventHandlersAt(const gfx::Point&) OVERRIDE;
+ // InputHandlerClient implementation
+ virtual InputHandlerClient::ScrollStatus ScrollBegin(
+ gfx::Point viewport_point,
+ InputHandlerClient::ScrollInputType type) OVERRIDE;
+ virtual bool ScrollBy(gfx::Point viewport_point,
+ gfx::Vector2dF scroll_delta) OVERRIDE;
+ virtual void ScrollEnd() OVERRIDE;
+ virtual void PinchGestureBegin() OVERRIDE;
+ virtual void PinchGestureUpdate(float magnify_delta,
+ gfx::Point anchor) OVERRIDE;
+ virtual void PinchGestureEnd() OVERRIDE;
+ virtual void StartPageScaleAnimation(gfx::Vector2d target_offset,
+ bool anchor_point,
+ float page_scale,
+ base::TimeTicks start_time,
+ base::TimeDelta duration) OVERRIDE;
+ virtual void ScheduleAnimation() OVERRIDE;
+ virtual bool HaveTouchEventHandlersAt(gfx::Point viewport_port) OVERRIDE;
- // TopControlsManagerClient implementation.
- virtual void setActiveTreeNeedsUpdateDrawProperties() OVERRIDE;
- virtual void setNeedsRedraw() OVERRIDE;
- virtual bool haveRootScrollLayer() const OVERRIDE;
- virtual float rootScrollLayerTotalScrollY() const OVERRIDE;
+ // TopControlsManagerClient implementation.
+ virtual void setActiveTreeNeedsUpdateDrawProperties() OVERRIDE;
+ virtual void setNeedsRedraw() OVERRIDE;
+ virtual bool haveRootScrollLayer() const OVERRIDE;
+ virtual float rootScrollLayerTotalScrollY() const OVERRIDE;
- struct CC_EXPORT FrameData : public RenderPassSink {
- FrameData();
- ~FrameData();
+ struct CC_EXPORT FrameData : public RenderPassSink {
+ FrameData();
+ ~FrameData();
- std::vector<gfx::Rect> occludingScreenSpaceRects;
- std::vector<gfx::Rect> nonOccludingScreenSpaceRects;
- RenderPassList renderPasses;
- RenderPassIdHashMap renderPassesById;
- const LayerList* renderSurfaceLayerList;
- LayerList willDrawLayers;
- bool containsIncompleteTile;
+ std::vector<gfx::Rect> occluding_screen_space_rects;
+ std::vector<gfx::Rect> non_occluding_screen_space_rects;
+ RenderPassList render_passes;
+ RenderPassIdHashMap render_passes_by_id;
+ const LayerList* render_surface_layer_list;
+ LayerList will_draw_layers;
+ bool contains_incomplete_tile;
- // RenderPassSink implementation.
- virtual void appendRenderPass(scoped_ptr<RenderPass>) OVERRIDE;
- };
+ // RenderPassSink implementation.
+ virtual void AppendRenderPass(scoped_ptr<RenderPass> render_pass) OVERRIDE;
+ };
- // Virtual for testing.
- virtual void beginCommit();
- virtual void commitComplete();
- virtual void animate(base::TimeTicks monotonicTime, base::Time wallClockTime);
- virtual void setVisible(bool);
+ virtual void BeginCommit();
+ virtual void CommitComplete();
+ virtual void Animate(base::TimeTicks monotonic_time,
+ base::Time wall_clock_time);
- void manageTiles();
+ void ManageTiles();
- // Returns false if problems occured preparing the frame, and we should try
- // to avoid displaying the frame. If prepareToDraw is called,
- // didDrawAllLayers must also be called, regardless of whether drawLayers is
- // called between the two.
- virtual bool prepareToDraw(FrameData&);
- virtual void drawLayers(FrameData&);
- // Must be called if and only if prepareToDraw was called.
- void didDrawAllLayers(const FrameData&);
+ // Returns false if problems occured preparing the frame, and we should try
+ // to avoid displaying the frame. If prepareToDraw is called, DidDrawAllLayers
+ // must also be called, regardless of whether DrawLayers is called between the
+ // two.
+ virtual bool PrepareToDraw(FrameData* frame);
+ virtual void DrawLayers(FrameData* frame);
+ // Must be called if and only if PrepareToDraw was called.
+ void DidDrawAllLayers(const FrameData& frame);
- // RendererClient implementation
- virtual gfx::Size DeviceViewportSize() const OVERRIDE;
- virtual const LayerTreeSettings& Settings() const OVERRIDE;
- virtual void DidLoseOutputSurface() OVERRIDE;
- virtual void OnSwapBuffersComplete() OVERRIDE;
- virtual void SetFullRootLayerDamage() OVERRIDE;
- virtual void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
- virtual void EnforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE;
- virtual bool HasImplThread() const OVERRIDE;
- virtual bool ShouldClearRootRenderPass() const OVERRIDE;
- virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const OVERRIDE;
+ const LayerTreeSettings& settings() const { return settings_; }
- // TileManagerClient implementation.
- virtual void ScheduleManageTiles() OVERRIDE;
- virtual void DidUploadVisibleHighResolutionTile() OVERRIDE;
+ // RendererClient implementation
+ private:
+ virtual gfx::Size DeviceViewportSize() const OVERRIDE;
+ virtual const LayerTreeSettings& Settings() const OVERRIDE;
+ public:
+ virtual void DidLoseOutputSurface() OVERRIDE;
+ virtual void OnSwapBuffersComplete() OVERRIDE;
+ virtual void SetFullRootLayerDamage() OVERRIDE;
+ virtual void SetManagedMemoryPolicy(const ManagedMemoryPolicy& policy)
+ OVERRIDE;
+ virtual void EnforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy)
+ OVERRIDE;
+ virtual bool HasImplThread() const OVERRIDE;
+ virtual bool ShouldClearRootRenderPass() const OVERRIDE;
+ virtual CompositorFrameMetadata MakeCompositorFrameMetadata() const OVERRIDE;
- // OutputSurfaceClient implementation.
- virtual void OnVSyncParametersChanged(base::TimeTicks timebase, base::TimeDelta interval) OVERRIDE;
- virtual void OnSendFrameToParentCompositorAck(const CompositorFrameAck&) OVERRIDE;
+ // TileManagerClient implementation.
+ virtual void ScheduleManageTiles() OVERRIDE;
+ virtual void DidUploadVisibleHighResolutionTile() OVERRIDE;
- // Called from LayerTreeImpl.
- void OnCanDrawStateChangedForTree(LayerTreeImpl*);
+ // OutputSurfaceClient implementation.
+ virtual void OnVSyncParametersChanged(base::TimeTicks timebase,
+ base::TimeDelta interval) OVERRIDE;
+ virtual void OnSendFrameToParentCompositorAck(const CompositorFrameAck& ack)
+ OVERRIDE;
- // Implementation
- bool canDraw();
- OutputSurface* outputSurface() const;
+ // Called from LayerTreeImpl.
+ void OnCanDrawStateChangedForTree();
- std::string layerTreeAsText() const;
- std::string layerTreeAsJson() const;
+ // Implementation
+ bool CanDraw();
+ OutputSurface* output_surface() const { return output_surface_.get(); }
- void finishAllRendering();
- int sourceAnimationFrameNumber() const;
+ std::string LayerTreeAsText() const;
+ std::string LayerTreeAsJson() const;
- virtual bool initializeRenderer(scoped_ptr<OutputSurface>);
- bool isContextLost();
- TileManager* tileManager() { return m_tileManager.get(); }
- Renderer* renderer() { return m_renderer.get(); }
- const RendererCapabilities& rendererCapabilities() const;
+ void FinishAllRendering();
+ int SourceAnimationFrameNumber() const;
- bool swapBuffers();
+ virtual bool InitializeRenderer(scoped_ptr<OutputSurface> output_surface);
+ bool IsContextLost();
+ TileManager* tile_manager() { return tile_manager_.get(); }
+ Renderer* renderer() { return renderer_.get(); }
+ const RendererCapabilities& GetRendererCapabilities() const;
- void readback(void* pixels, gfx::Rect rect_in_device_viewport);
+ bool SwapBuffers();
- LayerTreeImpl* activeTree() { return m_activeTree.get(); }
- const LayerTreeImpl* activeTree() const { return m_activeTree.get(); }
- LayerTreeImpl* pendingTree() { return m_pendingTree.get(); }
- const LayerTreeImpl* pendingTree() const { return m_pendingTree.get(); }
- const LayerTreeImpl* recycleTree() const { return m_recycleTree.get(); }
- void createPendingTree();
- void checkForCompletedTileUploads();
- virtual bool activatePendingTreeIfNeeded();
+ void Readback(void* pixels, gfx::Rect rect_in_device_viewport);
- // Shortcuts to layers on the active tree.
- LayerImpl* rootLayer() const;
- LayerImpl* rootScrollLayer() const;
- LayerImpl* currentlyScrollingLayer() const;
+ LayerTreeImpl* active_tree() { return active_tree_.get(); }
+ const LayerTreeImpl* active_tree() const { return active_tree_.get(); }
+ LayerTreeImpl* pending_tree() { return pending_tree_.get(); }
+ const LayerTreeImpl* pending_tree() const { return pending_tree_.get(); }
+ const LayerTreeImpl* recycle_tree() const { return recycle_tree_.get(); }
+ void CreatePendingTree();
+ void CheckForCompletedTileUploads();
+ virtual bool ActivatePendingTreeIfNeeded();
- bool visible() const { return m_visible; }
+ // Shortcuts to layers on the active tree.
+ LayerImpl* RootLayer() const;
+ LayerImpl* RootScrollLayer() const;
+ LayerImpl* CurrentlyScrollingLayer() const;
- size_t memoryAllocationLimitBytes() const { return m_managedMemoryPolicy.bytesLimitWhenVisible; }
+ virtual void SetVisible(bool visible);
+ bool visible() const { return visible_; }
- void setViewportSize(const gfx::Size& layoutViewportSize, const gfx::Size& deviceViewportSize);
- const gfx::Size& layoutViewportSize() const { return m_layoutViewportSize; }
+ size_t memory_allocation_limit_bytes() const {
+ return managed_memory_policy_.bytesLimitWhenVisible;
+ }
- float deviceScaleFactor() const { return m_deviceScaleFactor; }
- void setDeviceScaleFactor(float);
+ void SetViewportSize(gfx::Size layout_viewport_size,
+ gfx::Size device_viewport_size);
+ gfx::Size layout_viewport_size() const { return layout_viewport_size_; }
+ gfx::Size device_viewport_size() const { return device_viewport_size_; }
- scoped_ptr<ScrollAndScaleSet> processScrollDeltas();
+ void SetDeviceScaleFactor(float device_scale_factor);
+ float device_scale_factor() const { return device_scale_factor_; }
- void startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration);
+ scoped_ptr<ScrollAndScaleSet> ProcessScrollDeltas();
- bool needsAnimateLayers() const { return !m_animationRegistrar->active_animation_controllers().empty(); }
+ void StartPageScaleAnimation(gfx::Vector2d target_offset,
+ bool use_anchor,
+ float scale,
+ base::TimeDelta duration);
- void renderingStats(RenderingStats*) const;
+ bool needs_animate_layers() const {
+ return !animation_registrar_->active_animation_controllers().empty();
+ }
- void sendManagedMemoryStats(
- size_t memoryVisibleBytes,
- size_t memoryVisibleAndNearbyBytes,
- size_t memoryUseBytes);
+ void CollectRenderingStats(RenderingStats* stats) const;
- FrameRateCounter* fpsCounter() const { return m_fpsCounter.get(); }
- PaintTimeCounter* paintTimeCounter() const { return m_paintTimeCounter.get(); }
- MemoryHistory* memoryHistory() const { return m_memoryHistory.get(); }
- DebugRectHistory* debugRectHistory() const { return m_debugRectHistory.get(); }
- ResourceProvider* resourceProvider() const { return m_resourceProvider.get(); }
- TopControlsManager* topControlsManager() const { return m_topControlsManager.get(); }
+ void SendManagedMemoryStats(
+ size_t memory_visible_bytes,
+ size_t memory_visible_and_nearby_bytes,
+ size_t memoryUseBytes);
+
+ FrameRateCounter* fps_counter() {
+ return fps_counter_.get();
+ }
+ PaintTimeCounter* paint_time_counter() {
+ return paint_time_counter_.get();
+ }
+ MemoryHistory* memory_history() {
+ return memory_history_.get();
+ }
+ DebugRectHistory* debug_rect_history() {
+ return debug_rect_history_.get();
+ }
+ ResourceProvider* resource_provider() {
+ return resource_provider_.get();
+ }
+ TopControlsManager* top_controls_manager() {
+ return top_controls_manager_.get();
+ }
- Proxy* proxy() const { return m_proxy; }
+ Proxy* proxy() const { return proxy_; }
- AnimationRegistrar* animationRegistrar() const { return m_animationRegistrar.get(); }
+ AnimationRegistrar* animation_registrar() const {
+ return animation_registrar_.get();
+ }
- void setDebugState(const LayerTreeDebugState& debugState);
- const LayerTreeDebugState& debugState() const { return m_debugState; }
+ void SetDebugState(const LayerTreeDebugState& debug_state);
+ const LayerTreeDebugState& debug_state() const { return debug_state_; }
- void savePaintTime(const base::TimeDelta& totalPaintTime, int commitNumber);
+ void SavePaintTime(const base::TimeDelta& total_paint_time,
+ int commit_number);
- class CC_EXPORT CullRenderPassesWithCachedTextures {
- public:
- bool shouldRemoveRenderPass(const RenderPassDrawQuad&, const FrameData&) const;
+ class CC_EXPORT CullRenderPassesWithCachedTextures {
+ public:
+ bool ShouldRemoveRenderPass(const RenderPassDrawQuad& quad,
+ const FrameData& frame) const;
- // Iterates from the root first, in order to remove the surfaces closest
- // to the root with cached textures, and all surfaces that draw into
- // them.
- size_t renderPassListBegin(const RenderPassList& list) const { return list.size() - 1; }
- size_t renderPassListEnd(const RenderPassList&) const { return 0 - 1; }
- size_t renderPassListNext(size_t it) const { return it - 1; }
+ // Iterates from the root first, in order to remove the surfaces closest
+ // to the root with cached textures, and all surfaces that draw into
+ // them.
+ size_t RenderPassListBegin(const RenderPassList& list) const {
+ return list.size() - 1;
+ }
+ size_t RenderPassListEnd(const RenderPassList& list) const { return 0 - 1; }
+ size_t RenderPassListNext(size_t it) const { return it - 1; }
- CullRenderPassesWithCachedTextures(Renderer& renderer) : m_renderer(renderer) { }
- private:
- Renderer& m_renderer;
- };
+ CullRenderPassesWithCachedTextures(Renderer& renderer)
+ : renderer_(renderer) {}
+ private:
+ Renderer& renderer_;
+ };
- class CC_EXPORT CullRenderPassesWithNoQuads {
- public:
- bool shouldRemoveRenderPass(const RenderPassDrawQuad&, const FrameData&) const;
+ class CC_EXPORT CullRenderPassesWithNoQuads {
+ public:
+ bool ShouldRemoveRenderPass(const RenderPassDrawQuad& quad,
+ const FrameData& frame) const;
- // Iterates in draw order, so that when a surface is removed, and its
- // target becomes empty, then its target can be removed also.
- size_t renderPassListBegin(const RenderPassList&) const { return 0; }
- size_t renderPassListEnd(const RenderPassList& list) const { return list.size(); }
- size_t renderPassListNext(size_t it) const { return it + 1; }
- };
+ // Iterates in draw order, so that when a surface is removed, and its
+ // target becomes empty, then its target can be removed also.
+ size_t RenderPassListBegin(const RenderPassList& list) const { return 0; }
+ size_t RenderPassListEnd(const RenderPassList& list) const {
+ return list.size();
+ }
+ size_t RenderPassListNext(size_t it) const { return it + 1; }
+ };
- template<typename RenderPassCuller>
- static void removeRenderPasses(RenderPassCuller, FrameData&);
+ template <typename RenderPassCuller>
+ static void RemoveRenderPasses(RenderPassCuller culler, FrameData* frame);
- skia::RefPtr<SkPicture> capturePicture();
+ skia::RefPtr<SkPicture> CapturePicture();
- bool pinchGestureActive() const { return m_pinchGestureActive; }
+ bool pinch_gesture_active() const { return pinch_gesture_active_; }
- void setTreePriority(TreePriority priority);
+ void SetTreePriority(TreePriority priority);
- void beginNextFrame();
- base::TimeTicks currentFrameTime();
+ void BeginNextFrame();
+ base::TimeTicks CurrentFrameTime();
- scoped_ptr<base::Value> asValue() const;
- scoped_ptr<base::Value> activationStateAsValue() const;
- scoped_ptr<base::Value> frameStateAsValue() const;
+ scoped_ptr<base::Value> AsValue() const;
+ scoped_ptr<base::Value> ActivationStateAsValue() const;
+ scoped_ptr<base::Value> FrameStateAsValue() const;
- bool pageScaleAnimationActive() const { return !!m_pageScaleAnimation; }
+ bool page_scale_animation_active() const { return !!page_scale_animation_; }
-protected:
- LayerTreeHostImpl(const LayerTreeSettings&, LayerTreeHostImplClient*, Proxy*);
- void activatePendingTree();
+ protected:
+ LayerTreeHostImpl(const LayerTreeSettings& settings,
+ LayerTreeHostImplClient* client,
+ Proxy* proxy);
+ void ActivatePendingTree();
- // Virtual for testing.
- virtual void animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime);
- virtual void updateAnimationState();
+ // Virtual for testing.
+ virtual void AnimateLayers(base::TimeTicks monotonic_time,
+ base::Time wall_clock_time);
+ virtual void UpdateAnimationState();
- // Virtual for testing.
- virtual base::TimeDelta lowFrequencyAnimationInterval() const;
+ // Virtual for testing.
+ virtual base::TimeDelta LowFrequencyAnimationInterval() const;
- const AnimationRegistrar::AnimationControllerMap& activeAnimationControllers() const { return m_animationRegistrar->active_animation_controllers(); }
+ const AnimationRegistrar::AnimationControllerMap&
+ active_animation_controllers() const {
+ return animation_registrar_->active_animation_controllers();
+ }
- LayerTreeHostImplClient* m_client;
- Proxy* m_proxy;
+ LayerTreeHostImplClient* client_;
+ Proxy* proxy_;
-private:
- void animatePageScale(base::TimeTicks monotonicTime);
- void animateScrollbars(base::TimeTicks monotonicTime);
+ private:
+ void AnimatePageScale(base::TimeTicks monotonic_time);
+ void AnimateScrollbars(base::TimeTicks monotonic_time);
- void setPageScaleDelta(float);
- gfx::Vector2dF scrollLayerWithViewportSpaceDelta(LayerImpl* layerImpl, float scaleFromViewportToScreenSpace, gfx::PointF viewportPoint, gfx::Vector2dF viewportDelta);
+ gfx::Vector2dF ScrollLayerWithViewportSpaceDelta(
+ LayerImpl* layerImpl,
+ float scaleFromViewportToScreenSpace,
+ gfx::PointF viewportPoint,
+ gfx::Vector2dF viewportDelta);
- void updateMaxScrollOffset();
- void trackDamageForAllSurfaces(LayerImpl* rootDrawLayer, const LayerList& renderSurfaceLayerList);
+ void UpdateMaxScrollOffset();
+ void TrackDamageForAllSurfaces(LayerImpl* root_draw_layer,
+ const LayerList& render_surface_layer_list);
- // Returns false if the frame should not be displayed. This function should
- // only be called from prepareToDraw, as didDrawAllLayers must be called
- // if this helper function is called.
- bool calculateRenderPasses(FrameData&);
- void animateLayersRecursive(LayerImpl*, base::TimeTicks monotonicTime, base::Time wallClockTime, AnimationEventsVector*, bool& didAnimate, bool& needsAnimateLayers);
- void setBackgroundTickingEnabled(bool);
+ // Returns false if the frame should not be displayed. This function should
+ // only be called from prepareToDraw, as didDrawAllLayers must be called
+ // if this helper function is called.
+ bool CalculateRenderPasses(FrameData* frame);
+ void SetBackgroundTickingEnabled(bool enabled);
- void sendDidLoseOutputSurfaceRecursive(LayerImpl*);
- void clearRenderSurfaces();
- bool ensureRenderSurfaceLayerList();
- void clearCurrentlyScrollingLayer();
+ void SendDidLoseOutputSurfaceRecursive(LayerImpl* current);
+ void ClearRenderSurfaces();
+ bool EnsureRenderSurfaceLayerList();
+ void ClearCurrentlyScrollingLayer();
- void animateScrollbarsRecursive(LayerImpl*, base::TimeTicks monotonicTime);
+ void AnimateScrollbarsRecursive(LayerImpl* layer,
+ base::TimeTicks time);
- void dumpRenderSurfaces(std::string*, int indent, const LayerImpl*) const;
+ void DumpRenderSurfaces(std::string* str,
+ int indent,
+ const LayerImpl* layer) const;
- static LayerImpl* getNonCompositedContentLayerRecursive(LayerImpl* layer);
+ static LayerImpl* GetNonCompositedContentLayerRecursive(LayerImpl* layer);
- scoped_ptr<OutputSurface> m_outputSurface;
- scoped_ptr<ResourceProvider> m_resourceProvider;
- scoped_ptr<Renderer> m_renderer;
- scoped_ptr<TileManager> m_tileManager;
+ scoped_ptr<OutputSurface> output_surface_;
+ scoped_ptr<ResourceProvider> resource_provider_;
+ scoped_ptr<Renderer> renderer_;
+ scoped_ptr<TileManager> tile_manager_;
- // Tree currently being drawn.
- scoped_ptr<LayerTreeImpl> m_activeTree;
+ // Tree currently being drawn.
+ scoped_ptr<LayerTreeImpl> active_tree_;
- // In impl-side painting mode, tree with possibly incomplete rasterized
- // content. May be promoted to active by activatePendingTreeIfNeeded().
- scoped_ptr<LayerTreeImpl> m_pendingTree;
+ // In impl-side painting mode, tree with possibly incomplete rasterized
+ // content. May be promoted to active by ActivatePendingTreeIfNeeded().
+ scoped_ptr<LayerTreeImpl> pending_tree_;
- // In impl-side painting mode, inert tree with layers that can be recycled
- // by the next sync from the main thread.
- scoped_ptr<LayerTreeImpl> m_recycleTree;
+ // In impl-side painting mode, inert tree with layers that can be recycled
+ // by the next sync from the main thread.
+ scoped_ptr<LayerTreeImpl> recycle_tree_;
- bool m_didLockScrollingLayer;
- bool m_shouldBubbleScrolls;
- bool m_wheelScrolling;
- LayerTreeSettings m_settings;
- LayerTreeDebugState m_debugState;
- gfx::Size m_layoutViewportSize;
- gfx::Size m_deviceViewportSize;
- float m_deviceScaleFactor;
- bool m_visible;
- ManagedMemoryPolicy m_managedMemoryPolicy;
+ bool did_lock_scrolling_layer_;
+ bool should_bubble_scrolls_;
+ bool wheel_scrolling_;
+ LayerTreeSettings settings_;
+ LayerTreeDebugState debug_state_;
+ gfx::Size layout_viewport_size_;
+ gfx::Size device_viewport_size_;
+ float device_scale_factor_;
+ bool visible_;
+ ManagedMemoryPolicy managed_memory_policy_;
- bool m_pinchGestureActive;
- gfx::Point m_previousPinchAnchor;
+ bool pinch_gesture_active_;
+ gfx::Point previous_pinch_anchor_;
- // This is set by animateLayers() and used by updateAnimationState()
- // when sending animation events to the main thread.
- base::Time m_lastAnimationTime;
+ // This is set by AnimateLayers() and used by UpdateAnimationState()
+ // when sending animation events to the main thread.
+ base::Time last_animation_time_;
- scoped_ptr<TopControlsManager> m_topControlsManager;
+ scoped_ptr<TopControlsManager> top_controls_manager_;
- scoped_ptr<PageScaleAnimation> m_pageScaleAnimation;
+ scoped_ptr<PageScaleAnimation> page_scale_animation_;
- // This is used for ticking animations slowly when hidden.
- scoped_ptr<LayerTreeHostImplTimeSourceAdapter> m_timeSourceClientAdapter;
+ // This is used for ticking animations slowly when hidden.
+ scoped_ptr<LayerTreeHostImplTimeSourceAdapter> time_source_client_adapter_;
- scoped_ptr<FrameRateCounter> m_fpsCounter;
- scoped_ptr<PaintTimeCounter> m_paintTimeCounter;
- scoped_ptr<MemoryHistory> m_memoryHistory;
- scoped_ptr<DebugRectHistory> m_debugRectHistory;
+ scoped_ptr<FrameRateCounter> fps_counter_;
+ scoped_ptr<PaintTimeCounter> paint_time_counter_;
+ scoped_ptr<MemoryHistory> memory_history_;
+ scoped_ptr<DebugRectHistory> debug_rect_history_;
- int64 m_numImplThreadScrolls;
- int64 m_numMainThreadScrolls;
+ int64 num_impl_thread_scrolls_;
+ int64 num_main_thread_scrolls_;
- int64 m_cumulativeNumLayersDrawn;
+ int64 cumulative_num_layers_drawn_;
- int64 m_cumulativeNumMissingTiles;
+ int64 cumulative_num_missing_tiles_;
- size_t m_lastSentMemoryVisibleBytes;
- size_t m_lastSentMemoryVisibleAndNearbyBytes;
- size_t m_lastSentMemoryUseBytes;
+ size_t last_sent_memory_visible_bytes_;
+ size_t last_sent_memory_visible_and_nearby_bytes_;
+ size_t last_sent_memory_use_bytes_;
- base::TimeTicks m_currentFrameTime;
+ base::TimeTicks current_frame_time_;
- scoped_ptr<AnimationRegistrar> m_animationRegistrar;
+ scoped_ptr<AnimationRegistrar> animation_registrar_;
- DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
+ DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImpl);
};
} // namespace cc
diff --git a/cc/layer_tree_host_impl_unittest.cc b/cc/layer_tree_host_impl_unittest.cc
index d9dc92d4..1d3bcbe 100644
--- a/cc/layer_tree_host_impl_unittest.cc
+++ b/cc/layer_tree_host_impl_unittest.cc
@@ -78,30 +78,30 @@
LayerTreeSettings settings;
settings.minimumOcclusionTrackingSize = gfx::Size();
- m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
- m_hostImpl->initializeRenderer(createOutputSurface());
- m_hostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+ m_hostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+ m_hostImpl->InitializeRenderer(createOutputSurface());
+ m_hostImpl->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
}
virtual void TearDown()
{
}
- virtual void didLoseOutputSurfaceOnImplThread() OVERRIDE { }
- virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE { }
- virtual void onVSyncParametersChanged(base::TimeTicks, base::TimeDelta) OVERRIDE { }
- virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE { m_onCanDrawStateChangedCalled = true; }
- virtual void onHasPendingTreeStateChanged(bool hasPendingTree) OVERRIDE { m_hasPendingTree = hasPendingTree; }
- virtual void setNeedsRedrawOnImplThread() OVERRIDE { m_didRequestRedraw = true; }
- virtual void didUploadVisibleHighResolutionTileOnImplThread() OVERRIDE { m_didUploadVisibleHighResolutionTile = true; }
- virtual void setNeedsCommitOnImplThread() OVERRIDE { m_didRequestCommit = true; }
- virtual void setNeedsManageTilesOnImplThread() OVERRIDE { }
- virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector>, base::Time wallClockTime) OVERRIDE { }
- virtual bool reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff) OVERRIDE { return m_reduceMemoryResult; }
- virtual void reduceWastedContentsTextureMemoryOnImplThread() OVERRIDE { }
- virtual void sendManagedMemoryStats() OVERRIDE { }
- virtual bool isInsideDraw() OVERRIDE { return false; }
- virtual void renewTreePriority() OVERRIDE { }
+ virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE { }
+ virtual void OnSwapBuffersCompleteOnImplThread() OVERRIDE { }
+ virtual void OnVSyncParametersChanged(base::TimeTicks, base::TimeDelta) OVERRIDE { }
+ virtual void OnCanDrawStateChanged(bool canDraw) OVERRIDE { m_onCanDrawStateChangedCalled = true; }
+ virtual void OnHasPendingTreeStateChanged(bool hasPendingTree) OVERRIDE { m_hasPendingTree = hasPendingTree; }
+ virtual void SetNeedsRedrawOnImplThread() OVERRIDE { m_didRequestRedraw = true; }
+ virtual void DidUploadVisibleHighResolutionTileOnImplThread() OVERRIDE { m_didUploadVisibleHighResolutionTile = true; }
+ virtual void SetNeedsCommitOnImplThread() OVERRIDE { m_didRequestCommit = true; }
+ virtual void SetNeedsManageTilesOnImplThread() OVERRIDE { }
+ virtual void PostAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector>, base::Time wallClockTime) OVERRIDE { }
+ virtual bool ReduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff) OVERRIDE { return m_reduceMemoryResult; }
+ virtual void ReduceWastedContentsTextureMemoryOnImplThread() OVERRIDE { }
+ virtual void SendManagedMemoryStats() OVERRIDE { }
+ virtual bool IsInsideDraw() OVERRIDE { return false; }
+ virtual void RenewTreePriority() OVERRIDE { }
void setReduceMemoryResult(bool reduceMemoryResult) { m_reduceMemoryResult = reduceMemoryResult; }
@@ -111,10 +111,10 @@
settings.minimumOcclusionTrackingSize = gfx::Size();
settings.partialSwapEnabled = partialSwap;
- m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
+ m_hostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
- m_hostImpl->initializeRenderer(outputSurface.Pass());
- m_hostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+ m_hostImpl->InitializeRenderer(outputSurface.Pass());
+ m_hostImpl->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
}
void setupRootLayerImpl(scoped_ptr<LayerImpl> root)
@@ -125,7 +125,7 @@
root->SetContentBounds(gfx::Size(10, 10));
root->SetDrawsContent(true);
root->draw_properties().visible_content_rect = gfx::Rect(0, 0, 10, 10);
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
}
static void expectClearedScrollDeltasRecursive(LayerImpl* layer)
@@ -164,7 +164,7 @@
void setupScrollAndContentsLayers(const gfx::Size& contentSize)
{
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->active_tree(), 1);
root->SetScrollable(true);
root->SetScrollOffset(gfx::Vector2d(0, 0));
root->SetMaxScrollOffset(gfx::Vector2d(contentSize.width(), contentSize.height()));
@@ -173,20 +173,20 @@
root->SetPosition(gfx::PointF(0, 0));
root->SetAnchorPoint(gfx::PointF(0, 0));
- scoped_ptr<LayerImpl> contents = LayerImpl::Create(m_hostImpl->activeTree(), 2);
+ scoped_ptr<LayerImpl> contents = LayerImpl::Create(m_hostImpl->active_tree(), 2);
contents->SetDrawsContent(true);
contents->SetBounds(contentSize);
contents->SetContentBounds(contentSize);
contents->SetPosition(gfx::PointF(0, 0));
contents->SetAnchorPoint(gfx::PointF(0, 0));
root->AddChild(contents.Pass());
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
- m_hostImpl->activeTree()->DidBecomeActive();
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->DidBecomeActive();
}
scoped_ptr<LayerImpl> createScrollableLayer(int id, const gfx::Size& size)
{
- scoped_ptr<LayerImpl> layer = LayerImpl::Create(m_hostImpl->activeTree(), id);
+ scoped_ptr<LayerImpl> layer = LayerImpl::Create(m_hostImpl->active_tree(), id);
layer->SetScrollable(true);
layer->SetDrawsContent(true);
layer->SetBounds(size);
@@ -197,11 +197,11 @@
void initializeRendererAndDrawFrame()
{
- m_hostImpl->initializeRenderer(createOutputSurface());
+ m_hostImpl->InitializeRenderer(createOutputSurface());
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
void pinchZoomPanViewportForcesCommitRedraw(const float deviceScaleFactor);
@@ -214,8 +214,8 @@
void drawOneFrame() {
LayerTreeHostImpl::FrameData frameData;
- m_hostImpl->prepareToDraw(frameData);
- m_hostImpl->didDrawAllLayers(frameData);
+ m_hostImpl->PrepareToDraw(&frameData);
+ m_hostImpl->DidDrawAllLayers(frameData);
}
FakeProxy m_proxy;
@@ -241,33 +241,33 @@
// Note: It is not possible to disable the renderer once it has been set,
// so we do not need to test that disabling the renderer notifies us
// that canDraw changed.
- EXPECT_FALSE(m_hostImpl->canDraw());
+ EXPECT_FALSE(m_hostImpl->CanDraw());
m_onCanDrawStateChangedCalled = false;
setupScrollAndContentsLayers(gfx::Size(100, 100));
- EXPECT_TRUE(m_hostImpl->canDraw());
+ EXPECT_TRUE(m_hostImpl->CanDraw());
EXPECT_TRUE(m_onCanDrawStateChangedCalled);
m_onCanDrawStateChangedCalled = false;
// Toggle the root layer to make sure it toggles canDraw
- m_hostImpl->activeTree()->SetRootLayer(scoped_ptr<LayerImpl>());
- EXPECT_FALSE(m_hostImpl->canDraw());
+ m_hostImpl->active_tree()->SetRootLayer(scoped_ptr<LayerImpl>());
+ EXPECT_FALSE(m_hostImpl->CanDraw());
EXPECT_TRUE(m_onCanDrawStateChangedCalled);
m_onCanDrawStateChangedCalled = false;
setupScrollAndContentsLayers(gfx::Size(100, 100));
- EXPECT_TRUE(m_hostImpl->canDraw());
+ EXPECT_TRUE(m_hostImpl->CanDraw());
EXPECT_TRUE(m_onCanDrawStateChangedCalled);
m_onCanDrawStateChangedCalled = false;
// Toggle the device viewport size to make sure it toggles canDraw.
- m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(0, 0));
- EXPECT_FALSE(m_hostImpl->canDraw());
+ m_hostImpl->SetViewportSize(gfx::Size(100, 100), gfx::Size(0, 0));
+ EXPECT_FALSE(m_hostImpl->CanDraw());
EXPECT_TRUE(m_onCanDrawStateChangedCalled);
m_onCanDrawStateChangedCalled = false;
- m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
- EXPECT_TRUE(m_hostImpl->canDraw());
+ m_hostImpl->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+ EXPECT_TRUE(m_hostImpl->CanDraw());
EXPECT_TRUE(m_onCanDrawStateChangedCalled);
m_onCanDrawStateChangedCalled = false;
@@ -275,55 +275,55 @@
// and make sure that it does not change canDraw.
setReduceMemoryResult(false);
m_hostImpl->SetManagedMemoryPolicy(ManagedMemoryPolicy(
- m_hostImpl->memoryAllocationLimitBytes() - 1));
- EXPECT_TRUE(m_hostImpl->canDraw());
+ m_hostImpl->memory_allocation_limit_bytes() - 1));
+ EXPECT_TRUE(m_hostImpl->CanDraw());
EXPECT_FALSE(m_onCanDrawStateChangedCalled);
m_onCanDrawStateChangedCalled = false;
// Toggle contents textures purged to make sure it toggles canDraw.
setReduceMemoryResult(true);
m_hostImpl->SetManagedMemoryPolicy(ManagedMemoryPolicy(
- m_hostImpl->memoryAllocationLimitBytes() - 1));
- EXPECT_FALSE(m_hostImpl->canDraw());
+ m_hostImpl->memory_allocation_limit_bytes() - 1));
+ EXPECT_FALSE(m_hostImpl->CanDraw());
EXPECT_TRUE(m_onCanDrawStateChangedCalled);
m_onCanDrawStateChangedCalled = false;
- m_hostImpl->activeTree()->ResetContentsTexturesPurged();
- EXPECT_TRUE(m_hostImpl->canDraw());
+ m_hostImpl->active_tree()->ResetContentsTexturesPurged();
+ EXPECT_TRUE(m_hostImpl->CanDraw());
EXPECT_TRUE(m_onCanDrawStateChangedCalled);
m_onCanDrawStateChangedCalled = false;
}
TEST_F(LayerTreeHostImplTest, scrollDeltaNoLayers)
{
- ASSERT_FALSE(m_hostImpl->rootLayer());
+ ASSERT_FALSE(m_hostImpl->active_tree()->root_layer());
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
}
TEST_F(LayerTreeHostImplTest, scrollDeltaTreeButNoChanges)
{
{
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->activeTree(), 1);
- root->AddChild(LayerImpl::Create(m_hostImpl->activeTree(), 2));
- root->AddChild(LayerImpl::Create(m_hostImpl->activeTree(), 3));
- root->children()[1]->AddChild(LayerImpl::Create(m_hostImpl->activeTree(), 4));
- root->children()[1]->AddChild(LayerImpl::Create(m_hostImpl->activeTree(), 5));
- root->children()[1]->children()[0]->AddChild(LayerImpl::Create(m_hostImpl->activeTree(), 6));
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->active_tree(), 1);
+ root->AddChild(LayerImpl::Create(m_hostImpl->active_tree(), 2));
+ root->AddChild(LayerImpl::Create(m_hostImpl->active_tree(), 3));
+ root->children()[1]->AddChild(LayerImpl::Create(m_hostImpl->active_tree(), 4));
+ root->children()[1]->AddChild(LayerImpl::Create(m_hostImpl->active_tree(), 5));
+ root->children()[1]->children()[0]->AddChild(LayerImpl::Create(m_hostImpl->active_tree(), 6));
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
}
- LayerImpl* root = m_hostImpl->rootLayer();
+ LayerImpl* root = m_hostImpl->active_tree()->root_layer();
expectClearedScrollDeltasRecursive(root);
scoped_ptr<ScrollAndScaleSet> scrollInfo;
- scrollInfo = m_hostImpl->processScrollDeltas();
+ scrollInfo = m_hostImpl->ProcessScrollDeltas();
ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
expectClearedScrollDeltasRecursive(root);
- scrollInfo = m_hostImpl->processScrollDeltas();
+ scrollInfo = m_hostImpl->ProcessScrollDeltas();
ASSERT_EQ(scrollInfo->scrolls.size(), 0u);
expectClearedScrollDeltasRecursive(root);
}
@@ -333,43 +333,43 @@
gfx::Vector2d scrollOffset(20, 30);
gfx::Vector2d scrollDelta(11, -15);
{
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->active_tree(), 1);
root->SetScrollOffset(scrollOffset);
root->SetScrollable(true);
root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
root->ScrollBy(scrollDelta);
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
}
- LayerImpl* root = m_hostImpl->rootLayer();
+ LayerImpl* root = m_hostImpl->active_tree()->root_layer();
scoped_ptr<ScrollAndScaleSet> scrollInfo;
- scrollInfo = m_hostImpl->processScrollDeltas();
+ scrollInfo = m_hostImpl->ProcessScrollDeltas();
ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
EXPECT_VECTOR_EQ(root->sent_scroll_delta(), scrollDelta);
expectContains(*scrollInfo, root->id(), scrollDelta);
gfx::Vector2d scrollDelta2(-5, 27);
root->ScrollBy(scrollDelta2);
- scrollInfo = m_hostImpl->processScrollDeltas();
+ scrollInfo = m_hostImpl->ProcessScrollDeltas();
ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
EXPECT_VECTOR_EQ(root->sent_scroll_delta(), scrollDelta + scrollDelta2);
expectContains(*scrollInfo, root->id(), scrollDelta + scrollDelta2);
root->ScrollBy(gfx::Vector2d());
- scrollInfo = m_hostImpl->processScrollDeltas();
+ scrollInfo = m_hostImpl->ProcessScrollDeltas();
EXPECT_EQ(root->sent_scroll_delta(), scrollDelta + scrollDelta2);
}
TEST_F(LayerTreeHostImplTest, scrollRootCallsCommitAndRedraw)
{
setupScrollAndContentsLayers(gfx::Size(100, 100));
- m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+ m_hostImpl->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
initializeRendererAndDrawFrame();
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+ m_hostImpl->ScrollEnd();
EXPECT_TRUE(m_didRequestRedraw);
EXPECT_TRUE(m_didRequestCommit);
}
@@ -377,22 +377,22 @@
TEST_F(LayerTreeHostImplTest, scrollWithoutRootLayer)
{
// We should not crash when trying to scroll an empty layer tree.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
}
TEST_F(LayerTreeHostImplTest, scrollWithoutRenderer)
{
LayerTreeSettings settings;
- m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
+ m_hostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
// Initialization will fail here.
- m_hostImpl->initializeRenderer(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new TestWebGraphicsContext3DMakeCurrentFails)).PassAs<OutputSurface>());
- m_hostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+ m_hostImpl->InitializeRenderer(FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new TestWebGraphicsContext3DMakeCurrentFails)).PassAs<OutputSurface>());
+ m_hostImpl->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
setupScrollAndContentsLayers(gfx::Size(100, 100));
// We should not crash when trying to scroll after the renderer initialization fails.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
}
TEST_F(LayerTreeHostImplTest, replaceTreeWhileScrolling)
@@ -400,96 +400,96 @@
const int scrollLayerId = 1;
setupScrollAndContentsLayers(gfx::Size(100, 100));
- m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+ m_hostImpl->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
initializeRendererAndDrawFrame();
// We should not crash if the tree is replaced while we are scrolling.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->activeTree()->DetachLayerTree();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->active_tree()->DetachLayerTree();
setupScrollAndContentsLayers(gfx::Size(100, 100));
// We should still be scrolling, because the scrolled layer also exists in the new tree.
gfx::Vector2d scrollDelta(0, 10);
- m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
- m_hostImpl->scrollEnd();
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ m_hostImpl->ScrollBy(gfx::Point(), scrollDelta);
+ m_hostImpl->ScrollEnd();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
expectContains(*scrollInfo, scrollLayerId, scrollDelta);
}
TEST_F(LayerTreeHostImplTest, clearRootRenderSurfaceAndScroll)
{
setupScrollAndContentsLayers(gfx::Size(100, 100));
- m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+ m_hostImpl->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
initializeRendererAndDrawFrame();
// We should be able to scroll even if the root layer loses its render surface after the most
// recent render.
- m_hostImpl->rootLayer()->ClearRenderSurface();
- m_hostImpl->activeTree()->set_needs_update_draw_properties();
+ m_hostImpl->active_tree()->root_layer()->ClearRenderSurface();
+ m_hostImpl->active_tree()->set_needs_update_draw_properties();
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
}
TEST_F(LayerTreeHostImplTest, wheelEventHandlers)
{
setupScrollAndContentsLayers(gfx::Size(100, 100));
- m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+ m_hostImpl->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
initializeRendererAndDrawFrame();
- LayerImpl* root = m_hostImpl->rootLayer();
+ LayerImpl* root = m_hostImpl->active_tree()->root_layer();
root->SetHaveWheelEventHandlers(true);
// With registered event handlers, wheel scrolls have to go to the main thread.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
// But gesture scrolls can still be handled.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
}
TEST_F(LayerTreeHostImplTest, shouldScrollOnMainThread)
{
setupScrollAndContentsLayers(gfx::Size(100, 100));
- m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+ m_hostImpl->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
initializeRendererAndDrawFrame();
- LayerImpl* root = m_hostImpl->rootLayer();
+ LayerImpl* root = m_hostImpl->active_tree()->root_layer();
root->SetShouldScrollOnMainThread(true);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollOnMainThread);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollOnMainThread);
}
TEST_F(LayerTreeHostImplTest, nonFastScrollableRegionBasic)
{
setupScrollAndContentsLayers(gfx::Size(200, 200));
- m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+ m_hostImpl->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
- LayerImpl* root = m_hostImpl->rootLayer();
+ LayerImpl* root = m_hostImpl->active_tree()->root_layer();
root->SetContentsScale(2, 2);
root->SetNonFastScrollableRegion(gfx::Rect(0, 0, 50, 50));
initializeRendererAndDrawFrame();
// All scroll types inside the non-fast scrollable region should fail.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(25, 25), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(25, 25), InputHandlerClient::Gesture), InputHandlerClient::ScrollOnMainThread);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(25, 25), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(25, 25), InputHandlerClient::Gesture), InputHandlerClient::ScrollOnMainThread);
// All scroll types outside this region should succeed.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(75, 75), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
- m_hostImpl->scrollEnd();
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(75, 75), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(75, 75), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+ m_hostImpl->ScrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(75, 75), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+ m_hostImpl->ScrollEnd();
}
TEST_F(LayerTreeHostImplTest, nonFastScrollableRegionWithOffset)
{
setupScrollAndContentsLayers(gfx::Size(200, 200));
- m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+ m_hostImpl->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
- LayerImpl* root = m_hostImpl->rootLayer();
+ LayerImpl* root = m_hostImpl->active_tree()->root_layer();
root->SetContentsScale(2, 2);
root->SetNonFastScrollableRegion(gfx::Rect(0, 0, 50, 50));
root->SetPosition(gfx::PointF(-25, 0));
@@ -497,69 +497,69 @@
initializeRendererAndDrawFrame();
// This point would fall into the non-fast scrollable region except that we've moved the layer down by 25 pixels.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(40, 10), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 1));
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(40, 10), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(0, 1));
+ m_hostImpl->ScrollEnd();
// This point is still inside the non-fast region.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(10, 10), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(10, 10), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
}
TEST_F(LayerTreeHostImplTest, scrollByReturnsCorrectValue)
{
setupScrollAndContentsLayers(gfx::Size(200, 200));
- m_hostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+ m_hostImpl->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
initializeRendererAndDrawFrame();
EXPECT_EQ(InputHandlerClient::ScrollStarted,
- m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
+ m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
// Trying to scroll to the left/top will not succeed.
- EXPECT_FALSE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(-10, 0)));
- EXPECT_FALSE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, -10)));
- EXPECT_FALSE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(-10, -10)));
+ EXPECT_FALSE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 0)));
+ EXPECT_FALSE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(0, -10)));
+ EXPECT_FALSE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(-10, -10)));
// Scrolling to the right/bottom will succeed.
- EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(10, 0)));
- EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10)));
- EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(10, 10)));
+ EXPECT_TRUE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(10, 0)));
+ EXPECT_TRUE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10)));
+ EXPECT_TRUE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(10, 10)));
// Scrolling to left/top will now succeed.
- EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(-10, 0)));
- EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, -10)));
- EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(-10, -10)));
+ EXPECT_TRUE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 0)));
+ EXPECT_TRUE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(0, -10)));
+ EXPECT_TRUE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(-10, -10)));
// Scrolling diagonally against an edge will succeed.
- EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(10, -10)));
- EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(-10, 0)));
- EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(-10, 10)));
+ EXPECT_TRUE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(10, -10)));
+ EXPECT_TRUE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 0)));
+ EXPECT_TRUE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(-10, 10)));
// Trying to scroll more than the available space will also succeed.
- EXPECT_TRUE(m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(5000, 5000)));
+ EXPECT_TRUE(m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(5000, 5000)));
}
TEST_F(LayerTreeHostImplTest, clearRootRenderSurfaceAndHitTestTouchHandlerRegion)
{
setupScrollAndContentsLayers(gfx::Size(100, 100));
- m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+ m_hostImpl->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
initializeRendererAndDrawFrame();
// We should be able to hit test for touch event handlers even if the root layer loses
// its render surface after the most recent render.
- m_hostImpl->rootLayer()->ClearRenderSurface();
- m_hostImpl->activeTree()->set_needs_update_draw_properties();
+ m_hostImpl->active_tree()->root_layer()->ClearRenderSurface();
+ m_hostImpl->active_tree()->set_needs_update_draw_properties();
- EXPECT_EQ(m_hostImpl->haveTouchEventHandlersAt(gfx::Point(0, 0)), false);
+ EXPECT_EQ(m_hostImpl->HaveTouchEventHandlersAt(gfx::Point(0, 0)), false);
}
TEST_F(LayerTreeHostImplTest, implPinchZoom)
{
setupScrollAndContentsLayers(gfx::Size(100, 100));
- m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+ m_hostImpl->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
initializeRendererAndDrawFrame();
- LayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
+ LayerImpl* scrollLayer = m_hostImpl->RootScrollLayer();
DCHECK(scrollLayer);
const float minPageScale = 1, maxPageScale = 4;
@@ -567,54 +567,54 @@
// The impl-based pinch zoom should adjust the max scroll position.
{
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
- m_hostImpl->activeTree()->SetPageScaleDelta(1);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
+ m_hostImpl->active_tree()->SetPageScaleDelta(1);
scrollLayer->SetImplTransform(identityScaleTransform);
scrollLayer->SetScrollDelta(gfx::Vector2d());
float pageScaleDelta = 2;
- m_hostImpl->pinchGestureBegin();
- m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(50, 50));
- m_hostImpl->pinchGestureEnd();
+ m_hostImpl->PinchGestureBegin();
+ m_hostImpl->PinchGestureUpdate(pageScaleDelta, gfx::Point(50, 50));
+ m_hostImpl->PinchGestureEnd();
EXPECT_TRUE(m_didRequestRedraw);
EXPECT_TRUE(m_didRequestCommit);
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
- EXPECT_EQ(gfx::Vector2d(75, 75), m_hostImpl->rootLayer()->max_scroll_offset());
+ EXPECT_EQ(gfx::Vector2d(75, 75), m_hostImpl->active_tree()->root_layer()->max_scroll_offset());
}
// Scrolling after a pinch gesture should always be in local space. The scroll deltas do not
// have the page scale factor applied.
{
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
- m_hostImpl->activeTree()->SetPageScaleDelta(1);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
+ m_hostImpl->active_tree()->SetPageScaleDelta(1);
scrollLayer->SetImplTransform(identityScaleTransform);
scrollLayer->SetScrollDelta(gfx::Vector2d());
float pageScaleDelta = 2;
- m_hostImpl->pinchGestureBegin();
- m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(0, 0));
- m_hostImpl->pinchGestureEnd();
+ m_hostImpl->PinchGestureBegin();
+ m_hostImpl->PinchGestureUpdate(pageScaleDelta, gfx::Point(0, 0));
+ m_hostImpl->PinchGestureEnd();
gfx::Vector2d scrollDelta(0, 10);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), scrollDelta);
+ m_hostImpl->ScrollEnd();
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
- expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), scrollDelta);
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
+ expectContains(*scrollInfo.get(), m_hostImpl->active_tree()->root_layer()->id(), scrollDelta);
}
}
TEST_F(LayerTreeHostImplTest, pinchGesture)
{
setupScrollAndContentsLayers(gfx::Size(100, 100));
- m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+ m_hostImpl->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
initializeRendererAndDrawFrame();
- LayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
+ LayerImpl* scrollLayer = m_hostImpl->RootScrollLayer();
DCHECK(scrollLayer);
const float minPageScale = 1;
@@ -623,49 +623,49 @@
// Basic pinch zoom in gesture
{
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
scrollLayer->SetImplTransform(identityScaleTransform);
scrollLayer->SetScrollDelta(gfx::Vector2d());
float pageScaleDelta = 2;
- m_hostImpl->pinchGestureBegin();
- m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(50, 50));
- m_hostImpl->pinchGestureEnd();
+ m_hostImpl->PinchGestureBegin();
+ m_hostImpl->PinchGestureUpdate(pageScaleDelta, gfx::Point(50, 50));
+ m_hostImpl->PinchGestureEnd();
EXPECT_TRUE(m_didRequestRedraw);
EXPECT_TRUE(m_didRequestCommit);
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
}
// Zoom-in clamping
{
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
scrollLayer->SetImplTransform(identityScaleTransform);
scrollLayer->SetScrollDelta(gfx::Vector2d());
float pageScaleDelta = 10;
- m_hostImpl->pinchGestureBegin();
- m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(50, 50));
- m_hostImpl->pinchGestureEnd();
+ m_hostImpl->PinchGestureBegin();
+ m_hostImpl->PinchGestureUpdate(pageScaleDelta, gfx::Point(50, 50));
+ m_hostImpl->PinchGestureEnd();
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
EXPECT_EQ(scrollInfo->pageScaleDelta, maxPageScale);
}
// Zoom-out clamping
{
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
scrollLayer->SetImplTransform(identityScaleTransform);
scrollLayer->SetScrollDelta(gfx::Vector2d());
scrollLayer->SetScrollOffset(gfx::Vector2d(50, 50));
float pageScaleDelta = 0.1f;
- m_hostImpl->pinchGestureBegin();
- m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(0, 0));
- m_hostImpl->pinchGestureEnd();
+ m_hostImpl->PinchGestureBegin();
+ m_hostImpl->PinchGestureUpdate(pageScaleDelta, gfx::Point(0, 0));
+ m_hostImpl->PinchGestureEnd();
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
EXPECT_TRUE(scrollInfo->scrolls.empty());
@@ -673,39 +673,39 @@
// Two-finger panning should not happen based on pinch events only
{
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
scrollLayer->SetImplTransform(identityScaleTransform);
scrollLayer->SetScrollDelta(gfx::Vector2d());
scrollLayer->SetScrollOffset(gfx::Vector2d(20, 20));
float pageScaleDelta = 1;
- m_hostImpl->pinchGestureBegin();
- m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(10, 10));
- m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(20, 20));
- m_hostImpl->pinchGestureEnd();
+ m_hostImpl->PinchGestureBegin();
+ m_hostImpl->PinchGestureUpdate(pageScaleDelta, gfx::Point(10, 10));
+ m_hostImpl->PinchGestureUpdate(pageScaleDelta, gfx::Point(20, 20));
+ m_hostImpl->PinchGestureEnd();
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
EXPECT_TRUE(scrollInfo->scrolls.empty());
}
// Two-finger panning should work with interleaved scroll events
{
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
scrollLayer->SetImplTransform(identityScaleTransform);
scrollLayer->SetScrollDelta(gfx::Vector2d());
scrollLayer->SetScrollOffset(gfx::Vector2d(20, 20));
float pageScaleDelta = 1;
- m_hostImpl->scrollBegin(gfx::Point(10, 10), InputHandlerClient::Wheel);
- m_hostImpl->pinchGestureBegin();
- m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(10, 10));
- m_hostImpl->scrollBy(gfx::Point(10, 10), gfx::Vector2d(-10, -10));
- m_hostImpl->pinchGestureUpdate(pageScaleDelta, gfx::Point(20, 20));
- m_hostImpl->pinchGestureEnd();
- m_hostImpl->scrollEnd();
+ m_hostImpl->ScrollBegin(gfx::Point(10, 10), InputHandlerClient::Wheel);
+ m_hostImpl->PinchGestureBegin();
+ m_hostImpl->PinchGestureUpdate(pageScaleDelta, gfx::Point(10, 10));
+ m_hostImpl->ScrollBy(gfx::Point(10, 10), gfx::Vector2d(-10, -10));
+ m_hostImpl->PinchGestureUpdate(pageScaleDelta, gfx::Point(20, 20));
+ m_hostImpl->PinchGestureEnd();
+ m_hostImpl->ScrollEnd();
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
EXPECT_EQ(scrollInfo->pageScaleDelta, pageScaleDelta);
expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(-10, -10));
}
@@ -714,10 +714,10 @@
TEST_F(LayerTreeHostImplTest, pageScaleAnimation)
{
setupScrollAndContentsLayers(gfx::Size(100, 100));
- m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+ m_hostImpl->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
initializeRendererAndDrawFrame();
- LayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
+ LayerImpl* scrollLayer = m_hostImpl->RootScrollLayer();
DCHECK(scrollLayer);
const float minPageScale = 0.5;
@@ -730,33 +730,33 @@
// Non-anchor zoom-in
{
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
scrollLayer->SetImplTransform(identityScaleTransform);
scrollLayer->SetScrollOffset(gfx::Vector2d(50, 50));
- m_hostImpl->startPageScaleAnimation(gfx::Vector2d(0, 0), false, 2, startTime, duration);
- m_hostImpl->animate(halfwayThroughAnimation, base::Time());
+ m_hostImpl->StartPageScaleAnimation(gfx::Vector2d(0, 0), false, 2, startTime, duration);
+ m_hostImpl->Animate(halfwayThroughAnimation, base::Time());
EXPECT_TRUE(m_didRequestRedraw);
- m_hostImpl->animate(endTime, base::Time());
+ m_hostImpl->Animate(endTime, base::Time());
EXPECT_TRUE(m_didRequestCommit);
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
EXPECT_EQ(scrollInfo->pageScaleDelta, 2);
expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(-50, -50));
}
// Anchor zoom-out
{
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
scrollLayer->SetImplTransform(identityScaleTransform);
scrollLayer->SetScrollOffset(gfx::Vector2d(50, 50));
- m_hostImpl->startPageScaleAnimation(gfx::Vector2d(25, 25), true, minPageScale, startTime, duration);
- m_hostImpl->animate(endTime, base::Time());
+ m_hostImpl->StartPageScaleAnimation(gfx::Vector2d(25, 25), true, minPageScale, startTime, duration);
+ m_hostImpl->Animate(endTime, base::Time());
EXPECT_TRUE(m_didRequestRedraw);
EXPECT_TRUE(m_didRequestCommit);
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
EXPECT_EQ(scrollInfo->pageScaleDelta, minPageScale);
// Pushed to (0,0) via clamping against contents layer size.
expectContains(*scrollInfo, scrollLayer->id(), gfx::Vector2d(-50, -50));
@@ -766,10 +766,10 @@
TEST_F(LayerTreeHostImplTest, pageScaleAnimationNoOp)
{
setupScrollAndContentsLayers(gfx::Size(100, 100));
- m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+ m_hostImpl->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
initializeRendererAndDrawFrame();
- LayerImpl* scrollLayer = m_hostImpl->rootScrollLayer();
+ LayerImpl* scrollLayer = m_hostImpl->RootScrollLayer();
DCHECK(scrollLayer);
const float minPageScale = 0.5;
@@ -782,17 +782,17 @@
// Anchor zoom with unchanged page scale should not change scroll or scale.
{
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(1, minPageScale, maxPageScale);
scrollLayer->SetImplTransform(identityScaleTransform);
scrollLayer->SetScrollOffset(gfx::Vector2d(50, 50));
- m_hostImpl->startPageScaleAnimation(gfx::Vector2d(0, 0), true, 1, startTime, duration);
- m_hostImpl->animate(halfwayThroughAnimation, base::Time());
+ m_hostImpl->StartPageScaleAnimation(gfx::Vector2d(0, 0), true, 1, startTime, duration);
+ m_hostImpl->Animate(halfwayThroughAnimation, base::Time());
EXPECT_TRUE(m_didRequestRedraw);
- m_hostImpl->animate(endTime, base::Time());
+ m_hostImpl->Animate(endTime, base::Time());
EXPECT_TRUE(m_didRequestCommit);
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
EXPECT_EQ(scrollInfo->pageScaleDelta, 1);
expectNone(*scrollInfo, scrollLayer->id());
}
@@ -801,8 +801,8 @@
TEST_F(LayerTreeHostImplTest, compositorFrameMetadata)
{
setupScrollAndContentsLayers(gfx::Size(100, 100));
- m_hostImpl->setViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(1.0f, 0.5f, 4.0f);
+ m_hostImpl->SetViewportSize(gfx::Size(50, 50), gfx::Size(50, 50));
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(1.0f, 0.5f, 4.0f);
initializeRendererAndDrawFrame();
{
@@ -816,13 +816,13 @@
}
// Scrolling should update metadata immediately.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
{
CompositorFrameMetadata metadata = m_hostImpl->MakeCompositorFrameMetadata();
EXPECT_EQ(gfx::Vector2dF(0.0f, 10.0f), metadata.root_scroll_offset);
}
- m_hostImpl->scrollEnd();
+ m_hostImpl->ScrollEnd();
{
CompositorFrameMetadata metadata = m_hostImpl->MakeCompositorFrameMetadata();
@@ -830,9 +830,9 @@
}
// Page scale should update metadata correctly (shrinking only the viewport).
- m_hostImpl->pinchGestureBegin();
- m_hostImpl->pinchGestureUpdate(2.0f, gfx::Point(0, 0));
- m_hostImpl->pinchGestureEnd();
+ m_hostImpl->PinchGestureBegin();
+ m_hostImpl->PinchGestureUpdate(2.0f, gfx::Point(0, 0));
+ m_hostImpl->PinchGestureEnd();
{
CompositorFrameMetadata metadata = m_hostImpl->MakeCompositorFrameMetadata();
@@ -845,9 +845,9 @@
}
// Likewise if set from the main thread.
- m_hostImpl->processScrollDeltas();
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(4.0f, 0.5f, 4.0f);
- m_hostImpl->activeTree()->SetPageScaleDelta(1.0f);
+ m_hostImpl->ProcessScrollDeltas();
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(4.0f, 0.5f, 4.0f);
+ m_hostImpl->active_tree()->SetPageScaleDelta(1.0f);
{
CompositorFrameMetadata metadata = m_hostImpl->MakeCompositorFrameMetadata();
EXPECT_EQ(gfx::Vector2dF(0.0f, 10.0f), metadata.root_scroll_offset);
@@ -909,11 +909,11 @@
{
// The root layer is always drawn, so run this test on a child layer that
// will be masked out by the root layer's bounds.
- m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->activeTree(), 1));
- DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
+ m_hostImpl->active_tree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 1));
+ DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->active_tree()->root_layer());
root->SetMasksToBounds(true);
- root->AddChild(DidDrawCheckLayer::Create(m_hostImpl->activeTree(), 2));
+ root->AddChild(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 2));
DidDrawCheckLayer* layer = static_cast<DidDrawCheckLayer*>(root->children()[0]);
// Ensure visibleContentRect for layer is empty
layer->SetPosition(gfx::PointF(100, 100));
@@ -925,9 +925,9 @@
EXPECT_FALSE(layer->willDrawCalled());
EXPECT_FALSE(layer->didDrawCalled());
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
EXPECT_FALSE(layer->willDrawCalled());
EXPECT_FALSE(layer->didDrawCalled());
@@ -940,9 +940,9 @@
EXPECT_FALSE(layer->willDrawCalled());
EXPECT_FALSE(layer->didDrawCalled());
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
EXPECT_TRUE(layer->willDrawCalled());
EXPECT_TRUE(layer->didDrawCalled());
@@ -953,15 +953,15 @@
TEST_F(LayerTreeHostImplTest, willDrawNotCalledOnOccludedLayer)
{
gfx::Size bigSize(1000, 1000);
- m_hostImpl->setViewportSize(bigSize, bigSize);
+ m_hostImpl->SetViewportSize(bigSize, bigSize);
- m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->activeTree(), 1));
- DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
+ m_hostImpl->active_tree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 1));
+ DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->active_tree()->root_layer());
- root->AddChild(DidDrawCheckLayer::Create(m_hostImpl->activeTree(), 2));
+ root->AddChild(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 2));
DidDrawCheckLayer* occludedLayer = static_cast<DidDrawCheckLayer*>(root->children()[0]);
- root->AddChild(DidDrawCheckLayer::Create(m_hostImpl->activeTree(), 3));
+ root->AddChild(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 3));
DidDrawCheckLayer* topLayer = static_cast<DidDrawCheckLayer*>(root->children()[1]);
// This layer covers the occludedLayer above. Make this layer large so it can occlude.
topLayer->SetBounds(bigSize);
@@ -975,9 +975,9 @@
EXPECT_FALSE(topLayer->willDrawCalled());
EXPECT_FALSE(topLayer->didDrawCalled());
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
EXPECT_FALSE(occludedLayer->willDrawCalled());
EXPECT_FALSE(occludedLayer->didDrawCalled());
@@ -987,13 +987,13 @@
TEST_F(LayerTreeHostImplTest, didDrawCalledOnAllLayers)
{
- m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->activeTree(), 1));
- DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
+ m_hostImpl->active_tree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 1));
+ DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->active_tree()->root_layer());
- root->AddChild(DidDrawCheckLayer::Create(m_hostImpl->activeTree(), 2));
+ root->AddChild(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 2));
DidDrawCheckLayer* layer1 = static_cast<DidDrawCheckLayer*>(root->children()[0]);
- layer1->AddChild(DidDrawCheckLayer::Create(m_hostImpl->activeTree(), 3));
+ layer1->AddChild(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 3));
DidDrawCheckLayer* layer2 = static_cast<DidDrawCheckLayer*>(layer1->children()[0]);
layer1->SetOpacity(0.3f);
@@ -1004,9 +1004,9 @@
EXPECT_FALSE(layer2->didDrawCalled());
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
EXPECT_TRUE(root->didDrawCalled());
EXPECT_TRUE(layer1->didDrawCalled());
@@ -1044,53 +1044,53 @@
TEST_F(LayerTreeHostImplTest, prepareToDrawFailsWhenAnimationUsesCheckerboard)
{
// When the texture is not missing, we draw as usual.
- m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->activeTree(), 1));
- DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
- root->AddChild(MissingTextureAnimatingLayer::Create(m_hostImpl->activeTree(), 2, false, false, true, m_hostImpl->resourceProvider()));
+ m_hostImpl->active_tree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 1));
+ DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->active_tree()->root_layer());
+ root->AddChild(MissingTextureAnimatingLayer::Create(m_hostImpl->active_tree(), 2, false, false, true, m_hostImpl->resource_provider()));
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// When a texture is missing and we're not animating, we draw as usual with checkerboarding.
- m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->activeTree(), 3));
- root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
- root->AddChild(MissingTextureAnimatingLayer::Create(m_hostImpl->activeTree(), 4, true, false, false, m_hostImpl->resourceProvider()));
+ m_hostImpl->active_tree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 3));
+ root = static_cast<DidDrawCheckLayer*>(m_hostImpl->active_tree()->root_layer());
+ root->AddChild(MissingTextureAnimatingLayer::Create(m_hostImpl->active_tree(), 4, true, false, false, m_hostImpl->resource_provider()));
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// When a texture is missing and we're animating, we don't want to draw anything.
- m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->activeTree(), 5));
- root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
- root->AddChild(MissingTextureAnimatingLayer::Create(m_hostImpl->activeTree(), 6, true, false, true, m_hostImpl->resourceProvider()));
+ m_hostImpl->active_tree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 5));
+ root = static_cast<DidDrawCheckLayer*>(m_hostImpl->active_tree()->root_layer());
+ root->AddChild(MissingTextureAnimatingLayer::Create(m_hostImpl->active_tree(), 6, true, false, true, m_hostImpl->resource_provider()));
- EXPECT_FALSE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_FALSE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// When the layer skips draw and we're animating, we still draw the frame.
- m_hostImpl->activeTree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->activeTree(), 7));
- root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
- root->AddChild(MissingTextureAnimatingLayer::Create(m_hostImpl->activeTree(), 8, false, true, true, m_hostImpl->resourceProvider()));
+ m_hostImpl->active_tree()->SetRootLayer(DidDrawCheckLayer::Create(m_hostImpl->active_tree(), 7));
+ root = static_cast<DidDrawCheckLayer*>(m_hostImpl->active_tree()->root_layer());
+ root->AddChild(MissingTextureAnimatingLayer::Create(m_hostImpl->active_tree(), 8, false, true, true, m_hostImpl->resource_provider()));
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
TEST_F(LayerTreeHostImplTest, scrollRootIgnored)
{
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->active_tree(), 1);
root->SetScrollable(false);
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
initializeRendererAndDrawFrame();
// Scroll event is ignored because layer is not scrollable.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
EXPECT_FALSE(m_didRequestRedraw);
EXPECT_FALSE(m_didRequestCommit);
}
@@ -1101,30 +1101,30 @@
settings.calculateTopControlsPosition = true;
settings.topControlsHeight = 50;
- m_hostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
- m_hostImpl->initializeRenderer(createOutputSurface());
- m_hostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+ m_hostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+ m_hostImpl->InitializeRenderer(createOutputSurface());
+ m_hostImpl->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
gfx::Size layerSize(5, 5);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->active_tree(), 1);
root->SetScrollable(true);
root->SetMaxScrollOffset(gfx::Vector2d(layerSize.width(), layerSize.height()));
root->SetBounds(layerSize);
root->SetContentBounds(layerSize);
root->SetPosition(gfx::PointF(0, 0));
root->SetAnchorPoint(gfx::PointF(0, 0));
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
- m_hostImpl->activeTree()->FindRootScrollLayer();
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->FindRootScrollLayer();
initializeRendererAndDrawFrame();
- EXPECT_EQ(InputHandlerClient::ScrollIgnored, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
+ EXPECT_EQ(InputHandlerClient::ScrollIgnored, m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
- m_hostImpl->topControlsManager()->ScrollBegin();
- m_hostImpl->topControlsManager()->ScrollBy(gfx::Vector2dF(0, 50));
- m_hostImpl->topControlsManager()->ScrollEnd();
- EXPECT_EQ(m_hostImpl->topControlsManager()->content_top_offset(), 0.f);
+ m_hostImpl->top_controls_manager()->ScrollBegin();
+ m_hostImpl->top_controls_manager()->ScrollBy(gfx::Vector2dF(0, 50));
+ m_hostImpl->top_controls_manager()->ScrollEnd();
+ EXPECT_EQ(m_hostImpl->top_controls_manager()->content_top_offset(), 0.f);
- EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
+ EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture));
}
TEST_F(LayerTreeHostImplTest, scrollNonCompositedRoot)
@@ -1133,7 +1133,7 @@
// scrollable outer layer.
gfx::Size surfaceSize(10, 10);
- scoped_ptr<LayerImpl> contentLayer = LayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> contentLayer = LayerImpl::Create(m_hostImpl->active_tree(), 1);
contentLayer->SetDrawsContent(true);
contentLayer->SetPosition(gfx::PointF(0, 0));
contentLayer->SetAnchorPoint(gfx::PointF(0, 0));
@@ -1141,7 +1141,7 @@
contentLayer->SetContentBounds(gfx::Size(surfaceSize.width() * 2, surfaceSize.height() * 2));
contentLayer->SetContentsScale(2, 2);
- scoped_ptr<LayerImpl> scrollLayer = LayerImpl::Create(m_hostImpl->activeTree(), 2);
+ scoped_ptr<LayerImpl> scrollLayer = LayerImpl::Create(m_hostImpl->active_tree(), 2);
scrollLayer->SetScrollable(true);
scrollLayer->SetMaxScrollOffset(gfx::Vector2d(surfaceSize.width(), surfaceSize.height()));
scrollLayer->SetBounds(surfaceSize);
@@ -1150,13 +1150,13 @@
scrollLayer->SetAnchorPoint(gfx::PointF(0, 0));
scrollLayer->AddChild(contentLayer.Pass());
- m_hostImpl->activeTree()->SetRootLayer(scrollLayer.Pass());
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->active_tree()->SetRootLayer(scrollLayer.Pass());
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
initializeRendererAndDrawFrame();
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+ m_hostImpl->ScrollEnd();
EXPECT_TRUE(m_didRequestRedraw);
EXPECT_TRUE(m_didRequestCommit);
}
@@ -1164,17 +1164,17 @@
TEST_F(LayerTreeHostImplTest, scrollChildCallsCommitAndRedraw)
{
gfx::Size surfaceSize(10, 10);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->active_tree(), 1);
root->SetBounds(surfaceSize);
root->SetContentBounds(surfaceSize);
root->AddChild(createScrollableLayer(2, surfaceSize));
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
initializeRendererAndDrawFrame();
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), gfx::Vector2d(0, 10));
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
+ m_hostImpl->ScrollEnd();
EXPECT_TRUE(m_didRequestRedraw);
EXPECT_TRUE(m_didRequestCommit);
}
@@ -1182,14 +1182,14 @@
TEST_F(LayerTreeHostImplTest, scrollMissesChild)
{
gfx::Size surfaceSize(10, 10);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->active_tree(), 1);
root->AddChild(createScrollableLayer(2, surfaceSize));
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
initializeRendererAndDrawFrame();
// Scroll event is ignored because the input coordinate is outside the layer boundaries.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(15, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(15, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
EXPECT_FALSE(m_didRequestRedraw);
EXPECT_FALSE(m_didRequestCommit);
}
@@ -1197,9 +1197,9 @@
TEST_F(LayerTreeHostImplTest, scrollMissesBackfacingChild)
{
gfx::Size surfaceSize(10, 10);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->active_tree(), 1);
scoped_ptr<LayerImpl> child = createScrollableLayer(2, surfaceSize);
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
gfx::Transform matrix;
matrix.RotateAboutXAxis(180);
@@ -1207,12 +1207,12 @@
child->SetDoubleSided(false);
root->AddChild(child.Pass());
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
initializeRendererAndDrawFrame();
// Scroll event is ignored because the scrollable layer is not facing the viewer and there is
// nothing scrollable behind it.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollIgnored);
EXPECT_FALSE(m_didRequestRedraw);
EXPECT_FALSE(m_didRequestCommit);
}
@@ -1227,12 +1227,12 @@
scoped_ptr<LayerImpl> scrollLayer = createScrollableLayer(2, surfaceSize);
scrollLayer->AddChild(contentLayer.Pass());
- m_hostImpl->activeTree()->SetRootLayer(scrollLayer.Pass());
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->active_tree()->SetRootLayer(scrollLayer.Pass());
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
initializeRendererAndDrawFrame();
// Scrolling fails because the content layer is asking to be scrolled on the main thread.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollOnMainThread);
}
TEST_F(LayerTreeHostImplTest, scrollRootAndChangePageScaleOnMainThread)
@@ -1240,48 +1240,48 @@
gfx::Size surfaceSize(10, 10);
float pageScale = 2;
scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
- m_hostImpl->activeTree()->DidBecomeActive();
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->DidBecomeActive();
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
initializeRendererAndDrawFrame();
gfx::Vector2d scrollDelta(0, 10);
gfx::Vector2d expectedScrollDelta(scrollDelta);
- gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->max_scroll_offset());
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
- m_hostImpl->scrollEnd();
+ gfx::Vector2d expectedMaxScroll(m_hostImpl->active_tree()->root_layer()->max_scroll_offset());
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), scrollDelta);
+ m_hostImpl->ScrollEnd();
// Set new page scale from main thread.
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(pageScale, pageScale, pageScale);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(pageScale, pageScale, pageScale);
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
- expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
+ expectContains(*scrollInfo.get(), m_hostImpl->active_tree()->root_layer()->id(), expectedScrollDelta);
// The scroll range should also have been updated.
- EXPECT_EQ(m_hostImpl->rootLayer()->max_scroll_offset(), expectedMaxScroll);
+ EXPECT_EQ(m_hostImpl->active_tree()->root_layer()->max_scroll_offset(), expectedMaxScroll);
// The page scale delta remains constant because the impl thread did not scale.
// TODO: If possible, use gfx::Transform() or Skia equality functions. At
// the moment we avoid that because skia does exact bit-wise equality
// checking that does not consider -0 == +0.
// http://code.google.com/p/chromium/issues/detail?id=162747
- EXPECT_EQ(1.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(0, 0));
- EXPECT_EQ(0.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(0, 1));
- EXPECT_EQ(0.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(0, 2));
- EXPECT_EQ(0.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(0, 3));
- EXPECT_EQ(0.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(1, 0));
- EXPECT_EQ(1.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(1, 1));
- EXPECT_EQ(0.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(1, 2));
- EXPECT_EQ(0.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(1, 3));
- EXPECT_EQ(0.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(2, 0));
- EXPECT_EQ(0.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(2, 1));
- EXPECT_EQ(1.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(2, 2));
- EXPECT_EQ(0.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(2, 3));
- EXPECT_EQ(0.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(3, 0));
- EXPECT_EQ(0.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(3, 1));
- EXPECT_EQ(0.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(3, 2));
- EXPECT_EQ(1.0, m_hostImpl->rootLayer()->impl_transform().matrix().getDouble(3, 3));
+ EXPECT_EQ(1.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(0, 0));
+ EXPECT_EQ(0.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(0, 1));
+ EXPECT_EQ(0.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(0, 2));
+ EXPECT_EQ(0.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(0, 3));
+ EXPECT_EQ(0.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(1, 0));
+ EXPECT_EQ(1.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(1, 1));
+ EXPECT_EQ(0.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(1, 2));
+ EXPECT_EQ(0.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(1, 3));
+ EXPECT_EQ(0.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(2, 0));
+ EXPECT_EQ(0.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(2, 1));
+ EXPECT_EQ(1.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(2, 2));
+ EXPECT_EQ(0.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(2, 3));
+ EXPECT_EQ(0.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(3, 0));
+ EXPECT_EQ(0.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(3, 1));
+ EXPECT_EQ(0.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(3, 2));
+ EXPECT_EQ(1.0, m_hostImpl->active_tree()->root_layer()->impl_transform().matrix().getDouble(3, 3));
}
TEST_F(LayerTreeHostImplTest, scrollRootAndChangePageScaleOnImplThread)
@@ -1289,36 +1289,36 @@
gfx::Size surfaceSize(10, 10);
float pageScale = 2;
scoped_ptr<LayerImpl> root = createScrollableLayer(1, surfaceSize);
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
- m_hostImpl->activeTree()->DidBecomeActive();
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(1, 1, pageScale);
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->DidBecomeActive();
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(1, 1, pageScale);
initializeRendererAndDrawFrame();
gfx::Vector2d scrollDelta(0, 10);
gfx::Vector2d expectedScrollDelta(scrollDelta);
- gfx::Vector2d expectedMaxScroll(m_hostImpl->rootLayer()->max_scroll_offset());
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
- m_hostImpl->scrollEnd();
+ gfx::Vector2d expectedMaxScroll(m_hostImpl->active_tree()->root_layer()->max_scroll_offset());
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), scrollDelta);
+ m_hostImpl->ScrollEnd();
// Set new page scale on impl thread by pinching.
- m_hostImpl->pinchGestureBegin();
- m_hostImpl->pinchGestureUpdate(pageScale, gfx::Point());
- m_hostImpl->pinchGestureEnd();
+ m_hostImpl->PinchGestureBegin();
+ m_hostImpl->PinchGestureUpdate(pageScale, gfx::Point());
+ m_hostImpl->PinchGestureEnd();
drawOneFrame();
// The scroll delta is not scaled because the main thread did not scale.
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
- expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedScrollDelta);
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
+ expectContains(*scrollInfo.get(), m_hostImpl->active_tree()->root_layer()->id(), expectedScrollDelta);
// The scroll range should also have been updated.
- EXPECT_EQ(m_hostImpl->rootLayer()->max_scroll_offset(), expectedMaxScroll);
+ EXPECT_EQ(m_hostImpl->active_tree()->root_layer()->max_scroll_offset(), expectedMaxScroll);
// The page scale delta should match the new scale on the impl side.
gfx::Transform expectedScale;
expectedScale.Scale(pageScale, pageScale);
- EXPECT_EQ(m_hostImpl->rootLayer()->impl_transform(), expectedScale);
+ EXPECT_EQ(m_hostImpl->active_tree()->root_layer()->impl_transform(), expectedScale);
}
TEST_F(LayerTreeHostImplTest, pageScaleDeltaAppliedToRootScrollLayerOnly)
@@ -1333,7 +1333,7 @@
// Create a normal scrollable root layer and another scrollable child layer.
setupScrollAndContentsLayers(surfaceSize);
- LayerImpl* root = m_hostImpl->rootLayer();
+ LayerImpl* root = m_hostImpl->active_tree()->root_layer();
LayerImpl* child = root->children()[0];
scoped_ptr<LayerImpl> scrollableChild = createScrollableLayer(3, surfaceSize);
@@ -1341,9 +1341,9 @@
LayerImpl* grandChild = child->children()[0];
// Set new page scale on impl thread by pinching.
- m_hostImpl->pinchGestureBegin();
- m_hostImpl->pinchGestureUpdate(newPageScale, gfx::Point());
- m_hostImpl->pinchGestureEnd();
+ m_hostImpl->PinchGestureBegin();
+ m_hostImpl->PinchGestureUpdate(newPageScale, gfx::Point());
+ m_hostImpl->PinchGestureEnd();
drawOneFrame();
// The page scale delta should only be applied to the scrollable root layer.
@@ -1354,9 +1354,9 @@
// Make sure all the layers are drawn with the page scale delta applied, i.e., the page scale
// delta on the root layer is applied hierarchically.
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
EXPECT_EQ(root->draw_transform().matrix().getDouble(0, 0), newPageScale);
EXPECT_EQ(root->draw_transform().matrix().getDouble(1, 1), newPageScale);
@@ -1369,33 +1369,33 @@
TEST_F(LayerTreeHostImplTest, scrollChildAndChangePageScaleOnMainThread)
{
gfx::Size surfaceSize(10, 10);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->active_tree(), 1);
root->SetBounds(surfaceSize);
root->SetContentBounds(surfaceSize);
// Also mark the root scrollable so it becomes the root scroll layer.
root->SetScrollable(true);
int scrollLayerId = 2;
root->AddChild(createScrollableLayer(scrollLayerId, surfaceSize));
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
- m_hostImpl->activeTree()->DidBecomeActive();
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->DidBecomeActive();
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
initializeRendererAndDrawFrame();
- LayerImpl* child = m_hostImpl->rootLayer()->children()[0];
+ LayerImpl* child = m_hostImpl->active_tree()->root_layer()->children()[0];
gfx::Vector2d scrollDelta(0, 10);
gfx::Vector2d expectedScrollDelta(scrollDelta);
gfx::Vector2d expectedMaxScroll(child->max_scroll_offset());
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), scrollDelta);
+ m_hostImpl->ScrollEnd();
float pageScale = 2;
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(pageScale, 1, pageScale);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(pageScale, 1, pageScale);
drawOneFrame();
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
expectContains(*scrollInfo.get(), scrollLayerId, expectedScrollDelta);
// The scroll range should not have changed.
@@ -1422,20 +1422,20 @@
child->AddChild(grandChild.Pass());
root->AddChild(child.Pass());
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
- m_hostImpl->activeTree()->DidBecomeActive();
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->DidBecomeActive();
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
initializeRendererAndDrawFrame();
{
gfx::Vector2d scrollDelta(-8, -7);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), scrollDelta);
+ m_hostImpl->ScrollEnd();
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
// The grand child should have scrolled up to its limit.
- LayerImpl* child = m_hostImpl->rootLayer()->children()[0];
+ LayerImpl* child = m_hostImpl->active_tree()->root_layer()->children()[0];
LayerImpl* grandChild = child->children()[0];
expectContains(*scrollInfo.get(), grandChild->id(), gfx::Vector2d(0, -5));
@@ -1459,20 +1459,20 @@
child->AddChild(grandChild.Pass());
root->AddChild(child.Pass());
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
- m_hostImpl->activeTree()->DidBecomeActive();
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->DidBecomeActive();
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
initializeRendererAndDrawFrame();
{
gfx::Vector2d scrollDelta(0, -10);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::NonBubblingGesture), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::NonBubblingGesture), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), scrollDelta);
+ m_hostImpl->ScrollEnd();
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
// The grand child should have scrolled up to its limit.
- LayerImpl* child = m_hostImpl->rootLayer()->children()[0];
+ LayerImpl* child = m_hostImpl->active_tree()->root_layer()->children()[0];
LayerImpl* grandChild = child->children()[0];
expectContains(*scrollInfo.get(), grandChild->id(), gfx::Vector2d(0, -2));
@@ -1481,13 +1481,13 @@
// The next time we scroll we should only scroll the parent.
scrollDelta = gfx::Vector2d(0, -3);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::NonBubblingGesture), InputHandlerClient::ScrollStarted);
- EXPECT_EQ(m_hostImpl->currentlyScrollingLayer(), grandChild);
- m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
- EXPECT_EQ(m_hostImpl->currentlyScrollingLayer(), child);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::NonBubblingGesture), InputHandlerClient::ScrollStarted);
+ EXPECT_EQ(m_hostImpl->CurrentlyScrollingLayer(), grandChild);
+ m_hostImpl->ScrollBy(gfx::Point(), scrollDelta);
+ EXPECT_EQ(m_hostImpl->CurrentlyScrollingLayer(), child);
+ m_hostImpl->ScrollEnd();
- scrollInfo = m_hostImpl->processScrollDeltas();
+ scrollInfo = m_hostImpl->ProcessScrollDeltas();
// The child should have scrolled up to its limit.
expectContains(*scrollInfo.get(), child->id(), gfx::Vector2d(0, -3));
@@ -1498,13 +1498,13 @@
// After scrolling the parent, another scroll on the opposite direction
// should still scroll the child.
scrollDelta = gfx::Vector2d(0, 7);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::NonBubblingGesture), InputHandlerClient::ScrollStarted);
- EXPECT_EQ(m_hostImpl->currentlyScrollingLayer(), grandChild);
- m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
- EXPECT_EQ(m_hostImpl->currentlyScrollingLayer(), grandChild);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::NonBubblingGesture), InputHandlerClient::ScrollStarted);
+ EXPECT_EQ(m_hostImpl->CurrentlyScrollingLayer(), grandChild);
+ m_hostImpl->ScrollBy(gfx::Point(), scrollDelta);
+ EXPECT_EQ(m_hostImpl->CurrentlyScrollingLayer(), grandChild);
+ m_hostImpl->ScrollEnd();
- scrollInfo = m_hostImpl->processScrollDeltas();
+ scrollInfo = m_hostImpl->ProcessScrollDeltas();
// The grand child should have scrolled.
expectContains(*scrollInfo.get(), grandChild->id(), gfx::Vector2d(0, 5));
@@ -1514,19 +1514,19 @@
// Scrolling should be adjusted from viewport space.
- m_hostImpl->activeTree()->SetPageScaleFactorAndLimits(2, 2, 2);
- m_hostImpl->activeTree()->SetPageScaleDelta(1);
+ m_hostImpl->active_tree()->SetPageScaleFactorAndLimits(2, 2, 2);
+ m_hostImpl->active_tree()->SetPageScaleDelta(1);
gfx::Transform scaleTransform;
scaleTransform.Scale(2, 2);
- m_hostImpl->activeTree()->RootLayer()->SetImplTransform(scaleTransform);
+ m_hostImpl->active_tree()->root_layer()->SetImplTransform(scaleTransform);
scrollDelta = gfx::Vector2d(0, -2);
- EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->scrollBegin(gfx::Point(1, 1), InputHandlerClient::NonBubblingGesture));
- EXPECT_EQ(grandChild, m_hostImpl->currentlyScrollingLayer());
- m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(InputHandlerClient::ScrollStarted, m_hostImpl->ScrollBegin(gfx::Point(1, 1), InputHandlerClient::NonBubblingGesture));
+ EXPECT_EQ(grandChild, m_hostImpl->CurrentlyScrollingLayer());
+ m_hostImpl->ScrollBy(gfx::Point(), scrollDelta);
+ m_hostImpl->ScrollEnd();
- scrollInfo = m_hostImpl->processScrollDeltas();
+ scrollInfo = m_hostImpl->ProcessScrollDeltas();
// Should have scrolled by half the amount in layer space (5 - 2/2)
expectContains(*scrollInfo.get(), grandChild->id(), gfx::Vector2d(0, 4));
@@ -1545,39 +1545,39 @@
child->SetScrollable(false);
root->AddChild(child.Pass());
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
- m_hostImpl->activeTree()->DidBecomeActive();
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->DidBecomeActive();
initializeRendererAndDrawFrame();
{
gfx::Vector2d scrollDelta(0, 4);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), scrollDelta);
+ m_hostImpl->ScrollEnd();
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
// Only the root should have scrolled.
ASSERT_EQ(scrollInfo->scrolls.size(), 1u);
- expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), scrollDelta);
+ expectContains(*scrollInfo.get(), m_hostImpl->active_tree()->root_layer()->id(), scrollDelta);
}
}
TEST_F(LayerTreeHostImplTest, scrollBeforeRedraw)
{
gfx::Size surfaceSize(10, 10);
- m_hostImpl->activeTree()->SetRootLayer(createScrollableLayer(1, surfaceSize));
- m_hostImpl->activeTree()->DidBecomeActive();
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->active_tree()->SetRootLayer(createScrollableLayer(1, surfaceSize));
+ m_hostImpl->active_tree()->DidBecomeActive();
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
// Draw one frame and then immediately rebuild the layer tree to mimic a tree synchronization.
initializeRendererAndDrawFrame();
- m_hostImpl->activeTree()->DetachLayerTree();
- m_hostImpl->activeTree()->SetRootLayer(createScrollableLayer(2, surfaceSize));
- m_hostImpl->activeTree()->DidBecomeActive();
+ m_hostImpl->active_tree()->DetachLayerTree();
+ m_hostImpl->active_tree()->SetRootLayer(createScrollableLayer(2, surfaceSize));
+ m_hostImpl->active_tree()->DidBecomeActive();
// Scrolling should still work even though we did not draw yet.
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(5, 5), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
}
TEST_F(LayerTreeHostImplTest, scrollAxisAlignedRotatedLayer)
@@ -1587,32 +1587,32 @@
// Rotate the root layer 90 degrees counter-clockwise about its center.
gfx::Transform rotateTransform;
rotateTransform.Rotate(-90);
- m_hostImpl->rootLayer()->SetTransform(rotateTransform);
+ m_hostImpl->active_tree()->root_layer()->SetTransform(rotateTransform);
gfx::Size surfaceSize(50, 50);
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
initializeRendererAndDrawFrame();
// Scroll to the right in screen coordinates with a gesture.
gfx::Vector2d gestureScrollDelta(10, 0);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), gestureScrollDelta);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), gestureScrollDelta);
+ m_hostImpl->ScrollEnd();
// The layer should have scrolled down in its local coordinates.
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
- expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), gfx::Vector2d(0, gestureScrollDelta.x()));
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
+ expectContains(*scrollInfo.get(), m_hostImpl->active_tree()->root_layer()->id(), gfx::Vector2d(0, gestureScrollDelta.x()));
// Reset and scroll down with the wheel.
- m_hostImpl->rootLayer()->SetScrollDelta(gfx::Vector2dF());
+ m_hostImpl->active_tree()->root_layer()->SetScrollDelta(gfx::Vector2dF());
gfx::Vector2d wheelScrollDelta(0, 10);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), wheelScrollDelta);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), wheelScrollDelta);
+ m_hostImpl->ScrollEnd();
// The layer should have scrolled down in its local coordinates.
- scrollInfo = m_hostImpl->processScrollDeltas();
- expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), wheelScrollDelta);
+ scrollInfo = m_hostImpl->ProcessScrollDeltas();
+ expectContains(*scrollInfo.get(), m_hostImpl->active_tree()->root_layer()->id(), wheelScrollDelta);
}
TEST_F(LayerTreeHostImplTest, scrollNonAxisAlignedRotatedLayer)
@@ -1622,7 +1622,7 @@
float childLayerAngle = -20;
// Create a child layer that is rotated to a non-axis-aligned angle.
- scoped_ptr<LayerImpl> child = createScrollableLayer(childLayerId, m_hostImpl->rootLayer()->content_bounds());
+ scoped_ptr<LayerImpl> child = createScrollableLayer(childLayerId, m_hostImpl->active_tree()->root_layer()->content_bounds());
gfx::Transform rotateTransform;
rotateTransform.Translate(-50, -50);
rotateTransform.Rotate(childLayerAngle);
@@ -1631,23 +1631,23 @@
// Only allow vertical scrolling.
child->SetMaxScrollOffset(gfx::Vector2d(0, child->content_bounds().height()));
- m_hostImpl->rootLayer()->AddChild(child.Pass());
+ m_hostImpl->active_tree()->root_layer()->AddChild(child.Pass());
gfx::Size surfaceSize(50, 50);
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
initializeRendererAndDrawFrame();
{
// Scroll down in screen coordinates with a gesture.
gfx::Vector2d gestureScrollDelta(0, 10);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), gestureScrollDelta);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), gestureScrollDelta);
+ m_hostImpl->ScrollEnd();
// The child layer should have scrolled down in its local coordinates an amount proportional to
// the angle between it and the input scroll delta.
gfx::Vector2d expectedScrollDelta(0, gestureScrollDelta.y() * std::cos(MathUtil::Deg2Rad(childLayerAngle)));
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
expectContains(*scrollInfo.get(), childLayerId, expectedScrollDelta);
// The root layer should not have scrolled, because the input delta was close to the layer's
@@ -1657,22 +1657,22 @@
{
// Now reset and scroll the same amount horizontally.
- m_hostImpl->rootLayer()->children()[1]->SetScrollDelta(gfx::Vector2dF());
+ m_hostImpl->active_tree()->root_layer()->children()[1]->SetScrollDelta(gfx::Vector2dF());
gfx::Vector2d gestureScrollDelta(10, 0);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), gestureScrollDelta);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), gestureScrollDelta);
+ m_hostImpl->ScrollEnd();
// The child layer should have scrolled down in its local coordinates an amount proportional to
// the angle between it and the input scroll delta.
gfx::Vector2d expectedScrollDelta(0, -gestureScrollDelta.x() * std::sin(MathUtil::Deg2Rad(childLayerAngle)));
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
expectContains(*scrollInfo.get(), childLayerId, expectedScrollDelta);
// The root layer should have scrolled more, since the input scroll delta was mostly
// orthogonal to the child layer's vertical scroll axis.
gfx::Vector2d expectedRootScrollDelta(gestureScrollDelta.x() * std::pow(std::cos(MathUtil::Deg2Rad(childLayerAngle)), 2), 0);
- expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), expectedRootScrollDelta);
+ expectContains(*scrollInfo.get(), m_hostImpl->active_tree()->root_layer()->id(), expectedRootScrollDelta);
}
}
@@ -1684,32 +1684,32 @@
int scale = 2;
gfx::Transform scaleTransform;
scaleTransform.Scale(scale, scale);
- m_hostImpl->rootLayer()->SetTransform(scaleTransform);
+ m_hostImpl->active_tree()->root_layer()->SetTransform(scaleTransform);
gfx::Size surfaceSize(50, 50);
- m_hostImpl->setViewportSize(surfaceSize, surfaceSize);
+ m_hostImpl->SetViewportSize(surfaceSize, surfaceSize);
initializeRendererAndDrawFrame();
// Scroll down in screen coordinates with a gesture.
gfx::Vector2d scrollDelta(0, 10);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), scrollDelta);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Gesture), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), scrollDelta);
+ m_hostImpl->ScrollEnd();
// The layer should have scrolled down in its local coordinates, but half he amount.
- scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->processScrollDeltas();
- expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), gfx::Vector2d(0, scrollDelta.y() / scale));
+ scoped_ptr<ScrollAndScaleSet> scrollInfo = m_hostImpl->ProcessScrollDeltas();
+ expectContains(*scrollInfo.get(), m_hostImpl->active_tree()->root_layer()->id(), gfx::Vector2d(0, scrollDelta.y() / scale));
// Reset and scroll down with the wheel.
- m_hostImpl->rootLayer()->SetScrollDelta(gfx::Vector2dF());
+ m_hostImpl->active_tree()->root_layer()->SetScrollDelta(gfx::Vector2dF());
gfx::Vector2d wheelScrollDelta(0, 10);
- EXPECT_EQ(m_hostImpl->scrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
- m_hostImpl->scrollBy(gfx::Point(), wheelScrollDelta);
- m_hostImpl->scrollEnd();
+ EXPECT_EQ(m_hostImpl->ScrollBegin(gfx::Point(0, 0), InputHandlerClient::Wheel), InputHandlerClient::ScrollStarted);
+ m_hostImpl->ScrollBy(gfx::Point(), wheelScrollDelta);
+ m_hostImpl->ScrollEnd();
// The scale should not have been applied to the scroll delta.
- scrollInfo = m_hostImpl->processScrollDeltas();
- expectContains(*scrollInfo.get(), m_hostImpl->rootLayer()->id(), wheelScrollDelta);
+ scrollInfo = m_hostImpl->ProcessScrollDeltas();
+ expectContains(*scrollInfo.get(), m_hostImpl->active_tree()->root_layer()->id(), wheelScrollDelta);
}
class BlendStateTrackerContext: public TestWebGraphicsContext3D {
@@ -1799,16 +1799,16 @@
TEST_F(LayerTreeHostImplTest, blendingOffWhenDrawingOpaqueLayers)
{
{
- scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl->active_tree(), 1);
root->SetAnchorPoint(gfx::PointF(0, 0));
root->SetBounds(gfx::Size(10, 10));
root->SetContentBounds(root->bounds());
root->SetDrawsContent(false);
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
}
- LayerImpl* root = m_hostImpl->rootLayer();
+ LayerImpl* root = m_hostImpl->active_tree()->root_layer();
- root->AddChild(BlendStateCheckLayer::Create(m_hostImpl->activeTree(), 2, m_hostImpl->resourceProvider()));
+ root->AddChild(BlendStateCheckLayer::Create(m_hostImpl->active_tree(), 2, m_hostImpl->resource_provider()));
BlendStateCheckLayer* layer1 = static_cast<BlendStateCheckLayer*>(root->children()[0]);
layer1->SetPosition(gfx::PointF(2, 2));
@@ -1817,38 +1817,38 @@
// Opaque layer, drawn without blending.
layer1->SetContentsOpaque(true);
layer1->setExpectation(false, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// Layer with translucent content and painting, so drawn with blending.
layer1->SetContentsOpaque(false);
layer1->setExpectation(true, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// Layer with translucent opacity, drawn with blending.
layer1->SetContentsOpaque(true);
layer1->SetOpacity(0.5);
layer1->setExpectation(true, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// Layer with translucent opacity and painting, drawn with blending.
layer1->SetContentsOpaque(true);
layer1->SetOpacity(0.5);
layer1->setExpectation(true, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
- layer1->AddChild(BlendStateCheckLayer::Create(m_hostImpl->activeTree(), 3, m_hostImpl->resourceProvider()));
+ layer1->AddChild(BlendStateCheckLayer::Create(m_hostImpl->active_tree(), 3, m_hostImpl->resource_provider()));
BlendStateCheckLayer* layer2 = static_cast<BlendStateCheckLayer*>(layer1->children()[0]);
layer2->SetPosition(gfx::PointF(4, 4));
@@ -1859,33 +1859,33 @@
layer2->SetContentsOpaque(true);
layer2->SetOpacity(1);
layer2->setExpectation(false, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
EXPECT_TRUE(layer2->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// Parent layer with translucent content, drawn with blending.
// Child layer with opaque content, drawn without blending.
layer1->SetContentsOpaque(false);
layer1->setExpectation(true, false);
layer2->setExpectation(false, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
EXPECT_TRUE(layer2->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// Parent layer with translucent content but opaque painting, drawn without blending.
// Child layer with opaque content, drawn without blending.
layer1->SetContentsOpaque(true);
layer1->setExpectation(false, false);
layer2->setExpectation(false, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
EXPECT_TRUE(layer2->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// Parent layer with translucent opacity and opaque content. Since it has a
// drawing child, it's drawn to a render surface which carries the opacity,
@@ -1896,11 +1896,11 @@
layer1->SetOpacity(0.5);
layer1->setExpectation(false, true);
layer2->setExpectation(false, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
EXPECT_TRUE(layer2->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// Draw again, but with child non-opaque, to make sure
// layer1 not culled.
@@ -1910,11 +1910,11 @@
layer2->SetContentsOpaque(true);
layer2->SetOpacity(0.5);
layer2->setExpectation(true, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
EXPECT_TRUE(layer2->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// A second way of making the child non-opaque.
layer1->SetContentsOpaque(true);
@@ -1923,11 +1923,11 @@
layer2->SetContentsOpaque(false);
layer2->SetOpacity(1);
layer2->setExpectation(true, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
EXPECT_TRUE(layer2->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// And when the layer says its not opaque but is painted opaque, it is not blended.
layer1->SetContentsOpaque(true);
@@ -1936,11 +1936,11 @@
layer2->SetContentsOpaque(true);
layer2->SetOpacity(1);
layer2->setExpectation(false, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
EXPECT_TRUE(layer2->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// Layer with partially opaque contents, drawn with blending.
layer1->SetContentsOpaque(false);
@@ -1948,10 +1948,10 @@
layer1->setQuadVisibleRect(gfx::Rect(5, 5, 5, 5));
layer1->setOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
layer1->setExpectation(true, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// Layer with partially opaque contents partially culled, drawn with blending.
layer1->SetContentsOpaque(false);
@@ -1959,10 +1959,10 @@
layer1->setQuadVisibleRect(gfx::Rect(5, 5, 5, 2));
layer1->setOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
layer1->setExpectation(true, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// Layer with partially opaque contents culled, drawn with blending.
layer1->SetContentsOpaque(false);
@@ -1970,10 +1970,10 @@
layer1->setQuadVisibleRect(gfx::Rect(7, 5, 3, 5));
layer1->setOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
layer1->setExpectation(true, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
// Layer with partially opaque contents and translucent contents culled, drawn without blending.
layer1->SetContentsOpaque(false);
@@ -1981,24 +1981,24 @@
layer1->setQuadVisibleRect(gfx::Rect(5, 5, 2, 5));
layer1->setOpaqueContentRect(gfx::Rect(5, 5, 2, 5));
layer1->setExpectation(false, false);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(layer1->quadsAppended());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
TEST_F(LayerTreeHostImplTest, viewportCovered)
{
- m_hostImpl->initializeRenderer(createOutputSurface());
- m_hostImpl->activeTree()->set_background_color(SK_ColorGRAY);
+ m_hostImpl->InitializeRenderer(createOutputSurface());
+ m_hostImpl->active_tree()->set_background_color(SK_ColorGRAY);
gfx::Size viewportSize(1000, 1000);
- m_hostImpl->setViewportSize(viewportSize, viewportSize);
+ m_hostImpl->SetViewportSize(viewportSize, viewportSize);
- m_hostImpl->activeTree()->SetRootLayer(LayerImpl::Create(m_hostImpl->activeTree(), 1));
- m_hostImpl->rootLayer()->AddChild(BlendStateCheckLayer::Create(m_hostImpl->activeTree(), 2, m_hostImpl->resourceProvider()));
- BlendStateCheckLayer* child = static_cast<BlendStateCheckLayer*>(m_hostImpl->rootLayer()->children()[0]);
+ m_hostImpl->active_tree()->SetRootLayer(LayerImpl::Create(m_hostImpl->active_tree(), 1));
+ m_hostImpl->active_tree()->root_layer()->AddChild(BlendStateCheckLayer::Create(m_hostImpl->active_tree(), 2, m_hostImpl->resource_provider()));
+ BlendStateCheckLayer* child = static_cast<BlendStateCheckLayer*>(m_hostImpl->active_tree()->root_layer()->children()[0]);
child->setExpectation(false, false);
child->SetContentsOpaque(true);
@@ -2012,17 +2012,17 @@
child->setQuadVisibleRect(gfx::Rect(gfx::Point(), layerRect.size()));
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- ASSERT_EQ(1u, frame.renderPasses.size());
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ ASSERT_EQ(1u, frame.render_passes.size());
size_t numGutterQuads = 0;
- for (size_t i = 0; i < frame.renderPasses[0]->quad_list.size(); ++i)
- numGutterQuads += (frame.renderPasses[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
+ for (size_t i = 0; i < frame.render_passes[0]->quad_list.size(); ++i)
+ numGutterQuads += (frame.render_passes[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
EXPECT_EQ(0u, numGutterQuads);
- EXPECT_EQ(1u, frame.renderPasses[0]->quad_list.size());
+ EXPECT_EQ(1u, frame.render_passes[0]->quad_list.size());
- LayerTestCommon::verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
- m_hostImpl->didDrawAllLayers(frame);
+ LayerTestCommon::verifyQuadsExactlyCoverRect(frame.render_passes[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
+ m_hostImpl->DidDrawAllLayers(frame);
}
// Empty visible content area (fullscreen gutter rect)
@@ -2035,17 +2035,17 @@
child->setQuadVisibleRect(gfx::Rect(gfx::Point(), layerRect.size()));
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- ASSERT_EQ(1u, frame.renderPasses.size());
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ ASSERT_EQ(1u, frame.render_passes.size());
size_t numGutterQuads = 0;
- for (size_t i = 0; i < frame.renderPasses[0]->quad_list.size(); ++i)
- numGutterQuads += (frame.renderPasses[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
+ for (size_t i = 0; i < frame.render_passes[0]->quad_list.size(); ++i)
+ numGutterQuads += (frame.render_passes[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
EXPECT_EQ(1u, numGutterQuads);
- EXPECT_EQ(1u, frame.renderPasses[0]->quad_list.size());
+ EXPECT_EQ(1u, frame.render_passes[0]->quad_list.size());
- LayerTestCommon::verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
- m_hostImpl->didDrawAllLayers(frame);
+ LayerTestCommon::verifyQuadsExactlyCoverRect(frame.render_passes[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
+ m_hostImpl->DidDrawAllLayers(frame);
}
// Content area in middle of clip rect (four surrounding gutter rects)
@@ -2058,17 +2058,17 @@
child->setQuadVisibleRect(gfx::Rect(gfx::Point(), layerRect.size()));
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- ASSERT_EQ(1u, frame.renderPasses.size());
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ ASSERT_EQ(1u, frame.render_passes.size());
size_t numGutterQuads = 0;
- for (size_t i = 0; i < frame.renderPasses[0]->quad_list.size(); ++i)
- numGutterQuads += (frame.renderPasses[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
+ for (size_t i = 0; i < frame.render_passes[0]->quad_list.size(); ++i)
+ numGutterQuads += (frame.render_passes[0]->quad_list[i]->material == DrawQuad::SOLID_COLOR) ? 1 : 0;
EXPECT_EQ(4u, numGutterQuads);
- EXPECT_EQ(5u, frame.renderPasses[0]->quad_list.size());
+ EXPECT_EQ(5u, frame.render_passes[0]->quad_list.size());
- LayerTestCommon::verifyQuadsExactlyCoverRect(frame.renderPasses[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
- m_hostImpl->didDrawAllLayers(frame);
+ LayerTestCommon::verifyQuadsExactlyCoverRect(frame.render_passes[0]->quad_list, gfx::Rect(gfx::Point(), viewportSize));
+ m_hostImpl->DidDrawAllLayers(frame);
}
}
@@ -2103,20 +2103,20 @@
{
scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new ReshapeTrackerContext)).PassAs<OutputSurface>();
ReshapeTrackerContext* reshapeTracker = static_cast<ReshapeTrackerContext*>(outputSurface->context3d());
- m_hostImpl->initializeRenderer(outputSurface.Pass());
+ m_hostImpl->InitializeRenderer(outputSurface.Pass());
- scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::Create(m_hostImpl->active_tree(), 1);
root->SetAnchorPoint(gfx::PointF(0, 0));
root->SetBounds(gfx::Size(10, 10));
root->SetDrawsContent(true);
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
EXPECT_FALSE(reshapeTracker->reshapeCalled());
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
EXPECT_TRUE(reshapeTracker->reshapeCalled());
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
class PartialSwapTrackerContext : public TestWebGraphicsContext3D {
@@ -2151,12 +2151,12 @@
// that we can force partial swap enabled.
LayerTreeSettings settings;
settings.partialSwapEnabled = true;
- scoped_ptr<LayerTreeHostImpl> layerTreeHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
- layerTreeHostImpl->initializeRenderer(outputSurface.Pass());
- layerTreeHostImpl->setViewportSize(gfx::Size(500, 500), gfx::Size(500, 500));
+ scoped_ptr<LayerTreeHostImpl> layerTreeHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
+ layerTreeHostImpl->InitializeRenderer(outputSurface.Pass());
+ layerTreeHostImpl->SetViewportSize(gfx::Size(500, 500), gfx::Size(500, 500));
- scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::Create(layerTreeHostImpl->activeTree(), 1);
- scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::Create(layerTreeHostImpl->activeTree(), 2);
+ scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::Create(layerTreeHostImpl->active_tree(), 1);
+ scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::Create(layerTreeHostImpl->active_tree(), 2);
child->SetPosition(gfx::PointF(12, 13));
child->SetAnchorPoint(gfx::PointF(0, 0));
child->SetBounds(gfx::Size(14, 15));
@@ -2167,15 +2167,15 @@
root->SetContentBounds(gfx::Size(500, 500));
root->SetDrawsContent(true);
root->AddChild(child.Pass());
- layerTreeHostImpl->activeTree()->SetRootLayer(root.Pass());
+ layerTreeHostImpl->active_tree()->SetRootLayer(root.Pass());
LayerTreeHostImpl::FrameData frame;
// First frame, the entire screen should get swapped.
- EXPECT_TRUE(layerTreeHostImpl->prepareToDraw(frame));
- layerTreeHostImpl->drawLayers(frame);
- layerTreeHostImpl->didDrawAllLayers(frame);
- layerTreeHostImpl->swapBuffers();
+ EXPECT_TRUE(layerTreeHostImpl->PrepareToDraw(&frame));
+ layerTreeHostImpl->DrawLayers(&frame);
+ layerTreeHostImpl->DidDrawAllLayers(frame);
+ layerTreeHostImpl->SwapBuffers();
gfx::Rect actualSwapRect = partialSwapTracker->partialSwapRect();
gfx::Rect expectedSwapRect = gfx::Rect(gfx::Point(), gfx::Size(500, 500));
EXPECT_EQ(expectedSwapRect.x(), actualSwapRect.x());
@@ -2187,11 +2187,11 @@
// of old and new child rects.
// expected damage rect: gfx::Rect(gfx::Point(), gfx::Size(26, 28));
// expected swap rect: vertically flipped, with origin at bottom left corner.
- layerTreeHostImpl->rootLayer()->children()[0]->SetPosition(gfx::PointF(0, 0));
- EXPECT_TRUE(layerTreeHostImpl->prepareToDraw(frame));
- layerTreeHostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
- layerTreeHostImpl->swapBuffers();
+ layerTreeHostImpl->active_tree()->root_layer()->children()[0]->SetPosition(gfx::PointF(0, 0));
+ EXPECT_TRUE(layerTreeHostImpl->PrepareToDraw(&frame));
+ layerTreeHostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
+ layerTreeHostImpl->SwapBuffers();
actualSwapRect = partialSwapTracker->partialSwapRect();
expectedSwapRect = gfx::Rect(gfx::Point(0, 500-28), gfx::Size(26, 28));
EXPECT_EQ(expectedSwapRect.x(), actualSwapRect.x());
@@ -2202,12 +2202,12 @@
// Make sure that partial swap is constrained to the viewport dimensions
// expected damage rect: gfx::Rect(gfx::Point(), gfx::Size(500, 500));
// expected swap rect: flipped damage rect, but also clamped to viewport
- layerTreeHostImpl->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
- layerTreeHostImpl->rootLayer()->SetOpacity(0.7f); // this will damage everything
- EXPECT_TRUE(layerTreeHostImpl->prepareToDraw(frame));
- layerTreeHostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
- layerTreeHostImpl->swapBuffers();
+ layerTreeHostImpl->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
+ layerTreeHostImpl->active_tree()->root_layer()->SetOpacity(0.7f); // this will damage everything
+ EXPECT_TRUE(layerTreeHostImpl->PrepareToDraw(&frame));
+ layerTreeHostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
+ layerTreeHostImpl->SwapBuffers();
actualSwapRect = partialSwapTracker->partialSwapRect();
expectedSwapRect = gfx::Rect(gfx::Point(), gfx::Size(10, 10));
EXPECT_EQ(expectedSwapRect.x(), actualSwapRect.x());
@@ -2218,8 +2218,8 @@
TEST_F(LayerTreeHostImplTest, rootLayerDoesntCreateExtraSurface)
{
- scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::Create(m_hostImpl->activeTree(), 1);
- scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::Create(m_hostImpl->activeTree(), 2);
+ scoped_ptr<LayerImpl> root = FakeDrawableLayerImpl::Create(m_hostImpl->active_tree(), 1);
+ scoped_ptr<LayerImpl> child = FakeDrawableLayerImpl::Create(m_hostImpl->active_tree(), 2);
child->SetAnchorPoint(gfx::PointF(0, 0));
child->SetBounds(gfx::Size(10, 10));
child->SetContentBounds(gfx::Size(10, 10));
@@ -2231,14 +2231,14 @@
root->SetOpacity(0.7f);
root->AddChild(child.Pass());
- m_hostImpl->activeTree()->SetRootLayer(root.Pass());
+ m_hostImpl->active_tree()->SetRootLayer(root.Pass());
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- EXPECT_EQ(1u, frame.renderSurfaceLayerList->size());
- EXPECT_EQ(1u, frame.renderPasses.size());
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ EXPECT_EQ(1u, frame.render_surface_layer_list->size());
+ EXPECT_EQ(1u, frame.render_passes.size());
+ m_hostImpl->DidDrawAllLayers(frame);
}
class FakeLayerWithQuads : public LayerImpl {
@@ -2360,28 +2360,28 @@
// Run test case
createLayerTreeHost(false, outputSurface.Pass());
- setupRootLayerImpl(FakeLayerWithQuads::Create(m_hostImpl->activeTree(), 1));
+ setupRootLayerImpl(FakeLayerWithQuads::Create(m_hostImpl->active_tree(), 1));
// without partial swap, and no clipping, no scissor is set.
harness.mustDrawSolidQuad();
harness.mustSetNoScissor();
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
Mock::VerifyAndClearExpectations(&mockContext);
// without partial swap, but a layer does clip its subtree, one scissor is set.
- m_hostImpl->rootLayer()->SetMasksToBounds(true);
+ m_hostImpl->active_tree()->root_layer()->SetMasksToBounds(true);
harness.mustDrawSolidQuad();
harness.mustSetScissor(0, 0, 10, 10);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
Mock::VerifyAndClearExpectations(&mockContext);
}
@@ -2393,30 +2393,30 @@
MockContextHarness harness(mockContext);
createLayerTreeHost(true, outputSurface.Pass());
- setupRootLayerImpl(FakeLayerWithQuads::Create(m_hostImpl->activeTree(), 1));
+ setupRootLayerImpl(FakeLayerWithQuads::Create(m_hostImpl->active_tree(), 1));
// The first frame is not a partially-swapped one.
harness.mustSetScissor(0, 0, 10, 10);
harness.mustDrawSolidQuad();
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
Mock::VerifyAndClearExpectations(&mockContext);
// Damage a portion of the frame.
- m_hostImpl->rootLayer()->set_update_rect(gfx::Rect(0, 0, 2, 3));
+ m_hostImpl->active_tree()->root_layer()->set_update_rect(gfx::Rect(0, 0, 2, 3));
// The second frame will be partially-swapped (the y coordinates are flipped).
harness.mustSetScissor(0, 7, 2, 3);
harness.mustDrawSolidQuad();
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
Mock::VerifyAndClearExpectations(&mockContext);
}
@@ -2449,9 +2449,9 @@
LayerTreeSettings settings;
settings.partialSwapEnabled = partialSwap;
- scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, client, proxy);
- myHostImpl->initializeRenderer(outputSurface.Pass());
- myHostImpl->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
+ scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, client, proxy);
+ myHostImpl->InitializeRenderer(outputSurface.Pass());
+ myHostImpl->SetViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
/*
Layers are created as follows:
@@ -2471,9 +2471,9 @@
Layers 1, 2 have render surfaces
*/
- scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->activeTree(), 1);
- scoped_ptr<LayerImpl> child = LayerImpl::Create(myHostImpl->activeTree(), 2);
- scoped_ptr<LayerImpl> grandChild = FakeLayerWithQuads::Create(myHostImpl->activeTree(), 3);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->active_tree(), 1);
+ scoped_ptr<LayerImpl> child = LayerImpl::Create(myHostImpl->active_tree(), 2);
+ scoped_ptr<LayerImpl> grandChild = FakeLayerWithQuads::Create(myHostImpl->active_tree(), 3);
gfx::Rect rootRect(0, 0, 100, 100);
gfx::Rect childRect(10, 10, 50, 50);
@@ -2507,7 +2507,7 @@
child->AddChild(grandChild.Pass());
root->AddChild(child.Pass());
- myHostImpl->activeTree()->SetRootLayer(root.Pass());
+ myHostImpl->active_tree()->SetRootLayer(root.Pass());
return myHostImpl.Pass();
}
@@ -2517,17 +2517,17 @@
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Verify all quads have been computed
- ASSERT_EQ(2U, frame.renderPasses.size());
- ASSERT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- ASSERT_EQ(1U, frame.renderPasses[1]->quad_list.size());
- EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quad_list[0]->material);
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
+ ASSERT_EQ(2U, frame.render_passes.size());
+ ASSERT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ ASSERT_EQ(1U, frame.render_passes[1]->quad_list.size());
+ EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.render_passes[0]->quad_list[0]->material);
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
}
@@ -2537,17 +2537,17 @@
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Verify all quads have been computed
- ASSERT_EQ(2U, frame.renderPasses.size());
- ASSERT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- ASSERT_EQ(1U, frame.renderPasses[1]->quad_list.size());
- EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quad_list[0]->material);
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
+ ASSERT_EQ(2U, frame.render_passes.size());
+ ASSERT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ ASSERT_EQ(1U, frame.render_passes[1]->quad_list.size());
+ EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.render_passes[0]->quad_list[0]->material);
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
}
@@ -2613,9 +2613,9 @@
TestWebGraphicsContext3D* context3d = context.get();
scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(
context.PassAs<WebKit::WebGraphicsContext3D>()).PassAs<OutputSurface>();
- m_hostImpl->initializeRenderer(outputSurface.Pass());
+ m_hostImpl->InitializeRenderer(outputSurface.Pass());
- scoped_ptr<LayerImpl> rootLayer(LayerImpl::Create(m_hostImpl->activeTree(), 1));
+ scoped_ptr<LayerImpl> rootLayer(LayerImpl::Create(m_hostImpl->active_tree(), 1));
rootLayer->SetBounds(gfx::Size(10, 10));
rootLayer->SetAnchorPoint(gfx::PointF());
@@ -2623,14 +2623,14 @@
gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta()));
FakeVideoFrameProvider provider;
provider.set_frame(softwareFrame);
- scoped_ptr<VideoLayerImpl> videoLayer = VideoLayerImpl::Create(m_hostImpl->activeTree(), 4, &provider);
+ scoped_ptr<VideoLayerImpl> videoLayer = VideoLayerImpl::Create(m_hostImpl->active_tree(), 4, &provider);
videoLayer->SetBounds(gfx::Size(10, 10));
videoLayer->SetAnchorPoint(gfx::PointF(0, 0));
videoLayer->SetContentBounds(gfx::Size(10, 10));
videoLayer->SetDrawsContent(true);
rootLayer->AddChild(videoLayer.PassAs<LayerImpl>());
- scoped_ptr<IOSurfaceLayerImpl> ioSurfaceLayer = IOSurfaceLayerImpl::Create(m_hostImpl->activeTree(), 5);
+ scoped_ptr<IOSurfaceLayerImpl> ioSurfaceLayer = IOSurfaceLayerImpl::Create(m_hostImpl->active_tree(), 5);
ioSurfaceLayer->SetBounds(gfx::Size(10, 10));
ioSurfaceLayer->SetAnchorPoint(gfx::PointF(0, 0));
ioSurfaceLayer->SetContentBounds(gfx::Size(10, 10));
@@ -2638,20 +2638,20 @@
ioSurfaceLayer->setIOSurfaceProperties(1, gfx::Size(10, 10));
rootLayer->AddChild(ioSurfaceLayer.PassAs<LayerImpl>());
- m_hostImpl->activeTree()->SetRootLayer(rootLayer.Pass());
+ m_hostImpl->active_tree()->SetRootLayer(rootLayer.Pass());
EXPECT_EQ(0u, context3d->NumTextures());
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
- m_hostImpl->swapBuffers();
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
+ m_hostImpl->SwapBuffers();
EXPECT_GT(context3d->NumTextures(), 0u);
// Kill the layer tree.
- m_hostImpl->activeTree()->SetRootLayer(LayerImpl::Create(m_hostImpl->activeTree(), 100));
+ m_hostImpl->active_tree()->SetRootLayer(LayerImpl::Create(m_hostImpl->active_tree(), 100));
// There should be no textures left in use after.
EXPECT_EQ(0u, context3d->NumTextures());
}
@@ -2669,26 +2669,26 @@
// Run test case
createLayerTreeHost(false, outputSurface.Pass());
- setupRootLayerImpl(LayerImpl::Create(m_hostImpl->activeTree(), 1));
- m_hostImpl->activeTree()->set_background_color(SK_ColorWHITE);
+ setupRootLayerImpl(LayerImpl::Create(m_hostImpl->active_tree(), 1));
+ m_hostImpl->active_tree()->set_background_color(SK_ColorWHITE);
// Verify one quad is drawn when transparent background set is not set.
- m_hostImpl->activeTree()->set_has_transparent_background(false);
+ m_hostImpl->active_tree()->set_has_transparent_background(false);
EXPECT_CALL(*mockContext, useProgram(_))
.Times(1);
EXPECT_CALL(*mockContext, drawElements(_, _, _, _))
.Times(1);
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
Mock::VerifyAndClearExpectations(&mockContext);
// Verify no quads are drawn when transparent background is set.
- m_hostImpl->activeTree()->set_has_transparent_background(true);
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->active_tree()->set_has_transparent_background(true);
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
Mock::VerifyAndClearExpectations(&mockContext);
}
@@ -2711,10 +2711,10 @@
{
scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
- layerTreeHostImpl->initializeRenderer(outputSurface.Pass());
- layerTreeHostImpl->setViewportSize(rootSize, rootSize);
+ layerTreeHostImpl->InitializeRenderer(outputSurface.Pass());
+ layerTreeHostImpl->SetViewportSize(rootSize, rootSize);
- scoped_ptr<LayerImpl> root = LayerImpl::Create(layerTreeHostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(layerTreeHostImpl->active_tree(), 1);
rootPtr = root.get();
root->SetAnchorPoint(gfx::PointF(0, 0));
@@ -2722,7 +2722,7 @@
root->SetBounds(rootSize);
root->SetContentBounds(rootSize);
root->SetDrawsContent(true);
- layerTreeHostImpl->activeTree()->SetRootLayer(root.Pass());
+ layerTreeHostImpl->active_tree()->SetRootLayer(root.Pass());
addDrawingLayerTo(rootPtr, 2, gfx::Rect(10, 10, rootSize.width(), rootSize.height()), &intermediateLayerPtr);
intermediateLayerPtr->SetDrawsContent(false); // only children draw content
@@ -2748,7 +2748,7 @@
LayerTreeSettings settings;
settings.minimumOcclusionTrackingSize = gfx::Size();
settings.cacheRenderPassContents = true;
- scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
+ scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
// Layers are structure as follows:
//
@@ -2772,10 +2772,10 @@
gfx::Size rootSize(1000, 1000);
- myHostImpl->initializeRenderer(outputSurface.Pass());
- myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
+ myHostImpl->InitializeRenderer(outputSurface.Pass());
+ myHostImpl->SetViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
- scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->active_tree(), 1);
rootPtr = root.get();
root->SetAnchorPoint(gfx::PointF(0, 0));
@@ -2784,7 +2784,7 @@
root->SetContentBounds(rootSize);
root->SetDrawsContent(true);
root->SetMasksToBounds(true);
- myHostImpl->activeTree()->SetRootLayer(root.Pass());
+ myHostImpl->active_tree()->SetRootLayer(root.Pass());
addDrawingLayerTo(rootPtr, 2, gfx::Rect(300, 300, 300, 300), &layerS1Ptr);
layerS1Ptr->SetForceRenderSurface(true);
@@ -2800,18 +2800,18 @@
// Initial draw - must receive all quads
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive 3 render passes.
// For Root, there are 2 quads; for S1, there are 2 quads (1 is occluded); for S2, there is 2 quads.
- ASSERT_EQ(3U, frame.renderPasses.size());
+ ASSERT_EQ(3U, frame.render_passes.size());
- EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(2U, frame.renderPasses[1]->quad_list.size());
- EXPECT_EQ(2U, frame.renderPasses[2]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[2]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// "Unocclude" surface S1 and repeat draw.
@@ -2822,19 +2822,19 @@
layerS2Ptr->SetTransform(transform);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive 2 render passes.
// For Root, there are 2 quads
// For S1, the number of quads depends on what got unoccluded, so not asserted beyond being positive.
// For S2, there is no render pass
- ASSERT_EQ(2U, frame.renderPasses.size());
+ ASSERT_EQ(2U, frame.render_passes.size());
- EXPECT_GT(frame.renderPasses[0]->quad_list.size(), 0U);
- EXPECT_EQ(2U, frame.renderPasses[1]->quad_list.size());
+ EXPECT_GT(frame.render_passes[0]->quad_list.size(), 0U);
+ EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// "Re-occlude" surface S1 and repeat draw.
@@ -2845,15 +2845,15 @@
layerS2Ptr->SetTransform(transform);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive 1 render pass - for the root.
- ASSERT_EQ(1U, frame.renderPasses.size());
+ ASSERT_EQ(1U, frame.render_passes.size());
- EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
}
@@ -2863,7 +2863,7 @@
LayerTreeSettings settings;
settings.minimumOcclusionTrackingSize = gfx::Size();
settings.cacheRenderPassContents = true;
- scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
+ scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
// Layers are structure as follows:
//
@@ -2884,10 +2884,10 @@
gfx::Size rootSize(1000, 1000);
- myHostImpl->initializeRenderer(outputSurface.Pass());
- myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
+ myHostImpl->InitializeRenderer(outputSurface.Pass());
+ myHostImpl->SetViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
- scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->active_tree(), 1);
rootPtr = root.get();
root->SetAnchorPoint(gfx::PointF(0, 0));
@@ -2896,7 +2896,7 @@
root->SetContentBounds(rootSize);
root->SetDrawsContent(true);
root->SetMasksToBounds(true);
- myHostImpl->activeTree()->SetRootLayer(root.Pass());
+ myHostImpl->active_tree()->SetRootLayer(root.Pass());
addDrawingLayerTo(rootPtr, 2, gfx::Rect(0, 0, 800, 800), &layerS1Ptr);
layerS1Ptr->SetForceRenderSurface(true);
@@ -2914,20 +2914,20 @@
// Initial draw - must receive all quads
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive 3 render passes.
// For Root, there are 2 quads; for S1, there are 3 quads; for S2, there is 1 quad.
- ASSERT_EQ(3U, frame.renderPasses.size());
+ ASSERT_EQ(3U, frame.render_passes.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
// L14 is culled, so only 3 quads.
- EXPECT_EQ(3U, frame.renderPasses[1]->quad_list.size());
- EXPECT_EQ(2U, frame.renderPasses[2]->quad_list.size());
+ EXPECT_EQ(3U, frame.render_passes[1]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[2]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// "Unocclude" surface S1 and repeat draw.
@@ -2938,19 +2938,19 @@
layerS2Ptr->SetTransform(transform);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive 2 render passes.
// For Root, there are 2 quads
// For S1, the number of quads depends on what got unoccluded, so not asserted beyond being positive.
// For S2, there is no render pass
- ASSERT_EQ(2U, frame.renderPasses.size());
+ ASSERT_EQ(2U, frame.render_passes.size());
- EXPECT_GT(frame.renderPasses[0]->quad_list.size(), 0U);
- EXPECT_EQ(2U, frame.renderPasses[1]->quad_list.size());
+ EXPECT_GT(frame.render_passes[0]->quad_list.size(), 0U);
+ EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// "Re-occlude" surface S1 and repeat draw.
@@ -2961,15 +2961,15 @@
layerS2Ptr->SetTransform(transform);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive 1 render pass - for the root.
- ASSERT_EQ(1U, frame.renderPasses.size());
+ ASSERT_EQ(1U, frame.render_passes.size());
- EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
}
@@ -2978,7 +2978,7 @@
LayerTreeSettings settings;
settings.minimumOcclusionTrackingSize = gfx::Size();
settings.cacheRenderPassContents = true;
- scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
+ scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
// Layers are structured as follows:
//
@@ -2997,10 +2997,10 @@
gfx::Size rootSize(1000, 1000);
- myHostImpl->initializeRenderer(outputSurface.Pass());
- myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
+ myHostImpl->InitializeRenderer(outputSurface.Pass());
+ myHostImpl->SetViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
- scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->active_tree(), 1);
rootPtr = root.get();
root->SetAnchorPoint(gfx::PointF(0, 0));
@@ -3009,7 +3009,7 @@
root->SetContentBounds(rootSize);
root->SetDrawsContent(true);
root->SetMasksToBounds(true);
- myHostImpl->activeTree()->SetRootLayer(root.Pass());
+ myHostImpl->active_tree()->SetRootLayer(root.Pass());
addDrawingLayerTo(rootPtr, 2, gfx::Rect(0, 0, 400, 400), &layerS1Ptr);
layerS1Ptr->SetForceRenderSurface(true);
@@ -3023,18 +3023,18 @@
// Initial draw - must receive all quads
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive 3 render passes.
// For Root, there are 2 quads; for S1, there are 3 quads; for S2, there is 1 quad.
- ASSERT_EQ(3U, frame.renderPasses.size());
+ ASSERT_EQ(3U, frame.render_passes.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(3U, frame.renderPasses[1]->quad_list.size());
- EXPECT_EQ(2U, frame.renderPasses[2]->quad_list.size());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(3U, frame.render_passes[1]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[2]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// "Unocclude" surface S1 and repeat draw.
@@ -3045,19 +3045,19 @@
layerS2Ptr->SetTransform(transform);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive 2 render passes.
// For Root, there are 2 quads
// For S1, the number of quads depends on what got unoccluded, so not asserted beyond being positive.
// For S2, there is no render pass
- ASSERT_EQ(2U, frame.renderPasses.size());
+ ASSERT_EQ(2U, frame.render_passes.size());
- EXPECT_GT(frame.renderPasses[0]->quad_list.size(), 0U);
- EXPECT_EQ(2U, frame.renderPasses[1]->quad_list.size());
+ EXPECT_GT(frame.render_passes[0]->quad_list.size(), 0U);
+ EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
}
@@ -3065,7 +3065,7 @@
{
LayerTreeSettings settings;
settings.cacheRenderPassContents = true;
- scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
+ scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
// Layers are structured as follows:
//
@@ -3079,10 +3079,10 @@
gfx::Size rootSize(1000, 1000);
- myHostImpl->initializeRenderer(outputSurface.Pass());
- myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
+ myHostImpl->InitializeRenderer(outputSurface.Pass());
+ myHostImpl->SetViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
- scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->active_tree(), 1);
rootPtr = root.get();
root->SetAnchorPoint(gfx::PointF(0, 0));
@@ -3091,7 +3091,7 @@
root->SetContentBounds(rootSize);
root->SetDrawsContent(true);
root->SetMasksToBounds(true);
- myHostImpl->activeTree()->SetRootLayer(root.Pass());
+ myHostImpl->active_tree()->SetRootLayer(root.Pass());
addDrawingLayerTo(rootPtr, 2, gfx::Rect(0, 0, 400, 400), &layerS1Ptr);
layerS1Ptr->SetForceRenderSurface(true);
@@ -3106,31 +3106,31 @@
// Initial draw - must receive all quads
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive 2 render passes.
- ASSERT_EQ(2U, frame.renderPasses.size());
+ ASSERT_EQ(2U, frame.render_passes.size());
- EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(1U, frame.render_passes[1]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Change opacity and draw. Verify we used cached texture.
layerS1Ptr->SetOpacity(0.2f);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// One render pass must be gone due to cached texture.
- ASSERT_EQ(1U, frame.renderPasses.size());
+ ASSERT_EQ(1U, frame.render_passes.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
}
@@ -3140,7 +3140,7 @@
settings.minimumOcclusionTrackingSize = gfx::Size();
settings.partialSwapEnabled = true;
settings.cacheRenderPassContents = true;
- scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
+ scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
// Layers are structure as follows:
//
@@ -3164,10 +3164,10 @@
gfx::Size rootSize(1000, 1000);
- myHostImpl->initializeRenderer(outputSurface.Pass());
- myHostImpl->setViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
+ myHostImpl->InitializeRenderer(outputSurface.Pass());
+ myHostImpl->SetViewportSize(gfx::Size(rootSize.width(), rootSize.height()), gfx::Size(rootSize.width(), rootSize.height()));
- scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->active_tree(), 1);
rootPtr = root.get();
root->SetAnchorPoint(gfx::PointF(0, 0));
@@ -3176,7 +3176,7 @@
root->SetContentBounds(rootSize);
root->SetDrawsContent(true);
root->SetMasksToBounds(true);
- myHostImpl->activeTree()->SetRootLayer(root.Pass());
+ myHostImpl->active_tree()->SetRootLayer(root.Pass());
addDrawingLayerTo(rootPtr, 2, gfx::Rect(300, 300, 300, 300), &layerS1Ptr);
layerS1Ptr->SetForceRenderSurface(true);
@@ -3192,18 +3192,18 @@
// Initial draw - must receive all quads
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive 3 render passes.
// For Root, there are 2 quads; for S1, there are 2 quads (one is occluded); for S2, there is 2 quads.
- ASSERT_EQ(3U, frame.renderPasses.size());
+ ASSERT_EQ(3U, frame.render_passes.size());
- EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(2U, frame.renderPasses[1]->quad_list.size());
- EXPECT_EQ(2U, frame.renderPasses[2]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[2]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// "Unocclude" surface S1 and repeat draw.
@@ -3214,19 +3214,19 @@
layerS2Ptr->SetTransform(transform);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive 2 render passes.
// For Root, there are 2 quads.
// For S1, there are 2 quads.
// For S2, there is no render pass
- ASSERT_EQ(2U, frame.renderPasses.size());
+ ASSERT_EQ(2U, frame.render_passes.size());
- EXPECT_EQ(2U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(2U, frame.renderPasses[1]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(2U, frame.render_passes[1]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// "Re-occlude" surface S1 and repeat draw.
@@ -3237,13 +3237,13 @@
layerS2Ptr->SetTransform(transform);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Root render pass only.
- ASSERT_EQ(1U, frame.renderPasses.size());
+ ASSERT_EQ(1U, frame.render_passes.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
}
@@ -3252,7 +3252,7 @@
LayerTreeSettings settings;
settings.minimumOcclusionTrackingSize = gfx::Size();
settings.cacheRenderPassContents = true;
- scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
+ scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
/*
Layers are created as follows:
@@ -3272,16 +3272,16 @@
Layers 1, 2 have render surfaces
*/
- scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->activeTree(), 1);
- scoped_ptr<TiledLayerImpl> child = TiledLayerImpl::Create(myHostImpl->activeTree(), 2);
- scoped_ptr<LayerImpl> grandChild = LayerImpl::Create(myHostImpl->activeTree(), 3);
+ scoped_ptr<LayerImpl> root = LayerImpl::Create(myHostImpl->active_tree(), 1);
+ scoped_ptr<TiledLayerImpl> child = TiledLayerImpl::Create(myHostImpl->active_tree(), 2);
+ scoped_ptr<LayerImpl> grandChild = LayerImpl::Create(myHostImpl->active_tree(), 3);
gfx::Rect rootRect(0, 0, 100, 100);
gfx::Rect childRect(10, 10, 50, 50);
gfx::Rect grandChildRect(5, 5, 150, 150);
scoped_ptr<OutputSurface> outputSurface = FakeOutputSurface::Create3d(scoped_ptr<WebKit::WebGraphicsContext3D>(new PartialSwapContext)).PassAs<OutputSurface>();
- myHostImpl->initializeRenderer(outputSurface.Pass());
+ myHostImpl->InitializeRenderer(outputSurface.Pass());
root->SetAnchorPoint(gfx::PointF(0, 0));
root->SetPosition(gfx::PointF(rootRect.x(), rootRect.y()));
@@ -3314,16 +3314,16 @@
child->AddChild(grandChild.Pass());
root->AddChild(child.PassAs<LayerImpl>());
- myHostImpl->activeTree()->SetRootLayer(root.Pass());
- myHostImpl->setViewportSize(rootRect.size(), rootRect.size());
+ myHostImpl->active_tree()->SetRootLayer(root.Pass());
+ myHostImpl->SetViewportSize(rootRect.size(), rootRect.size());
EXPECT_FALSE(myHostImpl->renderer()->HaveCachedResourcesForRenderPassId(childPassId));
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// We should have cached textures for surface 2.
@@ -3331,9 +3331,9 @@
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// We should still have cached textures for surface 2 after drawing with no damage.
@@ -3344,9 +3344,9 @@
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// We should have a cached texture for surface 2 again even though it was damaged.
@@ -3359,7 +3359,7 @@
settings.minimumOcclusionTrackingSize = gfx::Size();
settings.partialSwapEnabled = true;
settings.cacheRenderPassContents = true;
- scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
+ scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
LayerImpl* rootPtr;
LayerImpl* intermediateLayerPtr;
@@ -3370,78 +3370,78 @@
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive two render passes, each with one quad
- ASSERT_EQ(2U, frame.renderPasses.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
+ ASSERT_EQ(2U, frame.render_passes.size());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(1U, frame.render_passes[1]->quad_list.size());
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
- const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
- RenderPass* targetPass = frame.renderPassesById[quad->render_pass_id];
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
+ const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
+ RenderPass* targetPass = frame.render_passes_by_id[quad->render_pass_id];
ASSERT_TRUE(targetPass);
EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Draw without any change
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive one render pass, as the other one should be culled
- ASSERT_EQ(1U, frame.renderPasses.size());
+ ASSERT_EQ(1U, frame.render_passes.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
- EXPECT_TRUE(frame.renderPassesById.find(quad->render_pass_id) == frame.renderPassesById.end());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+ EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) == frame.render_passes_by_id.end());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Change opacity and draw
surfaceLayerPtr->SetOpacity(0.6f);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive one render pass, as the other one should be culled
- ASSERT_EQ(1U, frame.renderPasses.size());
+ ASSERT_EQ(1U, frame.render_passes.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
- EXPECT_TRUE(frame.renderPassesById.find(quad->render_pass_id) == frame.renderPassesById.end());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+ EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) == frame.render_passes_by_id.end());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Change less benign property and draw - should have contents changed flag
surfaceLayerPtr->SetStackingOrderChanged(true);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive two render passes, each with one quad
- ASSERT_EQ(2U, frame.renderPasses.size());
+ ASSERT_EQ(2U, frame.render_passes.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quad_list[0]->material);
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.render_passes[0]->quad_list[0]->material);
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
- const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
- RenderPass* targetPass = frame.renderPassesById[quad->render_pass_id];
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
+ const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
+ RenderPass* targetPass = frame.render_passes_by_id[quad->render_pass_id];
ASSERT_TRUE(targetPass);
EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Change opacity again, and evict the cached surface texture.
@@ -3452,44 +3452,44 @@
surfaceLayerPtr->SetOpacity(0.6f);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive two render passes
- ASSERT_EQ(2U, frame.renderPasses.size());
+ ASSERT_EQ(2U, frame.render_passes.size());
// Even though not enough properties changed, the entire thing must be
// redrawn as we don't have cached textures
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(1U, frame.render_passes[1]->quad_list.size());
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
- const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
- RenderPass* targetPass = frame.renderPassesById[quad->render_pass_id];
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
+ const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
+ RenderPass* targetPass = frame.render_passes_by_id[quad->render_pass_id];
ASSERT_TRUE(targetPass);
EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
// Was our surface evicted?
EXPECT_FALSE(myHostImpl->renderer()->HaveCachedResourcesForRenderPassId(targetPass->id));
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Draw without any change, to make sure the state is clear
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive one render pass, as the other one should be culled
- ASSERT_EQ(1U, frame.renderPasses.size());
+ ASSERT_EQ(1U, frame.render_passes.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
- EXPECT_TRUE(frame.renderPassesById.find(quad->render_pass_id) == frame.renderPassesById.end());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+ EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) == frame.render_passes_by_id.end());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Change location of the intermediate layer
@@ -3498,18 +3498,18 @@
intermediateLayerPtr->SetTransform(transform);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive one render pass, as the other one should be culled.
- ASSERT_EQ(1U, frame.renderPasses.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
+ ASSERT_EQ(1U, frame.render_passes.size());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
- EXPECT_TRUE(frame.renderPassesById.find(quad->render_pass_id) == frame.renderPassesById.end());
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+ EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) == frame.render_passes_by_id.end());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
}
@@ -3518,7 +3518,7 @@
LayerTreeSettings settings;
settings.minimumOcclusionTrackingSize = gfx::Size();
settings.cacheRenderPassContents = true;
- scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::create(settings, this, &m_proxy);
+ scoped_ptr<LayerTreeHostImpl> myHostImpl = LayerTreeHostImpl::Create(settings, this, &m_proxy);
LayerImpl* rootPtr;
LayerImpl* intermediateLayerPtr;
@@ -3529,83 +3529,83 @@
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive two render passes, each with one quad
- ASSERT_EQ(2U, frame.renderPasses.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
+ ASSERT_EQ(2U, frame.render_passes.size());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(1U, frame.render_passes[1]->quad_list.size());
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
- const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
- RenderPass* targetPass = frame.renderPassesById[quad->render_pass_id];
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
+ const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
+ RenderPass* targetPass = frame.render_passes_by_id[quad->render_pass_id];
EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
- EXPECT_FALSE(frame.renderPasses[0]->damage_rect.IsEmpty());
- EXPECT_FALSE(frame.renderPasses[1]->damage_rect.IsEmpty());
+ EXPECT_FALSE(frame.render_passes[0]->damage_rect.IsEmpty());
+ EXPECT_FALSE(frame.render_passes[1]->damage_rect.IsEmpty());
- EXPECT_FALSE(frame.renderPasses[0]->has_occlusion_from_outside_target_surface);
- EXPECT_FALSE(frame.renderPasses[1]->has_occlusion_from_outside_target_surface);
+ EXPECT_FALSE(frame.render_passes[0]->has_occlusion_from_outside_target_surface);
+ EXPECT_FALSE(frame.render_passes[1]->has_occlusion_from_outside_target_surface);
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Draw without any change
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Even though there was no change, we set the damage to entire viewport.
// One of the passes should be culled as a result, since contents didn't change
// and we have cached texture.
- ASSERT_EQ(1U, frame.renderPasses.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
+ ASSERT_EQ(1U, frame.render_passes.size());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
- EXPECT_TRUE(frame.renderPasses[0]->damage_rect.IsEmpty());
+ EXPECT_TRUE(frame.render_passes[0]->damage_rect.IsEmpty());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Change opacity and draw
surfaceLayerPtr->SetOpacity(0.6f);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive one render pass, as the other one should be culled
- ASSERT_EQ(1U, frame.renderPasses.size());
+ ASSERT_EQ(1U, frame.render_passes.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
- EXPECT_TRUE(frame.renderPassesById.find(quad->render_pass_id) == frame.renderPassesById.end());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+ EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) == frame.render_passes_by_id.end());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Change less benign property and draw - should have contents changed flag
surfaceLayerPtr->SetStackingOrderChanged(true);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive two render passes, each with one quad
- ASSERT_EQ(2U, frame.renderPasses.size());
+ ASSERT_EQ(2U, frame.render_passes.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quad_list[0]->material);
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.render_passes[0]->quad_list[0]->material);
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
- const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
- RenderPass* targetPass = frame.renderPassesById[quad->render_pass_id];
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
+ const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
+ RenderPass* targetPass = frame.render_passes_by_id[quad->render_pass_id];
ASSERT_TRUE(targetPass);
EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Change opacity again, and evict the cached surface texture.
@@ -3616,42 +3616,42 @@
surfaceLayerPtr->SetOpacity(0.6f);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive two render passes
- ASSERT_EQ(2U, frame.renderPasses.size());
+ ASSERT_EQ(2U, frame.render_passes.size());
// Even though not enough properties changed, the entire thing must be
// redrawn as we don't have cached textures
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
- EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
+ EXPECT_EQ(1U, frame.render_passes[1]->quad_list.size());
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
- const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
- RenderPass* targetPass = frame.renderPassesById[quad->render_pass_id];
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[1]->quad_list[0]->material);
+ const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[1]->quad_list[0]);
+ RenderPass* targetPass = frame.render_passes_by_id[quad->render_pass_id];
ASSERT_TRUE(targetPass);
EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
// Was our surface evicted?
EXPECT_FALSE(myHostImpl->renderer()->HaveCachedResourcesForRenderPassId(targetPass->id));
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Draw without any change, to make sure the state is clear
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Even though there was no change, we set the damage to entire viewport.
// One of the passes should be culled as a result, since contents didn't change
// and we have cached texture.
- ASSERT_EQ(1U, frame.renderPasses.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
+ ASSERT_EQ(1U, frame.render_passes.size());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
// Change location of the intermediate layer
@@ -3660,18 +3660,18 @@
intermediateLayerPtr->SetTransform(transform);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(myHostImpl->PrepareToDraw(&frame));
// Must receive one render pass, as the other one should be culled.
- ASSERT_EQ(1U, frame.renderPasses.size());
- EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
+ ASSERT_EQ(1U, frame.render_passes.size());
+ EXPECT_EQ(1U, frame.render_passes[0]->quad_list.size());
- EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
- EXPECT_TRUE(frame.renderPassesById.find(quad->render_pass_id) == frame.renderPassesById.end());
+ EXPECT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
+ EXPECT_TRUE(frame.render_passes_by_id.find(quad->render_pass_id) == frame.render_passes_by_id.end());
- myHostImpl->drawLayers(frame);
- myHostImpl->didDrawAllLayers(frame);
+ myHostImpl->DrawLayers(&frame);
+ myHostImpl->DidDrawAllLayers(frame);
}
}
@@ -3684,7 +3684,7 @@
// drawing something different than before.
setReduceMemoryResult(false);
m_hostImpl->SetManagedMemoryPolicy(ManagedMemoryPolicy(
- m_hostImpl->memoryAllocationLimitBytes() - 1));
+ m_hostImpl->memory_allocation_limit_bytes() - 1));
EXPECT_TRUE(m_didRequestCommit);
m_didRequestCommit = false;
@@ -3692,14 +3692,14 @@
// to re-commit.
setReduceMemoryResult(true);
m_hostImpl->SetManagedMemoryPolicy(ManagedMemoryPolicy(
- m_hostImpl->memoryAllocationLimitBytes() - 1));
+ m_hostImpl->memory_allocation_limit_bytes() - 1));
EXPECT_TRUE(m_didRequestCommit);
m_didRequestCommit = false;
// But if we set it to the same value that it was before, we shouldn't
// re-commit.
m_hostImpl->SetManagedMemoryPolicy(ManagedMemoryPolicy(
- m_hostImpl->memoryAllocationLimitBytes()));
+ m_hostImpl->memory_allocation_limit_bytes()));
EXPECT_FALSE(m_didRequestCommit);
}
@@ -3830,8 +3830,8 @@
renderPass->AppendQuad(quad.PassAs<DrawQuad>());
}
}
- testData.renderPassesById[renderPassId] = renderPass.get();
- testData.renderPasses.insert(testData.renderPasses.begin(), renderPass.PassAs<RenderPass>());
+ testData.render_passes_by_id[renderPassId] = renderPass.get();
+ testData.render_passes.insert(testData.render_passes.begin(), renderPass.PassAs<RenderPass>());
if (*currentChar)
currentChar++;
}
@@ -3840,7 +3840,7 @@
void dumpRenderPassTestData(const RenderPassRemovalTestData& testData, char* buffer)
{
char* pos = buffer;
- for (RenderPassList::const_reverse_iterator it = testData.renderPasses.rbegin(); it != testData.renderPasses.rend(); ++it) {
+ for (RenderPassList::const_reverse_iterator it = testData.render_passes.rbegin(); it != testData.render_passes.rend(); ++it) {
const RenderPass* currentPass = *it;
*pos = currentPass->id.layer_id;
pos++;
@@ -4035,7 +4035,7 @@
while (removeRenderPassesCases[testCaseIndex].name) {
RenderPassRemovalTestData testData;
configureRenderPassTestData(removeRenderPassesCases[testCaseIndex].initScript, testData, renderer.get());
- LayerTreeHostImpl::removeRenderPasses(LayerTreeHostImpl::CullRenderPassesWithCachedTextures(*renderer), testData);
+ LayerTreeHostImpl::RemoveRenderPasses(LayerTreeHostImpl::CullRenderPassesWithCachedTextures(*renderer), &testData);
verifyRenderPassTestData(removeRenderPassesCases[testCaseIndex], testData);
testCaseIndex++;
}
@@ -4052,35 +4052,35 @@
void drawFrameAndTestDamage(const gfx::RectF& expectedDamage) {
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
- ASSERT_EQ(1u, frame.renderPasses.size());
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
+ ASSERT_EQ(1u, frame.render_passes.size());
// Verify the damage rect for the root render pass.
- const RenderPass* rootRenderPass = frame.renderPasses.back();
+ const RenderPass* rootRenderPass = frame.render_passes.back();
EXPECT_RECT_EQ(expectedDamage, rootRenderPass->damage_rect);
// Verify the root layer's quad is generated and not being culled.
ASSERT_EQ(1u, rootRenderPass->quad_list.size());
- gfx::Rect expectedVisibleRect(m_hostImpl->rootLayer()->content_bounds());
+ gfx::Rect expectedVisibleRect(m_hostImpl->active_tree()->root_layer()->content_bounds());
EXPECT_RECT_EQ(expectedVisibleRect, rootRenderPass->quad_list[0]->visible_rect);
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
};
TEST_F(LayerTreeHostImplTestWithDelegatingRenderer, FrameIncludesDamageRect)
{
- scoped_ptr<SolidColorLayerImpl> root = SolidColorLayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<SolidColorLayerImpl> root = SolidColorLayerImpl::Create(m_hostImpl->active_tree(), 1);
root->SetAnchorPoint(gfx::PointF(0.f, 0.f));
root->SetPosition(gfx::PointF(0.f, 0.f));
root->SetBounds(gfx::Size(10, 10));
root->SetContentBounds(gfx::Size(10, 10));
root->SetDrawsContent(true);
- m_hostImpl->activeTree()->SetRootLayer(root.PassAs<LayerImpl>());
+ m_hostImpl->active_tree()->SetRootLayer(root.PassAs<LayerImpl>());
// Draw a frame. In the first frame, the entire viewport should be damaged.
- gfx::Rect fullFrameDamage = gfx::Rect(m_hostImpl->DeviceViewportSize());
+ gfx::Rect fullFrameDamage = gfx::Rect(m_hostImpl->device_viewport_size());
drawFrameAndTestDamage(fullFrameDamage);
// The second frame should have no damage, but the quads should still be generated.
@@ -4109,19 +4109,19 @@
// |
// +-- Content Layer
// +--Mask
- scoped_ptr<LayerImpl> scopedRoot = LayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> scopedRoot = LayerImpl::Create(m_hostImpl->active_tree(), 1);
LayerImpl* root = scopedRoot.get();
- m_hostImpl->activeTree()->SetRootLayer(scopedRoot.Pass());
+ m_hostImpl->active_tree()->SetRootLayer(scopedRoot.Pass());
- scoped_ptr<LayerImpl> scopedScalingLayer = LayerImpl::Create(m_hostImpl->activeTree(), 2);
+ scoped_ptr<LayerImpl> scopedScalingLayer = LayerImpl::Create(m_hostImpl->active_tree(), 2);
LayerImpl* scalingLayer = scopedScalingLayer.get();
root->AddChild(scopedScalingLayer.Pass());
- scoped_ptr<LayerImpl> scopedContentLayer = LayerImpl::Create(m_hostImpl->activeTree(), 3);
+ scoped_ptr<LayerImpl> scopedContentLayer = LayerImpl::Create(m_hostImpl->active_tree(), 3);
LayerImpl* contentLayer = scopedContentLayer.get();
scalingLayer->AddChild(scopedContentLayer.Pass());
- scoped_ptr<FakeMaskLayerImpl> scopedMaskLayer = FakeMaskLayerImpl::Create(m_hostImpl->activeTree(), 4);
+ scoped_ptr<FakeMaskLayerImpl> scopedMaskLayer = FakeMaskLayerImpl::Create(m_hostImpl->active_tree(), 4);
FakeMaskLayerImpl* maskLayer = scopedMaskLayer.get();
contentLayer->SetMaskLayer(scopedMaskLayer.PassAs<LayerImpl>());
@@ -4156,21 +4156,21 @@
// Check that the tree scaling is correctly taken into account for the mask,
// that should fully map onto the quad.
float deviceScaleFactor = 1.f;
- m_hostImpl->setViewportSize(rootSize, rootSize);
- m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
+ m_hostImpl->SetViewportSize(rootSize, rootSize);
+ m_hostImpl->SetDeviceScaleFactor(deviceScaleFactor);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
- ASSERT_EQ(1u, frame.renderPasses.size());
- ASSERT_EQ(1u, frame.renderPasses[0]->quad_list.size());
- ASSERT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
+ ASSERT_EQ(1u, frame.render_passes.size());
+ ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
+ ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), renderPassQuad->rect.ToString());
EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
@@ -4178,22 +4178,22 @@
// which part of the mask is used.
deviceScaleFactor = 2.f;
gfx::Size deviceViewport(gfx::ToFlooredSize(gfx::ScaleSize(rootSize, deviceScaleFactor)));
- m_hostImpl->setViewportSize(rootSize, deviceViewport);
- m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
- m_hostImpl->activeTree()->set_needs_update_draw_properties();
+ m_hostImpl->SetViewportSize(rootSize, deviceViewport);
+ m_hostImpl->SetDeviceScaleFactor(deviceScaleFactor);
+ m_hostImpl->active_tree()->set_needs_update_draw_properties();
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
- ASSERT_EQ(1u, frame.renderPasses.size());
- ASSERT_EQ(1u, frame.renderPasses[0]->quad_list.size());
- ASSERT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
+ ASSERT_EQ(1u, frame.render_passes.size());
+ ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
+ ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
EXPECT_EQ(gfx::Rect(0, 0, 200, 200).ToString(), renderPassQuad->rect.ToString());
EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
@@ -4204,20 +4204,20 @@
contentLayer->SetContentsScale(deviceScaleFactor, deviceScaleFactor);
maskLayer->SetContentBounds(contentsBounds);
maskLayer->SetContentsScale(deviceScaleFactor, deviceScaleFactor);
- m_hostImpl->activeTree()->set_needs_update_draw_properties();
+ m_hostImpl->active_tree()->set_needs_update_draw_properties();
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
- ASSERT_EQ(1u, frame.renderPasses.size());
- ASSERT_EQ(1u, frame.renderPasses[0]->quad_list.size());
- ASSERT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
+ ASSERT_EQ(1u, frame.render_passes.size());
+ ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
+ ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
EXPECT_EQ(gfx::Rect(0, 0, 200, 200).ToString(), renderPassQuad->rect.ToString());
EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
}
@@ -4225,15 +4225,15 @@
{
// The mask layer has bounds 100x100 but is attached to a layer with bounds 50x50.
- scoped_ptr<LayerImpl> scopedRoot = LayerImpl::Create(m_hostImpl->activeTree(), 1);
+ scoped_ptr<LayerImpl> scopedRoot = LayerImpl::Create(m_hostImpl->active_tree(), 1);
LayerImpl* root = scopedRoot.get();
- m_hostImpl->activeTree()->SetRootLayer(scopedRoot.Pass());
+ m_hostImpl->active_tree()->SetRootLayer(scopedRoot.Pass());
- scoped_ptr<LayerImpl> scopedContentLayer = LayerImpl::Create(m_hostImpl->activeTree(), 3);
+ scoped_ptr<LayerImpl> scopedContentLayer = LayerImpl::Create(m_hostImpl->active_tree(), 3);
LayerImpl* contentLayer = scopedContentLayer.get();
root->AddChild(scopedContentLayer.Pass());
- scoped_ptr<FakeMaskLayerImpl> scopedMaskLayer = FakeMaskLayerImpl::Create(m_hostImpl->activeTree(), 4);
+ scoped_ptr<FakeMaskLayerImpl> scopedMaskLayer = FakeMaskLayerImpl::Create(m_hostImpl->active_tree(), 4);
FakeMaskLayerImpl* maskLayer = scopedMaskLayer.get();
contentLayer->SetMaskLayer(scopedMaskLayer.PassAs<LayerImpl>());
@@ -4260,21 +4260,21 @@
// Check that the mask fills the surface.
float deviceScaleFactor = 1.f;
- m_hostImpl->setViewportSize(rootSize, rootSize);
- m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
+ m_hostImpl->SetViewportSize(rootSize, rootSize);
+ m_hostImpl->SetDeviceScaleFactor(deviceScaleFactor);
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
- ASSERT_EQ(1u, frame.renderPasses.size());
- ASSERT_EQ(1u, frame.renderPasses[0]->quad_list.size());
- ASSERT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
+ ASSERT_EQ(1u, frame.render_passes.size());
+ ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
+ ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(), renderPassQuad->rect.ToString());
EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
@@ -4282,22 +4282,22 @@
// which part of the mask is used.
deviceScaleFactor = 2.f;
gfx::Size deviceViewport(gfx::ToFlooredSize(gfx::ScaleSize(rootSize, deviceScaleFactor)));
- m_hostImpl->setViewportSize(rootSize, deviceViewport);
- m_hostImpl->setDeviceScaleFactor(deviceScaleFactor);
- m_hostImpl->activeTree()->set_needs_update_draw_properties();
+ m_hostImpl->SetViewportSize(rootSize, deviceViewport);
+ m_hostImpl->SetDeviceScaleFactor(deviceScaleFactor);
+ m_hostImpl->active_tree()->set_needs_update_draw_properties();
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
- ASSERT_EQ(1u, frame.renderPasses.size());
- ASSERT_EQ(1u, frame.renderPasses[0]->quad_list.size());
- ASSERT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
+ ASSERT_EQ(1u, frame.render_passes.size());
+ ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
+ ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), renderPassQuad->rect.ToString());
EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
@@ -4309,40 +4309,40 @@
gfx::Size maskSizeLarge(gfx::ToRoundedSize(gfx::ScaleSize(maskSize, deviceScaleFactor)));
maskLayer->SetContentBounds(maskSizeLarge);
maskLayer->SetContentsScale(deviceScaleFactor, deviceScaleFactor);
- m_hostImpl->activeTree()->set_needs_update_draw_properties();
+ m_hostImpl->active_tree()->set_needs_update_draw_properties();
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
- ASSERT_EQ(1u, frame.renderPasses.size());
- ASSERT_EQ(1u, frame.renderPasses[0]->quad_list.size());
- ASSERT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
+ ASSERT_EQ(1u, frame.render_passes.size());
+ ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
+ ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), renderPassQuad->rect.ToString());
EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
// Applying a different contents scale to the mask layer will still result
// in the mask covering the owning layer.
maskLayer->SetContentBounds(maskSize);
maskLayer->SetContentsScale(deviceScaleFactor, deviceScaleFactor);
- m_hostImpl->activeTree()->set_needs_update_draw_properties();
+ m_hostImpl->active_tree()->set_needs_update_draw_properties();
{
LayerTreeHostImpl::FrameData frame;
- EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
+ EXPECT_TRUE(m_hostImpl->PrepareToDraw(&frame));
- ASSERT_EQ(1u, frame.renderPasses.size());
- ASSERT_EQ(1u, frame.renderPasses[0]->quad_list.size());
- ASSERT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
- const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
+ ASSERT_EQ(1u, frame.render_passes.size());
+ ASSERT_EQ(1u, frame.render_passes[0]->quad_list.size());
+ ASSERT_EQ(DrawQuad::RENDER_PASS, frame.render_passes[0]->quad_list[0]->material);
+ const RenderPassDrawQuad* renderPassQuad = RenderPassDrawQuad::MaterialCast(frame.render_passes[0]->quad_list[0]);
EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(), renderPassQuad->rect.ToString());
EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(), renderPassQuad->mask_uv_rect.ToString());
- m_hostImpl->drawLayers(frame);
- m_hostImpl->didDrawAllLayers(frame);
+ m_hostImpl->DrawLayers(&frame);
+ m_hostImpl->DidDrawAllLayers(frame);
}
}
diff --git a/cc/layer_tree_host_unittest.cc b/cc/layer_tree_host_unittest.cc
index ed6c727..a1c74c2 100644
--- a/cc/layer_tree_host_unittest.cc
+++ b/cc/layer_tree_host_unittest.cc
@@ -170,7 +170,7 @@
virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
{
m_numDraws++;
- if (!impl->activeTree()->source_frame_number())
+ if (!impl->active_tree()->source_frame_number())
endTest();
}
@@ -212,9 +212,9 @@
virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
{
- if (impl->activeTree()->source_frame_number() == 0)
+ if (impl->active_tree()->source_frame_number() == 0)
postSetNeedsCommitToMainThread();
- else if (impl->activeTree()->source_frame_number() == 1)
+ else if (impl->active_tree()->source_frame_number() == 1)
endTest();
}
@@ -256,7 +256,7 @@
virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
{
- EXPECT_EQ(0, impl->activeTree()->source_frame_number());
+ EXPECT_EQ(0, impl->active_tree()->source_frame_number());
if (!m_numDraws)
postSetNeedsRedrawToMainThread(); // Redraw again to verify that the second redraw doesn't commit.
else
@@ -428,8 +428,8 @@
if (m_done)
return;
// Only the initial draw should bring us here.
- EXPECT_TRUE(impl->canDraw());
- EXPECT_EQ(0, impl->activeTree()->source_frame_number());
+ EXPECT_TRUE(impl->CanDraw());
+ EXPECT_EQ(0, impl->active_tree()->source_frame_number());
}
virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
@@ -438,7 +438,7 @@
return;
if (m_numCommits >= 1) {
// After the first commit, we should not be able to draw.
- EXPECT_FALSE(impl->canDraw());
+ EXPECT_FALSE(impl->CanDraw());
}
}
@@ -647,9 +647,9 @@
virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
{
- EXPECT_EQ(gfx::Size(20, 20), impl->layoutViewportSize());
- EXPECT_EQ(SK_ColorGRAY, impl->activeTree()->background_color());
- EXPECT_EQ(5, impl->activeTree()->page_scale_factor());
+ EXPECT_EQ(gfx::Size(20, 20), impl->layout_viewport_size());
+ EXPECT_EQ(SK_ColorGRAY, impl->active_tree()->background_color());
+ EXPECT_EQ(5, impl->active_tree()->page_scale_factor());
endTest();
}
@@ -687,9 +687,9 @@
virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
{
- impl->rootLayer()->SetScrollable(true);
- impl->rootLayer()->SetScrollOffset(gfx::Vector2d());
- impl->activeTree()->SetPageScaleFactorAndLimits(impl->activeTree()->page_scale_factor(), 0.5, 2);
+ impl->active_tree()->root_layer()->SetScrollable(true);
+ impl->active_tree()->root_layer()->SetScrollOffset(gfx::Vector2d());
+ impl->active_tree()->SetPageScaleFactorAndLimits(impl->active_tree()->page_scale_factor(), 0.5, 2);
// We request animation only once.
if (!m_animationRequested) {
@@ -707,10 +707,10 @@
virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
{
- impl->processScrollDeltas();
+ impl->ProcessScrollDeltas();
// We get one commit before the first draw, and the animation doesn't happen until the second draw.
- if (impl->activeTree()->source_frame_number() == 1) {
- EXPECT_EQ(1.25, impl->activeTree()->page_scale_factor());
+ if (impl->active_tree()->source_frame_number() == 1) {
+ EXPECT_EQ(1.25, impl->active_tree()->page_scale_factor());
endTest();
} else
postSetNeedsRedrawToMainThread();
@@ -928,19 +928,19 @@
MockLayerTreeHostImpl* mockImpl = static_cast<MockLayerTreeHostImpl*>(impl);
// Should only do one commit.
- EXPECT_EQ(0, impl->activeTree()->source_frame_number());
+ EXPECT_EQ(0, impl->active_tree()->source_frame_number());
// Device scale factor should come over to impl.
- EXPECT_NEAR(impl->deviceScaleFactor(), 1.5, 0.00001);
+ EXPECT_NEAR(impl->device_scale_factor(), 1.5, 0.00001);
// Both layers are on impl.
- ASSERT_EQ(1u, impl->rootLayer()->children().size());
+ ASSERT_EQ(1u, impl->active_tree()->root_layer()->children().size());
// Device viewport is scaled.
- EXPECT_EQ(gfx::Size(40, 40), impl->layoutViewportSize());
- EXPECT_EQ(gfx::Size(60, 60), impl->DeviceViewportSize());
+ EXPECT_EQ(gfx::Size(40, 40), impl->layout_viewport_size());
+ EXPECT_EQ(gfx::Size(60, 60), impl->device_viewport_size());
- LayerImpl* root = impl->rootLayer();
- LayerImpl* child = impl->rootLayer()->children()[0];
+ LayerImpl* root = impl->active_tree()->root_layer();
+ LayerImpl* child = impl->active_tree()->root_layer()->children()[0];
// Positions remain in layout pixels.
EXPECT_EQ(gfx::Point(0, 0), root->position());
@@ -948,11 +948,11 @@
// Compute all the layer transforms for the frame.
LayerTreeHostImpl::FrameData frameData;
- mockImpl->prepareToDraw(frameData);
- mockImpl->didDrawAllLayers(frameData);
+ mockImpl->PrepareToDraw(&frameData);
+ mockImpl->DidDrawAllLayers(frameData);
const MockLayerTreeHostImpl::LayerList& renderSurfaceLayerList =
- *frameData.renderSurfaceLayerList;
+ *frameData.render_surface_layer_list;
// Both layers should be drawing into the root render surface.
ASSERT_EQ(1u, renderSurfaceLayerList.size());
@@ -967,7 +967,7 @@
EXPECT_EQ(childBoundsScaled, child->content_bounds());
gfx::Transform scaleTransform;
- scaleTransform.Scale(impl->deviceScaleFactor(), impl->deviceScaleFactor());
+ scaleTransform.Scale(impl->device_scale_factor(), impl->device_scale_factor());
// The root layer is scaled by 2x.
gfx::Transform rootScreenSpaceTransform = scaleTransform;
@@ -1042,9 +1042,9 @@
{
ASSERT_EQ(0u, m_layerTreeHost->settings().maxPartialTextureUpdates);
- TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(impl->outputSurface()->context3d());
+ TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(impl->output_surface()->context3d());
- switch (impl->activeTree()->source_frame_number()) {
+ switch (impl->active_tree()->source_frame_number()) {
case 0:
// Number of textures should be one for each layer
ASSERT_EQ(2, context->NumTextures());
@@ -1084,7 +1084,7 @@
virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
{
- TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(impl->outputSurface()->context3d());
+ TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(impl->output_surface()->context3d());
// Number of textures used for draw should always be one for each layer.
EXPECT_EQ(2, context->NumUsedTextures());
@@ -1174,9 +1174,9 @@
{
ASSERT_EQ(1u, m_layerTreeHost->settings().maxPartialTextureUpdates);
- TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(impl->outputSurface()->context3d());
+ TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(impl->output_surface()->context3d());
- switch (impl->activeTree()->source_frame_number()) {
+ switch (impl->active_tree()->source_frame_number()) {
case 0:
// Number of textures should be one for each layer.
ASSERT_EQ(4, context->NumTextures());
@@ -1259,11 +1259,11 @@
virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
{
- TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(impl->outputSurface()->context3d());
+ TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(impl->output_surface()->context3d());
// Number of textures used for drawing should one per layer except for
// frame 3 where the viewport only contains one layer.
- if (impl->activeTree()->source_frame_number() == 3)
+ if (impl->active_tree()->source_frame_number() == 3)
EXPECT_EQ(1, context->NumUsedTextures());
else
EXPECT_EQ(4, context->NumUsedTextures());
@@ -1437,10 +1437,10 @@
virtual void drawLayersOnThread(LayerTreeHostImpl* hostImpl) OVERRIDE
{
Renderer* renderer = hostImpl->renderer();
- RenderPass::Id surface1RenderPassId = hostImpl->rootLayer()->children()[0]->render_surface()->RenderPassId();
- RenderPass::Id surface2RenderPassId = hostImpl->rootLayer()->children()[0]->children()[0]->render_surface()->RenderPassId();
+ RenderPass::Id surface1RenderPassId = hostImpl->active_tree()->root_layer()->children()[0]->render_surface()->RenderPassId();
+ RenderPass::Id surface2RenderPassId = hostImpl->active_tree()->root_layer()->children()[0]->children()[0]->render_surface()->RenderPassId();
- switch (hostImpl->activeTree()->source_frame_number()) {
+ switch (hostImpl->active_tree()->source_frame_number()) {
case 0:
EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(surface1RenderPassId));
EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(surface2RenderPassId));
@@ -2142,7 +2142,7 @@
m_layerTreeHost->contents_texture_manager()->memoryUseBytes());
// Make sure that contents textures are marked as having been
// purged.
- EXPECT_TRUE(hostImpl->activeTree()->ContentsTexturesPurged());
+ EXPECT_TRUE(hostImpl->active_tree()->ContentsTexturesPurged());
// End the test in this state.
endTest();
}
diff --git a/cc/layer_tree_host_unittest_animation.cc b/cc/layer_tree_host_unittest_animation.cc
index 6bfa36e..837e8cb1 100644
--- a/cc/layer_tree_host_unittest_animation.cc
+++ b/cc/layer_tree_host_unittest_animation.cc
@@ -185,7 +185,7 @@
virtual bool prepareToDrawOnThread(
LayerTreeHostImpl* host_impl,
- LayerTreeHostImpl::FrameData& frame,
+ LayerTreeHostImpl::FrameData* frame,
bool result) OVERRIDE {
return false;
}
@@ -271,7 +271,7 @@
EXPECT_FLOAT_EQ(linearly_interpolated_opacity, curve->GetValue(time));
LayerAnimationController* controller_impl =
- host_impl->rootLayer()->layer_animation_controller();
+ host_impl->RootLayer()->layer_animation_controller();
Animation* animation_impl =
controller_impl->GetAnimation(0, Animation::Opacity);
@@ -316,7 +316,7 @@
LayerTreeHostImpl* impl_host,
bool hasUnfinishedAnimation) OVERRIDE {
LayerAnimationController* controller =
- impl_host->rootLayer()->layer_animation_controller();
+ impl_host->RootLayer()->layer_animation_controller();
Animation* animation =
controller->GetAnimation(0, Animation::Opacity);
if (!animation)
diff --git a/cc/layer_tree_host_unittest_context.cc b/cc/layer_tree_host_unittest_context.cc
index 551dc7ca..dee96c5 100644
--- a/cc/layer_tree_host_unittest_context.cc
+++ b/cc/layer_tree_host_unittest_context.cc
@@ -148,8 +148,9 @@
return offscreen_contexts_compositor_thread_;
}
- virtual bool prepareToDrawOnThread(
- LayerTreeHostImpl*, LayerTreeHostImpl::FrameData&, bool result)
+ virtual bool prepareToDrawOnThread(LayerTreeHostImpl* host_impl,
+ LayerTreeHostImpl::FrameData* frame,
+ bool result)
OVERRIDE {
EXPECT_TRUE(result);
if (!times_to_lose_during_draw_)
@@ -423,14 +424,14 @@
virtual void drawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
FakeContentLayerImpl* content_impl = static_cast<FakeContentLayerImpl*>(
- host_impl->rootLayer()->children()[0]);
+ host_impl->active_tree()->root_layer()->children()[0]);
// Even though the context was lost, we should have a resource. The
// TestWebGraphicsContext3D ensures that this resource is created with
// the active context.
EXPECT_TRUE(content_impl->HaveResourceForTileAt(0, 0));
cc::ContextProvider* contexts =
- host_impl->resourceProvider()->offscreen_context_provider();
+ host_impl->resource_provider()->offscreen_context_provider();
if (use_surface_) {
EXPECT_TRUE(contexts->Context3d());
// TODO(danakj): Make a fake GrContext.
@@ -519,7 +520,7 @@
virtual void drawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
cc::ContextProvider* contexts =
- host_impl->resourceProvider()->offscreen_context_provider();
+ host_impl->resource_provider()->offscreen_context_provider();
EXPECT_FALSE(contexts);
endTest();
}
@@ -558,16 +559,16 @@
++num_commits_;
if (num_commits_ == 1) {
// When the context is ok, we should have these things.
- EXPECT_TRUE(host_impl->outputSurface());
+ EXPECT_TRUE(host_impl->output_surface());
EXPECT_TRUE(host_impl->renderer());
- EXPECT_TRUE(host_impl->resourceProvider());
+ EXPECT_TRUE(host_impl->resource_provider());
return;
}
// When context recreation fails we shouldn't be left with any of them.
- EXPECT_FALSE(host_impl->outputSurface());
+ EXPECT_FALSE(host_impl->output_surface());
EXPECT_FALSE(host_impl->renderer());
- EXPECT_FALSE(host_impl->resourceProvider());
+ EXPECT_FALSE(host_impl->resource_provider());
}
virtual void afterTest() OVERRIDE {}
@@ -576,42 +577,48 @@
int num_commits_;
};
-TEST_F(LayerTreeHostContextTestLostContextFails, FailReinitialize100_SingleThread) {
+TEST_F(LayerTreeHostContextTestLostContextFails,
+ FailReinitialize100_SingleThread) {
times_to_fail_reinitialize_ = 100;
times_to_fail_recreate_ = 0;
times_to_lose_on_recreate_ = 0;
runTest(false);
}
-TEST_F(LayerTreeHostContextTestLostContextFails, FailReinitialize100_MultiThread) {
+TEST_F(LayerTreeHostContextTestLostContextFails,
+ FailReinitialize100_MultiThread) {
times_to_fail_reinitialize_ = 100;
times_to_fail_recreate_ = 0;
times_to_lose_on_recreate_ = 0;
runTest(true);
}
-TEST_F(LayerTreeHostContextTestLostContextFails, FailRecreate100_SingleThread) {
+TEST_F(LayerTreeHostContextTestLostContextFails,
+ FailRecreate100_SingleThread) {
times_to_fail_reinitialize_ = 0;
times_to_fail_recreate_ = 100;
times_to_lose_on_recreate_ = 0;
runTest(false);
}
-TEST_F(LayerTreeHostContextTestLostContextFails, FailRecreate100_MultiThread) {
+TEST_F(LayerTreeHostContextTestLostContextFails,
+ FailRecreate100_MultiThread) {
times_to_fail_reinitialize_ = 0;
times_to_fail_recreate_ = 100;
times_to_lose_on_recreate_ = 0;
runTest(true);
}
-TEST_F(LayerTreeHostContextTestLostContextFails, LoseOnRecreate100_SingleThread) {
+TEST_F(LayerTreeHostContextTestLostContextFails,
+ LoseOnRecreate100_SingleThread) {
times_to_fail_reinitialize_ = 0;
times_to_fail_recreate_ = 0;
times_to_lose_on_recreate_ = 100;
runTest(false);
}
-TEST_F(LayerTreeHostContextTestLostContextFails, LoseOnRecreate100_MultiThread) {
+TEST_F(LayerTreeHostContextTestLostContextFails,
+ LoseOnRecreate100_MultiThread) {
times_to_fail_reinitialize_ = 0;
times_to_fail_recreate_ = 0;
times_to_lose_on_recreate_ = 100;
@@ -824,7 +831,7 @@
LayerTreeHostContextTest::commitCompleteOnThread(host_impl);
FakeContentLayerImpl* root = static_cast<FakeContentLayerImpl*>(
- host_impl->rootLayer());
+ host_impl->active_tree()->root_layer());
FakeContentLayerImpl* child = static_cast<FakeContentLayerImpl*>(
root->children()[0]);
FakeContentLayerImpl* grandchild = static_cast<FakeContentLayerImpl*>(
@@ -982,9 +989,9 @@
virtual void commitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
LayerTreeHostContextTest::commitCompleteOnThread(host_impl);
- ResourceProvider* resource_provider = host_impl->resourceProvider();
+ ResourceProvider* resource_provider = host_impl->resource_provider();
- if (host_impl->activeTree()->source_frame_number() == 0) {
+ if (host_impl->active_tree()->source_frame_number() == 0) {
// Set up impl resources on the first commit.
scoped_ptr<TestRenderPass> pass_for_quad = TestRenderPass::Create();
@@ -1010,7 +1017,7 @@
// First child is the delegated layer.
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(
- host_impl->rootLayer()->children()[0]);
+ host_impl->active_tree()->root_layer()->children()[0]);
delegated_impl->SetFrameDataForRenderPasses(&pass_list);
EXPECT_TRUE(pass_list.empty());
@@ -1037,7 +1044,7 @@
return;
}
- if (host_impl->activeTree()->source_frame_number() == 3) {
+ if (host_impl->active_tree()->source_frame_number() == 3) {
// On the third commit we're recovering from context loss. Hardware
// video frames should not be reused by the VideoFrameProvider, but
// software frames can be.
@@ -1048,9 +1055,9 @@
virtual bool prepareToDrawOnThread(
LayerTreeHostImpl* host_impl,
- LayerTreeHostImpl::FrameData& frame,
+ LayerTreeHostImpl::FrameData* frame,
bool result) OVERRIDE {
- if (host_impl->activeTree()->source_frame_number() == 2) {
+ if (host_impl->active_tree()->source_frame_number() == 2) {
// Lose the context during draw on the second commit. This will cause
// a third commit to recover.
if (context3d_)
diff --git a/cc/layer_tree_host_unittest_delegated.cc b/cc/layer_tree_host_unittest_delegated.cc
index e856e6d3f..ecec114 100644
--- a/cc/layer_tree_host_unittest_delegated.cc
+++ b/cc/layer_tree_host_unittest_delegated.cc
@@ -110,7 +110,7 @@
}
virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+ LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
@@ -120,7 +120,7 @@
EXPECT_TRUE(delegated_impl->ChildId());
EXPECT_FALSE(did_reset_child_id_);
- host_impl->resourceProvider()->GraphicsContext3D()->loseContextCHROMIUM(
+ host_impl->resource_provider()->GraphicsContext3D()->loseContextCHROMIUM(
GL_GUILTY_CONTEXT_RESET_ARB, GL_INNOCENT_CONTEXT_RESET_ARB);
break;
case 3:
@@ -138,7 +138,7 @@
if (num_activates_ < 2)
return;
- LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+ LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
@@ -242,16 +242,16 @@
}
virtual bool prepareToDrawOnThread(LayerTreeHostImpl* host_impl,
- LayerTreeHostImpl::FrameData& frame,
+ LayerTreeHostImpl::FrameData* frame,
bool result) {
EXPECT_TRUE(result);
if (!first_draw_for_source_frame_)
return result;
- gfx::RectF damage_rect = frame.renderPasses.back()->damage_rect;
+ gfx::RectF damage_rect = frame->render_passes.back()->damage_rect;
- switch (host_impl->activeTree()->source_frame_number()) {
+ switch (host_impl->active_tree()->source_frame_number()) {
case 0:
// Before the layer has a frame to display it should not
// be visible at all, and not damage anything.
@@ -351,12 +351,12 @@
}
virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+ LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
const ResourceProvider::ResourceIdMap& map =
- host_impl->resourceProvider()->GetChildToParentMap(
+ host_impl->resource_provider()->GetChildToParentMap(
delegated_impl->ChildId());
// Both frames' resources should be in the parent's resource provider.
@@ -393,12 +393,12 @@
}
virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+ LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
const ResourceProvider::ResourceIdMap& map =
- host_impl->resourceProvider()->GetChildToParentMap(
+ host_impl->resource_provider()->GetChildToParentMap(
delegated_impl->ChildId());
// The frame's resource should be in the parent's resource provider.
@@ -619,15 +619,15 @@
}
virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- if (host_impl->activeTree()->source_frame_number() != 3)
+ if (host_impl->active_tree()->source_frame_number() != 3)
return;
- LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+ LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
const ResourceProvider::ResourceIdMap& map =
- host_impl->resourceProvider()->GetChildToParentMap(
+ host_impl->resource_provider()->GetChildToParentMap(
delegated_impl->ChildId());
// The bad frame should be dropped. So we should only have one quad (the
@@ -716,15 +716,15 @@
}
virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- if (host_impl->activeTree()->source_frame_number() != 3)
+ if (host_impl->active_tree()->source_frame_number() != 3)
return;
- LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+ LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
const ResourceProvider::ResourceIdMap& map =
- host_impl->resourceProvider()->GetChildToParentMap(
+ host_impl->resource_provider()->GetChildToParentMap(
delegated_impl->ChildId());
// The third frame has all of the resources in it again, the delegated
@@ -822,18 +822,18 @@
}
virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- if (host_impl->activeTree()->source_frame_number() < 1)
+ if (host_impl->active_tree()->source_frame_number() < 1)
return;
- LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+ LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
const ResourceProvider::ResourceIdMap& map =
- host_impl->resourceProvider()->GetChildToParentMap(
+ host_impl->resource_provider()->GetChildToParentMap(
delegated_impl->ChildId());
- switch (host_impl->activeTree()->source_frame_number()) {
+ switch (host_impl->active_tree()->source_frame_number()) {
case 1: {
// We have the first good frame with just 990 and 555 in it.
// layer.
@@ -933,15 +933,15 @@
}
virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- if (host_impl->activeTree()->source_frame_number() != 1)
+ if (host_impl->active_tree()->source_frame_number() != 1)
return;
- LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+ LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
const ResourceProvider::ResourceIdMap& map =
- host_impl->resourceProvider()->GetChildToParentMap(
+ host_impl->resource_provider()->GetChildToParentMap(
delegated_impl->ChildId());
// The layer only held on to the resource that was used.
@@ -996,15 +996,15 @@
}
virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- if (host_impl->activeTree()->source_frame_number() != 1)
+ if (host_impl->active_tree()->source_frame_number() != 1)
return;
- LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+ LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
const ResourceProvider::ResourceIdMap& map =
- host_impl->resourceProvider()->GetChildToParentMap(
+ host_impl->resource_provider()->GetChildToParentMap(
delegated_impl->ChildId());
// The layer only held on to the resource that was used.
@@ -1073,18 +1073,18 @@
}
virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- if (host_impl->activeTree()->source_frame_number() < 1)
+ if (host_impl->active_tree()->source_frame_number() < 1)
return;
- LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+ LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
const ResourceProvider::ResourceIdMap& map =
- host_impl->resourceProvider()->GetChildToParentMap(
+ host_impl->resource_provider()->GetChildToParentMap(
delegated_impl->ChildId());
- switch (host_impl->activeTree()->source_frame_number()) {
+ switch (host_impl->active_tree()->source_frame_number()) {
case 1: {
EXPECT_EQ(2u, map.size());
EXPECT_EQ(1u, map.count(999));
@@ -1098,7 +1098,7 @@
ResourceProvider::ResourceIdArray resources_for_parent;
resources_for_parent.push_back(map.find(999)->second);
TransferableResourceArray transferable_resources;
- host_impl->resourceProvider()->PrepareSendToParent(
+ host_impl->resource_provider()->PrepareSendToParent(
resources_for_parent, &transferable_resources);
break;
}
@@ -1116,7 +1116,7 @@
resource.id = map.find(999)->second;
TransferableResourceArray transferable_resources;
transferable_resources.push_back(resource);
- host_impl->resourceProvider()->ReceiveFromParent(
+ host_impl->resource_provider()->ReceiveFromParent(
transferable_resources);
break;
}
@@ -1188,18 +1188,18 @@
}
virtual void treeActivatedOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- if (host_impl->activeTree()->source_frame_number() < 1)
+ if (host_impl->active_tree()->source_frame_number() < 1)
return;
- LayerImpl* root_impl = host_impl->activeTree()->RootLayer();
+ LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
const ResourceProvider::ResourceIdMap& map =
- host_impl->resourceProvider()->GetChildToParentMap(
+ host_impl->resource_provider()->GetChildToParentMap(
delegated_impl->ChildId());
- switch (host_impl->activeTree()->source_frame_number()) {
+ switch (host_impl->active_tree()->source_frame_number()) {
case 1:
EXPECT_EQ(3u, map.size());
EXPECT_EQ(1u, map.count(999));
diff --git a/cc/layer_tree_host_unittest_scroll.cc b/cc/layer_tree_host_unittest_scroll.cc
index 28fd4fb..896e646 100644
--- a/cc/layer_tree_host_unittest_scroll.cc
+++ b/cc/layer_tree_host_unittest_scroll.cc
@@ -49,14 +49,14 @@
}
virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
- LayerImpl* root = impl->rootLayer();
+ LayerImpl* root = impl->active_tree()->root_layer();
EXPECT_VECTOR_EQ(gfx::Vector2d(), root->scroll_delta());
root->SetScrollable(true);
root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
root->ScrollBy(scroll_amount_);
- switch (impl->activeTree()->source_frame_number()) {
+ switch (impl->active_tree()->source_frame_number()) {
case 0:
EXPECT_VECTOR_EQ(initial_scroll_, root->scroll_offset());
EXPECT_VECTOR_EQ(scroll_amount_, root->scroll_delta());
@@ -124,12 +124,12 @@
}
virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
- LayerImpl* root = impl->rootLayer();
+ LayerImpl* root = impl->active_tree()->root_layer();
root->SetScrollable(true);
root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
- if (impl->activeTree()->source_frame_number() == 0 &&
- impl->sourceAnimationFrameNumber() == 1) {
+ if (impl->active_tree()->source_frame_number() == 0 &&
+ impl->SourceAnimationFrameNumber() == 1) {
// First draw after first commit.
EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d());
root->ScrollBy(scroll_amount_);
@@ -137,8 +137,8 @@
EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
postSetNeedsRedrawToMainThread();
- } else if (impl->activeTree()->source_frame_number() == 0 &&
- impl->sourceAnimationFrameNumber() == 2) {
+ } else if (impl->active_tree()->source_frame_number() == 0 &&
+ impl->SourceAnimationFrameNumber() == 2) {
// Second draw after first commit.
EXPECT_EQ(root->scroll_delta(), scroll_amount_);
root->ScrollBy(scroll_amount_);
@@ -146,9 +146,9 @@
EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
postSetNeedsCommitToMainThread();
- } else if (impl->activeTree()->source_frame_number() == 1) {
+ } else if (impl->active_tree()->source_frame_number() == 1) {
// Third or later draw after second commit.
- EXPECT_GE(impl->sourceAnimationFrameNumber(), 3);
+ EXPECT_GE(impl->SourceAnimationFrameNumber(), 3);
EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d());
EXPECT_VECTOR_EQ(
root->scroll_offset(),
@@ -187,12 +187,12 @@
}
virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
- LayerImpl* root = impl->rootLayer();
+ LayerImpl* root = impl->active_tree()->root_layer();
root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
// Check that a fractional scroll delta is correctly accumulated over
// multiple commits.
- switch (impl->activeTree()->source_frame_number()) {
+ switch (impl->active_tree()->source_frame_number()) {
case 0:
EXPECT_VECTOR_EQ(root->scroll_offset(), gfx::Vector2d(0, 0));
EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d(0, 0));
@@ -336,7 +336,7 @@
}
virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
- LayerImpl* root_impl = impl->rootLayer();
+ LayerImpl* root_impl = impl->active_tree()->root_layer();
LayerImpl* root_scroll_layer_impl = root_impl->children()[0];
LayerImpl* child_layer_impl = root_scroll_layer_impl->children()[0];
@@ -366,17 +366,17 @@
gfx::ScaleSize(child_layer_impl->bounds(), device_scale_factor_));
EXPECT_SIZE_EQ(expected_content_bounds, child_layer_->content_bounds());
- switch (impl->activeTree()->source_frame_number()) {
+ switch (impl->active_tree()->source_frame_number()) {
case 0: {
// Gesture scroll on impl thread.
- InputHandlerClient::ScrollStatus status = impl->scrollBegin(
+ InputHandlerClient::ScrollStatus status = impl->ScrollBegin(
gfx::ToCeiledPoint(
expected_scroll_layer_impl->position() +
gfx::Vector2dF(0.5f, 0.5f)),
InputHandlerClient::Gesture);
EXPECT_EQ(InputHandlerClient::ScrollStarted, status);
- impl->scrollBy(gfx::Point(), scroll_amount_);
- impl->scrollEnd();
+ impl->ScrollBy(gfx::Point(), scroll_amount_);
+ impl->ScrollEnd();
// Check the scroll is applied as a delta.
EXPECT_VECTOR_EQ(
@@ -389,14 +389,14 @@
}
case 1: {
// Wheel scroll on impl thread.
- InputHandlerClient::ScrollStatus status = impl->scrollBegin(
+ InputHandlerClient::ScrollStatus status = impl->ScrollBegin(
gfx::ToCeiledPoint(
expected_scroll_layer_impl->position() +
gfx::Vector2dF(0.5f, 0.5f)),
InputHandlerClient::Wheel);
EXPECT_EQ(InputHandlerClient::ScrollStarted, status);
- impl->scrollBy(gfx::Point(), scroll_amount_);
- impl->scrollEnd();
+ impl->ScrollBy(gfx::Point(), scroll_amount_);
+ impl->ScrollEnd();
// Check the scroll is applied as a delta.
EXPECT_VECTOR_EQ(
@@ -498,7 +498,7 @@
virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
// Manual vsync tick.
- if (impl->pendingTree())
+ if (impl->pending_tree())
impl->setNeedsRedraw();
}
};
@@ -540,23 +540,23 @@
virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
// We force a second draw here of the first commit before activating
// the second commit.
- if (impl->activeTree()->source_frame_number() == 0)
+ if (impl->active_tree()->source_frame_number() == 0)
impl->setNeedsRedraw();
}
virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
ImplSidePaintingScrollTest::drawLayersOnThread(impl);
- LayerImpl* root = impl->rootLayer();
+ LayerImpl* root = impl->active_tree()->root_layer();
root->SetScrollable(true);
root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
LayerImpl* pending_root =
- impl->activeTree()->FindPendingTreeLayerById(root->id());
+ impl->active_tree()->FindPendingTreeLayerById(root->id());
- switch (impl->activeTree()->source_frame_number()) {
+ switch (impl->active_tree()->source_frame_number()) {
case 0:
- if (!impl->pendingTree()) {
+ if (!impl->pending_tree()) {
can_activate_ = false;
EXPECT_VECTOR_EQ(root->scroll_delta(), gfx::Vector2d());
root->ScrollBy(impl_thread_scroll1_);
@@ -571,7 +571,7 @@
} else {
can_activate_ = true;
ASSERT_TRUE(pending_root);
- EXPECT_EQ(impl->pendingTree()->source_frame_number(), 1);
+ EXPECT_EQ(impl->pending_tree()->source_frame_number(), 1);
root->ScrollBy(impl_thread_scroll2_);
EXPECT_VECTOR_EQ(root->scroll_offset(), initial_scroll_);
@@ -586,7 +586,7 @@
}
break;
case 1:
- EXPECT_FALSE(impl->pendingTree());
+ EXPECT_FALSE(impl->pending_tree());
EXPECT_VECTOR_EQ(root->scroll_offset(),
initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
EXPECT_VECTOR_EQ(root->scroll_delta(), impl_thread_scroll2_);
@@ -628,7 +628,7 @@
}
virtual void drawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
- LayerImpl* root = impl->rootLayer();
+ LayerImpl* root = impl->active_tree()->root_layer();
root->SetScrollable(true);
root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
diff --git a/cc/layer_tree_impl.cc b/cc/layer_tree_impl.cc
index 8840c190..5e8aa5b 100644
--- a/cc/layer_tree_impl.cc
+++ b/cc/layer_tree_impl.cc
@@ -60,7 +60,7 @@
root_scroll_layer_ = NULL;
currently_scrolling_layer_ = NULL;
- layer_tree_host_impl_->OnCanDrawStateChangedForTree(this);
+ layer_tree_host_impl_->OnCanDrawStateChangedForTree();
}
void LayerTreeImpl::FindRootScrollLayer() {
@@ -113,7 +113,7 @@
if (hud_layer())
target_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(
LayerTreeHostCommon::findLayerInSubtree(
- target_tree->RootLayer(), hud_layer()->id())));
+ target_tree->root_layer(), hud_layer()->id())));
else
target_tree->set_hud_layer(NULL);
}
@@ -159,7 +159,7 @@
page_scale_delta_ = delta;
if (IsActiveTree()) {
- LayerTreeImpl* pending_tree = layer_tree_host_impl_->pendingTree();
+ LayerTreeImpl* pending_tree = layer_tree_host_impl_->pending_tree();
if (pending_tree) {
DCHECK_EQ(1, pending_tree->sent_page_scale_delta());
pending_tree->SetPageScaleDelta(page_scale_delta_ / sent_page_scale_delta_);
@@ -217,9 +217,9 @@
void LayerTreeImpl::UpdateDrawProperties(UpdateDrawPropertiesReason reason) {
if (!needs_update_draw_properties_) {
- if (reason == UPDATE_ACTIVE_TREE_FOR_DRAW && RootLayer())
+ if (reason == UPDATE_ACTIVE_TREE_FOR_DRAW && root_layer())
LayerTreeHostCommon::callFunctionForSubtree<UpdateTilePrioritiesForLayer>(
- RootLayer());
+ root_layer());
return;
}
@@ -230,7 +230,7 @@
if (!layer_tree_host_impl_->renderer())
return;
- if (!RootLayer())
+ if (!root_layer())
return;
if (root_scroll_layer_) {
@@ -240,12 +240,15 @@
}
{
- TRACE_EVENT1("cc", "LayerTreeImpl::UpdateDrawProperties", "IsActive", IsActiveTree());
+ TRACE_EVENT1("cc",
+ "LayerTreeImpl::UpdateDrawProperties",
+ "IsActive",
+ IsActiveTree());
bool update_tile_priorities =
reason == UPDATE_PENDING_TREE ||
reason == UPDATE_ACTIVE_TREE_FOR_DRAW;
LayerTreeHostCommon::calculateDrawProperties(
- RootLayer(),
+ root_layer(),
device_viewport_size(),
device_scale_factor(),
total_page_scale_factor(),
@@ -268,7 +271,7 @@
}
void LayerTreeImpl::ClearRenderSurfaces() {
- ClearRenderSurfacesOnLayerImplRecursive(RootLayer());
+ ClearRenderSurfacesOnLayerImplRecursive(root_layer());
render_surface_layer_list_.clear();
set_needs_update_draw_properties();
}
@@ -320,7 +323,7 @@
void LayerTreeImpl::PushPersistedState(LayerTreeImpl* pendingTree) {
int id = currently_scrolling_layer_ ? currently_scrolling_layer_->id() : 0;
pendingTree->set_currently_scrolling_layer(
- LayerTreeHostCommon::findLayerInSubtree(pendingTree->RootLayer(), id));
+ LayerTreeHostCommon::findLayerInSubtree(pendingTree->root_layer(), id));
}
static void DidBecomeActiveRecursive(LayerImpl* layer) {
@@ -330,8 +333,8 @@
}
void LayerTreeImpl::DidBecomeActive() {
- if (RootLayer())
- DidBecomeActiveRecursive(RootLayer());
+ if (root_layer())
+ DidBecomeActiveRecursive(root_layer());
FindRootScrollLayer();
UpdateMaxScrollOffset();
}
@@ -342,12 +345,12 @@
void LayerTreeImpl::SetContentsTexturesPurged() {
contents_textures_purged_ = true;
- layer_tree_host_impl_->OnCanDrawStateChangedForTree(this);
+ layer_tree_host_impl_->OnCanDrawStateChangedForTree();
}
void LayerTreeImpl::ResetContentsTexturesPurged() {
contents_textures_purged_ = false;
- layer_tree_host_impl_->OnCanDrawStateChangedForTree(this);
+ layer_tree_host_impl_->OnCanDrawStateChangedForTree();
}
bool LayerTreeImpl::ViewportSizeInvalid() const {
@@ -356,12 +359,12 @@
void LayerTreeImpl::SetViewportSizeInvalid() {
viewport_size_invalid_ = true;
- layer_tree_host_impl_->OnCanDrawStateChangedForTree(this);
+ layer_tree_host_impl_->OnCanDrawStateChangedForTree();
}
void LayerTreeImpl::ResetViewportSizeInvalid() {
viewport_size_invalid_ = false;
- layer_tree_host_impl_->OnCanDrawStateChangedForTree(this);
+ layer_tree_host_impl_->OnCanDrawStateChangedForTree();
}
Proxy* LayerTreeImpl::proxy() const {
@@ -369,73 +372,73 @@
}
const LayerTreeSettings& LayerTreeImpl::settings() const {
- return layer_tree_host_impl_->Settings();
+ return layer_tree_host_impl_->settings();
}
const RendererCapabilities& LayerTreeImpl::rendererCapabilities() const {
- return layer_tree_host_impl_->rendererCapabilities();
+ return layer_tree_host_impl_->GetRendererCapabilities();
}
OutputSurface* LayerTreeImpl::output_surface() const {
- return layer_tree_host_impl_->outputSurface();
+ return layer_tree_host_impl_->output_surface();
}
ResourceProvider* LayerTreeImpl::resource_provider() const {
- return layer_tree_host_impl_->resourceProvider();
+ return layer_tree_host_impl_->resource_provider();
}
TileManager* LayerTreeImpl::tile_manager() const {
- return layer_tree_host_impl_->tileManager();
+ return layer_tree_host_impl_->tile_manager();
}
FrameRateCounter* LayerTreeImpl::frame_rate_counter() const {
- return layer_tree_host_impl_->fpsCounter();
+ return layer_tree_host_impl_->fps_counter();
}
PaintTimeCounter* LayerTreeImpl::paint_time_counter() const {
- return layer_tree_host_impl_->paintTimeCounter();
+ return layer_tree_host_impl_->paint_time_counter();
}
MemoryHistory* LayerTreeImpl::memory_history() const {
- return layer_tree_host_impl_->memoryHistory();
+ return layer_tree_host_impl_->memory_history();
}
bool LayerTreeImpl::IsActiveTree() const {
- return layer_tree_host_impl_->activeTree() == this;
+ return layer_tree_host_impl_->active_tree() == this;
}
bool LayerTreeImpl::IsPendingTree() const {
- return layer_tree_host_impl_->pendingTree() == this;
+ return layer_tree_host_impl_->pending_tree() == this;
}
bool LayerTreeImpl::IsRecycleTree() const {
- return layer_tree_host_impl_->recycleTree() == this;
+ return layer_tree_host_impl_->recycle_tree() == this;
}
LayerImpl* LayerTreeImpl::FindActiveTreeLayerById(int id) {
- LayerTreeImpl* tree = layer_tree_host_impl_->activeTree();
+ LayerTreeImpl* tree = layer_tree_host_impl_->active_tree();
if (!tree)
return NULL;
return tree->LayerById(id);
}
LayerImpl* LayerTreeImpl::FindPendingTreeLayerById(int id) {
- LayerTreeImpl* tree = layer_tree_host_impl_->pendingTree();
+ LayerTreeImpl* tree = layer_tree_host_impl_->pending_tree();
if (!tree)
return NULL;
return tree->LayerById(id);
}
int LayerTreeImpl::MaxTextureSize() const {
- return layer_tree_host_impl_->rendererCapabilities().max_texture_size;
+ return layer_tree_host_impl_->GetRendererCapabilities().max_texture_size;
}
bool LayerTreeImpl::PinchGestureActive() const {
- return layer_tree_host_impl_->pinchGestureActive();
+ return layer_tree_host_impl_->pinch_gesture_active();
}
base::TimeTicks LayerTreeImpl::CurrentFrameTime() const {
- return layer_tree_host_impl_->currentFrameTime();
+ return layer_tree_host_impl_->CurrentFrameTime();
}
void LayerTreeImpl::SetNeedsRedraw() {
@@ -443,31 +446,31 @@
}
const LayerTreeDebugState& LayerTreeImpl::debug_state() const {
- return layer_tree_host_impl_->debugState();
+ return layer_tree_host_impl_->debug_state();
}
float LayerTreeImpl::device_scale_factor() const {
- return layer_tree_host_impl_->deviceScaleFactor();
+ return layer_tree_host_impl_->device_scale_factor();
}
gfx::Size LayerTreeImpl::device_viewport_size() const {
- return layer_tree_host_impl_->DeviceViewportSize();
+ return layer_tree_host_impl_->device_viewport_size();
}
-const gfx::Size& LayerTreeImpl::layout_viewport_size() const {
- return layer_tree_host_impl_->layoutViewportSize();
+gfx::Size LayerTreeImpl::layout_viewport_size() const {
+ return layer_tree_host_impl_->layout_viewport_size();
}
std::string LayerTreeImpl::layer_tree_as_text() const {
- return layer_tree_host_impl_->layerTreeAsText();
+ return layer_tree_host_impl_->LayerTreeAsText();
}
DebugRectHistory* LayerTreeImpl::debug_rect_history() const {
- return layer_tree_host_impl_->debugRectHistory();
+ return layer_tree_host_impl_->debug_rect_history();
}
AnimationRegistrar* LayerTreeImpl::animationRegistrar() const {
- return layer_tree_host_impl_->animationRegistrar();
+ return layer_tree_host_impl_->animation_registrar();
}
scoped_ptr<base::Value> LayerTreeImpl::AsValue() const {
diff --git a/cc/layer_tree_impl.h b/cc/layer_tree_impl.h
index 9c752b8..189434d 100644
--- a/cc/layer_tree_impl.h
+++ b/cc/layer_tree_impl.h
@@ -75,14 +75,14 @@
const LayerTreeDebugState& debug_state() const;
float device_scale_factor() const;
gfx::Size device_viewport_size() const;
- const gfx::Size& layout_viewport_size() const;
+ gfx::Size layout_viewport_size() const;
std::string layer_tree_as_text() const;
DebugRectHistory* debug_rect_history() const;
scoped_ptr<base::Value> AsValue() const;
// Other public methods
// ---------------------------------------------------------------------------
- LayerImpl* RootLayer() const { return root_layer_.get(); }
+ LayerImpl* root_layer() const { return root_layer_.get(); }
void SetRootLayer(scoped_ptr<LayerImpl>);
scoped_ptr<LayerImpl> DetachLayerTree();
diff --git a/cc/layer_unittest.cc b/cc/layer_unittest.cc
index c62ad09..5b61332 100644
--- a/cc/layer_unittest.cc
+++ b/cc/layer_unittest.cc
@@ -596,7 +596,7 @@
TEST_F(LayerTest, verifyPushPropertiesAccumulatesUpdateRect)
{
scoped_refptr<Layer> testLayer = Layer::Create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.active_tree(), 1);
testLayer->SetNeedsDisplayRect(gfx::RectF(gfx::PointF(), gfx::SizeF(5, 5)));
testLayer->PushPropertiesTo(implLayer.get());
@@ -617,7 +617,7 @@
TEST_F(LayerTest, verifyPushPropertiesCausesSurfacePropertyChangedForTransform)
{
scoped_refptr<Layer> testLayer = Layer::Create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.active_tree(), 1);
gfx::Transform transform;
transform.Rotate(45.0);
@@ -633,7 +633,7 @@
TEST_F(LayerTest, verifyPushPropertiesCausesSurfacePropertyChangedForOpacity)
{
scoped_refptr<Layer> testLayer = Layer::Create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.active_tree(), 1);
testLayer->SetOpacity(0.5);
@@ -647,7 +647,7 @@
TEST_F(LayerTest, verifyPushPropertiesDoesNotCauseSurfacePropertyChangedDuringImplOnlyTransformAnimation)
{
scoped_refptr<Layer> testLayer = Layer::Create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.active_tree(), 1);
scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::create();
implLayer->layer_animation_controller()->SetAnimationRegistrar(registrar.get());
@@ -676,7 +676,7 @@
TEST_F(LayerTest, verifyPushPropertiesDoesNotCauseSurfacePropertyChangedDuringImplOnlyOpacityAnimation)
{
scoped_refptr<Layer> testLayer = Layer::Create();
- scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> implLayer = LayerImpl::Create(m_hostImpl.active_tree(), 1);
scoped_ptr<AnimationRegistrar> registrar = AnimationRegistrar::create();
implLayer->layer_animation_controller()->SetAnimationRegistrar(registrar.get());
diff --git a/cc/nine_patch_layer_impl_unittest.cc b/cc/nine_patch_layer_impl_unittest.cc
index 19f7d0d8..faaf705c 100644
--- a/cc/nine_patch_layer_impl_unittest.cc
+++ b/cc/nine_patch_layer_impl_unittest.cc
@@ -41,7 +41,7 @@
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<NinePatchLayerImpl> layer = NinePatchLayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<NinePatchLayerImpl> layer = NinePatchLayerImpl::Create(hostImpl.active_tree(), 1);
layer->draw_properties().visible_content_rect = visibleContentRect;
layer->SetBounds(layerSize);
layer->SetContentBounds(layerSize);
@@ -102,7 +102,7 @@
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<NinePatchLayerImpl> layer = NinePatchLayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<NinePatchLayerImpl> layer = NinePatchLayerImpl::Create(hostImpl.active_tree(), 1);
layer->draw_properties().visible_content_rect = visibleContentRect;
layer->SetBounds(layerSize);
layer->SetContentBounds(layerSize);
diff --git a/cc/occlusion_tracker_unittest.cc b/cc/occlusion_tracker_unittest.cc
index 5f830ec..d779370 100644
--- a/cc/occlusion_tracker_unittest.cc
+++ b/cc/occlusion_tracker_unittest.cc
@@ -407,13 +407,13 @@
template<>
LayerTreeHost* OcclusionTrackerTest<OcclusionTrackerTestMainThreadTypes>::getHost()
{
- return 0;
+ return NULL;
}
template<>
LayerTreeImpl* OcclusionTrackerTest<OcclusionTrackerTestImplThreadTypes>::getHost()
{
- return m_hostImpl.activeTree();
+ return m_hostImpl.active_tree();
}
#define RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \
diff --git a/cc/overdraw_metrics.cc b/cc/overdraw_metrics.cc
index f28258b..3b0244f 100644
--- a/cc/overdraw_metrics.cc
+++ b/cc/overdraw_metrics.cc
@@ -151,7 +151,7 @@
return host->device_viewport_size();
}
static gfx::Size DeviceViewportSize(const LayerTreeHostImpl* host_impl) {
- return host_impl->DeviceViewportSize();
+ return host_impl->device_viewport_size();
}
template <typename LayerTreeHostType>
diff --git a/cc/picture_layer_impl_unittest.cc b/cc/picture_layer_impl_unittest.cc
index 4de1022..823a7c9 100644
--- a/cc/picture_layer_impl_unittest.cc
+++ b/cc/picture_layer_impl_unittest.cc
@@ -149,7 +149,7 @@
PictureLayerImplTest()
: host_impl_(ImplSidePaintingSettings(), &proxy_),
id_(7) {
- host_impl_.initializeRenderer(createFakeOutputSurface());
+ host_impl_.InitializeRenderer(createFakeOutputSurface());
}
virtual ~PictureLayerImplTest() {
@@ -159,14 +159,14 @@
scoped_refptr<PicturePileImpl> pending_pile,
scoped_refptr<PicturePileImpl> active_pile) {
SetupPendingTree(active_pile);
- host_impl_.activatePendingTree();
+ host_impl_.ActivatePendingTree();
active_layer_ = static_cast<TestablePictureLayerImpl*>(
- host_impl_.activeTree()->LayerById(id_));
+ host_impl_.active_tree()->LayerById(id_));
SetupPendingTree(pending_pile);
pending_layer_ = static_cast<TestablePictureLayerImpl*>(
- host_impl_.pendingTree()->LayerById(id_));
+ host_impl_.pending_tree()->LayerById(id_));
}
void AddDefaultTilingsWithInvalidation(const Region& invalidation) {
@@ -179,8 +179,8 @@
void SetupPendingTree(
scoped_refptr<PicturePileImpl> pile) {
- host_impl_.createPendingTree();
- LayerTreeImpl* pending_tree = host_impl_.pendingTree();
+ host_impl_.CreatePendingTree();
+ LayerTreeImpl* pending_tree = host_impl_.pending_tree();
// Clear recycled tree.
pending_tree->DetachLayerTree();
@@ -229,7 +229,7 @@
SetupTrees(pending_pile, active_pile);
- host_impl_.activeTree()->SetPageScaleFactorAndLimits(1.f, 1.f, 1.f);
+ host_impl_.active_tree()->SetPageScaleFactorAndLimits(1.f, 1.f, 1.f);
float result_scale_x, result_scale_y;
gfx::Size result_bounds;
active_layer_->CalculateContentsScale(
@@ -284,12 +284,12 @@
};
TEST_F(PictureLayerImplTest, tileGridAlignment) {
- host_impl_.setDeviceScaleFactor(1.f);
+ host_impl_.SetDeviceScaleFactor(1.f);
TestTileGridAlignmentCommon();
}
TEST_F(PictureLayerImplTest, tileGridAlignmentHiDPI) {
- host_impl_.setDeviceScaleFactor(2.f);
+ host_impl_.SetDeviceScaleFactor(2.f);
TestTileGridAlignmentCommon();
}
@@ -489,8 +489,8 @@
SetupTrees(pending_pile, active_pile);
// These are included in the scale given to the layer.
- host_impl_.setDeviceScaleFactor(1.f);
- host_impl_.pendingTree()->SetPageScaleFactorAndLimits(1.f, 1.f, 1.f);
+ host_impl_.SetDeviceScaleFactor(1.f);
+ host_impl_.pending_tree()->SetPageScaleFactorAndLimits(1.f, 1.f, 1.f);
pending_layer_->CalculateContentsScale(
1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
@@ -513,12 +513,12 @@
SetupTrees(pending_pile, active_pile);
EXPECT_EQ(0u, pending_layer_->tilings().num_tilings());
- float low_res_factor = host_impl_.Settings().lowResContentsScaleFactor;
+ float low_res_factor = host_impl_.settings().lowResContentsScaleFactor;
EXPECT_LT(low_res_factor, 1.f);
// These are included in the scale given to the layer.
- host_impl_.setDeviceScaleFactor(1.7f);
- host_impl_.pendingTree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
+ host_impl_.SetDeviceScaleFactor(1.7f);
+ host_impl_.pending_tree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
pending_layer_->CalculateContentsScale(
1.3f, false, &result_scale_x, &result_scale_y, &result_bounds);
@@ -543,7 +543,7 @@
pending_layer_->tilings().tiling_at(1)->contents_scale());
// If we change the page scale factor, then we should get new tilings.
- host_impl_.pendingTree()->SetPageScaleFactorAndLimits(2.2f, 2.2f, 2.2f);
+ host_impl_.pending_tree()->SetPageScaleFactorAndLimits(2.2f, 2.2f, 2.2f);
pending_layer_->CalculateContentsScale(
1.8f, false, &result_scale_x, &result_scale_y, &result_bounds);
@@ -556,7 +556,7 @@
pending_layer_->tilings().tiling_at(2)->contents_scale());
// If we change the device scale factor, then we should get new tilings.
- host_impl_.setDeviceScaleFactor(1.4f);
+ host_impl_.SetDeviceScaleFactor(1.4f);
pending_layer_->CalculateContentsScale(
1.9f, false, &result_scale_x, &result_scale_y, &result_bounds);
@@ -570,8 +570,8 @@
// If we change the device scale factor, but end up at the same total scale
// factor somehow, then we don't get new tilings.
- host_impl_.setDeviceScaleFactor(2.2f);
- host_impl_.pendingTree()->SetPageScaleFactorAndLimits(1.4f, 1.4f, 1.4f);
+ host_impl_.SetDeviceScaleFactor(2.2f);
+ host_impl_.pending_tree()->SetPageScaleFactorAndLimits(1.4f, 1.4f, 1.4f);
pending_layer_->CalculateContentsScale(
1.9f, false, &result_scale_x, &result_scale_y, &result_bounds);
@@ -600,13 +600,13 @@
SetupTrees(pending_pile, active_pile);
EXPECT_EQ(0u, pending_layer_->tilings().num_tilings());
- float low_res_factor = host_impl_.Settings().lowResContentsScaleFactor;
+ float low_res_factor = host_impl_.settings().lowResContentsScaleFactor;
EXPECT_LT(low_res_factor, 1.f);
// These are included in the scale given to the layer.
- host_impl_.setDeviceScaleFactor(1.7f);
- host_impl_.pendingTree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
- host_impl_.activeTree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
+ host_impl_.SetDeviceScaleFactor(1.7f);
+ host_impl_.pending_tree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
+ host_impl_.active_tree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
SetContentsScaleOnBothLayers(1.f, false);
ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
@@ -626,8 +626,8 @@
ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
// Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2.
- host_impl_.pendingTree()->SetPageScaleFactorAndLimits(1.2f, 1.2f, 1.2f);
- host_impl_.activeTree()->SetPageScaleFactorAndLimits(1.2f, 1.2f, 1.2f);
+ host_impl_.pending_tree()->SetPageScaleFactorAndLimits(1.2f, 1.2f, 1.2f);
+ host_impl_.active_tree()->SetPageScaleFactorAndLimits(1.2f, 1.2f, 1.2f);
SetContentsScaleOnBothLayers(1.2f, false);
ASSERT_EQ(4u, active_layer_->tilings().num_tilings());
EXPECT_FLOAT_EQ(
diff --git a/cc/quad_culler_unittest.cc b/cc/quad_culler_unittest.cc
index 55749dc..7016583 100644
--- a/cc/quad_culler_unittest.cc
+++ b/cc/quad_culler_unittest.cc
@@ -49,7 +49,7 @@
scoped_ptr<TiledLayerImpl> makeLayer(TiledLayerImpl* parent, const gfx::Transform& drawTransform, const gfx::Rect& layerRect, float opacity, bool opaque, const gfx::Rect& layerOpaqueRect, std::vector<LayerImpl*>& surfaceLayerList)
{
- scoped_ptr<TiledLayerImpl> layer = TiledLayerImpl::Create(m_hostImpl.activeTree(), layer_id_++);
+ scoped_ptr<TiledLayerImpl> layer = TiledLayerImpl::Create(m_hostImpl.active_tree(), layer_id_++);
scoped_ptr<LayerTilingData> tiler = LayerTilingData::create(gfx::Size(100, 100), LayerTilingData::NoBorderTexels);
tiler->setBounds(layerRect.size());
layer->setTilingData(*tiler);
diff --git a/cc/render_pass_sink.h b/cc/render_pass_sink.h
index ae00f62..1c98c69 100644
--- a/cc/render_pass_sink.h
+++ b/cc/render_pass_sink.h
@@ -9,13 +9,13 @@
#include "cc/cc_export.h"
namespace cc {
-
class RenderPass;
class CC_EXPORT RenderPassSink {
-public:
- virtual void appendRenderPass(scoped_ptr<RenderPass>) = 0;
+ public:
+ virtual void AppendRenderPass(scoped_ptr<RenderPass> render_pass) = 0;
};
-}
+} // namespace cc
+
#endif // CC_RENDER_PASS_SINK_H_
diff --git a/cc/render_surface_impl.cc b/cc/render_surface_impl.cc
index dd8fc3a..d35ccfc 100644
--- a/cc/render_surface_impl.cc
+++ b/cc/render_surface_impl.cc
@@ -191,7 +191,7 @@
content_rect_,
damage_tracker_->current_damage_rect(),
screen_space_transform_);
- pass_sink->appendRenderPass(pass.Pass());
+ pass_sink->AppendRenderPass(pass.Pass());
}
void RenderSurfaceImpl::AppendQuads(QuadSink* quad_sink,
diff --git a/cc/render_surface_unittest.cc b/cc/render_surface_unittest.cc
index dbd169f..d848f118 100644
--- a/cc/render_surface_unittest.cc
+++ b/cc/render_surface_unittest.cc
@@ -39,7 +39,7 @@
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> owningLayer = LayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> owningLayer = LayerImpl::Create(hostImpl.active_tree(), 1);
owningLayer->CreateRenderSurface();
ASSERT_TRUE(owningLayer->render_surface());
RenderSurfaceImpl* renderSurface = owningLayer->render_surface();
@@ -59,7 +59,7 @@
EXECUTE_AND_VERIFY_SURFACE_DID_NOT_CHANGE(renderSurface->SetClipRect(testRect));
EXECUTE_AND_VERIFY_SURFACE_DID_NOT_CHANGE(renderSurface->SetContentRect(testRect));
- scoped_ptr<LayerImpl> dummyMask = LayerImpl::Create(hostImpl.activeTree(), 2);
+ scoped_ptr<LayerImpl> dummyMask = LayerImpl::Create(hostImpl.active_tree(), 2);
gfx::Transform dummyMatrix;
dummyMatrix.Translate(1.0, 2.0);
@@ -75,9 +75,9 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> rootLayer = LayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> rootLayer = LayerImpl::Create(hostImpl.active_tree(), 1);
- scoped_ptr<LayerImpl> owningLayer = LayerImpl::Create(hostImpl.activeTree(), 2);
+ scoped_ptr<LayerImpl> owningLayer = LayerImpl::Create(hostImpl.active_tree(), 2);
owningLayer->CreateRenderSurface();
ASSERT_TRUE(owningLayer->render_surface());
owningLayer->draw_properties().render_target = owningLayer.get();
@@ -115,7 +115,7 @@
class TestRenderPassSink : public RenderPassSink {
public:
- virtual void appendRenderPass(scoped_ptr<RenderPass> renderPass) OVERRIDE { m_renderPasses.push_back(renderPass.Pass()); }
+ virtual void AppendRenderPass(scoped_ptr<RenderPass> renderPass) OVERRIDE { m_renderPasses.push_back(renderPass.Pass()); }
const ScopedPtrVector<RenderPass>& renderPasses() const { return m_renderPasses; }
@@ -127,9 +127,9 @@
{
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<LayerImpl> rootLayer = LayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<LayerImpl> rootLayer = LayerImpl::Create(hostImpl.active_tree(), 1);
- scoped_ptr<LayerImpl> owningLayer = LayerImpl::Create(hostImpl.activeTree(), 2);
+ scoped_ptr<LayerImpl> owningLayer = LayerImpl::Create(hostImpl.active_tree(), 2);
owningLayer->CreateRenderSurface();
ASSERT_TRUE(owningLayer->render_surface());
owningLayer->draw_properties().render_target = owningLayer.get();
diff --git a/cc/scrollbar_animation_controller_linear_fade_unittest.cc b/cc/scrollbar_animation_controller_linear_fade_unittest.cc
index 10977a7..e3c2c23 100644
--- a/cc/scrollbar_animation_controller_linear_fade_unittest.cc
+++ b/cc/scrollbar_animation_controller_linear_fade_unittest.cc
@@ -24,9 +24,9 @@
protected:
virtual void SetUp()
{
- m_scrollLayer = LayerImpl::Create(m_hostImpl.activeTree(), 1);
+ m_scrollLayer = LayerImpl::Create(m_hostImpl.active_tree(), 1);
scoped_ptr<ScrollbarGeometryFixedThumb> geometry(ScrollbarGeometryFixedThumb::create(FakeWebScrollbarThemeGeometry::create(false)));
- m_scrollbarLayer = ScrollbarLayerImpl::Create(m_hostImpl.activeTree(), 2, geometry.Pass());
+ m_scrollbarLayer = ScrollbarLayerImpl::Create(m_hostImpl.active_tree(), 2, geometry.Pass());
m_scrollLayer->SetMaxScrollOffset(gfx::Vector2d(50, 50));
m_scrollLayer->SetBounds(gfx::Size(50, 50));
diff --git a/cc/scrollbar_layer_unittest.cc b/cc/scrollbar_layer_unittest.cc
index bf37810..cdb4cc9 100644
--- a/cc/scrollbar_layer_unittest.cc
+++ b/cc/scrollbar_layer_unittest.cc
@@ -41,7 +41,7 @@
scoped_refptr<Layer> child2 = ScrollbarLayer::Create(scrollbar.Pass(), FakeScrollbarThemePainter::Create(false).PassAs<ScrollbarThemePainter>(), FakeWebScrollbarThemeGeometry::create(true), child1->id());
layerTreeRoot->AddChild(child1);
layerTreeRoot->InsertChild(child2, reverse_order ? 0 : 1);
- scoped_ptr<LayerImpl> layerImpl = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), host_impl->activeTree());
+ scoped_ptr<LayerImpl> layerImpl = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), host_impl->active_tree());
TreeSynchronizer::pushProperties(layerTreeRoot.get(), layerImpl.get());
return layerImpl.Pass();
}
@@ -117,7 +117,7 @@
layerTreeRoot->SetBounds(gfx::Size(100, 200));
contentLayer->SetBounds(gfx::Size(100, 200));
- scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), hostImpl.activeTree());
+ scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), hostImpl.active_tree());
TreeSynchronizer::pushProperties(layerTreeRoot.get(), layerImplTreeRoot.get());
ScrollbarLayerImpl* ccScrollbarLayer = static_cast<ScrollbarLayerImpl*>(layerImplTreeRoot->children()[1]);
@@ -132,7 +132,7 @@
contentLayer->SetBounds(gfx::Size(1000, 2000));
ScrollbarAnimationController* scrollbarController = layerImplTreeRoot->scrollbar_animation_controller();
- layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), hostImpl.activeTree());
+ layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), hostImpl.active_tree());
TreeSynchronizer::pushProperties(layerTreeRoot.get(), layerImplTreeRoot.get());
EXPECT_EQ(scrollbarController, layerImplTreeRoot->scrollbar_animation_controller());
@@ -216,7 +216,7 @@
virtual void commitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
{
- const int kMaxTextureSize = impl->rendererCapabilities().max_texture_size;
+ const int kMaxTextureSize = impl->GetRendererCapabilities().max_texture_size;
// Check first that we're actually testing something.
EXPECT_GT(m_scrollbarLayer->bounds().width(), kMaxTextureSize);
diff --git a/cc/single_thread_proxy.cc b/cc/single_thread_proxy.cc
index c6b90882..0c2314ba 100644
--- a/cc/single_thread_proxy.cc
+++ b/cc/single_thread_proxy.cc
@@ -60,12 +60,12 @@
{
DebugScopedSetImplThread impl(this);
- layer_tree_host_impl_->readback(pixels, rect);
+ layer_tree_host_impl_->Readback(pixels, rect);
- if (layer_tree_host_impl_->isContextLost())
+ if (layer_tree_host_impl_->IsContextLost())
return false;
- layer_tree_host_impl_->swapBuffers();
+ layer_tree_host_impl_->SwapBuffers();
}
DidSwapFrame();
@@ -76,7 +76,7 @@
bool use_anchor,
float scale,
base::TimeDelta duration) {
- layer_tree_host_impl_->startPageScaleAnimation(
+ layer_tree_host_impl_->StartPageScaleAnimation(
target_offset, use_anchor, scale, base::TimeTicks::Now(), duration);
}
@@ -84,7 +84,7 @@
DCHECK(Proxy::IsMainThread());
{
DebugScopedSetImplThread impl(this);
- layer_tree_host_impl_->finishAllRendering();
+ layer_tree_host_impl_->FinishAllRendering();
}
}
@@ -110,7 +110,7 @@
void SingleThreadProxy::SetVisible(bool visible) {
DebugScopedSetImplThread impl(this);
- layer_tree_host_impl_->setVisible(visible);
+ layer_tree_host_impl_->SetVisible(visible);
}
bool SingleThreadProxy::InitializeRenderer() {
@@ -118,12 +118,12 @@
DCHECK(output_surface_before_initialization_.get());
{
DebugScopedSetImplThread impl(this);
- bool ok = layer_tree_host_impl_->initializeRenderer(
+ bool ok = layer_tree_host_impl_->InitializeRenderer(
output_surface_before_initialization_.Pass());
if (ok) {
renderer_initialized_ = true;
renderer_capabilities_for_main_thread_ =
- layer_tree_host_impl_->rendererCapabilities();
+ layer_tree_host_impl_->GetRendererCapabilities();
}
return ok;
@@ -152,13 +152,13 @@
DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
DebugScopedSetImplThread impl(this);
layer_tree_host_->DeleteContentsTexturesOnImplThread(
- layer_tree_host_impl_->resourceProvider());
+ layer_tree_host_impl_->resource_provider());
initialized =
- layer_tree_host_impl_->initializeRenderer(outputSurface.Pass());
+ layer_tree_host_impl_->InitializeRenderer(outputSurface.Pass());
if (initialized) {
renderer_capabilities_for_main_thread_ =
- layer_tree_host_impl_->rendererCapabilities();
- layer_tree_host_impl_->resourceProvider()
+ layer_tree_host_impl_->GetRendererCapabilities();
+ layer_tree_host_impl_->resource_provider()
->SetOffscreenContextProvider(offscreen_context_provider);
} else if (offscreen_context_provider) {
offscreen_context_provider->VerifyContexts();
@@ -174,7 +174,7 @@
void SingleThreadProxy::CollectRenderingStats(RenderingStats* stats) {
stats->totalCommitTime = total_commit_time_;
stats->totalCommitCount = total_commit_count_;
- layer_tree_host_impl_->renderingStats(stats);
+ layer_tree_host_impl_->CollectRenderingStats(stats);
}
const RendererCapabilities& SingleThreadProxy::GetRendererCapabilities() const {
@@ -196,7 +196,7 @@
DebugScopedSetImplThread impl(this);
base::TimeTicks startTime = base::TimeTicks::HighResNow();
- layer_tree_host_impl_->beginCommit();
+ layer_tree_host_impl_->BeginCommit();
layer_tree_host_->contents_texture_manager()->
pushTexturePrioritiesToBackings();
@@ -207,18 +207,18 @@
NULL,
Proxy::MainThread(),
queue.Pass(),
- layer_tree_host_impl_->resourceProvider());
+ layer_tree_host_impl_->resource_provider());
updateController->Finalize();
layer_tree_host_->FinishCommitOnImplThread(layer_tree_host_impl_.get());
- layer_tree_host_impl_->commitComplete();
+ layer_tree_host_impl_->CommitComplete();
#ifndef NDEBUG
// In the single-threaded case, the scroll deltas should never be
// touched on the impl layer tree.
scoped_ptr<ScrollAndScaleSet> scrollInfo =
- layer_tree_host_impl_->processScrollDeltas();
+ layer_tree_host_impl_->ProcessScrollDeltas();
DCHECK(!scrollInfo->scrolls.size());
#endif
@@ -242,7 +242,7 @@
SetNeedsCommit();
}
-void SingleThreadProxy::onHasPendingTreeStateChanged(bool have_pending_tree) {
+void SingleThreadProxy::OnHasPendingTreeStateChanged(bool have_pending_tree) {
// Thread-only feature.
NOTREACHED();
}
@@ -266,30 +266,30 @@
DebugScopedSetImplThread impl(this);
layer_tree_host_->DeleteContentsTexturesOnImplThread(
- layer_tree_host_impl_->resourceProvider());
+ layer_tree_host_impl_->resource_provider());
layer_tree_host_impl_.reset();
}
layer_tree_host_ = NULL;
}
-void SingleThreadProxy::setNeedsRedrawOnImplThread() {
+void SingleThreadProxy::SetNeedsRedrawOnImplThread() {
layer_tree_host_->ScheduleComposite();
}
-void SingleThreadProxy::didUploadVisibleHighResolutionTileOnImplThread() {
+void SingleThreadProxy::DidUploadVisibleHighResolutionTileOnImplThread() {
// Impl-side painting only.
NOTREACHED();
}
-void SingleThreadProxy::setNeedsCommitOnImplThread() {
+void SingleThreadProxy::SetNeedsCommitOnImplThread() {
layer_tree_host_->ScheduleComposite();
}
-void SingleThreadProxy::setNeedsManageTilesOnImplThread() {
+void SingleThreadProxy::SetNeedsManageTilesOnImplThread() {
layer_tree_host_->ScheduleComposite();
}
-void SingleThreadProxy::postAnimationEventsToMainThreadOnImplThread(
+void SingleThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
scoped_ptr<AnimationEventsVector> events,
base::Time wall_clock_time) {
DCHECK(Proxy::IsImplThread());
@@ -297,7 +297,7 @@
layer_tree_host_->SetAnimationEvents(events.Pass(), wall_clock_time);
}
-bool SingleThreadProxy::reduceContentsTextureMemoryOnImplThread(
+bool SingleThreadProxy::ReduceContentsTextureMemoryOnImplThread(
size_t limit_bytes,
int priority_cutoff) {
DCHECK(IsImplThread());
@@ -305,15 +305,15 @@
return false;
return layer_tree_host_->contents_texture_manager()->reduceMemoryOnImplThread(
- limit_bytes, priority_cutoff, layer_tree_host_impl_->resourceProvider());
+ limit_bytes, priority_cutoff, layer_tree_host_impl_->resource_provider());
}
-void SingleThreadProxy::reduceWastedContentsTextureMemoryOnImplThread() {
+void SingleThreadProxy::ReduceWastedContentsTextureMemoryOnImplThread() {
// Impl-side painting only.
NOTREACHED();
}
-void SingleThreadProxy::sendManagedMemoryStats() {
+void SingleThreadProxy::SendManagedMemoryStats() {
DCHECK(Proxy::IsImplThread());
if (!layer_tree_host_impl_.get())
return;
@@ -322,24 +322,24 @@
PrioritizedResourceManager* contents_texture_manager =
layer_tree_host_->contents_texture_manager();
- layer_tree_host_impl_->sendManagedMemoryStats(
+ layer_tree_host_impl_->SendManagedMemoryStats(
contents_texture_manager->memoryVisibleBytes(),
contents_texture_manager->memoryVisibleAndNearbyBytes(),
contents_texture_manager->memoryUseBytes());
}
-bool SingleThreadProxy::isInsideDraw() { return inside_draw_; }
+bool SingleThreadProxy::IsInsideDraw() { return inside_draw_; }
-void SingleThreadProxy::didLoseOutputSurfaceOnImplThread() {
+void SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() {
// Cause a commit so we can notice the lost context.
- setNeedsCommitOnImplThread();
+ SetNeedsCommitOnImplThread();
}
// Called by the legacy scheduling path (e.g. where render_widget does the
// scheduling)
void SingleThreadProxy::CompositeImmediately() {
if (CommitAndComposite()) {
- layer_tree_host_impl_->swapBuffers();
+ layer_tree_host_impl_->SwapBuffers();
DidSwapFrame();
}
}
@@ -353,7 +353,7 @@
DebugScopedSetImplThread impl(const_cast<SingleThreadProxy*>(this));
state->Set("layer_tree_host_impl",
- layer_tree_host_impl_->asValue().release());
+ layer_tree_host_impl_->AsValue().release());
}
return state.PassAs<base::Value>();
}
@@ -366,7 +366,7 @@
}
}
-void SingleThreadProxy::onSwapBuffersCompleteOnImplThread() { NOTREACHED(); }
+void SingleThreadProxy::OnSwapBuffersCompleteOnImplThread() { NOTREACHED(); }
bool SingleThreadProxy::CommitAndComposite() {
DCHECK(Proxy::IsMainThread());
@@ -390,7 +390,7 @@
scoped_ptr<ResourceUpdateQueue> queue =
make_scoped_ptr(new ResourceUpdateQueue);
layer_tree_host_->UpdateLayers(
- queue.get(), layer_tree_host_impl_->memoryAllocationLimitBytes());
+ queue.get(), layer_tree_host_impl_->memory_allocation_limit_bytes());
layer_tree_host_->WillCommit();
DoCommit(queue.Pass());
@@ -406,33 +406,33 @@
DebugScopedSetImplThread impl(this);
base::AutoReset<bool> mark_inside(&inside_draw_, true);
- layer_tree_host_impl_->resourceProvider()->
+ layer_tree_host_impl_->resource_provider()->
SetOffscreenContextProvider(offscreen_context_provider);
if (!layer_tree_host_impl_->visible())
return false;
- layer_tree_host_impl_->animate(base::TimeTicks::Now(), base::Time::Now());
+ layer_tree_host_impl_->Animate(base::TimeTicks::Now(), base::Time::Now());
// We guard prepareToDraw() with canDraw() because it always returns a valid
// frame, so can only be used when such a frame is possible. Since
// drawLayers() depends on the result of prepareToDraw(), it is guarded on
// canDraw() as well.
- if (!layer_tree_host_impl_->canDraw())
+ if (!layer_tree_host_impl_->CanDraw())
return false;
LayerTreeHostImpl::FrameData frame;
- layer_tree_host_impl_->prepareToDraw(frame);
- layer_tree_host_impl_->drawLayers(frame);
- layer_tree_host_impl_->didDrawAllLayers(frame);
- output_surface_lost_ = layer_tree_host_impl_->isContextLost();
+ layer_tree_host_impl_->PrepareToDraw(&frame);
+ layer_tree_host_impl_->DrawLayers(&frame);
+ layer_tree_host_impl_->DidDrawAllLayers(frame);
+ output_surface_lost_ = layer_tree_host_impl_->IsContextLost();
- layer_tree_host_impl_->beginNextFrame();
+ layer_tree_host_impl_->BeginNextFrame();
}
if (output_surface_lost_) {
cc::ContextProvider* offscreen_contexts = layer_tree_host_impl_->
- resourceProvider()->offscreen_context_provider();
+ resource_provider()->offscreen_context_provider();
if (offscreen_contexts)
offscreen_contexts->VerifyContexts();
layer_tree_host_->DidLoseOutputSurface();
diff --git a/cc/single_thread_proxy.h b/cc/single_thread_proxy.h
index f8e92b6..4180b02 100644
--- a/cc/single_thread_proxy.h
+++ b/cc/single_thread_proxy.h
@@ -53,26 +53,26 @@
virtual bool CommitPendingForTesting() OVERRIDE;
// LayerTreeHostImplClient implementation
- virtual void didLoseOutputSurfaceOnImplThread() OVERRIDE;
- virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE;
- virtual void onVSyncParametersChanged(base::TimeTicks timebase,
+ virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE;
+ virtual void OnSwapBuffersCompleteOnImplThread() OVERRIDE;
+ virtual void OnVSyncParametersChanged(base::TimeTicks timebase,
base::TimeDelta interval) OVERRIDE {}
- virtual void onCanDrawStateChanged(bool can_draw) OVERRIDE {}
- virtual void onHasPendingTreeStateChanged(bool have_pending_tree) OVERRIDE;
- virtual void setNeedsRedrawOnImplThread() OVERRIDE;
- virtual void didUploadVisibleHighResolutionTileOnImplThread() OVERRIDE;
- virtual void setNeedsCommitOnImplThread() OVERRIDE;
- virtual void setNeedsManageTilesOnImplThread() OVERRIDE;
- virtual void postAnimationEventsToMainThreadOnImplThread(
+ virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE {}
+ virtual void OnHasPendingTreeStateChanged(bool have_pending_tree) OVERRIDE;
+ virtual void SetNeedsRedrawOnImplThread() OVERRIDE;
+ virtual void DidUploadVisibleHighResolutionTileOnImplThread() OVERRIDE;
+ virtual void SetNeedsCommitOnImplThread() OVERRIDE;
+ virtual void SetNeedsManageTilesOnImplThread() OVERRIDE;
+ virtual void PostAnimationEventsToMainThreadOnImplThread(
scoped_ptr<AnimationEventsVector> events,
base::Time wall_clock_time) OVERRIDE;
- virtual bool reduceContentsTextureMemoryOnImplThread(
+ virtual bool ReduceContentsTextureMemoryOnImplThread(
size_t limit_bytes,
int priority_cutoff) OVERRIDE;
- virtual void reduceWastedContentsTextureMemoryOnImplThread() OVERRIDE;
- virtual void sendManagedMemoryStats() OVERRIDE;
- virtual bool isInsideDraw() OVERRIDE;
- virtual void renewTreePriority() OVERRIDE {}
+ virtual void ReduceWastedContentsTextureMemoryOnImplThread() OVERRIDE;
+ virtual void SendManagedMemoryStats() OVERRIDE;
+ virtual bool IsInsideDraw() OVERRIDE;
+ virtual void RenewTreePriority() OVERRIDE {}
// Called by the legacy path where RenderWidget does the scheduling.
void CompositeImmediately();
diff --git a/cc/solid_color_layer_impl_unittest.cc b/cc/solid_color_layer_impl_unittest.cc
index d5f7f61..a9faf40d 100644
--- a/cc/solid_color_layer_impl_unittest.cc
+++ b/cc/solid_color_layer_impl_unittest.cc
@@ -26,7 +26,7 @@
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<SolidColorLayerImpl> layer = SolidColorLayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<SolidColorLayerImpl> layer = SolidColorLayerImpl::Create(hostImpl.active_tree(), 1);
layer->draw_properties().visible_content_rect = visibleContentRect;
layer->SetBounds(layerSize);
layer->SetContentBounds(layerSize);
@@ -49,7 +49,7 @@
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<SolidColorLayerImpl> layer = SolidColorLayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<SolidColorLayerImpl> layer = SolidColorLayerImpl::Create(hostImpl.active_tree(), 1);
layer->draw_properties().visible_content_rect = visibleContentRect;
layer->SetBounds(layerSize);
layer->SetContentBounds(layerSize);
@@ -74,7 +74,7 @@
FakeImplProxy proxy;
FakeLayerTreeHostImpl hostImpl(&proxy);
- scoped_ptr<SolidColorLayerImpl> layer = SolidColorLayerImpl::Create(hostImpl.activeTree(), 1);
+ scoped_ptr<SolidColorLayerImpl> layer = SolidColorLayerImpl::Create(hostImpl.active_tree(), 1);
layer->draw_properties().visible_content_rect = visibleContentRect;
layer->SetBounds(layerSize);
layer->SetContentBounds(layerSize);
@@ -119,7 +119,7 @@
EXPECT_TRUE(layer->contents_opaque());
{
- scoped_ptr<SolidColorLayerImpl> layerImpl = SolidColorLayerImpl::Create(hostImpl.activeTree(), layer->id());
+ scoped_ptr<SolidColorLayerImpl> layerImpl = SolidColorLayerImpl::Create(hostImpl.active_tree(), layer->id());
layer->PushPropertiesTo(layerImpl.get());
// The impl layer should call itself opaque as well.
@@ -141,7 +141,7 @@
EXPECT_FALSE(layer->contents_opaque());
{
- scoped_ptr<SolidColorLayerImpl> layerImpl = SolidColorLayerImpl::Create(hostImpl.activeTree(), layer->id());
+ scoped_ptr<SolidColorLayerImpl> layerImpl = SolidColorLayerImpl::Create(hostImpl.active_tree(), layer->id());
layer->PushPropertiesTo(layerImpl.get());
// The impl layer should callnot itself opaque anymore.
diff --git a/cc/test/fake_layer_tree_host_impl.cc b/cc/test/fake_layer_tree_host_impl.cc
index 64d0150..334ff9f 100644
--- a/cc/test/fake_layer_tree_host_impl.cc
+++ b/cc/test/fake_layer_tree_host_impl.cc
@@ -7,23 +7,19 @@
namespace cc {
FakeLayerTreeHostImpl::FakeLayerTreeHostImpl(Proxy* proxy)
- : LayerTreeHostImpl(LayerTreeSettings(), &client_, proxy)
-{
+ : LayerTreeHostImpl(LayerTreeSettings(), &client_, proxy) {
// Explicitly clear all debug settings.
- setDebugState(LayerTreeDebugState());
+ SetDebugState(LayerTreeDebugState());
}
FakeLayerTreeHostImpl::FakeLayerTreeHostImpl(
const LayerTreeSettings& settings,
Proxy* proxy)
- : LayerTreeHostImpl(settings, &client_, proxy)
-{
+ : LayerTreeHostImpl(settings, &client_, proxy) {
// Explicitly clear all debug settings.
- setDebugState(LayerTreeDebugState());
+ SetDebugState(LayerTreeDebugState());
}
-FakeLayerTreeHostImpl::~FakeLayerTreeHostImpl()
-{
-}
+FakeLayerTreeHostImpl::~FakeLayerTreeHostImpl() {}
} // namespace cc
diff --git a/cc/test/fake_layer_tree_host_impl.h b/cc/test/fake_layer_tree_host_impl.h
index 0d218df..54015dc 100644
--- a/cc/test/fake_layer_tree_host_impl.h
+++ b/cc/test/fake_layer_tree_host_impl.h
@@ -17,13 +17,13 @@
FakeLayerTreeHostImpl(const LayerTreeSettings& settings, Proxy* proxy);
virtual ~FakeLayerTreeHostImpl();
- void forcePrepareToDraw() {
- LayerTreeHostImpl::FrameData frameData;
- prepareToDraw(frameData);
- didDrawAllLayers(frameData);
+ void ForcePrepareToDraw() {
+ LayerTreeHostImpl::FrameData frame_data;
+ PrepareToDraw(&frame_data);
+ DidDrawAllLayers(frame_data);
}
- using LayerTreeHostImpl::activatePendingTree;
+ using LayerTreeHostImpl::ActivatePendingTree;
private:
FakeLayerTreeHostImplClient client_;
diff --git a/cc/test/fake_layer_tree_host_impl_client.cc b/cc/test/fake_layer_tree_host_impl_client.cc
index dcefd0e..c4d38ab 100644
--- a/cc/test/fake_layer_tree_host_impl_client.cc
+++ b/cc/test/fake_layer_tree_host_impl_client.cc
@@ -6,13 +6,13 @@
namespace cc {
-bool FakeLayerTreeHostImplClient::reduceContentsTextureMemoryOnImplThread(
- size_t,
- int) {
+bool FakeLayerTreeHostImplClient::ReduceContentsTextureMemoryOnImplThread(
+ size_t limit_butes,
+ int priority_cutoff) {
return false;
}
-bool FakeLayerTreeHostImplClient::isInsideDraw() {
+bool FakeLayerTreeHostImplClient::IsInsideDraw() {
return false;
}
diff --git a/cc/test/fake_layer_tree_host_impl_client.h b/cc/test/fake_layer_tree_host_impl_client.h
index e50ca570..fc68a18 100644
--- a/cc/test/fake_layer_tree_host_impl_client.h
+++ b/cc/test/fake_layer_tree_host_impl_client.h
@@ -12,25 +12,27 @@
class FakeLayerTreeHostImplClient : public LayerTreeHostImplClient {
public:
// LayerTreeHostImplClient implementation.
- virtual void didLoseOutputSurfaceOnImplThread() OVERRIDE { }
- virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE { }
- virtual void onVSyncParametersChanged(
+ virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE {}
+ virtual void OnSwapBuffersCompleteOnImplThread() OVERRIDE {}
+ virtual void OnVSyncParametersChanged(
base::TimeTicks,
- base::TimeDelta) OVERRIDE { }
- virtual void onCanDrawStateChanged(bool) OVERRIDE { }
- virtual void onHasPendingTreeStateChanged(bool) OVERRIDE { }
- virtual void setNeedsRedrawOnImplThread() OVERRIDE { }
- virtual void didUploadVisibleHighResolutionTileOnImplThread() OVERRIDE { }
- virtual void setNeedsCommitOnImplThread() OVERRIDE { }
- virtual void setNeedsManageTilesOnImplThread() OVERRIDE { }
- virtual void postAnimationEventsToMainThreadOnImplThread(
- scoped_ptr<AnimationEventsVector>,
- base::Time) OVERRIDE { }
- virtual bool reduceContentsTextureMemoryOnImplThread(size_t, int) OVERRIDE;
- virtual void reduceWastedContentsTextureMemoryOnImplThread() OVERRIDE { }
- virtual void sendManagedMemoryStats() OVERRIDE { }
- virtual bool isInsideDraw() OVERRIDE;
- virtual void renewTreePriority() OVERRIDE { }
+ base::TimeDelta) OVERRIDE {}
+ virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE {}
+ virtual void OnHasPendingTreeStateChanged(bool has_pending_tree) OVERRIDE {}
+ virtual void SetNeedsRedrawOnImplThread() OVERRIDE {}
+ virtual void DidUploadVisibleHighResolutionTileOnImplThread() OVERRIDE {}
+ virtual void SetNeedsCommitOnImplThread() OVERRIDE {}
+ virtual void SetNeedsManageTilesOnImplThread() OVERRIDE {}
+ virtual void PostAnimationEventsToMainThreadOnImplThread(
+ scoped_ptr<AnimationEventsVector> events,
+ base::Time wall_clock_time) OVERRIDE {}
+ virtual bool ReduceContentsTextureMemoryOnImplThread(
+ size_t limit_bytes,
+ int priority_cutoff) OVERRIDE;
+ virtual void ReduceWastedContentsTextureMemoryOnImplThread() OVERRIDE {}
+ virtual void SendManagedMemoryStats() OVERRIDE {}
+ virtual bool IsInsideDraw() OVERRIDE;
+ virtual void RenewTreePriority() OVERRIDE {}
};
} // namespace cc
diff --git a/cc/test/layer_tree_test_common.cc b/cc/test/layer_tree_test_common.cc
index a27afc2..def1820 100644
--- a/cc/test/layer_tree_test_common.cc
+++ b/cc/test/layer_tree_test_common.cc
@@ -38,7 +38,7 @@
TestHooks::~TestHooks() { }
-bool TestHooks::prepareToDrawOnThread(cc::LayerTreeHostImpl*, LayerTreeHostImpl::FrameData&, bool)
+bool TestHooks::prepareToDrawOnThread(cc::LayerTreeHostImpl*, LayerTreeHostImpl::FrameData*, bool)
{
return true;
}
@@ -68,76 +68,76 @@
return make_scoped_ptr(new MockLayerTreeHostImpl(testHooks, settings, client, proxy));
}
-void MockLayerTreeHostImpl::beginCommit()
+void MockLayerTreeHostImpl::BeginCommit()
{
- LayerTreeHostImpl::beginCommit();
+ LayerTreeHostImpl::BeginCommit();
m_testHooks->beginCommitOnThread(this);
}
-void MockLayerTreeHostImpl::commitComplete()
+void MockLayerTreeHostImpl::CommitComplete()
{
- LayerTreeHostImpl::commitComplete();
+ LayerTreeHostImpl::CommitComplete();
m_testHooks->commitCompleteOnThread(this);
- if (!Settings().implSidePainting)
+ if (!settings().implSidePainting)
m_testHooks->treeActivatedOnThread(this);
}
-bool MockLayerTreeHostImpl::prepareToDraw(FrameData& frame)
+bool MockLayerTreeHostImpl::PrepareToDraw(FrameData* frame)
{
- bool result = LayerTreeHostImpl::prepareToDraw(frame);
+ bool result = LayerTreeHostImpl::PrepareToDraw(frame);
if (!m_testHooks->prepareToDrawOnThread(this, frame, result))
result = false;
return result;
}
-void MockLayerTreeHostImpl::drawLayers(FrameData& frame)
+void MockLayerTreeHostImpl::DrawLayers(FrameData* frame)
{
- LayerTreeHostImpl::drawLayers(frame);
+ LayerTreeHostImpl::DrawLayers(frame);
m_testHooks->drawLayersOnThread(this);
}
-bool MockLayerTreeHostImpl::activatePendingTreeIfNeeded()
+bool MockLayerTreeHostImpl::ActivatePendingTreeIfNeeded()
{
- if (!pendingTree())
+ if (!pending_tree())
return false;
if (!m_testHooks->canActivatePendingTree())
return false;
- bool activated = LayerTreeHostImpl::activatePendingTreeIfNeeded();
+ bool activated = LayerTreeHostImpl::ActivatePendingTreeIfNeeded();
if (activated)
m_testHooks->treeActivatedOnThread(this);
return activated;
}
-bool MockLayerTreeHostImpl::initializeRenderer(scoped_ptr<OutputSurface> outputSurface)
+bool MockLayerTreeHostImpl::InitializeRenderer(scoped_ptr<OutputSurface> outputSurface)
{
- bool success = LayerTreeHostImpl::initializeRenderer(outputSurface.Pass());
+ bool success = LayerTreeHostImpl::InitializeRenderer(outputSurface.Pass());
m_testHooks->initializedRendererOnThread(this, success);
return success;
}
-void MockLayerTreeHostImpl::setVisible(bool visible)
+void MockLayerTreeHostImpl::SetVisible(bool visible)
{
- LayerTreeHostImpl::setVisible(visible);
+ LayerTreeHostImpl::SetVisible(visible);
m_testHooks->didSetVisibleOnImplTree(this, visible);
}
-void MockLayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
+void MockLayerTreeHostImpl::AnimateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
{
m_testHooks->willAnimateLayers(this, monotonicTime);
- LayerTreeHostImpl::animateLayers(monotonicTime, wallClockTime);
+ LayerTreeHostImpl::AnimateLayers(monotonicTime, wallClockTime);
m_testHooks->animateLayers(this, monotonicTime);
}
-void MockLayerTreeHostImpl::updateAnimationState()
+void MockLayerTreeHostImpl::UpdateAnimationState()
{
- LayerTreeHostImpl::updateAnimationState();
+ LayerTreeHostImpl::UpdateAnimationState();
bool hasUnfinishedAnimation = false;
- AnimationRegistrar::AnimationControllerMap::const_iterator iter = activeAnimationControllers().begin();
- for (; iter != activeAnimationControllers().end(); ++iter) {
+ AnimationRegistrar::AnimationControllerMap::const_iterator iter = active_animation_controllers().begin();
+ for (; iter != active_animation_controllers().end(); ++iter) {
if (iter->second->HasActiveAnimation()) {
hasUnfinishedAnimation = true;
break;
@@ -146,7 +146,7 @@
m_testHooks->updateAnimationState(this, hasUnfinishedAnimation);
}
-base::TimeDelta MockLayerTreeHostImpl::lowFrequencyAnimationInterval() const
+base::TimeDelta MockLayerTreeHostImpl::LowFrequencyAnimationInterval() const
{
return base::TimeDelta::FromMilliseconds(16);
}
diff --git a/cc/test/layer_tree_test_common.h b/cc/test/layer_tree_test_common.h
index 6a61a11..ac9534e3 100644
--- a/cc/test/layer_tree_test_common.h
+++ b/cc/test/layer_tree_test_common.h
@@ -35,7 +35,7 @@
virtual void treeActivatedOnThread(LayerTreeHostImpl*) { }
virtual void initializedRendererOnThread(LayerTreeHostImpl*, bool success) { }
virtual bool prepareToDrawOnThread(
- LayerTreeHostImpl*, LayerTreeHostImpl::FrameData&, bool result);
+ LayerTreeHostImpl*, LayerTreeHostImpl::FrameData*, bool result);
virtual void drawLayersOnThread(LayerTreeHostImpl*) { }
virtual void animateLayers(LayerTreeHostImpl*, base::TimeTicks monotonicTime) { }
virtual void updateAnimationState(LayerTreeHostImpl*, bool hasUnfinishedAnimation) { }
@@ -163,21 +163,21 @@
public:
static scoped_ptr<MockLayerTreeHostImpl> create(TestHooks*, const LayerTreeSettings&, LayerTreeHostImplClient*, Proxy*);
- virtual void beginCommit() OVERRIDE;
- virtual void commitComplete() OVERRIDE;
- virtual bool prepareToDraw(FrameData&) OVERRIDE;
- virtual void drawLayers(FrameData&) OVERRIDE;
- virtual bool activatePendingTreeIfNeeded() OVERRIDE;
- virtual bool initializeRenderer(scoped_ptr<OutputSurface> outputSurface) OVERRIDE;
- virtual void setVisible(bool visible) OVERRIDE;
+ virtual void BeginCommit() OVERRIDE;
+ virtual void CommitComplete() OVERRIDE;
+ virtual bool PrepareToDraw(FrameData* frame) OVERRIDE;
+ virtual void DrawLayers(FrameData* frame) OVERRIDE;
+ virtual bool ActivatePendingTreeIfNeeded() OVERRIDE;
+ virtual bool InitializeRenderer(scoped_ptr<OutputSurface> outputSurface) OVERRIDE;
+ virtual void SetVisible(bool visible) OVERRIDE;
// Make these public.
typedef std::vector<LayerImpl*> LayerList;
protected:
- virtual void animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime) OVERRIDE;
- virtual void updateAnimationState() OVERRIDE;
- virtual base::TimeDelta lowFrequencyAnimationInterval() const OVERRIDE;
+ virtual void AnimateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime) OVERRIDE;
+ virtual void UpdateAnimationState() OVERRIDE;
+ virtual base::TimeDelta LowFrequencyAnimationInterval() const OVERRIDE;
private:
MockLayerTreeHostImpl(TestHooks*, const LayerTreeSettings&, LayerTreeHostImplClient*, Proxy*);
diff --git a/cc/texture_layer_unittest.cc b/cc/texture_layer_unittest.cc
index 5b08c509..195bf43 100644
--- a/cc/texture_layer_unittest.cc
+++ b/cc/texture_layer_unittest.cc
@@ -105,7 +105,7 @@
scoped_refptr<TextureLayer> testLayer = TextureLayer::Create(NULL);
ASSERT_TRUE(testLayer);
scoped_ptr<TextureLayerImpl> implLayer;
- implLayer = TextureLayerImpl::Create(m_hostImpl.activeTree(), 1, false);
+ implLayer = TextureLayerImpl::Create(m_hostImpl.active_tree(), 1, false);
ASSERT_TRUE(implLayer);
EXPECT_CALL(*m_layerTreeHost, AcquireLayerTextures()).Times(AnyNumber());
@@ -400,7 +400,7 @@
{
TextureLayerTest::SetUp();
m_layerTreeHost.reset(new MockLayerImplTreeHost);
- EXPECT_TRUE(m_hostImpl.initializeRenderer(createFakeOutputSurface()));
+ EXPECT_TRUE(m_hostImpl.InitializeRenderer(createFakeOutputSurface()));
}
CommonMailboxObjects m_testData;
@@ -408,13 +408,13 @@
TEST_F(TextureLayerImplWithMailboxTest, testImplLayerCallbacks)
{
- m_hostImpl.createPendingTree();
+ m_hostImpl.CreatePendingTree();
scoped_ptr<TextureLayerImpl> pendingLayer;
- pendingLayer = TextureLayerImpl::Create(m_hostImpl.pendingTree(), 1, true);
+ pendingLayer = TextureLayerImpl::Create(m_hostImpl.pending_tree(), 1, true);
ASSERT_TRUE(pendingLayer);
scoped_ptr<LayerImpl> activeLayer(pendingLayer->CreateLayerImpl(
- m_hostImpl.activeTree()));
+ m_hostImpl.active_tree()));
ASSERT_TRUE(activeLayer);
pendingLayer->setTextureMailbox(m_testData.m_mailbox1);
@@ -459,20 +459,20 @@
TEST_F(TextureLayerImplWithMailboxTest, testDestructorCallbackOnCreatedResource)
{
scoped_ptr<TextureLayerImpl> implLayer;
- implLayer = TextureLayerImpl::Create(m_hostImpl.activeTree(), 1, true);
+ implLayer = TextureLayerImpl::Create(m_hostImpl.active_tree(), 1, true);
ASSERT_TRUE(implLayer);
EXPECT_CALL(m_testData.m_mockCallback,
Release(m_testData.m_mailboxName1, _)).Times(1);
implLayer->setTextureMailbox(m_testData.m_mailbox1);
- implLayer->WillDraw(m_hostImpl.activeTree()->resource_provider());
- implLayer->DidDraw(m_hostImpl.activeTree()->resource_provider());
+ implLayer->WillDraw(m_hostImpl.active_tree()->resource_provider());
+ implLayer->DidDraw(m_hostImpl.active_tree()->resource_provider());
implLayer->setTextureMailbox(TextureMailbox());
}
TEST_F(TextureLayerImplWithMailboxTest, testCallbackOnInUseResource)
{
- ResourceProvider *provider = m_hostImpl.activeTree()->resource_provider();
+ ResourceProvider *provider = m_hostImpl.active_tree()->resource_provider();
ResourceProvider::ResourceId id =
provider->CreateResourceFromTextureMailbox(m_testData.m_mailbox1);
provider->AllocateForTesting(id);
diff --git a/cc/thread_proxy.cc b/cc/thread_proxy.cc
index faa6695..b3053c0 100644
--- a/cc/thread_proxy.cc
+++ b/cc/thread_proxy.cc
@@ -134,7 +134,7 @@
{
DCHECK(Proxy::IsImplThread());
if (m_layerTreeHostImpl.get())
- m_layerTreeHostImpl->startPageScaleAnimation(targetOffset, useAnchor, scale, base::TimeTicks::Now(), duration);
+ m_layerTreeHostImpl->StartPageScaleAnimation(targetOffset, useAnchor, scale, base::TimeTicks::Now(), duration);
}
void ThreadProxy::FinishAllRendering()
@@ -190,7 +190,7 @@
void ThreadProxy::setVisibleOnImplThread(CompletionEvent* completion, bool visible)
{
TRACE_EVENT0("cc", "ThreadProxy::setVisibleOnImplThread");
- m_layerTreeHostImpl->setVisible(visible);
+ m_layerTreeHostImpl->SetVisible(visible);
m_schedulerOnImplThread->setVisible(visible);
completion->signal();
}
@@ -287,7 +287,7 @@
if (m_commitRequestSentToImplThread)
return;
m_commitRequestSentToImplThread = true;
- Proxy::ImplThread()->postTask(base::Bind(&ThreadProxy::setNeedsCommitOnImplThread, m_implThreadWeakPtr));
+ Proxy::ImplThread()->postTask(base::Bind(&ThreadProxy::SetNeedsCommitOnImplThread, m_implThreadWeakPtr));
}
void ThreadProxy::SetNeedsCommit()
@@ -301,10 +301,10 @@
if (m_commitRequestSentToImplThread)
return;
m_commitRequestSentToImplThread = true;
- Proxy::ImplThread()->postTask(base::Bind(&ThreadProxy::setNeedsCommitOnImplThread, m_implThreadWeakPtr));
+ Proxy::ImplThread()->postTask(base::Bind(&ThreadProxy::SetNeedsCommitOnImplThread, m_implThreadWeakPtr));
}
-void ThreadProxy::didLoseOutputSurfaceOnImplThread()
+void ThreadProxy::DidLoseOutputSurfaceOnImplThread()
{
DCHECK(IsImplThread());
TRACE_EVENT0("cc", "ThreadProxy::didLoseOutputSurfaceOnImplThread");
@@ -315,14 +315,14 @@
{
DCHECK(IsImplThread());
TRACE_EVENT0("cc", "ThreadProxy::checkOutputSurfaceStatusOnImplThread");
- if (!m_layerTreeHostImpl->isContextLost())
+ if (!m_layerTreeHostImpl->IsContextLost())
return;
- if (cc::ContextProvider* offscreenContexts = m_layerTreeHostImpl->resourceProvider()->offscreen_context_provider())
+ if (cc::ContextProvider* offscreenContexts = m_layerTreeHostImpl->resource_provider()->offscreen_context_provider())
offscreenContexts->VerifyContexts();
m_schedulerOnImplThread->didLoseOutputSurface();
}
-void ThreadProxy::onSwapBuffersCompleteOnImplThread()
+void ThreadProxy::OnSwapBuffersCompleteOnImplThread()
{
DCHECK(IsImplThread());
TRACE_EVENT0("cc", "ThreadProxy::onSwapBuffersCompleteOnImplThread");
@@ -330,35 +330,35 @@
Proxy::MainThread()->postTask(base::Bind(&ThreadProxy::didCompleteSwapBuffers, m_mainThreadWeakPtr));
}
-void ThreadProxy::onVSyncParametersChanged(base::TimeTicks timebase, base::TimeDelta interval)
+void ThreadProxy::OnVSyncParametersChanged(base::TimeTicks timebase, base::TimeDelta interval)
{
DCHECK(IsImplThread());
TRACE_EVENT2("cc", "ThreadProxy::onVSyncParametersChanged", "timebase", (timebase - base::TimeTicks()).InMilliseconds(), "interval", interval.InMilliseconds());
m_schedulerOnImplThread->setTimebaseAndInterval(timebase, interval);
}
-void ThreadProxy::onCanDrawStateChanged(bool canDraw)
+void ThreadProxy::OnCanDrawStateChanged(bool canDraw)
{
DCHECK(IsImplThread());
TRACE_EVENT1("cc", "ThreadProxy::onCanDrawStateChanged", "canDraw", canDraw);
m_schedulerOnImplThread->setCanDraw(canDraw);
}
-void ThreadProxy::onHasPendingTreeStateChanged(bool hasPendingTree)
+void ThreadProxy::OnHasPendingTreeStateChanged(bool hasPendingTree)
{
DCHECK(IsImplThread());
TRACE_EVENT1("cc", "ThreadProxy::onHasPendingTreeStateChanged", "hasPendingTree", hasPendingTree);
m_schedulerOnImplThread->setHasPendingTree(hasPendingTree);
}
-void ThreadProxy::setNeedsCommitOnImplThread()
+void ThreadProxy::SetNeedsCommitOnImplThread()
{
DCHECK(IsImplThread());
TRACE_EVENT0("cc", "ThreadProxy::setNeedsCommitOnImplThread");
m_schedulerOnImplThread->setNeedsCommit();
}
-void ThreadProxy::setNeedsManageTilesOnImplThread()
+void ThreadProxy::SetNeedsManageTilesOnImplThread()
{
if (m_manageTilesPending)
return;
@@ -371,7 +371,7 @@
// TODO(nduca): If needed, move this into CCSchedulerStateMachine.
m_manageTilesPending = false;
if (m_layerTreeHostImpl)
- m_layerTreeHostImpl->manageTiles();
+ m_layerTreeHostImpl->ManageTiles();
}
void ThreadProxy::setNeedsForcedCommitOnImplThread()
@@ -381,21 +381,21 @@
m_schedulerOnImplThread->setNeedsForcedCommit();
}
-void ThreadProxy::postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector> events, base::Time wallClockTime)
+void ThreadProxy::PostAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector> events, base::Time wallClockTime)
{
DCHECK(IsImplThread());
TRACE_EVENT0("cc", "ThreadProxy::postAnimationEventsToMainThreadOnImplThread");
Proxy::MainThread()->postTask(base::Bind(&ThreadProxy::setAnimationEvents, m_mainThreadWeakPtr, base::Passed(&events), wallClockTime));
}
-bool ThreadProxy::reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff)
+bool ThreadProxy::ReduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff)
{
DCHECK(IsImplThread());
if (!m_layerTreeHost->contents_texture_manager())
return false;
- bool reduceResult = m_layerTreeHost->contents_texture_manager()->reduceMemoryOnImplThread(limitBytes, priorityCutoff, m_layerTreeHostImpl->resourceProvider());
+ bool reduceResult = m_layerTreeHost->contents_texture_manager()->reduceMemoryOnImplThread(limitBytes, priorityCutoff, m_layerTreeHostImpl->resource_provider());
if (!reduceResult)
return false;
@@ -406,17 +406,17 @@
return true;
}
-void ThreadProxy::reduceWastedContentsTextureMemoryOnImplThread()
+void ThreadProxy::ReduceWastedContentsTextureMemoryOnImplThread()
{
DCHECK(IsImplThread());
if (!m_layerTreeHost->contents_texture_manager())
return;
- m_layerTreeHost->contents_texture_manager()->reduceWastedMemoryOnImplThread(m_layerTreeHostImpl->resourceProvider());
+ m_layerTreeHost->contents_texture_manager()->reduceWastedMemoryOnImplThread(m_layerTreeHostImpl->resource_provider());
}
-void ThreadProxy::sendManagedMemoryStats()
+void ThreadProxy::SendManagedMemoryStats()
{
DCHECK(IsImplThread());
if (!m_layerTreeHostImpl.get())
@@ -430,13 +430,13 @@
if (m_layerTreeHost->settings().implSidePainting)
return;
- m_layerTreeHostImpl->sendManagedMemoryStats(
+ m_layerTreeHostImpl->SendManagedMemoryStats(
m_layerTreeHost->contents_texture_manager()->memoryVisibleBytes(),
m_layerTreeHost->contents_texture_manager()->memoryVisibleAndNearbyBytes(),
m_layerTreeHost->contents_texture_manager()->memoryUseBytes());
}
-bool ThreadProxy::isInsideDraw()
+bool ThreadProxy::IsInsideDraw()
{
return m_insideDraw;
}
@@ -446,7 +446,7 @@
DCHECK(IsMainThread());
TRACE_EVENT0("cc", "ThreadProxy::setNeedsRedraw");
Proxy::ImplThread()->postTask(base::Bind(&ThreadProxy::setFullRootLayerDamageOnImplThread, m_implThreadWeakPtr));
- Proxy::ImplThread()->postTask(base::Bind(&ThreadProxy::setNeedsRedrawOnImplThread, m_implThreadWeakPtr));
+ Proxy::ImplThread()->postTask(base::Bind(&ThreadProxy::SetNeedsRedrawOnImplThread, m_implThreadWeakPtr));
}
void ThreadProxy::SetDeferCommits(bool deferCommits)
@@ -470,7 +470,7 @@
return m_commitRequested;
}
-void ThreadProxy::setNeedsRedrawOnImplThread()
+void ThreadProxy::SetNeedsRedrawOnImplThread()
{
DCHECK(IsImplThread());
TRACE_EVENT0("cc", "ThreadProxy::setNeedsRedrawOnImplThread");
@@ -484,7 +484,7 @@
m_schedulerOnImplThread->didSwapUseIncompleteTile();
}
-void ThreadProxy::didUploadVisibleHighResolutionTileOnImplThread()
+void ThreadProxy::DidUploadVisibleHighResolutionTileOnImplThread()
{
DCHECK(IsImplThread());
TRACE_EVENT0("cc", "ThreadProxy::didUploadVisibleHighResolutionTileOnImplThread");
@@ -494,7 +494,7 @@
void ThreadProxy::MainThreadHasStoppedFlinging()
{
if (m_inputHandlerOnImplThread)
- m_inputHandlerOnImplThread->mainThreadHasStoppedFlinging();
+ m_inputHandlerOnImplThread->MainThreadHasStoppedFlinging();
}
void ThreadProxy::Start()
@@ -555,7 +555,7 @@
{
TRACE_EVENT0("cc", "ThreadProxy::finishAllRenderingOnImplThread");
DCHECK(IsImplThread());
- m_layerTreeHostImpl->finishAllRendering();
+ m_layerTreeHostImpl->FinishAllRendering();
completion->signal();
}
@@ -578,10 +578,10 @@
TRACE_EVENT0("cc", "ThreadProxy::scheduledActionBeginFrame");
scoped_ptr<BeginFrameAndCommitState> beginFrameState(new BeginFrameAndCommitState);
beginFrameState->monotonicFrameBeginTime = base::TimeTicks::Now();
- beginFrameState->scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
- beginFrameState->implTransform = m_layerTreeHostImpl->activeTree()->ImplTransform();
- DCHECK_GT(m_layerTreeHostImpl->memoryAllocationLimitBytes(), 0u);
- beginFrameState->memoryAllocationLimitBytes = m_layerTreeHostImpl->memoryAllocationLimitBytes();
+ beginFrameState->scrollInfo = m_layerTreeHostImpl->ProcessScrollDeltas();
+ beginFrameState->implTransform = m_layerTreeHostImpl->active_tree()->ImplTransform();
+ DCHECK_GT(m_layerTreeHostImpl->memory_allocation_limit_bytes(), 0u);
+ beginFrameState->memoryAllocationLimitBytes = m_layerTreeHostImpl->memory_allocation_limit_bytes();
Proxy::MainThread()->postTask(base::Bind(&ThreadProxy::beginFrame, m_mainThreadWeakPtr, base::Passed(&beginFrameState)));
if (m_beginFrameCompletionEventOnImplThread) {
@@ -721,7 +721,7 @@
return;
}
- m_layerTreeHostImpl->resourceProvider()->SetOffscreenContextProvider(offscreenContextProvider);
+ m_layerTreeHostImpl->resource_provider()->SetOffscreenContextProvider(offscreenContextProvider);
if (m_layerTreeHost->contents_texture_manager()->linkedEvictedBackingsExist()) {
// Clear any uploads we were making to textures linked to evicted
@@ -729,12 +729,12 @@
queue->clearUploadsToEvictedResources();
// Some textures in the layer tree are invalid. Kick off another commit
// to fill them again.
- setNeedsCommitOnImplThread();
+ SetNeedsCommitOnImplThread();
}
m_layerTreeHost->contents_texture_manager()->pushTexturePrioritiesToBackings();
- m_currentResourceUpdateControllerOnImplThread = ResourceUpdateController::Create(this, Proxy::ImplThread(), queue.Pass(), m_layerTreeHostImpl->resourceProvider());
+ m_currentResourceUpdateControllerOnImplThread = ResourceUpdateController::Create(this, Proxy::ImplThread(), queue.Pass(), m_layerTreeHostImpl->resource_provider());
m_currentResourceUpdateControllerOnImplThread->PerformMoreUpdates(
m_schedulerOnImplThread->anticipatedDrawTime());
@@ -762,10 +762,10 @@
m_currentResourceUpdateControllerOnImplThread->Finalize();
m_currentResourceUpdateControllerOnImplThread.reset();
- m_layerTreeHostImpl->beginCommit();
+ m_layerTreeHostImpl->BeginCommit();
m_layerTreeHost->BeginCommitOnImplThread(m_layerTreeHostImpl.get());
m_layerTreeHost->FinishCommitOnImplThread(m_layerTreeHostImpl.get());
- m_layerTreeHostImpl->commitComplete();
+ m_layerTreeHostImpl->CommitComplete();
m_nextFrameIsNewlyCommittedFrameOnImplThread = true;
@@ -791,14 +791,14 @@
{
DCHECK(IsImplThread());
TRACE_EVENT0("cc", "ThreadProxy::scheduledActionCheckForCompletedTileUploads");
- m_layerTreeHostImpl->checkForCompletedTileUploads();
+ m_layerTreeHostImpl->CheckForCompletedTileUploads();
}
void ThreadProxy::scheduledActionActivatePendingTreeIfNeeded()
{
DCHECK(IsImplThread());
TRACE_EVENT0("cc", "ThreadProxy::scheduledActionActivatePendingTreeIfNeeded");
- m_layerTreeHostImpl->activatePendingTreeIfNeeded();
+ m_layerTreeHostImpl->ActivatePendingTreeIfNeeded();
}
void ThreadProxy::scheduledActionBeginContextRecreation()
@@ -830,10 +830,10 @@
base::Time wallClockTime = base::Time::Now();
if (m_inputHandlerOnImplThread.get())
- m_inputHandlerOnImplThread->animate(monotonicTime);
+ m_inputHandlerOnImplThread->Animate(monotonicTime);
- m_layerTreeHostImpl->activatePendingTreeIfNeeded();
- m_layerTreeHostImpl->animate(monotonicTime, wallClockTime);
+ m_layerTreeHostImpl->ActivatePendingTreeIfNeeded();
+ m_layerTreeHostImpl->Animate(monotonicTime, wallClockTime);
// This method is called on a forced draw, regardless of whether we are able to produce a frame,
// as the calling site on main thread is blocked until its request completes, and we signal
@@ -845,18 +845,18 @@
// prepareToDraw(), it is guarded on canDraw() as well.
LayerTreeHostImpl::FrameData frame;
- bool drawFrame = m_layerTreeHostImpl->canDraw() && (m_layerTreeHostImpl->prepareToDraw(frame) || forcedDraw);
+ bool drawFrame = m_layerTreeHostImpl->CanDraw() && (m_layerTreeHostImpl->PrepareToDraw(&frame) || forcedDraw);
if (drawFrame) {
- m_layerTreeHostImpl->drawLayers(frame);
+ m_layerTreeHostImpl->DrawLayers(&frame);
result.didDraw = true;
}
- m_layerTreeHostImpl->didDrawAllLayers(frame);
+ m_layerTreeHostImpl->DidDrawAllLayers(frame);
// Check for tree activation.
- if (m_completionEventForCommitHeldOnTreeActivation && !m_layerTreeHostImpl->pendingTree())
+ if (m_completionEventForCommitHeldOnTreeActivation && !m_layerTreeHostImpl->pending_tree())
{
TRACE_EVENT_INSTANT0("cc", "ReleaseCommitbyActivation");
- DCHECK(m_layerTreeHostImpl->Settings().implSidePainting);
+ DCHECK(m_layerTreeHostImpl->settings().implSidePainting);
m_completionEventForCommitHeldOnTreeActivation->signal();
m_completionEventForCommitHeldOnTreeActivation = 0;
}
@@ -865,15 +865,15 @@
if (m_readbackRequestOnImplThread) {
m_readbackRequestOnImplThread->success = false;
if (drawFrame) {
- m_layerTreeHostImpl->readback(m_readbackRequestOnImplThread->pixels, m_readbackRequestOnImplThread->rect);
- m_readbackRequestOnImplThread->success = !m_layerTreeHostImpl->isContextLost();
+ m_layerTreeHostImpl->Readback(m_readbackRequestOnImplThread->pixels, m_readbackRequestOnImplThread->rect);
+ m_readbackRequestOnImplThread->success = !m_layerTreeHostImpl->IsContextLost();
}
m_readbackRequestOnImplThread->completion.signal();
m_readbackRequestOnImplThread = 0;
} else if (drawFrame) {
- result.didSwap = m_layerTreeHostImpl->swapBuffers();
+ result.didSwap = m_layerTreeHostImpl->SwapBuffers();
- if (frame.containsIncompleteTile)
+ if (frame.contains_incomplete_tile)
didSwapUseIncompleteTileOnImplThread();
}
@@ -886,7 +886,7 @@
if (drawFrame)
checkOutputSurfaceStatusOnImplThread();
- m_layerTreeHostImpl->beginNextFrame();
+ m_layerTreeHostImpl->BeginNextFrame();
return result;
}
@@ -1016,7 +1016,7 @@
m_inputHandlerOnImplThread = scoped_ptr<InputHandler>(handler);
if (m_inputHandlerOnImplThread.get())
- m_inputHandlerOnImplThread->bindToClient(m_layerTreeHostImpl.get());
+ m_inputHandlerOnImplThread->BindToClient(m_layerTreeHostImpl.get());
m_implThreadWeakPtr = m_weakFactoryOnImplThread.GetWeakPtr();
completion->signal();
@@ -1034,14 +1034,14 @@
TRACE_EVENT0("cc", "ThreadProxy::initializeRendererOnImplThread");
DCHECK(IsImplThread());
DCHECK(m_outputSurfaceBeforeInitializationOnImplThread.get());
- *initializeSucceeded = m_layerTreeHostImpl->initializeRenderer(m_outputSurfaceBeforeInitializationOnImplThread.Pass());
+ *initializeSucceeded = m_layerTreeHostImpl->InitializeRenderer(m_outputSurfaceBeforeInitializationOnImplThread.Pass());
if (*initializeSucceeded) {
- *capabilities = m_layerTreeHostImpl->rendererCapabilities();
+ *capabilities = m_layerTreeHostImpl->GetRendererCapabilities();
m_schedulerOnImplThread->setSwapBuffersCompleteSupported(
capabilities->using_swap_complete_callback);
int maxFramesPending = FrameRateController::kDefaultMaxFramesPending;
- if (m_layerTreeHostImpl->outputSurface()->capabilities().has_parent_compositor)
+ if (m_layerTreeHostImpl->output_surface()->capabilities().has_parent_compositor)
maxFramesPending = 1;
m_schedulerOnImplThread->setMaxFramesPending(maxFramesPending);
}
@@ -1053,7 +1053,7 @@
{
TRACE_EVENT0("cc", "ThreadProxy::layerTreeHostClosedOnImplThread");
DCHECK(IsImplThread());
- m_layerTreeHost->DeleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
+ m_layerTreeHost->DeleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resource_provider());
m_inputHandlerOnImplThread.reset();
m_layerTreeHostImpl.reset();
m_schedulerOnImplThread.reset();
@@ -1076,11 +1076,11 @@
{
TRACE_EVENT0("cc", "ThreadProxy::recreateOutputSurfaceOnImplThread");
DCHECK(IsImplThread());
- m_layerTreeHost->DeleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
- *recreateSucceeded = m_layerTreeHostImpl->initializeRenderer(outputSurface.Pass());
+ m_layerTreeHost->DeleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resource_provider());
+ *recreateSucceeded = m_layerTreeHostImpl->InitializeRenderer(outputSurface.Pass());
if (*recreateSucceeded) {
- *capabilities = m_layerTreeHostImpl->rendererCapabilities();
- m_layerTreeHostImpl->resourceProvider()->SetOffscreenContextProvider(offscreenContextProvider);
+ *capabilities = m_layerTreeHostImpl->GetRendererCapabilities();
+ m_layerTreeHostImpl->resource_provider()->SetOffscreenContextProvider(offscreenContextProvider);
m_schedulerOnImplThread->didRecreateOutputSurface();
} else if (offscreenContextProvider) {
offscreenContextProvider->VerifyContexts();
@@ -1091,7 +1091,7 @@
void ThreadProxy::renderingStatsOnImplThread(CompletionEvent* completion, RenderingStats* stats)
{
DCHECK(IsImplThread());
- m_layerTreeHostImpl->renderingStats(stats);
+ m_layerTreeHostImpl->CollectRenderingStats(stats);
completion->signal();
}
@@ -1123,7 +1123,7 @@
void ThreadProxy::asValueOnImplThread(CompletionEvent* completion, base::DictionaryValue* state) const
{
- state->Set("layer_tree_host_impl", m_layerTreeHostImpl->asValue().release());
+ state->Set("layer_tree_host_impl", m_layerTreeHostImpl->AsValue().release());
completion->signal();
}
@@ -1142,7 +1142,7 @@
void ThreadProxy::commitPendingOnImplThreadForTesting(CommitPendingRequest* request)
{
DCHECK(IsImplThread());
- if (m_layerTreeHostImpl->outputSurface())
+ if (m_layerTreeHostImpl->output_surface())
request->commitPending = m_schedulerOnImplThread->commitPending();
else
request->commitPending = false;
@@ -1168,16 +1168,16 @@
void ThreadProxy::capturePictureOnImplThread(CompletionEvent* completion, skia::RefPtr<SkPicture>* picture)
{
DCHECK(IsImplThread());
- *picture = m_layerTreeHostImpl->capturePicture();
+ *picture = m_layerTreeHostImpl->CapturePicture();
completion->signal();
}
-void ThreadProxy::renewTreePriority()
+void ThreadProxy::RenewTreePriority()
{
bool smoothnessTakesPriority =
- m_layerTreeHostImpl->pinchGestureActive() ||
- m_layerTreeHostImpl->currentlyScrollingLayer() ||
- m_layerTreeHostImpl->pageScaleAnimationActive();
+ m_layerTreeHostImpl->pinch_gesture_active() ||
+ m_layerTreeHostImpl->CurrentlyScrollingLayer() ||
+ m_layerTreeHostImpl->page_scale_animation_active();
// Update expiration time if smoothness currently takes priority.
if (smoothnessTakesPriority) {
@@ -1195,17 +1195,17 @@
// New content always takes priority when the active tree has
// evicted resources or there is an invalid viewport size.
- if (m_layerTreeHostImpl->activeTree()->ContentsTexturesPurged() ||
- m_layerTreeHostImpl->activeTree()->ViewportSizeInvalid())
+ if (m_layerTreeHostImpl->active_tree()->ContentsTexturesPurged() ||
+ m_layerTreeHostImpl->active_tree()->ViewportSizeInvalid())
priority = NEW_CONTENT_TAKES_PRIORITY;
- m_layerTreeHostImpl->setTreePriority(priority);
+ m_layerTreeHostImpl->SetTreePriority(priority);
// Notify the the client of this compositor via the output surface.
// TODO(epenner): Route this to compositor-thread instead of output-surface
// after GTFO refactor of compositor-thread (http://crbug/170828).
- if (m_layerTreeHostImpl->outputSurface()) {
- m_layerTreeHostImpl->outputSurface()->UpdateSmoothnessTakesPriority(
+ if (m_layerTreeHostImpl->output_surface()) {
+ m_layerTreeHostImpl->output_surface()->UpdateSmoothnessTakesPriority(
priority == SMOOTHNESS_TAKES_PRIORITY);
}
@@ -1232,7 +1232,7 @@
DCHECK(m_renewTreePriorityOnImplThreadPending);
m_renewTreePriorityOnImplThreadPending = false;
- renewTreePriority();
+ RenewTreePriority();
}
} // namespace cc
diff --git a/cc/thread_proxy.h b/cc/thread_proxy.h
index 1b027e0..a56b5be 100644
--- a/cc/thread_proxy.h
+++ b/cc/thread_proxy.h
@@ -59,21 +59,21 @@
virtual bool CommitPendingForTesting() OVERRIDE;
// LayerTreeHostImplClient implementation
- virtual void didLoseOutputSurfaceOnImplThread() OVERRIDE;
- virtual void onSwapBuffersCompleteOnImplThread() OVERRIDE;
- virtual void onVSyncParametersChanged(base::TimeTicks timebase, base::TimeDelta interval) OVERRIDE;
- virtual void onCanDrawStateChanged(bool canDraw) OVERRIDE;
- virtual void onHasPendingTreeStateChanged(bool hasPendingTree) OVERRIDE;
- virtual void setNeedsRedrawOnImplThread() OVERRIDE;
- virtual void didUploadVisibleHighResolutionTileOnImplThread() OVERRIDE;
- virtual void setNeedsCommitOnImplThread() OVERRIDE;
- virtual void setNeedsManageTilesOnImplThread() OVERRIDE;
- virtual void postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector>, base::Time wallClockTime) OVERRIDE;
- virtual bool reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff) OVERRIDE;
- virtual void reduceWastedContentsTextureMemoryOnImplThread() OVERRIDE;
- virtual void sendManagedMemoryStats() OVERRIDE;
- virtual bool isInsideDraw() OVERRIDE;
- virtual void renewTreePriority() OVERRIDE;
+ virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE;
+ virtual void OnSwapBuffersCompleteOnImplThread() OVERRIDE;
+ virtual void OnVSyncParametersChanged(base::TimeTicks timebase, base::TimeDelta interval) OVERRIDE;
+ virtual void OnCanDrawStateChanged(bool canDraw) OVERRIDE;
+ virtual void OnHasPendingTreeStateChanged(bool hasPendingTree) OVERRIDE;
+ virtual void SetNeedsRedrawOnImplThread() OVERRIDE;
+ virtual void DidUploadVisibleHighResolutionTileOnImplThread() OVERRIDE;
+ virtual void SetNeedsCommitOnImplThread() OVERRIDE;
+ virtual void SetNeedsManageTilesOnImplThread() OVERRIDE;
+ virtual void PostAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector>, base::Time wallClockTime) OVERRIDE;
+ virtual bool ReduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff) OVERRIDE;
+ virtual void ReduceWastedContentsTextureMemoryOnImplThread() OVERRIDE;
+ virtual void SendManagedMemoryStats() OVERRIDE;
+ virtual bool IsInsideDraw() OVERRIDE;
+ virtual void RenewTreePriority() OVERRIDE;
// SchedulerClient implementation
virtual void scheduledActionBeginFrame() OVERRIDE;
diff --git a/cc/tiled_layer_impl_unittest.cc b/cc/tiled_layer_impl_unittest.cc
index c816f91..bdf9f7b 100644
--- a/cc/tiled_layer_impl_unittest.cc
+++ b/cc/tiled_layer_impl_unittest.cc
@@ -30,7 +30,7 @@
// visibility of the entire layer size.
scoped_ptr<TiledLayerImpl> createLayer(const gfx::Size& tileSize, const gfx::Size& layerSize, LayerTilingData::BorderTexelOption borderTexels)
{
- scoped_ptr<TiledLayerImpl> layer = TiledLayerImpl::Create(m_hostImpl.activeTree(), 1);
+ scoped_ptr<TiledLayerImpl> layer = TiledLayerImpl::Create(m_hostImpl.active_tree(), 1);
scoped_ptr<LayerTilingData> tiler = LayerTilingData::create(tileSize, borderTexels);
tiler->setBounds(layerSize);
layer->setTilingData(*tiler);
diff --git a/cc/tiled_layer_unittest.cc b/cc/tiled_layer_unittest.cc
index 52293aa..e955155 100644
--- a/cc/tiled_layer_unittest.cc
+++ b/cc/tiled_layer_unittest.cc
@@ -196,7 +196,7 @@
TEST_F(TiledLayerTest, pushDirtyTiles)
{
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
// The tile size is 100x100, so this invalidates and then paints two tiles.
layer->SetBounds(gfx::Size(100, 200));
@@ -220,7 +220,7 @@
TEST_F(TiledLayerTest, pushOccludedDirtyTiles)
{
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
TestOcclusionTracker occluded;
m_occlusion = &occluded;
layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000), gfx::Size(1000, 1000));
@@ -257,7 +257,7 @@
TEST_F(TiledLayerTest, pushDeletedTiles)
{
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
// The tile size is 100x100, so this invalidates and then paints two tiles.
layer->SetBounds(gfx::Size(100, 200));
@@ -291,7 +291,7 @@
TEST_F(TiledLayerTest, pushIdlePaintTiles)
{
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
// The tile size is 100x100. Setup 5x5 tiles with one visible tile in the center.
// This paints 1 visible of the 25 invalid tiles.
@@ -327,7 +327,7 @@
TEST_F(TiledLayerTest, predictivePainting)
{
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
// Prepainting should occur in the scroll direction first, and the
// visible rect should be extruded only along the dominant axis.
@@ -400,9 +400,9 @@
// Start with 2mb of memory, but the test is going to try to use just more than 1mb, so we reduce to 1mb later.
m_resourceManager->setMaxMemoryLimitBytes(2 * 1024 * 1024);
scoped_refptr<FakeTiledLayer> layer1 = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl1 = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl1 = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
scoped_refptr<FakeTiledLayer> layer2 = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl2 = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 2));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl2 = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 2));
// 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 we paint layer1, and one tile from layer2. Then when we idle paint
@@ -453,7 +453,7 @@
TEST_F(TiledLayerTest, pushIdlePaintedOccludedTiles)
{
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
TestOcclusionTracker occluded;
m_occlusion = &occluded;
@@ -473,7 +473,7 @@
TEST_F(TiledLayerTest, pushTilesMarkedDirtyDuringPaint)
{
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
// 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
@@ -493,8 +493,8 @@
{
scoped_refptr<FakeTiledLayer> layer1 = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
scoped_refptr<FakeTiledLayer> layer2 = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layer1Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
- scoped_ptr<FakeTiledLayerImpl> layer2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 2));
+ scoped_ptr<FakeTiledLayerImpl> layer1Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layer2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 2));
// Invalidate a tile on layer1, during update of layer 2.
layer2->fakeLayerUpdater()->setRectToInvalidate(gfx::Rect(0, 50, 100, 50), layer1.get());
@@ -517,8 +517,8 @@
{
scoped_refptr<FakeTiledLayer> layer1 = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
scoped_refptr<FakeTiledLayer> layer2 = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layer1Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
- scoped_ptr<FakeTiledLayerImpl> layer2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 2));
+ scoped_ptr<FakeTiledLayerImpl> layer1Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layer2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 2));
layer1->fakeLayerUpdater()->setRectToInvalidate(gfx::Rect(0, 50, 100, 50), layer2.get());
layer1->SetBounds(gfx::Size(100, 200));
@@ -559,7 +559,7 @@
m_resourceManager->setMaxMemoryLimitBytes(memoryForLayer);
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
// Full size layer with half being visible.
layer->SetBounds(gfx::Size(layerWidth, layerHeight));
@@ -599,7 +599,7 @@
TEST_F(TiledLayerTest, idlePaintOutOfMemory)
{
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
// We have enough memory for only the visible rect, so we will run out of memory in first idle paint.
int memoryLimit = 4 * 100 * 100; // 1 tiles, 4 bytes per pixel.
@@ -623,7 +623,7 @@
TEST_F(TiledLayerTest, idlePaintZeroSizedLayer)
{
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
bool animating[2] = {false, true};
for (int i = 0; i < 2; i++) {
@@ -651,7 +651,7 @@
TEST_F(TiledLayerTest, idlePaintNonVisibleLayers)
{
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
// Alternate between not visible and visible.
gfx::Rect v(0, 0, 100, 100);
@@ -682,7 +682,7 @@
TEST_F(TiledLayerTest, invalidateFromPrepare)
{
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
// The tile size is 100x100, so this invalidates and then paints two tiles.
layer->SetBounds(gfx::Size(100, 200));
@@ -756,7 +756,7 @@
TEST_F(TiledLayerTest, verifyInvalidationWhenContentsScaleChanges)
{
scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
// Create a layer with one tile.
layer->SetBounds(gfx::Size(100, 100));
@@ -911,7 +911,7 @@
layer_tree_host_->UpdateLayers(m_queue.get(),
std::numeric_limits<size_t>::max());
{
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
EXPECT_EQ(6, m_queue->fullUploadSize());
EXPECT_EQ(0, m_queue->partialUploadSize());
updateTextures();
@@ -926,7 +926,7 @@
layer->invalidateContentRect(gfx::Rect(0, 0, 300, 150));
layer_tree_host_->UpdateLayers(m_queue.get(), std::numeric_limits<size_t>::max());
{
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
EXPECT_EQ(3, m_queue->fullUploadSize());
EXPECT_EQ(3, m_queue->partialUploadSize());
updateTextures();
@@ -940,7 +940,7 @@
// Partial update of 6 tiles.
layer->invalidateContentRect(gfx::Rect(50, 50, 200, 100));
{
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
layer_tree_host_->UpdateLayers(m_queue.get(), std::numeric_limits<size_t>::max());
EXPECT_EQ(2, m_queue->fullUploadSize());
EXPECT_EQ(4, m_queue->partialUploadSize());
@@ -955,7 +955,7 @@
// Checkerboard all tiles.
layer->invalidateContentRect(gfx::Rect(0, 0, 300, 200));
{
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
layerPushPropertiesTo(layer.get(), layerImpl.get());
}
layer_tree_host_->CommitComplete();
@@ -963,7 +963,7 @@
// Partial update of 6 checkerboard tiles.
layer->invalidateContentRect(gfx::Rect(50, 50, 200, 100));
{
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
layer_tree_host_->UpdateLayers(m_queue.get(), std::numeric_limits<size_t>::max());
EXPECT_EQ(6, m_queue->fullUploadSize());
EXPECT_EQ(0, m_queue->partialUploadSize());
@@ -978,7 +978,7 @@
// Partial update of 4 tiles.
layer->invalidateContentRect(gfx::Rect(50, 50, 100, 100));
{
- scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+ scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
layer_tree_host_->UpdateLayers(m_queue.get(), std::numeric_limits<size_t>::max());
EXPECT_EQ(0, m_queue->fullUploadSize());
EXPECT_EQ(4, m_queue->partialUploadSize());
@@ -1478,9 +1478,9 @@
child->fakeLayerUpdater()->clearUpdateCount();
child2->fakeLayerUpdater()->clearUpdateCount();
- scoped_ptr<FakeTiledLayerImpl> rootImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), root->id()));
- scoped_ptr<FakeTiledLayerImpl> childImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), child->id()));
- scoped_ptr<FakeTiledLayerImpl> child2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), child2->id()));
+ scoped_ptr<FakeTiledLayerImpl> rootImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), root->id()));
+ scoped_ptr<FakeTiledLayerImpl> childImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), child->id()));
+ scoped_ptr<FakeTiledLayerImpl> child2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), child2->id()));
layerPushPropertiesTo(root.get(), rootImpl.get());
layerPushPropertiesTo(child.get(), childImpl.get());
layerPushPropertiesTo(child2.get(), child2Impl.get());
@@ -1512,9 +1512,9 @@
child->fakeLayerUpdater()->clearUpdateCount();
child2->fakeLayerUpdater()->clearUpdateCount();
- scoped_ptr<FakeTiledLayerImpl> rootImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), root->id()));
- scoped_ptr<FakeTiledLayerImpl> childImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), child->id()));
- scoped_ptr<FakeTiledLayerImpl> child2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), child2->id()));
+ scoped_ptr<FakeTiledLayerImpl> rootImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), root->id()));
+ scoped_ptr<FakeTiledLayerImpl> childImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), child->id()));
+ scoped_ptr<FakeTiledLayerImpl> child2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), child2->id()));
layerPushPropertiesTo(root.get(), rootImpl.get());
layerPushPropertiesTo(child.get(), childImpl.get());
layerPushPropertiesTo(child2.get(), child2Impl.get());
@@ -1547,9 +1547,9 @@
child->fakeLayerUpdater()->clearUpdateCount();
child2->fakeLayerUpdater()->clearUpdateCount();
- scoped_ptr<FakeTiledLayerImpl> rootImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), root->id()));
- scoped_ptr<FakeTiledLayerImpl> childImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), child->id()));
- scoped_ptr<FakeTiledLayerImpl> child2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), child2->id()));
+ scoped_ptr<FakeTiledLayerImpl> rootImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), root->id()));
+ scoped_ptr<FakeTiledLayerImpl> childImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), child->id()));
+ scoped_ptr<FakeTiledLayerImpl> child2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), child2->id()));
layerPushPropertiesTo(root.get(), rootImpl.get());
layerPushPropertiesTo(child.get(), childImpl.get());
layerPushPropertiesTo(child2.get(), child2Impl.get());
diff --git a/cc/tree_synchronizer_unittest.cc b/cc/tree_synchronizer_unittest.cc
index b7879bf..88d4436e 100644
--- a/cc/tree_synchronizer_unittest.cc
+++ b/cc/tree_synchronizer_unittest.cc
@@ -143,7 +143,7 @@
// return a null tree.
TEST_F(TreeSynchronizerTest, syncNullTree)
{
- scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(static_cast<Layer*>(NULL), scoped_ptr<LayerImpl>(), m_hostImpl.activeTree());
+ scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(static_cast<Layer*>(NULL), scoped_ptr<LayerImpl>(), m_hostImpl.active_tree());
EXPECT_TRUE(!layerImplTreeRoot.get());
}
@@ -155,9 +155,9 @@
layerTreeRoot->AddChild(Layer::Create());
layerTreeRoot->AddChild(Layer::Create());
- scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.activeTree());
+ scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.active_tree());
- expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
}
// Constructs a very simple tree and synchronizes it attempting to reuse some layers
@@ -169,8 +169,8 @@
layerTreeRoot->AddChild(MockLayer::Create(&layerImplDestructionList));
layerTreeRoot->AddChild(MockLayer::Create(&layerImplDestructionList));
- scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.activeTree());
- expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.active_tree());
+ expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
// We have to push properties to pick up the destruction list pointer.
TreeSynchronizer::pushProperties(layerTreeRoot.get(), layerImplTreeRoot.get());
@@ -182,8 +182,8 @@
int secondLayerImplId = layerImplTreeRoot->children()[1]->id();
// Synchronize again. After the sync the trees should be equivalent and we should have created and destroyed one LayerImpl.
- layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.activeTree());
- expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.active_tree());
+ expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
ASSERT_EQ(1u, layerImplDestructionList.size());
EXPECT_EQ(secondLayerImplId, layerImplDestructionList[0]);
@@ -200,8 +200,8 @@
scoped_refptr<Layer> child2 = MockLayer::Create(&layerImplDestructionList);
layerTreeRoot->AddChild(MockLayer::Create(&layerImplDestructionList));
layerTreeRoot->AddChild(child2);
- scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.activeTree());
- expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.active_tree());
+ expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
// We have to push properties to pick up the destruction list pointer.
TreeSynchronizer::pushProperties(layerTreeRoot.get(), layerImplTreeRoot.get());
@@ -211,8 +211,8 @@
// re-insert the layer and sync again.
child2->RemoveFromParent();
layerTreeRoot->AddChild(child2);
- layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.activeTree());
- expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.active_tree());
+ expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
TreeSynchronizer::pushProperties(layerTreeRoot.get(), layerImplTreeRoot.get());
@@ -238,8 +238,8 @@
gfx::Size secondChildBounds = gfx::Size(25, 53);
layerTreeRoot->children()[1]->SetBounds(secondChildBounds);
- scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.activeTree());
- expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.active_tree());
+ expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
TreeSynchronizer::pushProperties(layerTreeRoot.get(), layerImplTreeRoot.get());
@@ -276,8 +276,8 @@
layerB->AddChild(MockLayer::Create(&layerImplDestructionList));
scoped_refptr<Layer> layerD = layerB->children()[1].get();
- scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.activeTree());
- expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.active_tree());
+ expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
// We have to push properties to pick up the destruction list pointer.
TreeSynchronizer::pushProperties(layerTreeRoot.get(), layerImplTreeRoot.get());
@@ -297,8 +297,8 @@
layerC->AddChild(layerB);
// After another synchronize our trees should match and we should not have destroyed any LayerImpls
- layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.activeTree());
- expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.active_tree());
+ expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
EXPECT_EQ(0u, layerImplDestructionList.size());
}
@@ -316,8 +316,8 @@
int oldTreeFirstChildLayerId = oldLayerTreeRoot->children()[0]->id();
int oldTreeSecondChildLayerId = oldLayerTreeRoot->children()[1]->id();
- scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(oldLayerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.activeTree());
- expectTreesAreIdentical(oldLayerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(oldLayerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.active_tree());
+ expectTreesAreIdentical(oldLayerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
// We have to push properties to pick up the destruction list pointer.
TreeSynchronizer::pushProperties(oldLayerTreeRoot.get(), layerImplTreeRoot.get());
@@ -327,8 +327,8 @@
// Synchronize again. After the sync all LayerImpls from the old tree should be deleted.
scoped_refptr<Layer> newLayerTreeRoot = Layer::Create();
- layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(newLayerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.activeTree());
- expectTreesAreIdentical(newLayerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(newLayerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.active_tree());
+ expectTreesAreIdentical(newLayerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
ASSERT_EQ(3u, layerImplDestructionList.size());
@@ -359,24 +359,24 @@
replicaLayerWithMask->SetMaskLayer(replicaMaskLayer.get());
layerTreeRoot->children()[2]->SetReplicaLayer(replicaLayerWithMask.get());
- scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.activeTree());
+ scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.active_tree());
- expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
// Remove the mask layer.
layerTreeRoot->children()[0]->SetMaskLayer(0);
- layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.activeTree());
- expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.active_tree());
+ expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
// Remove the replica layer.
layerTreeRoot->children()[1]->SetReplicaLayer(0);
- layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.activeTree());
- expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.active_tree());
+ expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
// Remove the replica mask.
replicaLayerWithMask->SetMaskLayer(0);
- layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.activeTree());
- expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.activeTree());
+ layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.active_tree());
+ expectTreesAreIdentical(layerTreeRoot.get(), layerImplTreeRoot.get(), m_hostImpl.active_tree());
}
TEST_F(TreeSynchronizerTest, synchronizeAnimations)
@@ -384,7 +384,7 @@
LayerTreeSettings settings;
FakeProxy proxy(scoped_ptr<Thread>(NULL));
DebugScopedSetImplThread impl(&proxy);
- scoped_ptr<LayerTreeHostImpl> hostImpl = LayerTreeHostImpl::create(settings, 0, &proxy);
+ scoped_ptr<LayerTreeHostImpl> hostImpl = LayerTreeHostImpl::Create(settings, NULL, &proxy);
scoped_refptr<Layer> layerTreeRoot = Layer::Create();
@@ -392,9 +392,9 @@
EXPECT_FALSE(static_cast<FakeLayerAnimationController*>(layerTreeRoot->layer_animation_controller())->synchronizedAnimations());
- scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.activeTree());
+ scoped_ptr<LayerImpl> layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), scoped_ptr<LayerImpl>(), m_hostImpl.active_tree());
TreeSynchronizer::pushProperties(layerTreeRoot.get(), layerImplTreeRoot.get());
- layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.activeTree());
+ layerImplTreeRoot = TreeSynchronizer::synchronizeTrees(layerTreeRoot.get(), layerImplTreeRoot.Pass(), m_hostImpl.active_tree());
EXPECT_TRUE(static_cast<FakeLayerAnimationController*>(layerTreeRoot->layer_animation_controller())->synchronizedAnimations());
}
