blob: 691fd4648d846019085a7242c3cde90c14531147 [file] [log] [blame]
// Copyright 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "cc/trees/layer_tree_host.h"
#include <algorithm>
#include "base/auto_reset.h"
#include "base/synchronization/lock.h"
#include "cc/animation/timing_function.h"
#include "cc/debug/frame_rate_counter.h"
#include "cc/layers/content_layer.h"
#include "cc/layers/content_layer_client.h"
#include "cc/layers/io_surface_layer.h"
#include "cc/layers/layer_impl.h"
#include "cc/layers/picture_layer.h"
#include "cc/layers/scrollbar_layer.h"
#include "cc/output/begin_frame_args.h"
#include "cc/output/copy_output_request.h"
#include "cc/output/copy_output_result.h"
#include "cc/output/output_surface.h"
#include "cc/resources/prioritized_resource.h"
#include "cc/resources/prioritized_resource_manager.h"
#include "cc/resources/resource_update_queue.h"
#include "cc/scheduler/frame_rate_controller.h"
#include "cc/test/fake_content_layer.h"
#include "cc/test/fake_content_layer_client.h"
#include "cc/test/fake_layer_tree_host_client.h"
#include "cc/test/fake_output_surface.h"
#include "cc/test/fake_picture_layer.h"
#include "cc/test/fake_picture_layer_impl.h"
#include "cc/test/fake_proxy.h"
#include "cc/test/fake_scrollbar_layer.h"
#include "cc/test/geometry_test_utils.h"
#include "cc/test/layer_tree_test.h"
#include "cc/test/occlusion_tracker_test_common.h"
#include "cc/trees/layer_tree_host_impl.h"
#include "cc/trees/layer_tree_impl.h"
#include "cc/trees/single_thread_proxy.h"
#include "cc/trees/thread_proxy.h"
#include "gpu/GLES2/gl2extchromium.h"
#include "skia/ext/refptr.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "third_party/khronos/GLES2/gl2.h"
#include "third_party/khronos/GLES2/gl2ext.h"
#include "third_party/skia/include/core/SkPicture.h"
#include "ui/gfx/point_conversions.h"
#include "ui/gfx/size_conversions.h"
#include "ui/gfx/vector2d_conversions.h"
using testing::_;
using testing::AnyNumber;
using testing::AtLeast;
using testing::Mock;
namespace cc {
namespace {
class LayerTreeHostTest : public LayerTreeTest {
};
// Two setNeedsCommits in a row should lead to at least 1 commit and at least 1
// draw with frame 0.
class LayerTreeHostTestSetNeedsCommit1 : public LayerTreeHostTest {
public:
LayerTreeHostTestSetNeedsCommit1() : num_commits_(0), num_draws_(0) {}
virtual void BeginTest() OVERRIDE {
PostSetNeedsCommitToMainThread();
PostSetNeedsCommitToMainThread();
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
num_draws_++;
if (!impl->active_tree()->source_frame_number())
EndTest();
}
virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
num_commits_++;
}
virtual void AfterTest() OVERRIDE {
EXPECT_GE(1, num_commits_);
EXPECT_GE(1, num_draws_);
}
private:
int num_commits_;
int num_draws_;
};
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommit1);
// A SetNeedsCommit should lead to 1 commit. Issuing a second commit after that
// first committed frame draws should lead to another commit.
class LayerTreeHostTestSetNeedsCommit2 : public LayerTreeHostTest {
public:
LayerTreeHostTestSetNeedsCommit2() : num_commits_(0), num_draws_(0) {}
virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
++num_draws_;
}
virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
++num_commits_;
switch (num_commits_) {
case 1:
PostSetNeedsCommitToMainThread();
break;
case 2:
EndTest();
break;
default:
NOTREACHED();
}
}
virtual void AfterTest() OVERRIDE {
EXPECT_EQ(2, num_commits_);
EXPECT_LE(1, num_draws_);
}
private:
int num_commits_;
int num_draws_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommit2);
// Verify that we pass property values in PushPropertiesTo.
class LayerTreeHostTestPushPropertiesTo : public LayerTreeHostTest {
protected:
virtual void SetupTree() OVERRIDE {
scoped_refptr<Layer> root = Layer::Create();
root->SetBounds(gfx::Size(10, 10));
layer_tree_host()->SetRootLayer(root);
LayerTreeHostTest::SetupTree();
}
enum Properties {
STARTUP,
BOUNDS,
HIDE_LAYER_AND_SUBTREE,
DRAWS_CONTENT,
DONE,
};
virtual void BeginTest() OVERRIDE {
index_ = STARTUP;
PostSetNeedsCommitToMainThread();
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
VerifyAfterValues(impl->active_tree()->root_layer());
}
virtual void DidCommitAndDrawFrame() OVERRIDE {
SetBeforeValues(layer_tree_host()->root_layer());
VerifyBeforeValues(layer_tree_host()->root_layer());
++index_;
if (index_ == DONE) {
EndTest();
return;
}
SetAfterValues(layer_tree_host()->root_layer());
}
virtual void AfterTest() OVERRIDE {}
void VerifyBeforeValues(Layer* layer) {
EXPECT_EQ(gfx::Size(10, 10).ToString(), layer->bounds().ToString());
EXPECT_FALSE(layer->hide_layer_and_subtree());
EXPECT_FALSE(layer->DrawsContent());
}
void SetBeforeValues(Layer* layer) {
layer->SetBounds(gfx::Size(10, 10));
layer->SetHideLayerAndSubtree(false);
layer->SetIsDrawable(false);
}
void VerifyAfterValues(LayerImpl* layer) {
switch (static_cast<Properties>(index_)) {
case STARTUP:
case DONE:
break;
case BOUNDS:
EXPECT_EQ(gfx::Size(20, 20).ToString(), layer->bounds().ToString());
break;
case HIDE_LAYER_AND_SUBTREE:
EXPECT_TRUE(layer->hide_layer_and_subtree());
break;
case DRAWS_CONTENT:
EXPECT_TRUE(layer->DrawsContent());
break;
}
}
void SetAfterValues(Layer* layer) {
switch (static_cast<Properties>(index_)) {
case STARTUP:
case DONE:
break;
case BOUNDS:
layer->SetBounds(gfx::Size(20, 20));
break;
case HIDE_LAYER_AND_SUBTREE:
layer->SetHideLayerAndSubtree(true);
break;
case DRAWS_CONTENT:
layer->SetIsDrawable(true);
break;
}
}
int index_;
};
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPushPropertiesTo);
// 1 setNeedsRedraw after the first commit has completed should lead to 1
// additional draw.
class LayerTreeHostTestSetNeedsRedraw : public LayerTreeHostTest {
public:
LayerTreeHostTestSetNeedsRedraw() : num_commits_(0), num_draws_(0) {}
virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
EXPECT_EQ(0, impl->active_tree()->source_frame_number());
if (!num_draws_) {
// Redraw again to verify that the second redraw doesn't commit.
PostSetNeedsRedrawToMainThread();
} else {
EndTest();
}
num_draws_++;
}
virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
EXPECT_EQ(0, num_draws_);
num_commits_++;
}
virtual void AfterTest() OVERRIDE {
EXPECT_GE(2, num_draws_);
EXPECT_EQ(1, num_commits_);
}
private:
int num_commits_;
int num_draws_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsRedraw);
// After setNeedsRedrawRect(invalid_rect) the final damage_rect
// must contain invalid_rect.
class LayerTreeHostTestSetNeedsRedrawRect : public LayerTreeHostTest {
public:
LayerTreeHostTestSetNeedsRedrawRect()
: num_draws_(0),
bounds_(50, 50),
invalid_rect_(10, 10, 20, 20),
root_layer_(ContentLayer::Create(&client_)) {
}
virtual void BeginTest() OVERRIDE {
root_layer_->SetIsDrawable(true);
root_layer_->SetBounds(bounds_);
layer_tree_host()->SetRootLayer(root_layer_);
layer_tree_host()->SetViewportSize(bounds_);
PostSetNeedsCommitToMainThread();
}
virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
LayerTreeHostImpl::FrameData* frame_data,
bool result) OVERRIDE {
EXPECT_TRUE(result);
gfx::RectF root_damage_rect;
if (!frame_data->render_passes.empty())
root_damage_rect = frame_data->render_passes.back()->damage_rect;
if (!num_draws_) {
// If this is the first frame, expect full frame damage.
EXPECT_RECT_EQ(root_damage_rect, gfx::Rect(bounds_));
} else {
// Check that invalid_rect_ is indeed repainted.
EXPECT_TRUE(root_damage_rect.Contains(invalid_rect_));
}
return result;
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
if (!num_draws_) {
PostSetNeedsRedrawRectToMainThread(invalid_rect_);
} else {
EndTest();
}
num_draws_++;
}
virtual void AfterTest() OVERRIDE {
EXPECT_EQ(2, num_draws_);
}
private:
int num_draws_;
const gfx::Size bounds_;
const gfx::Rect invalid_rect_;
FakeContentLayerClient client_;
scoped_refptr<ContentLayer> root_layer_;
};
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsRedrawRect);
class LayerTreeHostTestNoExtraCommitFromInvalidate : public LayerTreeHostTest {
public:
virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
settings->layer_transforms_should_scale_layer_contents = true;
}
virtual void SetupTree() OVERRIDE {
root_layer_ = Layer::Create();
root_layer_->SetBounds(gfx::Size(10, 20));
scaled_layer_ = FakeContentLayer::Create(&client_);
scaled_layer_->SetBounds(gfx::Size(1, 1));
root_layer_->AddChild(scaled_layer_);
layer_tree_host()->SetRootLayer(root_layer_);
LayerTreeHostTest::SetupTree();
}
virtual void BeginTest() OVERRIDE {
PostSetNeedsCommitToMainThread();
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
if (host_impl->active_tree()->source_frame_number() == 1)
EndTest();
}
virtual void DidCommit() OVERRIDE {
switch (layer_tree_host()->commit_number()) {
case 1:
// Changing the device scale factor causes a commit. It also changes
// the content bounds of |scaled_layer_|, which should not generate
// a second commit as a result.
layer_tree_host()->SetDeviceScaleFactor(4.f);
break;
default:
// No extra commits.
EXPECT_EQ(2, layer_tree_host()->commit_number());
}
}
virtual void AfterTest() OVERRIDE {
EXPECT_EQ(gfx::Size(4, 4).ToString(),
scaled_layer_->content_bounds().ToString());
}
private:
FakeContentLayerClient client_;
scoped_refptr<Layer> root_layer_;
scoped_refptr<FakeContentLayer> scaled_layer_;
};
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNoExtraCommitFromInvalidate);
class LayerTreeHostTestNoExtraCommitFromScrollbarInvalidate
: public LayerTreeHostTest {
public:
virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
settings->layer_transforms_should_scale_layer_contents = true;
}
virtual void SetupTree() OVERRIDE {
root_layer_ = Layer::Create();
root_layer_->SetBounds(gfx::Size(10, 20));
bool paint_scrollbar = true;
bool has_thumb = false;
scrollbar_ = FakeScrollbarLayer::Create(paint_scrollbar,
has_thumb,
root_layer_->id());
scrollbar_->SetPosition(gfx::Point(0, 10));
scrollbar_->SetBounds(gfx::Size(10, 10));
root_layer_->AddChild(scrollbar_);
layer_tree_host()->SetRootLayer(root_layer_);
LayerTreeHostTest::SetupTree();
}
virtual void BeginTest() OVERRIDE {
PostSetNeedsCommitToMainThread();
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
if (host_impl->active_tree()->source_frame_number() == 1)
EndTest();
}
virtual void DidCommit() OVERRIDE {
switch (layer_tree_host()->commit_number()) {
case 1:
// Changing the device scale factor causes a commit. It also changes
// the content bounds of |scrollbar_|, which should not generate
// a second commit as a result.
layer_tree_host()->SetDeviceScaleFactor(4.f);
break;
default:
// No extra commits.
EXPECT_EQ(2, layer_tree_host()->commit_number());
}
}
virtual void AfterTest() OVERRIDE {
EXPECT_EQ(gfx::Size(40, 40).ToString(),
scrollbar_->content_bounds().ToString());
}
private:
FakeContentLayerClient client_;
scoped_refptr<Layer> root_layer_;
scoped_refptr<FakeScrollbarLayer> scrollbar_;
};
SINGLE_AND_MULTI_THREAD_TEST_F(
LayerTreeHostTestNoExtraCommitFromScrollbarInvalidate);
class LayerTreeHostTestCompositeAndReadback : public LayerTreeHostTest {
public:
LayerTreeHostTestCompositeAndReadback() : num_commits_(0) {}
virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
virtual void DidCommit() OVERRIDE {
num_commits_++;
if (num_commits_ == 1) {
char pixels[4];
layer_tree_host()->CompositeAndReadback(&pixels, gfx::Rect(0, 0, 1, 1));
} else if (num_commits_ == 2) {
// This is inside the readback. We should get another commit after it.
} else if (num_commits_ == 3) {
EndTest();
} else {
NOTREACHED();
}
}
virtual void AfterTest() OVERRIDE {}
private:
int num_commits_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestCompositeAndReadback);
class LayerTreeHostTestCompositeAndReadbackBeforePreviousCommitDraws
: public LayerTreeHostTest {
public:
LayerTreeHostTestCompositeAndReadbackBeforePreviousCommitDraws()
: num_commits_(0) {}
virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
virtual void DidCommit() OVERRIDE {
num_commits_++;
if (num_commits_ == 1) {
layer_tree_host()->SetNeedsCommit();
} else if (num_commits_ == 2) {
char pixels[4];
layer_tree_host()->CompositeAndReadback(&pixels, gfx::Rect(0, 0, 1, 1));
} else if (num_commits_ == 3) {
// This is inside the readback. We should get another commit after it.
} else if (num_commits_ == 4) {
EndTest();
} else {
NOTREACHED();
}
}
virtual void AfterTest() OVERRIDE {}
private:
int num_commits_;
};
MULTI_THREAD_TEST_F(
LayerTreeHostTestCompositeAndReadbackBeforePreviousCommitDraws);
// If the layerTreeHost says it can't draw, Then we should not try to draw.
class LayerTreeHostTestCanDrawBlocksDrawing : public LayerTreeHostTest {
public:
LayerTreeHostTestCanDrawBlocksDrawing() : num_commits_(0), done_(false) {}
virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
if (done_)
return;
// Only the initial draw should bring us here.
EXPECT_TRUE(impl->CanDraw());
EXPECT_EQ(0, impl->active_tree()->source_frame_number());
}
virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
if (done_)
return;
if (num_commits_ >= 1) {
// After the first commit, we should not be able to draw.
EXPECT_FALSE(impl->CanDraw());
}
}
virtual void DidCommit() OVERRIDE {
num_commits_++;
if (num_commits_ == 1) {
// Make the viewport empty so the host says it can't draw.
layer_tree_host()->SetViewportSize(gfx::Size(0, 0));
} else if (num_commits_ == 2) {
char pixels[4];
layer_tree_host()->CompositeAndReadback(&pixels, gfx::Rect(0, 0, 1, 1));
} else if (num_commits_ == 3) {
// Let it draw so we go idle and end the test.
layer_tree_host()->SetViewportSize(gfx::Size(1, 1));
done_ = true;
EndTest();
}
}
virtual void AfterTest() OVERRIDE {}
private:
int num_commits_;
bool done_;
};
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestCanDrawBlocksDrawing);
// beginLayerWrite should prevent draws from executing until a commit occurs
class LayerTreeHostTestWriteLayersRedraw : public LayerTreeHostTest {
public:
LayerTreeHostTestWriteLayersRedraw() : num_commits_(0), num_draws_(0) {}
virtual void BeginTest() OVERRIDE {
PostAcquireLayerTextures();
PostSetNeedsRedrawToMainThread(); // should be inhibited without blocking
PostSetNeedsCommitToMainThread();
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
num_draws_++;
EXPECT_EQ(num_draws_, num_commits_);
}
virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
num_commits_++;
EndTest();
}
virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_commits_); }
private:
int num_commits_;
int num_draws_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestWriteLayersRedraw);
// Verify that when resuming visibility, Requesting layer write permission
// will not deadlock the main thread even though there are not yet any
// scheduled redraws. This behavior is critical for reliably surviving tab
// switching. There are no failure conditions to this test, it just passes
// by not timing out.
class LayerTreeHostTestWriteLayersAfterVisible : public LayerTreeHostTest {
public:
LayerTreeHostTestWriteLayersAfterVisible() : num_commits_(0) {}
virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
num_commits_++;
if (num_commits_ == 2)
EndTest();
else if (num_commits_ < 2) {
PostSetVisibleToMainThread(false);
PostSetVisibleToMainThread(true);
PostAcquireLayerTextures();
PostSetNeedsCommitToMainThread();
}
}
virtual void AfterTest() OVERRIDE {}
private:
int num_commits_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestWriteLayersAfterVisible);
// A compositeAndReadback while invisible should force a normal commit without
// assertion.
class LayerTreeHostTestCompositeAndReadbackWhileInvisible
: public LayerTreeHostTest {
public:
LayerTreeHostTestCompositeAndReadbackWhileInvisible() : num_commits_(0) {}
virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
virtual void DidCommitAndDrawFrame() OVERRIDE {
num_commits_++;
if (num_commits_ == 1) {
layer_tree_host()->SetVisible(false);
layer_tree_host()->SetNeedsCommit();
layer_tree_host()->SetNeedsCommit();
char pixels[4];
layer_tree_host()->CompositeAndReadback(&pixels, gfx::Rect(0, 0, 1, 1));
} else {
EndTest();
}
}
virtual void AfterTest() OVERRIDE {}
private:
int num_commits_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestCompositeAndReadbackWhileInvisible);
class LayerTreeHostTestAbortFrameWhenInvisible : public LayerTreeHostTest {
public:
LayerTreeHostTestAbortFrameWhenInvisible() {}
virtual void BeginTest() OVERRIDE {
// Request a commit (from the main thread), Which will trigger the commit
// flow from the impl side.
layer_tree_host()->SetNeedsCommit();
// Then mark ourselves as not visible before processing any more messages
// on the main thread.
layer_tree_host()->SetVisible(false);
// If we make it without kicking a frame, we pass!
EndTestAfterDelay(1);
}
virtual void Layout() OVERRIDE {
ASSERT_FALSE(true);
EndTest();
}
virtual void AfterTest() OVERRIDE {}
private:
};
MULTI_THREAD_TEST_F(LayerTreeHostTestAbortFrameWhenInvisible);
// This test verifies that properties on the layer tree host are commited
// to the impl side.
class LayerTreeHostTestCommit : public LayerTreeHostTest {
public:
LayerTreeHostTestCommit() {}
virtual void BeginTest() OVERRIDE {
layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
layer_tree_host()->set_background_color(SK_ColorGRAY);
layer_tree_host()->SetPageScaleFactorAndLimits(5.f, 5.f, 5.f);
PostSetNeedsCommitToMainThread();
}
virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
EXPECT_EQ(gfx::Size(20, 20), impl->device_viewport_size());
EXPECT_EQ(SK_ColorGRAY, impl->active_tree()->background_color());
EXPECT_EQ(5.f, impl->active_tree()->page_scale_factor());
EndTest();
}
virtual void AfterTest() OVERRIDE {}
};
MULTI_THREAD_TEST_F(LayerTreeHostTestCommit);
// This test verifies that LayerTreeHostImpl's current frame time gets
// updated in consecutive frames when it doesn't draw due to tree
// activation failure.
class LayerTreeHostTestFrameTimeUpdatesAfterActivationFails
: public LayerTreeHostTest {
public:
LayerTreeHostTestFrameTimeUpdatesAfterActivationFails() : frame_(0) {}
virtual void BeginTest() OVERRIDE {
layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
layer_tree_host()->set_background_color(SK_ColorGRAY);
PostSetNeedsCommitToMainThread();
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
if (frame_ >= 1) {
EXPECT_NE(first_frame_time_, impl->CurrentFrameTimeTicks());
EndTest();
return;
}
EXPECT_FALSE(impl->settings().impl_side_painting);
EndTest();
}
virtual bool CanActivatePendingTree(LayerTreeHostImpl* impl) OVERRIDE {
if (frame_ >= 1)
return true;
return false;
}
virtual bool CanActivatePendingTreeIfNeeded(LayerTreeHostImpl* impl)
OVERRIDE {
frame_++;
if (frame_ == 1) {
first_frame_time_ = impl->CurrentFrameTimeTicks();
// Since base::TimeTicks::Now() uses a low-resolution clock on
// Windows, we need to make sure that the clock has incremented past
// first_frame_time_.
while (first_frame_time_ == base::TimeTicks::Now()) {}
return false;
}
return true;
}
virtual void AfterTest() OVERRIDE {}
private:
int frame_;
base::TimeTicks first_frame_time_;
};
SINGLE_AND_MULTI_THREAD_TEST_F(
LayerTreeHostTestFrameTimeUpdatesAfterActivationFails);
// This test verifies that LayerTreeHostImpl's current frame time gets
// updated in consecutive frames when it draws in each frame.
class LayerTreeHostTestFrameTimeUpdatesAfterDraw : public LayerTreeHostTest {
public:
LayerTreeHostTestFrameTimeUpdatesAfterDraw() : frame_(0) {}
virtual void BeginTest() OVERRIDE {
layer_tree_host()->SetViewportSize(gfx::Size(20, 20));
layer_tree_host()->set_background_color(SK_ColorGRAY);
PostSetNeedsCommitToMainThread();
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
frame_++;
if (frame_ == 1) {
first_frame_time_ = impl->CurrentFrameTimeTicks();
impl->SetNeedsRedraw();
// Since base::TimeTicks::Now() uses a low-resolution clock on
// Windows, we need to make sure that the clock has incremented past
// first_frame_time_.
while (first_frame_time_ == base::TimeTicks::Now()) {}
return;
}
EXPECT_NE(first_frame_time_, impl->CurrentFrameTimeTicks());
EndTest();
}
virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
// Ensure there isn't a commit between the two draws, to ensure that a
// commit isn't required for updating the current frame time. We can
// only check for this in the multi-threaded case, since in the single-
// threaded case there will always be a commit between consecutive draws.
if (HasImplThread())
EXPECT_EQ(0, frame_);
}
virtual void AfterTest() OVERRIDE {}
private:
int frame_;
base::TimeTicks first_frame_time_;
};
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestFrameTimeUpdatesAfterDraw);
// Verifies that StartPageScaleAnimation events propagate correctly
// from LayerTreeHost to LayerTreeHostImpl in the MT compositor.
class LayerTreeHostTestStartPageScaleAnimation : public LayerTreeHostTest {
public:
LayerTreeHostTestStartPageScaleAnimation() {}
virtual void SetupTree() OVERRIDE {
LayerTreeHostTest::SetupTree();
scroll_layer_ = FakeContentLayer::Create(&client_);
scroll_layer_->SetScrollable(true);
scroll_layer_->SetScrollOffset(gfx::Vector2d());
layer_tree_host()->root_layer()->AddChild(scroll_layer_);
}
virtual void BeginTest() OVERRIDE {
PostSetNeedsCommitToMainThread();
}
virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta, float scale)
OVERRIDE {
gfx::Vector2d offset = scroll_layer_->scroll_offset();
scroll_layer_->SetScrollOffset(offset + scroll_delta);
layer_tree_host()->SetPageScaleFactorAndLimits(scale, 0.5f, 2.f);
}
virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
impl->ProcessScrollDeltas();
// We get one commit before the first draw, and the animation doesn't happen
// until the second draw.
switch (impl->active_tree()->source_frame_number()) {
case 0:
EXPECT_EQ(1.f, impl->active_tree()->page_scale_factor());
// We'll start an animation when we get back to the main thread.
break;
case 1:
EXPECT_EQ(1.f, impl->active_tree()->page_scale_factor());
PostSetNeedsRedrawToMainThread();
break;
case 2:
EXPECT_EQ(1.25f, impl->active_tree()->page_scale_factor());
EndTest();
break;
default:
NOTREACHED();
}
}
virtual void DidCommitAndDrawFrame() OVERRIDE {
switch (layer_tree_host()->commit_number()) {
case 1:
layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.5f, 2.f);
layer_tree_host()->StartPageScaleAnimation(
gfx::Vector2d(), false, 1.25f, base::TimeDelta());
break;
}
}
virtual void AfterTest() OVERRIDE {}
FakeContentLayerClient client_;
scoped_refptr<FakeContentLayer> scroll_layer_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestStartPageScaleAnimation);
class LayerTreeHostTestSetVisible : public LayerTreeHostTest {
public:
LayerTreeHostTestSetVisible() : num_draws_(0) {}
virtual void BeginTest() OVERRIDE {
PostSetNeedsCommitToMainThread();
PostSetVisibleToMainThread(false);
// This is suppressed while we're invisible.
PostSetNeedsRedrawToMainThread();
// Triggers the redraw.
PostSetVisibleToMainThread(true);
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
EXPECT_TRUE(impl->visible());
++num_draws_;
EndTest();
}
virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_draws_); }
private:
int num_draws_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestSetVisible);
class TestOpacityChangeLayerDelegate : public ContentLayerClient {
public:
TestOpacityChangeLayerDelegate() : test_layer_(0) {}
void SetTestLayer(Layer* test_layer) { test_layer_ = test_layer; }
virtual void PaintContents(SkCanvas*, gfx::Rect, gfx::RectF*) OVERRIDE {
// Set layer opacity to 0.
if (test_layer_)
test_layer_->SetOpacity(0.f);
}
virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
private:
Layer* test_layer_;
};
class ContentLayerWithUpdateTracking : public ContentLayer {
public:
static scoped_refptr<ContentLayerWithUpdateTracking> Create(
ContentLayerClient* client) {
return make_scoped_refptr(new ContentLayerWithUpdateTracking(client));
}
int PaintContentsCount() { return paint_contents_count_; }
void ResetPaintContentsCount() { paint_contents_count_ = 0; }
virtual bool Update(ResourceUpdateQueue* queue,
const OcclusionTracker* occlusion) OVERRIDE {
bool updated = ContentLayer::Update(queue, occlusion);
paint_contents_count_++;
return updated;
}
private:
explicit ContentLayerWithUpdateTracking(ContentLayerClient* client)
: ContentLayer(client), paint_contents_count_(0) {
SetAnchorPoint(gfx::PointF(0.f, 0.f));
SetBounds(gfx::Size(10, 10));
SetIsDrawable(true);
}
virtual ~ContentLayerWithUpdateTracking() {}
int paint_contents_count_;
};
// Layer opacity change during paint should not prevent compositor resources
// from being updated during commit.
class LayerTreeHostTestOpacityChange : public LayerTreeHostTest {
public:
LayerTreeHostTestOpacityChange()
: test_opacity_change_delegate_(),
update_check_layer_(ContentLayerWithUpdateTracking::Create(
&test_opacity_change_delegate_)) {
test_opacity_change_delegate_.SetTestLayer(update_check_layer_.get());
}
virtual void BeginTest() OVERRIDE {
layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
layer_tree_host()->root_layer()->AddChild(update_check_layer_);
PostSetNeedsCommitToMainThread();
}
virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
EndTest();
}
virtual void AfterTest() OVERRIDE {
// Update() should have been called once.
EXPECT_EQ(1, update_check_layer_->PaintContentsCount());
}
private:
TestOpacityChangeLayerDelegate test_opacity_change_delegate_;
scoped_refptr<ContentLayerWithUpdateTracking> update_check_layer_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestOpacityChange);
class NoScaleContentLayer : public ContentLayer {
public:
static scoped_refptr<NoScaleContentLayer> Create(ContentLayerClient* client) {
return make_scoped_refptr(new NoScaleContentLayer(client));
}
virtual void CalculateContentsScale(float ideal_contents_scale,
float device_scale_factor,
float page_scale_factor,
bool animating_transform_to_screen,
float* contents_scale_x,
float* contents_scale_y,
gfx::Size* contentBounds) OVERRIDE {
// Skip over the ContentLayer's method to the base Layer class.
Layer::CalculateContentsScale(ideal_contents_scale,
device_scale_factor,
page_scale_factor,
animating_transform_to_screen,
contents_scale_x,
contents_scale_y,
contentBounds);
}
private:
explicit NoScaleContentLayer(ContentLayerClient* client)
: ContentLayer(client) {}
virtual ~NoScaleContentLayer() {}
};
class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers
: public LayerTreeHostTest {
public:
LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers()
: root_layer_(NoScaleContentLayer::Create(&client_)),
child_layer_(ContentLayer::Create(&client_)) {}
virtual void BeginTest() OVERRIDE {
layer_tree_host()->SetViewportSize(gfx::Size(60, 60));
layer_tree_host()->SetDeviceScaleFactor(1.5);
EXPECT_EQ(gfx::Size(60, 60), layer_tree_host()->device_viewport_size());
root_layer_->AddChild(child_layer_);
root_layer_->SetIsDrawable(true);
root_layer_->SetBounds(gfx::Size(30, 30));
root_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
child_layer_->SetIsDrawable(true);
child_layer_->SetPosition(gfx::Point(2, 2));
child_layer_->SetBounds(gfx::Size(10, 10));
child_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
layer_tree_host()->SetRootLayer(root_layer_);
PostSetNeedsCommitToMainThread();
}
virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
// Should only do one commit.
EXPECT_EQ(0, impl->active_tree()->source_frame_number());
// Device scale factor should come over to impl.
EXPECT_NEAR(impl->device_scale_factor(), 1.5f, 0.00001f);
// Both layers are on impl.
ASSERT_EQ(1u, impl->active_tree()->root_layer()->children().size());
// Device viewport is scaled.
EXPECT_EQ(gfx::Size(60, 60), impl->device_viewport_size());
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());
EXPECT_EQ(gfx::Point(2, 2), child->position());
// Compute all the layer transforms for the frame.
LayerTreeHostImpl::FrameData frame_data;
impl->PrepareToDraw(&frame_data, gfx::Rect());
impl->DidDrawAllLayers(frame_data);
const LayerImplList& render_surface_layer_list =
*frame_data.render_surface_layer_list;
// Both layers should be drawing into the root render surface.
ASSERT_EQ(1u, render_surface_layer_list.size());
ASSERT_EQ(root->render_surface(),
render_surface_layer_list[0]->render_surface());
ASSERT_EQ(2u, root->render_surface()->layer_list().size());
// The root render surface is the size of the viewport.
EXPECT_RECT_EQ(gfx::Rect(0, 0, 60, 60),
root->render_surface()->content_rect());
// The content bounds of the child should be scaled.
gfx::Size child_bounds_scaled =
gfx::ToCeiledSize(gfx::ScaleSize(child->bounds(), 1.5));
EXPECT_EQ(child_bounds_scaled, child->content_bounds());
gfx::Transform scale_transform;
scale_transform.Scale(impl->device_scale_factor(),
impl->device_scale_factor());
// The root layer is scaled by 2x.
gfx::Transform root_screen_space_transform = scale_transform;
gfx::Transform root_draw_transform = scale_transform;
EXPECT_EQ(root_draw_transform, root->draw_transform());
EXPECT_EQ(root_screen_space_transform, root->screen_space_transform());
// The child is at position 2,2, which is transformed to 3,3 after the scale
gfx::Transform child_screen_space_transform;
child_screen_space_transform.Translate(3.f, 3.f);
gfx::Transform child_draw_transform = child_screen_space_transform;
EXPECT_TRANSFORMATION_MATRIX_EQ(child_draw_transform,
child->draw_transform());
EXPECT_TRANSFORMATION_MATRIX_EQ(child_screen_space_transform,
child->screen_space_transform());
EndTest();
}
virtual void AfterTest() OVERRIDE {}
private:
FakeContentLayerClient client_;
scoped_refptr<NoScaleContentLayer> root_layer_;
scoped_refptr<ContentLayer> child_layer_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers);
// Verify atomicity of commits and reuse of textures.
class LayerTreeHostTestAtomicCommit : public LayerTreeHostTest {
public:
virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
// Make sure partial texture updates are turned off.
settings->max_partial_texture_updates = 0;
// Linear fade animator prevents scrollbars from drawing immediately.
settings->use_linear_fade_scrollbar_animator = false;
}
virtual void SetupTree() OVERRIDE {
layer_ = FakeContentLayer::Create(&client_);
layer_->SetBounds(gfx::Size(10, 20));
bool paint_scrollbar = true;
bool has_thumb = false;
scrollbar_ =
FakeScrollbarLayer::Create(paint_scrollbar, has_thumb, layer_->id());
scrollbar_->SetPosition(gfx::Point(0, 10));
scrollbar_->SetBounds(gfx::Size(10, 10));
layer_->AddChild(scrollbar_);
layer_tree_host()->SetRootLayer(layer_);
LayerTreeHostTest::SetupTree();
}
virtual void BeginTest() OVERRIDE {
drew_frame_ = -1;
PostSetNeedsCommitToMainThread();
}
virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
ASSERT_EQ(0u, layer_tree_host()->settings().max_partial_texture_updates);
TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
impl->output_surface()->context3d());
switch (impl->active_tree()->source_frame_number()) {
case 0:
// Number of textures should be one for each layer
ASSERT_EQ(2u, context->NumTextures());
// Number of textures used for commit should be one for each layer.
EXPECT_EQ(2u, context->NumUsedTextures());
// Verify that used texture is correct.
EXPECT_TRUE(context->UsedTexture(context->TextureAt(0)));
EXPECT_TRUE(context->UsedTexture(context->TextureAt(1)));
context->ResetUsedTextures();
PostSetNeedsCommitToMainThread();
break;
case 1:
// Number of textures should be doubled as the first textures
// are used by impl thread and cannot by used for update.
ASSERT_EQ(4u, context->NumTextures());
// Number of textures used for commit should still be
// one for each layer.
EXPECT_EQ(2u, context->NumUsedTextures());
// First textures should not have been used.
EXPECT_FALSE(context->UsedTexture(context->TextureAt(0)));
EXPECT_FALSE(context->UsedTexture(context->TextureAt(1)));
// New textures should have been used.
EXPECT_TRUE(context->UsedTexture(context->TextureAt(2)));
EXPECT_TRUE(context->UsedTexture(context->TextureAt(3)));
context->ResetUsedTextures();
PostSetNeedsCommitToMainThread();
break;
case 2:
EndTest();
break;
default:
NOTREACHED();
break;
}
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
impl->output_surface()->context3d());
if (drew_frame_ == impl->active_tree()->source_frame_number()) {
EXPECT_EQ(0u, context->NumUsedTextures()) << "For frame " << drew_frame_;
return;
}
drew_frame_ = impl->active_tree()->source_frame_number();
// We draw/ship one texture each frame for each layer.
EXPECT_EQ(2u, context->NumUsedTextures());
context->ResetUsedTextures();
}
virtual void Layout() OVERRIDE {
layer_->SetNeedsDisplay();
scrollbar_->SetNeedsDisplay();
}
virtual void AfterTest() OVERRIDE {}
private:
FakeContentLayerClient client_;
scoped_refptr<FakeContentLayer> layer_;
scoped_refptr<FakeScrollbarLayer> scrollbar_;
int drew_frame_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestAtomicCommit);
static void SetLayerPropertiesForTesting(Layer* layer,
Layer* parent,
const gfx::Transform& transform,
gfx::PointF anchor,
gfx::PointF position,
gfx::Size bounds,
bool opaque) {
layer->RemoveAllChildren();
if (parent)
parent->AddChild(layer);
layer->SetTransform(transform);
layer->SetAnchorPoint(anchor);
layer->SetPosition(position);
layer->SetBounds(bounds);
layer->SetContentsOpaque(opaque);
}
class LayerTreeHostTestAtomicCommitWithPartialUpdate
: public LayerTreeHostTest {
public:
virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
// Allow one partial texture update.
settings->max_partial_texture_updates = 1;
// Linear fade animator prevents scrollbars from drawing immediately.
settings->use_linear_fade_scrollbar_animator = false;
// No partial updates when impl side painting is enabled.
settings->impl_side_painting = false;
}
virtual void SetupTree() OVERRIDE {
parent_ = FakeContentLayer::Create(&client_);
parent_->SetBounds(gfx::Size(10, 20));
child_ = FakeContentLayer::Create(&client_);
child_->SetPosition(gfx::Point(0, 10));
child_->SetBounds(gfx::Size(3, 10));
bool paint_scrollbar = true;
bool has_thumb = false;
scrollbar_with_paints_ =
FakeScrollbarLayer::Create(paint_scrollbar, has_thumb, parent_->id());
scrollbar_with_paints_->SetPosition(gfx::Point(3, 10));
scrollbar_with_paints_->SetBounds(gfx::Size(3, 10));
paint_scrollbar = false;
scrollbar_without_paints_ =
FakeScrollbarLayer::Create(paint_scrollbar, has_thumb, parent_->id());
scrollbar_without_paints_->SetPosition(gfx::Point(6, 10));
scrollbar_without_paints_->SetBounds(gfx::Size(3, 10));
parent_->AddChild(child_);
parent_->AddChild(scrollbar_with_paints_);
parent_->AddChild(scrollbar_without_paints_);
layer_tree_host()->SetRootLayer(parent_);
LayerTreeHostTest::SetupTree();
}
virtual void BeginTest() OVERRIDE {
PostSetNeedsCommitToMainThread();
}
virtual void DidCommitAndDrawFrame() OVERRIDE {
switch (layer_tree_host()->commit_number()) {
case 1:
parent_->SetNeedsDisplay();
child_->SetNeedsDisplay();
scrollbar_with_paints_->SetNeedsDisplay();
scrollbar_without_paints_->SetNeedsDisplay();
break;
case 2:
// Damage part of layers.
parent_->SetNeedsDisplayRect(gfx::RectF(0.f, 0.f, 5.f, 5.f));
child_->SetNeedsDisplayRect(gfx::RectF(0.f, 0.f, 5.f, 5.f));
scrollbar_with_paints_->SetNeedsDisplayRect(
gfx::RectF(0.f, 0.f, 5.f, 5.f));
scrollbar_without_paints_->SetNeedsDisplayRect(
gfx::RectF(0.f, 0.f, 5.f, 5.f));
break;
case 3:
child_->SetNeedsDisplay();
scrollbar_with_paints_->SetNeedsDisplay();
scrollbar_without_paints_->SetNeedsDisplay();
layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
break;
case 4:
layer_tree_host()->SetViewportSize(gfx::Size(10, 20));
break;
case 5:
EndTest();
break;
default:
NOTREACHED() << layer_tree_host()->commit_number();
break;
}
}
virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
ASSERT_EQ(1u, layer_tree_host()->settings().max_partial_texture_updates);
TestWebGraphicsContext3D* context = static_cast<TestWebGraphicsContext3D*>(
impl->output_surface()->context3d());
switch (impl->active_tree()->source_frame_number()) {
case 0:
// Number of textures should be one for each layer.
ASSERT_EQ(4u, context->NumTextures());
// Number of textures used for commit should be one for each layer.
EXPECT_EQ(4u, context->NumUsedTextures());
// Verify that used textures are correct.
EXPECT_TRUE(context->UsedTexture(context->TextureAt(0)));
EXPECT_TRUE(context->UsedTexture(context->TextureAt(1)));
EXPECT_TRUE(context->UsedTexture(context->TextureAt(2)));
EXPECT_TRUE(context->UsedTexture(context->TextureAt(3)));
context->ResetUsedTextures();
break;
case 1:
// Number of textures should be two for each content layer and one
// for each scrollbar, since they always do a partial update.
ASSERT_EQ(6u, context->NumTextures());
// Number of textures used for commit should be one for each content
// layer, and one for the scrollbar layer that paints.
EXPECT_EQ(3u, context->NumUsedTextures());
// First content textures should not have been used.
EXPECT_FALSE(context->UsedTexture(context->TextureAt(0)));
EXPECT_FALSE(context->UsedTexture(context->TextureAt(1)));
// The non-painting scrollbar's texture wasn't updated.
EXPECT_FALSE(context->UsedTexture(context->TextureAt(2)));
// The painting scrollbar's partial update texture was used.
EXPECT_TRUE(context->UsedTexture(context->TextureAt(3)));
// New textures should have been used.
EXPECT_TRUE(context->UsedTexture(context->TextureAt(4)));
EXPECT_TRUE(context->UsedTexture(context->TextureAt(5)));
context->ResetUsedTextures();
break;
case 2:
// Number of textures should be two for each content layer and one
// for each scrollbar, since they always do a partial update.
ASSERT_EQ(6u, context->NumTextures());
// Number of textures used for commit should be one for each content
// layer, and one for the scrollbar layer that paints.
EXPECT_EQ(3u, context->NumUsedTextures());
// The non-painting scrollbar's texture wasn't updated.
EXPECT_FALSE(context->UsedTexture(context->TextureAt(2)));
// The painting scrollbar does a partial update.
EXPECT_TRUE(context->UsedTexture(context->TextureAt(3)));
// One content layer does a partial update also.
EXPECT_TRUE(context->UsedTexture(context->TextureAt(4)));
EXPECT_FALSE(context->UsedTexture(context->TextureAt(5)));
context->ResetUsedTextures();
break;
case 3:
// No textures should be used for commit.
EXPECT_EQ(0u, context->NumUsedTextures());
context->ResetUsedTextures();
break;
case 4:
// Number of textures used for commit should be two. One for the
// content layer, and one for the painting scrollbar. The
// non-painting scrollbar doesn't update its texture.
EXPECT_EQ(2u, context->NumUsedTextures());
context->ResetUsedTextures();
break;
default:
NOTREACHED();
break;
}
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
EXPECT_LT(impl->active_tree()->source_frame_number(), 5);
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->active_tree()->source_frame_number() == 3) {
EXPECT_EQ(1u, context->NumUsedTextures());
} else {
EXPECT_EQ(4u, context->NumUsedTextures()) <<
"For frame " << impl->active_tree()->source_frame_number();
}
context->ResetUsedTextures();
}
virtual void AfterTest() OVERRIDE {}
private:
FakeContentLayerClient client_;
scoped_refptr<FakeContentLayer> parent_;
scoped_refptr<FakeContentLayer> child_;
scoped_refptr<FakeScrollbarLayer> scrollbar_with_paints_;
scoped_refptr<FakeScrollbarLayer> scrollbar_without_paints_;
};
// Partial updates are not possible with a delegating renderer.
SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
LayerTreeHostTestAtomicCommitWithPartialUpdate);
class LayerTreeHostTestFinishAllRendering : public LayerTreeHostTest {
public:
LayerTreeHostTestFinishAllRendering() : once_(false), draw_count_(0) {}
virtual void BeginTest() OVERRIDE {
layer_tree_host()->SetNeedsRedraw();
PostSetNeedsCommitToMainThread();
}
virtual void DidCommitAndDrawFrame() OVERRIDE {
if (once_)
return;
once_ = true;
layer_tree_host()->SetNeedsRedraw();
layer_tree_host()->AcquireLayerTextures();
{
base::AutoLock lock(lock_);
draw_count_ = 0;
}
layer_tree_host()->FinishAllRendering();
{
base::AutoLock lock(lock_);
EXPECT_EQ(0, draw_count_);
}
EndTest();
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
base::AutoLock lock(lock_);
++draw_count_;
}
virtual void AfterTest() OVERRIDE {}
private:
bool once_;
base::Lock lock_;
int draw_count_;
};
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestFinishAllRendering);
class LayerTreeHostTestCompositeAndReadbackCleanup : public LayerTreeHostTest {
public:
virtual void BeginTest() OVERRIDE {
Layer* root_layer = layer_tree_host()->root_layer();
char pixels[4];
layer_tree_host()->CompositeAndReadback(static_cast<void*>(&pixels),
gfx::Rect(0, 0, 1, 1));
EXPECT_FALSE(root_layer->render_surface());
EndTest();
}
virtual void AfterTest() OVERRIDE {}
};
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestCompositeAndReadbackCleanup);
class LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit
: public LayerTreeHostTest {
public:
LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit()
: root_layer_(FakeContentLayer::Create(&client_)),
surface_layer1_(
FakeContentLayer::Create(&client_)),
replica_layer1_(
FakeContentLayer::Create(&client_)),
surface_layer2_(
FakeContentLayer::Create(&client_)),
replica_layer2_(
FakeContentLayer::Create(&client_)) {}
virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
settings->cache_render_pass_contents = true;
}
virtual void BeginTest() OVERRIDE {
layer_tree_host()->SetViewportSize(gfx::Size(100, 100));
root_layer_->SetBounds(gfx::Size(100, 100));
surface_layer1_->SetBounds(gfx::Size(100, 100));
surface_layer1_->SetForceRenderSurface(true);
surface_layer1_->SetOpacity(0.5f);
surface_layer2_->SetBounds(gfx::Size(100, 100));
surface_layer2_->SetForceRenderSurface(true);
surface_layer2_->SetOpacity(0.5f);
surface_layer1_->SetReplicaLayer(replica_layer1_.get());
surface_layer2_->SetReplicaLayer(replica_layer2_.get());
root_layer_->AddChild(surface_layer1_);
surface_layer1_->AddChild(surface_layer2_);
layer_tree_host()->SetRootLayer(root_layer_);
PostSetNeedsCommitToMainThread();
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
Renderer* renderer = host_impl->renderer();
RenderPass::Id surface1_render_pass_id = host_impl->active_tree()
->root_layer()->children()[0]->render_surface()->RenderPassId();
RenderPass::Id surface2_render_pass_id =
host_impl->active_tree()->root_layer()->children()[0]->children()[0]
->render_surface()->RenderPassId();
switch (host_impl->active_tree()->source_frame_number()) {
case 0:
EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(
surface1_render_pass_id));
EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(
surface2_render_pass_id));
// Reduce the memory limit to only fit the root layer and one render
// surface. This prevents any contents drawing into surfaces
// from being allocated.
host_impl->SetMemoryPolicy(
ManagedMemoryPolicy(100 * 100 * 4 * 2), true);
break;
case 1:
EXPECT_FALSE(renderer->HaveCachedResourcesForRenderPassId(
surface1_render_pass_id));
EXPECT_FALSE(renderer->HaveCachedResourcesForRenderPassId(
surface2_render_pass_id));
EndTest();
break;
}
}
virtual void DidCommit() OVERRIDE {
if (layer_tree_host()->commit_number() < 2)
root_layer_->SetNeedsDisplay();
}
virtual void AfterTest() OVERRIDE {
EXPECT_EQ(2u, root_layer_->update_count());
EXPECT_EQ(2u, surface_layer1_->update_count());
EXPECT_EQ(2u, surface_layer2_->update_count());
}
private:
FakeContentLayerClient client_;
scoped_refptr<FakeContentLayer> root_layer_;
scoped_refptr<FakeContentLayer> surface_layer1_;
scoped_refptr<FakeContentLayer> replica_layer1_;
scoped_refptr<FakeContentLayer> surface_layer2_;
scoped_refptr<FakeContentLayer> replica_layer2_;
};
// Surfaces don't exist with a delegated renderer.
SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit);
class EvictionTestLayer : public Layer {
public:
static scoped_refptr<EvictionTestLayer> Create() {
return make_scoped_refptr(new EvictionTestLayer());
}
virtual bool Update(ResourceUpdateQueue*,
const OcclusionTracker*) OVERRIDE;
virtual bool DrawsContent() const OVERRIDE { return true; }
virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
OVERRIDE;
virtual void PushPropertiesTo(LayerImpl* impl) OVERRIDE;
virtual void SetTexturePriorities(const PriorityCalculator&) OVERRIDE;
bool HaveBackingTexture() const {
return texture_.get() ? texture_->have_backing_texture() : false;
}
private:
EvictionTestLayer() : Layer() {}
virtual ~EvictionTestLayer() {}
void CreateTextureIfNeeded() {
if (texture_)
return;
texture_ = PrioritizedResource::Create(
layer_tree_host()->contents_texture_manager());
texture_->SetDimensions(gfx::Size(10, 10), GL_RGBA);
bitmap_.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
}
scoped_ptr<PrioritizedResource> texture_;
SkBitmap bitmap_;
};
class EvictionTestLayerImpl : public LayerImpl {
public:
static scoped_ptr<EvictionTestLayerImpl> Create(LayerTreeImpl* tree_impl,
int id) {
return make_scoped_ptr(new EvictionTestLayerImpl(tree_impl, id));
}
virtual ~EvictionTestLayerImpl() {}
virtual void AppendQuads(QuadSink* quad_sink,
AppendQuadsData* append_quads_data) OVERRIDE {
ASSERT_TRUE(has_texture_);
ASSERT_NE(0u, layer_tree_impl()->resource_provider()->num_resources());
}
void SetHasTexture(bool has_texture) { has_texture_ = has_texture; }
private:
EvictionTestLayerImpl(LayerTreeImpl* tree_impl, int id)
: LayerImpl(tree_impl, id), has_texture_(false) {}
bool has_texture_;
};
void EvictionTestLayer::SetTexturePriorities(const PriorityCalculator&) {
CreateTextureIfNeeded();
if (!texture_)
return;
texture_->set_request_priority(PriorityCalculator::UIPriority(true));
}
bool EvictionTestLayer::Update(ResourceUpdateQueue* queue,
const OcclusionTracker*) {
CreateTextureIfNeeded();
if (!texture_)
return false;
gfx::Rect full_rect(0, 0, 10, 10);
ResourceUpdate upload = ResourceUpdate::Create(
texture_.get(), &bitmap_, full_rect, full_rect, gfx::Vector2d());
queue->AppendFullUpload(upload);
return true;
}
scoped_ptr<LayerImpl> EvictionTestLayer::CreateLayerImpl(
LayerTreeImpl* tree_impl) {
return EvictionTestLayerImpl::Create(tree_impl, layer_id_)
.PassAs<LayerImpl>();
}
void EvictionTestLayer::PushPropertiesTo(LayerImpl* layer_impl) {
Layer::PushPropertiesTo(layer_impl);
EvictionTestLayerImpl* test_layer_impl =
static_cast<EvictionTestLayerImpl*>(layer_impl);
test_layer_impl->SetHasTexture(texture_->have_backing_texture());
}
class LayerTreeHostTestEvictTextures : public LayerTreeHostTest {
public:
LayerTreeHostTestEvictTextures()
: layer_(EvictionTestLayer::Create()),
impl_for_evict_textures_(0),
num_commits_(0) {}
virtual void BeginTest() OVERRIDE {
layer_tree_host()->SetRootLayer(layer_);
layer_tree_host()->SetViewportSize(gfx::Size(10, 20));
gfx::Transform identity_matrix;
SetLayerPropertiesForTesting(layer_.get(),
0,
identity_matrix,
gfx::PointF(0.f, 0.f),
gfx::PointF(0.f, 0.f),
gfx::Size(10, 20),
true);
PostSetNeedsCommitToMainThread();
}
void PostEvictTextures() {
DCHECK(HasImplThread());
ImplThreadTaskRunner()->PostTask(
FROM_HERE,
base::Bind(&LayerTreeHostTestEvictTextures::EvictTexturesOnImplThread,
base::Unretained(this)));
}
void EvictTexturesOnImplThread() {
DCHECK(impl_for_evict_textures_);
impl_for_evict_textures_->EvictTexturesForTesting();
}
// Commit 1: Just commit and draw normally, then post an eviction at the end
// that will trigger a commit.
// Commit 2: Triggered by the eviction, let it go through and then set
// needsCommit.
// Commit 3: Triggered by the setNeedsCommit. In Layout(), post an eviction
// task, which will be handled before the commit. Don't set needsCommit, it
// should have been posted. A frame should not be drawn (note,
// didCommitAndDrawFrame may be called anyway).
// Commit 4: Triggered by the eviction, let it go through and then set
// needsCommit.
// Commit 5: Triggered by the setNeedsCommit, post an eviction task in
// Layout(), a frame should not be drawn but a commit will be posted.
// Commit 6: Triggered by the eviction, post an eviction task in
// Layout(), which will be a noop, letting the commit (which recreates the
// textures) go through and draw a frame, then end the test.
//
// Commits 1+2 test the eviction recovery path where eviction happens outside
// of the beginFrame/commit pair.
// Commits 3+4 test the eviction recovery path where eviction happens inside
// the beginFrame/commit pair.
// Commits 5+6 test the path where an eviction happens during the eviction
// recovery path.
virtual void DidCommit() OVERRIDE {
switch (num_commits_) {
case 1:
EXPECT_TRUE(layer_->HaveBackingTexture());
PostEvictTextures();
break;
case 2:
EXPECT_TRUE(layer_->HaveBackingTexture());
layer_tree_host()->SetNeedsCommit();
break;
case 3:
break;
case 4:
EXPECT_TRUE(layer_->HaveBackingTexture());
layer_tree_host()->SetNeedsCommit();
break;
case 5:
break;
case 6:
EXPECT_TRUE(layer_->HaveBackingTexture());
EndTest();
break;
default:
NOTREACHED();
break;
}
}
virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
impl_for_evict_textures_ = impl;
}
virtual void Layout() OVERRIDE {
++num_commits_;
switch (num_commits_) {
case 1:
case 2:
break;
case 3:
PostEvictTextures();
break;
case 4:
// We couldn't check in didCommitAndDrawFrame on commit 3,
// so check here.
EXPECT_FALSE(layer_->HaveBackingTexture());
break;
case 5:
PostEvictTextures();
break;
case 6:
// We couldn't check in didCommitAndDrawFrame on commit 5,
// so check here.
EXPECT_FALSE(layer_->HaveBackingTexture());
PostEvictTextures();
break;
default:
NOTREACHED();
break;
}
}
virtual void AfterTest() OVERRIDE {}
private:
FakeContentLayerClient client_;
scoped_refptr<EvictionTestLayer> layer_;
LayerTreeHostImpl* impl_for_evict_textures_;
int num_commits_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestEvictTextures);
class LayerTreeHostTestContinuousCommit : public LayerTreeHostTest {
public:
LayerTreeHostTestContinuousCommit()
: num_commit_complete_(0), num_draw_layers_(0) {}
virtual void BeginTest() OVERRIDE {
layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10));
PostSetNeedsCommitToMainThread();
}
virtual void DidCommit() OVERRIDE {
if (num_draw_layers_ == 2)
return;
layer_tree_host()->root_layer()->SetNeedsDisplay();
}
virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
if (num_draw_layers_ == 1)
num_commit_complete_++;
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
num_draw_layers_++;
if (num_draw_layers_ == 2)
EndTest();
}
virtual void AfterTest() OVERRIDE {
// Check that we didn't commit twice between first and second draw.
EXPECT_EQ(1, num_commit_complete_);
}
private:
int num_commit_complete_;
int num_draw_layers_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousCommit);
class LayerTreeHostTestContinuousInvalidate : public LayerTreeHostTest {
public:
LayerTreeHostTestContinuousInvalidate()
: num_commit_complete_(0), num_draw_layers_(0) {}
virtual void BeginTest() OVERRIDE {
layer_tree_host()->SetViewportSize(gfx::Size(10, 10));
layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10));
content_layer_ = ContentLayer::Create(&client_);
content_layer_->SetBounds(gfx::Size(10, 10));
content_layer_->SetPosition(gfx::PointF(0.f, 0.f));
content_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
content_layer_->SetIsDrawable(true);
layer_tree_host()->root_layer()->AddChild(content_layer_);
PostSetNeedsCommitToMainThread();
}
virtual void DidCommitAndDrawFrame() OVERRIDE {
if (num_draw_layers_ == 2)
return;
content_layer_->SetNeedsDisplay();
}
virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
if (num_draw_layers_ == 1)
num_commit_complete_++;
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
num_draw_layers_++;
if (num_draw_layers_ == 2)
EndTest();
}
virtual void AfterTest() OVERRIDE {
// Check that we didn't commit twice between first and second draw.
EXPECT_EQ(1, num_commit_complete_);
}
private:
FakeContentLayerClient client_;
scoped_refptr<Layer> content_layer_;
int num_commit_complete_;
int num_draw_layers_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousInvalidate);
class LayerTreeHostTestDeferCommits : public LayerTreeHostTest {
public:
LayerTreeHostTestDeferCommits()
: num_commits_deferred_(0), num_complete_commits_(0) {}
virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
virtual void DidDeferCommit() OVERRIDE {
num_commits_deferred_++;
layer_tree_host()->SetDeferCommits(false);
}
virtual void DidCommit() OVERRIDE {
num_complete_commits_++;
switch (num_complete_commits_) {
case 1:
EXPECT_EQ(0, num_commits_deferred_);
layer_tree_host()->SetDeferCommits(true);
PostSetNeedsCommitToMainThread();
break;
case 2:
EndTest();
break;
default:
NOTREACHED();
break;
}
}
virtual void AfterTest() OVERRIDE {
EXPECT_EQ(1, num_commits_deferred_);
EXPECT_EQ(2, num_complete_commits_);
}
private:
int num_commits_deferred_;
int num_complete_commits_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestDeferCommits);
class LayerTreeHostWithProxy : public LayerTreeHost {
public:
LayerTreeHostWithProxy(FakeLayerTreeHostClient* client,
const LayerTreeSettings& settings,
scoped_ptr<FakeProxy> proxy)
: LayerTreeHost(client, settings) {
proxy->SetLayerTreeHost(this);
EXPECT_TRUE(InitializeForTesting(proxy.PassAs<Proxy>()));
}
};
TEST(LayerTreeHostTest, LimitPartialUpdates) {
// When partial updates are not allowed, max updates should be 0.
{
FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
scoped_ptr<FakeProxy> proxy(new FakeProxy);
proxy->GetRendererCapabilities().allow_partial_texture_updates = false;
proxy->SetMaxPartialTextureUpdates(5);
LayerTreeSettings settings;
settings.max_partial_texture_updates = 10;
LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
EXPECT_TRUE(host.InitializeOutputSurfaceIfNeeded());
EXPECT_EQ(0u, host.settings().max_partial_texture_updates);
}
// When partial updates are allowed,
// max updates should be limited by the proxy.
{
FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
scoped_ptr<FakeProxy> proxy(new FakeProxy);
proxy->GetRendererCapabilities().allow_partial_texture_updates = true;
proxy->SetMaxPartialTextureUpdates(5);
LayerTreeSettings settings;
settings.max_partial_texture_updates = 10;
LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
EXPECT_TRUE(host.InitializeOutputSurfaceIfNeeded());
EXPECT_EQ(5u, host.settings().max_partial_texture_updates);
}
// When partial updates are allowed,
// max updates should also be limited by the settings.
{
FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
scoped_ptr<FakeProxy> proxy(new FakeProxy);
proxy->GetRendererCapabilities().allow_partial_texture_updates = true;
proxy->SetMaxPartialTextureUpdates(20);
LayerTreeSettings settings;
settings.max_partial_texture_updates = 10;
LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
EXPECT_TRUE(host.InitializeOutputSurfaceIfNeeded());
EXPECT_EQ(10u, host.settings().max_partial_texture_updates);
}
}
TEST(LayerTreeHostTest, PartialUpdatesWithGLRenderer) {
FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
LayerTreeSettings settings;
settings.max_partial_texture_updates = 4;
scoped_ptr<LayerTreeHost> host =
LayerTreeHost::Create(&client, settings, NULL);
EXPECT_TRUE(host->InitializeOutputSurfaceIfNeeded());
EXPECT_EQ(4u, host->settings().max_partial_texture_updates);
}
TEST(LayerTreeHostTest, PartialUpdatesWithSoftwareRenderer) {
FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_SOFTWARE);
LayerTreeSettings settings;
settings.max_partial_texture_updates = 4;
scoped_ptr<LayerTreeHost> host =
LayerTreeHost::Create(&client, settings, NULL);
EXPECT_TRUE(host->InitializeOutputSurfaceIfNeeded());
EXPECT_EQ(4u, host->settings().max_partial_texture_updates);
}
TEST(LayerTreeHostTest, PartialUpdatesWithDelegatingRendererAndGLContent) {
FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DELEGATED_3D);
LayerTreeSettings settings;
settings.max_partial_texture_updates = 4;
scoped_ptr<LayerTreeHost> host =
LayerTreeHost::Create(&client, settings, NULL);
EXPECT_TRUE(host->InitializeOutputSurfaceIfNeeded());
EXPECT_EQ(0u, host->settings().max_partial_texture_updates);
}
TEST(LayerTreeHostTest,
PartialUpdatesWithDelegatingRendererAndSoftwareContent) {
FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DELEGATED_SOFTWARE);
LayerTreeSettings settings;
settings.max_partial_texture_updates = 4;
scoped_ptr<LayerTreeHost> host =
LayerTreeHost::Create(&client, settings, NULL);
EXPECT_TRUE(host->InitializeOutputSurfaceIfNeeded());
EXPECT_EQ(0u, host->settings().max_partial_texture_updates);
}
class LayerTreeHostTestCapturePicture : public LayerTreeHostTest {
public:
LayerTreeHostTestCapturePicture()
: bounds_(gfx::Size(100, 100)),
layer_(PictureLayer::Create(&content_client_)) {}
virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
settings->impl_side_painting = true;
}
class FillRectContentLayerClient : public ContentLayerClient {
public:
virtual void PaintContents(SkCanvas* canvas,
gfx::Rect clip,
gfx::RectF* opaque) OVERRIDE {
SkPaint paint;
paint.setColor(SK_ColorGREEN);
SkRect rect = SkRect::MakeWH(canvas->getDeviceSize().width(),
canvas->getDeviceSize().height());
*opaque = gfx::RectF(rect.width(), rect.height());
canvas->drawRect(rect, paint);
}
virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
};
virtual void BeginTest() OVERRIDE {
layer_->SetIsDrawable(true);
layer_->SetBounds(bounds_);
// Outside viewport so tiles don't have to be initialized for commit.
layer_->SetPosition(gfx::Point(100, 100));
layer_tree_host()->SetViewportSize(bounds_);
layer_tree_host()->SetRootLayer(layer_);
PostSetNeedsCommitToMainThread();
}
virtual void DidCommitAndDrawFrame() OVERRIDE {
picture_ = layer_tree_host()->CapturePicture();
EndTest();
}
virtual void AfterTest() OVERRIDE {
EXPECT_EQ(bounds_, gfx::Size(picture_->width(), picture_->height()));
SkBitmap bitmap;
bitmap.setConfig(
SkBitmap::kARGB_8888_Config, bounds_.width(), bounds_.height());
bitmap.allocPixels();
bitmap.eraseARGB(0, 0, 0, 0);
SkCanvas canvas(bitmap);
picture_->draw(&canvas);
bitmap.lockPixels();
SkColor* pixels = reinterpret_cast<SkColor*>(bitmap.getPixels());
EXPECT_EQ(SK_ColorGREEN, pixels[0]);
bitmap.unlockPixels();
}
private:
gfx::Size bounds_;
FillRectContentLayerClient content_client_;
scoped_refptr<PictureLayer> layer_;
skia::RefPtr<SkPicture> picture_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestCapturePicture);
class LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted
: public LayerTreeHostTest {
public:
LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted()
: root_layer_(FakeContentLayer::Create(&client_)),
child_layer1_(FakeContentLayer::Create(&client_)),
child_layer2_(FakeContentLayer::Create(&client_)),
num_commits_(0) {}
virtual void BeginTest() OVERRIDE {
layer_tree_host()->SetViewportSize(gfx::Size(100, 100));
root_layer_->SetBounds(gfx::Size(100, 100));
child_layer1_->SetBounds(gfx::Size(100, 100));
child_layer2_->SetBounds(gfx::Size(100, 100));
root_layer_->AddChild(child_layer1_);
root_layer_->AddChild(child_layer2_);
layer_tree_host()->SetRootLayer(root_layer_);
PostSetNeedsCommitToMainThread();
}
virtual void DidSetVisibleOnImplTree(LayerTreeHostImpl* host_impl,
bool visible) OVERRIDE {
// One backing should remain unevicted.
EXPECT_EQ(100u * 100u * 4u * 1u,
layer_tree_host()->contents_texture_manager()->MemoryUseBytes());
// Make sure that contents textures are marked as having been
// purged.
EXPECT_TRUE(host_impl->active_tree()->ContentsTexturesPurged());
// End the test in this state.
EndTest();
}
virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
++num_commits_;
switch (num_commits_) {
case 1:
// All three backings should have memory.
EXPECT_EQ(
100u * 100u * 4u * 3u,
layer_tree_host()->contents_texture_manager()->MemoryUseBytes());
// Set a new policy that will kick out 1 of the 3 resources.
// Because a resource was evicted, a commit will be kicked off.
host_impl->SetMemoryPolicy(
ManagedMemoryPolicy(100 * 100 * 4 * 2,
ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING,
100 * 100 * 4 * 1,
ManagedMemoryPolicy::CUTOFF_ALLOW_EVERYTHING),
true);
break;
case 2:
// Only two backings should have memory.
EXPECT_EQ(
100u * 100u * 4u * 2u,
layer_tree_host()->contents_texture_manager()->MemoryUseBytes());
// Become backgrounded, which will cause 1 more resource to be
// evicted.
PostSetVisibleToMainThread(false);
break;
default:
// No further commits should happen because this is not visible
// anymore.
NOTREACHED();
break;
}
}
virtual void AfterTest() OVERRIDE {}
private:
FakeContentLayerClient client_;
scoped_refptr<FakeContentLayer> root_layer_;
scoped_refptr<FakeContentLayer> child_layer1_;
scoped_refptr<FakeContentLayer> child_layer2_;
int num_commits_;
};
SINGLE_AND_MULTI_THREAD_TEST_F(
LayerTreeHostTestShutdownWithOnlySomeResourcesEvicted);
class LayerTreeHostTestLCDNotification : public LayerTreeHostTest {
public:
class NotificationClient : public ContentLayerClient {
public:
NotificationClient()
: layer_(0), paint_count_(0), lcd_notification_count_(0) {}
void set_layer(Layer* layer) { layer_ = layer; }
int paint_count() const { return paint_count_; }
int lcd_notification_count() const { return lcd_notification_count_; }
virtual void PaintContents(SkCanvas* canvas,
gfx::Rect clip,
gfx::RectF* opaque) OVERRIDE {
++paint_count_;
}
virtual void DidChangeLayerCanUseLCDText() OVERRIDE {
++lcd_notification_count_;
layer_->SetNeedsDisplay();
}
private:
Layer* layer_;
int paint_count_;
int lcd_notification_count_;
};
virtual void SetupTree() OVERRIDE {
scoped_refptr<ContentLayer> root_layer = ContentLayer::Create(&client_);
root_layer->SetIsDrawable(true);
root_layer->SetBounds(gfx::Size(1, 1));
layer_tree_host()->SetRootLayer(root_layer);
client_.set_layer(root_layer.get());
// The expecations are based on the assumption that the default
// LCD settings are:
EXPECT_TRUE(layer_tree_host()->settings().can_use_lcd_text);
EXPECT_FALSE(root_layer->can_use_lcd_text());
LayerTreeHostTest::SetupTree();
}
virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
virtual void AfterTest() OVERRIDE {}
virtual void DidCommit() OVERRIDE {
switch (layer_tree_host()->commit_number()) {
case 1:
// The first update consists one LCD notification and one paint.
EXPECT_EQ(1, client_.lcd_notification_count());
EXPECT_EQ(1, client_.paint_count());
// LCD text must have been enabled on the layer.
EXPECT_TRUE(layer_tree_host()->root_layer()->can_use_lcd_text());
PostSetNeedsCommitToMainThread();
break;
case 2:
// Since nothing changed on layer, there should be no notification
// or paint on the second update.
EXPECT_EQ(1, client_.lcd_notification_count());
EXPECT_EQ(1, client_.paint_count());
// LCD text must not have changed.
EXPECT_TRUE(layer_tree_host()->root_layer()->can_use_lcd_text());
// Change layer opacity that should trigger lcd notification.
layer_tree_host()->root_layer()->SetOpacity(.5f);
// No need to request a commit - setting opacity will do it.
break;
default:
// Verify that there is not extra commit due to layer invalidation.
EXPECT_EQ(3, layer_tree_host()->commit_number());
// LCD notification count should have incremented due to
// change in layer opacity.
EXPECT_EQ(2, client_.lcd_notification_count());
// Paint count should be incremented due to invalidation.
EXPECT_EQ(2, client_.paint_count());
// LCD text must have been disabled on the layer due to opacity.
EXPECT_FALSE(layer_tree_host()->root_layer()->can_use_lcd_text());
EndTest();
break;
}
}
private:
NotificationClient client_;
};
SINGLE_THREAD_TEST_F(LayerTreeHostTestLCDNotification);
// Verify that the BeginFrame notification is used to initiate rendering.
class LayerTreeHostTestBeginFrameNotification : public LayerTreeHostTest {
public:
virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
settings->begin_frame_scheduling_enabled = true;
}
virtual void BeginTest() OVERRIDE {
// This will trigger a SetNeedsBeginFrame which will trigger a BeginFrame.
PostSetNeedsCommitToMainThread();
}
virtual bool PrepareToDrawOnThread(
LayerTreeHostImpl* host_impl,
LayerTreeHostImpl::FrameData* frame,
bool result) OVERRIDE {
EndTest();
return true;
}
virtual void AfterTest() OVERRIDE {}
private:
base::TimeTicks frame_time_;
};
MULTI_THREAD_TEST_F(LayerTreeHostTestBeginFrameNotification);
class LayerTreeHostTestBeginFrameNotificationShutdownWhileEnabled
: public LayerTreeHostTest {
public:
virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
settings->begin_frame_scheduling_enabled = true;
settings->using_synchronous_renderer_compositor = true;
}
virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
// The BeginFrame notification is turned off now but will get enabled
// once we return. End test while it's enabled.
ImplThreadTaskRunner()->PostTask(
FROM_HERE,
base::Bind(&LayerTreeHostTestBeginFrameNotification::EndTest,
base::Unretained(this)));
}
virtual void AfterTest() OVERRIDE {}
};
MULTI_THREAD_TEST_F(
LayerTreeHostTestBeginFrameNotificationShutdownWhileEnabled);
class LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation
: public LayerTreeHostTest {
protected:
virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
settings->impl_side_painting = true;
}
virtual void SetupTree() OVERRIDE {
LayerTreeHostTest::SetupTree();
scoped_refptr<Layer> layer = PictureLayer::Create(&client_);
layer->SetTransform(gfx::Transform(0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
layer->SetBounds(gfx::Size(10, 10));
layer_tree_host()->root_layer()->AddChild(layer);
}
virtual void BeginTest() OVERRIDE {
PostSetNeedsCommitToMainThread();
}
virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
EndTest();
}
virtual void AfterTest() OVERRIDE {
}
FakeContentLayerClient client_;
};
MULTI_THREAD_TEST_F(
LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation);
class LayerTreeHostTestChangeLayerPropertiesInPaintContents
: public LayerTreeHostTest {
public:
class SetBoundsClient : public ContentLayerClient {
public:
SetBoundsClient() : layer_(0) {}
void set_layer(Layer* layer) { layer_ = layer; }
virtual void PaintContents(SkCanvas* canvas,
gfx::Rect clip,
gfx::RectF* opaque) OVERRIDE {
layer_->SetBounds(gfx::Size(2, 2));
}
virtual void DidChangeLayerCanUseLCDText() OVERRIDE {}
private:
Layer* layer_;
};
LayerTreeHostTestChangeLayerPropertiesInPaintContents() : num_commits_(0) {}
virtual void SetupTree() OVERRIDE {
scoped_refptr<ContentLayer> root_layer = ContentLayer::Create(&client_);
root_layer->SetIsDrawable(true);
root_layer->SetBounds(gfx::Size(1, 1));
layer_tree_host()->SetRootLayer(root_layer);
client_.set_layer(root_layer.get());
LayerTreeHostTest::SetupTree();
}
virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
virtual void AfterTest() OVERRIDE {}
virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
num_commits_++;
if (num_commits_ == 1) {
LayerImpl* root_layer = host_impl->active_tree()->root_layer();
EXPECT_SIZE_EQ(gfx::Size(1, 1), root_layer->bounds());
} else {
LayerImpl* root_layer = host_impl->active_tree()->root_layer();
EXPECT_SIZE_EQ(gfx::Size(2, 2), root_layer->bounds());
EndTest();
}
}
private:
SetBoundsClient client_;
int num_commits_;
};
SINGLE_THREAD_TEST_F(LayerTreeHostTestChangeLayerPropertiesInPaintContents);
class MockIOSurfaceWebGraphicsContext3D : public FakeWebGraphicsContext3D {
public:
MockIOSurfaceWebGraphicsContext3D()
: FakeWebGraphicsContext3D() {}
virtual WebKit::WebGLId createTexture() OVERRIDE {
return 1;
}
virtual WebKit::WebString getString(WebKit::WGC3Denum name) OVERRIDE {
if (name == GL_EXTENSIONS) {
return WebKit::WebString(
"GL_CHROMIUM_iosurface GL_ARB_texture_rectangle");
}
return WebKit::WebString();
}
MOCK_METHOD1(activeTexture, void(WebKit::WGC3Denum texture));
MOCK_METHOD2(bindTexture, void(WebKit::WGC3Denum target,
WebKit::WebGLId texture_id));
MOCK_METHOD3(texParameteri, void(WebKit::WGC3Denum target,
WebKit::WGC3Denum pname,
WebKit::WGC3Dint param));
MOCK_METHOD5(texImageIOSurface2DCHROMIUM, void(WebKit::WGC3Denum target,
WebKit::WGC3Dint width,
WebKit::WGC3Dint height,
WebKit::WGC3Duint ioSurfaceId,
WebKit::WGC3Duint plane));
MOCK_METHOD4(drawElements, void(WebKit::WGC3Denum mode,
WebKit::WGC3Dsizei count,
WebKit::WGC3Denum type,
WebKit::WGC3Dintptr offset));
};
class LayerTreeHostTestIOSurfaceDrawing : public LayerTreeHostTest {
protected:
virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
scoped_ptr<MockIOSurfaceWebGraphicsContext3D> context(
new MockIOSurfaceWebGraphicsContext3D);
mock_context_ = context.get();
scoped_ptr<OutputSurface> output_surface = FakeOutputSurface::Create3d(
context.PassAs<WebKit::WebGraphicsContext3D>()).PassAs<OutputSurface>();
return output_surface.Pass();
}
virtual void SetupTree() OVERRIDE {
LayerTreeHostTest::SetupTree();
layer_tree_host()->root_layer()->SetIsDrawable(false);
io_surface_id_ = 9;
io_surface_size_ = gfx::Size(6, 7);
scoped_refptr<IOSurfaceLayer> io_surface_layer = IOSurfaceLayer::Create();
io_surface_layer->SetBounds(gfx::Size(10, 10));
io_surface_layer->SetAnchorPoint(gfx::PointF());
io_surface_layer->SetIsDrawable(true);
io_surface_layer->SetIOSurfaceProperties(io_surface_id_, io_surface_size_);
layer_tree_host()->root_layer()->AddChild(io_surface_layer);
}
virtual void BeginTest() OVERRIDE {
PostSetNeedsCommitToMainThread();
}
virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
// In WillDraw, the IOSurfaceLayer sets up the io surface texture.
EXPECT_CALL(*mock_context_, activeTexture(_))
.Times(0);
EXPECT_CALL(*mock_context_, bindTexture(GL_TEXTURE_RECTANGLE_ARB, 1))
.Times(AtLeast(1));
EXPECT_CALL(*mock_context_, texParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MIN_FILTER,
GL_LINEAR))
.Times(1);
EXPECT_CALL(*mock_context_, texParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_MAG_FILTER,
GL_LINEAR))
.Times(1);
EXPECT_CALL(*mock_context_, texParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_WRAP_S,
GL_CLAMP_TO_EDGE))
.Times(1);
EXPECT_CALL(*mock_context_, texParameteri(GL_TEXTURE_RECTANGLE_ARB,
GL_TEXTURE_WRAP_T,
GL_CLAMP_TO_EDGE))
.Times(1);
EXPECT_CALL(*mock_context_, texImageIOSurface2DCHROMIUM(
GL_TEXTURE_RECTANGLE_ARB,
io_surface_size_.width(),
io_surface_size_.height(),
io_surface_id_,
0))
.Times(1);
EXPECT_CALL(*mock_context_, bindTexture(_, 0))
.Times(AnyNumber());
}
virtual bool PrepareToDrawOnThread(
LayerTreeHostImpl* host_impl,
LayerTreeHostImpl::FrameData* frame,
bool result) OVERRIDE {
Mock::VerifyAndClearExpectations(&mock_context_);
// The io surface layer's texture is drawn.
EXPECT_CALL(*mock_context_, activeTexture(GL_TEXTURE0))
.Times(AtLeast(1));
EXPECT_CALL(*mock_context_, bindTexture(GL_TEXTURE_RECTANGLE_ARB, 1))
.Times(1);
EXPECT_CALL(*mock_context_, drawElements(GL_TRIANGLES, 6, _, _))
.Times(AtLeast(1));
return result;
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
Mock::VerifyAndClearExpectations(&mock_context_);
EndTest();
}
virtual void AfterTest() OVERRIDE {}
int io_surface_id_;
MockIOSurfaceWebGraphicsContext3D* mock_context_;
gfx::Size io_surface_size_;
};
// TODO(danakj): IOSurface layer can not be transported. crbug.com/239335
SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
LayerTreeHostTestIOSurfaceDrawing);
class LayerTreeHostTestAsyncReadback : public LayerTreeHostTest {
protected:
virtual void SetupTree() OVERRIDE {
root = FakeContentLayer::Create(&client_);
root->SetBounds(gfx::Size(20, 20));
child = FakeContentLayer::Create(&client_);
child->SetBounds(gfx::Size(10, 10));
root->AddChild(child);
layer_tree_host()->SetRootLayer(root);
LayerTreeHostTest::SetupTree();
}
virtual void BeginTest() OVERRIDE {
PostSetNeedsCommitToMainThread();
}
virtual void DidCommitAndDrawFrame() OVERRIDE {
WaitForCallback();
}
void WaitForCallback() {
base::MessageLoop::current()->PostTask(
FROM_HERE,
base::Bind(
&LayerTreeHostTestAsyncReadback::NextStep,
base::Unretained(this)));
}
void NextStep() {
int frame = layer_tree_host()->commit_number();
switch (frame) {
case 1:
child->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
base::Bind(&LayerTreeHostTestAsyncReadback::CopyOutputCallback,
base::Unretained(this))));
EXPECT_EQ(0u, callbacks_.size());
break;
case 2:
if (callbacks_.size() < 1u) {
WaitForCallback();
return;
}
EXPECT_EQ(1u, callbacks_.size());
EXPECT_EQ(gfx::Size(10, 10).ToString(), callbacks_[0].ToString());
child->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
base::Bind(&LayerTreeHostTestAsyncReadback::CopyOutputCallback,
base::Unretained(this))));
root->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
base::Bind(&LayerTreeHostTestAsyncReadback::CopyOutputCallback,
base::Unretained(this))));
child->RequestCopyOfOutput(CopyOutputRequest::CreateBitmapRequest(
base::Bind(&LayerTreeHostTestAsyncReadback::CopyOutputCallback,
base::Unretained(this))));
EXPECT_EQ(1u, callbacks_.size());
break;
case 3:
if (callbacks_.size() < 4u) {
WaitForCallback();
return;
}
EXPECT_EQ(4u, callbacks_.size());
// The child was copied to a bitmap and passed back twice.
EXPECT_EQ(gfx::Size(10, 10).ToString(), callbacks_[1].ToString());
EXPECT_EQ(gfx::Size(10, 10).ToString(), callbacks_[2].ToString());
// The root was copied to a bitmap and passed back also.
EXPECT_EQ(gfx::Size(20, 20).ToString(), callbacks_[3].ToString());
EndTest();
break;
}
}
void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
EXPECT_TRUE(result->HasBitmap());
scoped_ptr<SkBitmap> bitmap = result->TakeBitmap().Pass();
EXPECT_EQ(result->size().ToString(),
gfx::Size(bitmap->width(), bitmap->height()).ToString());
callbacks_.push_back(result->size());
}
virtual void AfterTest() OVERRIDE {
EXPECT_EQ(4u, callbacks_.size());
}
virtual scoped_ptr<OutputSurface> CreateOutputSurface() OVERRIDE {
if (use_gl_renderer_)
return FakeOutputSurface::Create3d().PassAs<OutputSurface>();
return FakeOutputSurface::CreateSoftware(
make_scoped_ptr(new SoftwareOutputDevice)).PassAs<OutputSurface>();
}
bool use_gl_renderer_;
std::vector<gfx::Size> callbacks_;
FakeContentLayerClient client_;
scoped_refptr<FakeContentLayer> root;
scoped_refptr<FakeContentLayer> child;
};
// Readback can't be done with a delegating renderer.
TEST_F(LayerTreeHostTestAsyncReadback, GLRenderer_RunSingleThread) {
use_gl_renderer_ = true;
RunTest(false, false, false);
}
TEST_F(LayerTreeHostTestAsyncReadback,
GLRenderer_RunMultiThread_MainThreadPainting) {
use_gl_renderer_ = true;
RunTest(true, false, false);
}
TEST_F(LayerTreeHostTestAsyncReadback,
GLRenderer_RunMultiThread_ImplSidePainting) {
use_gl_renderer_ = true;
RunTest(true, false, true);
}
TEST_F(LayerTreeHostTestAsyncReadback, SoftwareRenderer_RunSingleThread) {
use_gl_renderer_ = false;
RunTest(false, false, false);
}
TEST_F(LayerTreeHostTestAsyncReadback,
SoftwareRenderer_RunMultiThread_MainThreadPainting) {
use_gl_renderer_ = false;
RunTest(true, false, false);
}
TEST_F(LayerTreeHostTestAsyncReadback,
SoftwareRenderer_RunMultiThread_ImplSidePainting) {
use_gl_renderer_ = false;
RunTest(true, false, true);
}
class LayerTreeHostTestAsyncReadbackLayerDestroyed : public LayerTreeHostTest {
protected:
virtual void SetupTree() OVERRIDE {
root_ = FakeContentLayer::Create(&client_);
root_->SetBounds(gfx::Size(20, 20));
main_destroyed_ = FakeContentLayer::Create(&client_);
main_destroyed_->SetBounds(gfx::Size(15, 15));
root_->AddChild(main_destroyed_);
impl_destroyed_ = FakeContentLayer::Create(&client_);
impl_destroyed_->SetBounds(gfx::Size(10, 10));
root_->AddChild(impl_destroyed_);
layer_tree_host()->SetRootLayer(root_);
LayerTreeHostTest::SetupTree();
}
virtual void BeginTest() OVERRIDE {
callback_count_ = 0;
PostSetNeedsCommitToMainThread();
}
virtual void DidCommit() OVERRIDE {
int frame = layer_tree_host()->commit_number();
switch (frame) {
case 1:
main_destroyed_->RequestCopyOfOutput(
CopyOutputRequest::CreateBitmapRequest(base::Bind(
&LayerTreeHostTestAsyncReadbackLayerDestroyed::
CopyOutputCallback,
base::Unretained(this))));
impl_destroyed_->RequestCopyOfOutput(
CopyOutputRequest::CreateBitmapRequest(base::Bind(
&LayerTreeHostTestAsyncReadbackLayerDestroyed::
CopyOutputCallback,
base::Unretained(this))));
EXPECT_EQ(0, callback_count_);
// Destroy the main thread layer right away.
main_destroyed_->RemoveFromParent();
main_destroyed_ = NULL;
// Should callback with a NULL bitmap.
EXPECT_EQ(1, callback_count_);
// Prevent drawing so we can't make a copy of the impl_destroyed layer.
layer_tree_host()->SetViewportSize(gfx::Size());
break;
case 2:
// Flush the message loops and make sure the callbacks run.
layer_tree_host()->SetNeedsCommit();
break;
case 3:
// No drawing means no readback yet.
EXPECT_EQ(1, callback_count_);
// Destroy the impl thread layer.
impl_destroyed_->RemoveFromParent();
impl_destroyed_ = NULL;
// No callback yet because it's on the impl side.
EXPECT_EQ(1, callback_count_);
break;
case 4:
// Flush the message loops and make sure the callbacks run.
layer_tree_host()->SetNeedsCommit();
break;
case 5:
// We should get another callback with a NULL bitmap.
EXPECT_EQ(2, callback_count_);
EndTest();
break;
}
}
void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
EXPECT_TRUE(result->IsEmpty());
++callback_count_;
}
virtual void AfterTest() OVERRIDE {}
int callback_count_;
FakeContentLayerClient client_;
scoped_refptr<FakeContentLayer> root_;
scoped_refptr<FakeContentLayer> main_destroyed_;
scoped_refptr<FakeContentLayer> impl_destroyed_;
};
SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestAsyncReadbackLayerDestroyed);
class LayerTreeHostTestAsyncReadbackInHiddenSubtree : public LayerTreeHostTest {
protected:
virtual void SetupTree() OVERRIDE {
root_ = FakeContentLayer::Create(&client_);
root_->SetBounds(gfx::Size(20, 20));
grand_parent_layer_ = FakeContentLayer::Create(&client_);
grand_parent_layer_->SetBounds(gfx::Size(15, 15));
root_->AddChild(grand_parent_layer_);
// parent_layer_ owns a render surface.
parent_layer_ = FakeContentLayer::Create(&client_);
parent_layer_->SetBounds(gfx::Size(15, 15));
parent_layer_->SetForceRenderSurface(true);
grand_parent_layer_->AddChild(parent_layer_);
copy_layer_ = FakeContentLayer::Create(&client_);
copy_layer_->SetBounds(gfx::Size(10, 10));
parent_layer_->AddChild(copy_layer_);
layer_tree_host()->SetRootLayer(root_);
LayerTreeHostTest::SetupTree();
}
void AddCopyRequest(Layer* layer) {
layer->RequestCopyOfOutput(
CopyOutputRequest::CreateBitmapRequest(base::Bind(
&LayerTreeHostTestAsyncReadbackInHiddenSubtree::CopyOutputCallback,
base::Unretained(this))));
}
virtual void BeginTest() OVERRIDE {
callback_count_ = 0;
PostSetNeedsCommitToMainThread();
AddCopyRequest(copy_layer_.get());
}
void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
EXPECT_EQ(copy_layer_->bounds().ToString(), result->size().ToString());
++callback_count_;
switch (callback_count_) {
case 1:
// Hide the copy request layer.
grand_parent_layer_->SetHideLayerAndSubtree(false);
parent_layer_->SetHideLayerAndSubtree(false);
copy_layer_->SetHideLayerAndSubtree(true);
AddCopyRequest(copy_layer_.get());
break;
case 2:
// Hide the copy request layer's parent only.
grand_parent_layer_->SetHideLayerAndSubtree(false);
parent_layer_->SetHideLayerAndSubtree(true);
copy_layer_->SetHideLayerAndSubtree(false);
AddCopyRequest(copy_layer_.get());
break;
case 3:
// Hide the copy request layer's grand parent only.
grand_parent_layer_->SetHideLayerAndSubtree(true);
parent_layer_->SetHideLayerAndSubtree(false);
copy_layer_->SetHideLayerAndSubtree(false);
AddCopyRequest(copy_layer_.get());
break;
case 4:
// Hide the copy request layer's parent and grandparent.
grand_parent_layer_->SetHideLayerAndSubtree(true);
parent_layer_->SetHideLayerAndSubtree(true);
copy_layer_->SetHideLayerAndSubtree(false);
AddCopyRequest(copy_layer_.get());
break;
case 5:
// Hide the copy request layer as well as its parent and grandparent.
grand_parent_layer_->SetHideLayerAndSubtree(true);
parent_layer_->SetHideLayerAndSubtree(true);
copy_layer_->SetHideLayerAndSubtree(true);
AddCopyRequest(copy_layer_.get());
break;
case 6:
EndTest();
break;
}
}
virtual void AfterTest() OVERRIDE {}
int callback_count_;
FakeContentLayerClient client_;
scoped_refptr<FakeContentLayer> root_;
scoped_refptr<FakeContentLayer> grand_parent_layer_;
scoped_refptr<FakeContentLayer> parent_layer_;
scoped_refptr<FakeContentLayer> copy_layer_;
};
// No output to copy for delegated renderers.
SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
LayerTreeHostTestAsyncReadbackInHiddenSubtree);
class LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest
: public LayerTreeHostTest {
protected:
virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
settings->cache_render_pass_contents = true;
}
virtual void SetupTree() OVERRIDE {
root_ = FakeContentLayer::Create(&client_);
root_->SetBounds(gfx::Size(20, 20));
grand_parent_layer_ = FakeContentLayer::Create(&client_);
grand_parent_layer_->SetBounds(gfx::Size(15, 15));
grand_parent_layer_->SetHideLayerAndSubtree(true);
root_->AddChild(grand_parent_layer_);
// parent_layer_ owns a render surface.
parent_layer_ = FakeContentLayer::Create(&client_);
parent_layer_->SetBounds(gfx::Size(15, 15));
parent_layer_->SetForceRenderSurface(true);
grand_parent_layer_->AddChild(parent_layer_);
copy_layer_ = FakeContentLayer::Create(&client_);
copy_layer_->SetBounds(gfx::Size(10, 10));
parent_layer_->AddChild(copy_layer_);
layer_tree_host()->SetRootLayer(root_);
LayerTreeHostTest::SetupTree();
}
virtual void BeginTest() OVERRIDE {
did_draw_ = false;
PostSetNeedsCommitToMainThread();
copy_layer_->RequestCopyOfOutput(
CopyOutputRequest::CreateBitmapRequest(base::Bind(
&LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest::
CopyOutputCallback,
base::Unretained(this))));
}
void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
EXPECT_EQ(copy_layer_->bounds().ToString(), result->size().ToString());
EndTest();
}
virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
Renderer* renderer = host_impl->renderer();
LayerImpl* root = host_impl->active_tree()->root_layer();
LayerImpl* grand_parent = root->children()[0];
LayerImpl* parent = grand_parent->children()[0];
LayerImpl* copy_layer = parent->children()[0];
// |parent| owns a surface, but it was hidden and not part of the copy
// request so it should not allocate any resource.
EXPECT_FALSE(renderer->HaveCachedResourcesForRenderPassId(
parent->render_surface()->RenderPassId()));
// |copy_layer| should have been rendered to a texture since it was needed
// for a copy request.
EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(
copy_layer->render_surface()->RenderPassId()));
did_draw_ = true;
}
virtual void AfterTest() OVERRIDE { EXPECT_TRUE(did_draw_); }
FakeContentLayerClient client_;
bool did_draw_;
scoped_refptr<FakeContentLayer> root_;
scoped_refptr<FakeContentLayer> grand_parent_layer_;
scoped_refptr<FakeContentLayer> parent_layer_;
scoped_refptr<FakeContentLayer> copy_layer_;
};
// No output to copy for delegated renderers.
SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
LayerTreeHostTestHiddenSurfaceNotAllocatedForSubtreeCopyRequest);
class LayerTreeHostTestAsyncReadbackClippedOut : public LayerTreeHostTest {
protected:
virtual void SetupTree() OVERRIDE {
root_ = FakeContentLayer::Create(&client_);
root_->SetBounds(gfx::Size(20, 20));
parent_layer_ = FakeContentLayer::Create(&client_);
parent_layer_->SetBounds(gfx::Size(15, 15));
parent_layer_->SetMasksToBounds(true);
root_->AddChild(parent_layer_);
copy_layer_ = FakeContentLayer::Create(&client_);
copy_layer_->SetPosition(gfx::Point(15, 15));
copy_layer_->SetBounds(gfx::Size(10, 10));
parent_layer_->AddChild(copy_layer_);
layer_tree_host()->SetRootLayer(root_);
LayerTreeHostTest::SetupTree();
}
virtual void BeginTest() OVERRIDE {
PostSetNeedsCommitToMainThread();
copy_layer_->RequestCopyOfOutput(
CopyOutputRequest::CreateBitmapRequest(base::Bind(
&LayerTreeHostTestAsyncReadbackClippedOut::CopyOutputCallback,
base::Unretained(this))));
}
void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {
// We should still get a callback with no output if the copy requested layer
// was completely clipped away.
EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
EXPECT_EQ(gfx::Size().ToString(), result->size().ToString());
EndTest();
}
virtual void AfterTest() OVERRIDE {}
FakeContentLayerClient client_;
scoped_refptr<FakeContentLayer> root_;
scoped_refptr<FakeContentLayer> parent_layer_;
scoped_refptr<FakeContentLayer> copy_layer_;
};
// No output to copy for delegated renderers.
SINGLE_AND_MULTI_THREAD_DIRECT_RENDERER_TEST_F(
LayerTreeHostTestAsyncReadbackClippedOut);
class LayerTreeHostTestNumFramesPending : public LayerTreeHostTest {
public:
virtual void BeginTest() OVERRIDE {
frame_ = 0;
PostSetNeedsCommitToMainThread();
}
// Round 1: commit + draw
// Round 2: commit only (no draw/swap)
// Round 3: draw only (no commit)
// Round 4: composite & readback (2 commits, no draw/swap)
// Round 5: commit + draw
virtual void DidCommit() OVERRIDE {
int commit = layer_tree_host()->commit_number();
switch (commit) {
case 2:
// Round 2 done.
EXPECT_EQ(1, frame_);
layer_tree_host()->SetNeedsRedraw();
break;
case 3:
// CompositeAndReadback in Round 4, first commit.
EXPECT_EQ(2, frame_);
break;
case 4:
// Round 4 done.
EXPECT_EQ(2, frame_);
layer_tree_host()->SetNeedsCommit();
layer_tree_host()->SetNeedsRedraw();
break;