scoped_ptr<DelegatedFrameData> frame(new DelegatedFrameData);
scoped_ptr<RenderPass> root_pass(RenderPass::Create());
- root_pass->SetNew(RenderPass::Id(1, 1),
+ root_pass->SetNew(RenderPassId(1, 1),
root_output_rect,
root_damage_rect,
gfx::Transform());
scoped_ptr<DelegatedFrameData> frame(new DelegatedFrameData);
scoped_ptr<RenderPass> root_pass(RenderPass::Create());
- root_pass->SetNew(RenderPass::Id(1, 1),
+ root_pass->SetNew(RenderPassId(1, 1),
root_output_rect,
root_damage_rect,
gfx::Transform());
- scoped_ptr<SharedQuadState> shared_quad_state = SharedQuadState::Create();
+ SharedQuadState* shared_quad_state =
+ root_pass->CreateAndAppendSharedQuadState();
gfx::Rect rect = root_output_rect;
gfx::Rect opaque_rect = root_output_rect;
+ gfx::Rect visible_rect = root_output_rect;
// An invalid resource id! The resource isn't part of the frame.
unsigned resource_id = 5;
bool premultiplied_alpha = false;
float vertex_opacity[4] = {1.f, 1.f, 1.f, 1.f};
bool flipped = false;
- scoped_ptr<TextureDrawQuad> invalid_draw_quad = TextureDrawQuad::Create();
- invalid_draw_quad->SetNew(shared_quad_state.get(),
+ TextureDrawQuad* invalid_draw_quad =
+ root_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
+ invalid_draw_quad->SetNew(shared_quad_state,
rect,
opaque_rect,
+ visible_rect,
resource_id,
premultiplied_alpha,
uv_top_left,
background_color,
vertex_opacity,
flipped);
- root_pass->quad_list.push_back(invalid_draw_quad.PassAs<DrawQuad>());
-
- root_pass->shared_quad_state_list.push_back(shared_quad_state.Pass());
frame->render_pass_list.push_back(root_pass.Pass());
return frame.Pass();
void AddTextureQuad(DelegatedFrameData* frame,
ResourceProvider::ResourceId resource_id) {
- scoped_ptr<SharedQuadState> sqs = SharedQuadState::Create();
- scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
+ RenderPass* render_pass = frame->render_pass_list[0];
+ SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();
+ TextureDrawQuad* quad =
+ render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
float vertex_opacity[4] = { 1.f, 1.f, 1.f, 1.f };
- quad->SetNew(sqs.get(),
+ quad->SetNew(sqs,
+ gfx::Rect(0, 0, 10, 10),
gfx::Rect(0, 0, 10, 10),
gfx::Rect(0, 0, 10, 10),
resource_id,
SK_ColorTRANSPARENT,
vertex_opacity,
false);
- frame->render_pass_list[0]->shared_quad_state_list.push_back(sqs.Pass());
- frame->render_pass_list[0]->quad_list.push_back(quad.PassAs<DrawQuad>());
}
void AddRenderPass(DelegatedFrameData* frame,
- RenderPass::Id id,
+ RenderPassId id,
const gfx::Rect& output_rect,
const gfx::Rect& damage_rect,
const FilterOperations& filters,
gfx::Transform());
frame->render_pass_list.push_back(pass.Pass());
- scoped_ptr<SharedQuadState> sqs = SharedQuadState::Create();
- scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
+ RenderPass* render_pass = frame->render_pass_list[0];
+ SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();
+ RenderPassDrawQuad* quad =
+ render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
- quad->SetNew(sqs.get(),
+ quad->SetNew(sqs,
+ output_rect,
output_rect,
id,
- false, // is_replica
- 0, // mask_resource_id
- damage_rect,
- gfx::Rect(0, 0, 1, 1), // mask_uv_rect
+ 0,
+ gfx::Vector2dF(),
+ gfx::Size(),
filters,
+ gfx::Vector2dF(),
background_filters);
- frame->render_pass_list[0]->shared_quad_state_list.push_back(sqs.Pass());
- frame->render_pass_list[0]->quad_list.push_back(quad.PassAs<DrawQuad>());
}
static ResourceProvider::ResourceId AppendResourceId(
for (size_t i = 0; i < resources_to_return.size(); ++i)
output_surface()->ReturnResource(resources_to_return[i], &ack);
host_impl->ReclaimResources(&ack);
- host_impl->OnSwapBuffersComplete();
}
};
resource_collection_->SetClient(this);
}
- virtual void SetupTree() OVERRIDE {
+ void SetupTree() override {
root_ = Layer::Create();
- root_->SetAnchorPoint(gfx::PointF());
- root_->SetBounds(gfx::Size(10, 10));
+ root_->SetBounds(gfx::Size(15, 15));
layer_tree_host()->SetRootLayer(root_);
LayerTreeHostDelegatedTest::SetupTree();
}
- virtual void BeginTest() OVERRIDE {
+ void BeginTest() override {
resource_collection_->SetClient(this);
PostSetNeedsCommitToMainThread();
}
DelegatedFrameProvider* frame_provider) {
scoped_refptr<DelegatedRendererLayer> delegated =
FakeDelegatedRendererLayer::Create(frame_provider);
- delegated->SetAnchorPoint(gfx::PointF());
delegated->SetBounds(gfx::Size(10, 10));
delegated->SetIsDrawable(true);
return delegated;
}
- virtual void AfterTest() OVERRIDE { resource_collection_->SetClient(NULL); }
+ void AfterTest() override { resource_collection_->SetClient(NULL); }
// DelegatedFrameProviderClient implementation.
- virtual void UnusedResourcesAreAvailable() OVERRIDE { available_ = true; }
+ void UnusedResourcesAreAvailable() override { available_ = true; }
bool TestAndResetAvailable() {
bool available = available_;
num_activates_(0),
did_reset_child_id_(false) {}
- virtual void DidCommit() OVERRIDE {
+ void DidCommit() override {
if (TestEnded())
return;
SetFrameData(CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1)));
}
- virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+ void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
if (host_impl->active_tree()->source_frame_number() < 1)
return;
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
TestContextProvider* context_provider = static_cast<TestContextProvider*>(
- host_impl->output_surface()->context_provider().get());
+ host_impl->output_surface()->context_provider());
++num_activates_;
switch (num_activates_) {
}
}
- virtual void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
- bool success) OVERRIDE {
+ void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
+ bool success) override {
EXPECT_TRUE(success);
if (num_activates_ < 2)
LayerTreeHostDelegatedTestInvalidFrameAfterContextLost()
: num_activates_(0), num_output_surfaces_initialized_(0) {}
- virtual void DidCommit() OVERRIDE {
+ void DidCommit() override {
if (TestEnded())
return;
scoped_ptr<DelegatedFrameData> frame1 =
SetFrameData(frame1.Pass());
}
- virtual void DidInitializeOutputSurface(bool succeeded) OVERRIDE {
+ void DidInitializeOutputSurface() override {
if (!num_output_surfaces_initialized_++)
return;
DCHECK(delegated_.get() == old_delegated.get());
}
- virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+ void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
if (host_impl->active_tree()->source_frame_number() < 1)
return;
TestContextProvider* context_provider = static_cast<TestContextProvider*>(
- host_impl->output_surface()->context_provider().get());
+ host_impl->output_surface()->context_provider());
++num_activates_;
switch (num_activates_) {
}
}
- virtual void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
- bool success) OVERRIDE {
+ void InitializedRendererOnThread(LayerTreeHostImpl* host_impl,
+ bool success) override {
EXPECT_TRUE(success);
if (num_activates_ < 2)
EXPECT_EQ(0U, delegated_impl->Resources().size());
}
- virtual void AfterTest() OVERRIDE {
+ void AfterTest() override {
LayerTreeHostDelegatedTestCaseSingleDelegatedLayer::AfterTest();
EXPECT_EQ(2, num_output_surfaces_initialized_);
}
SINGLE_AND_MULTI_THREAD_TEST_F(
LayerTreeHostDelegatedTestInvalidFrameAfterContextLost);
-class LayerTreeHostDelegatedTestOffscreenContext_NoFilters
- : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
- protected:
- virtual void BeginTest() OVERRIDE {
- scoped_ptr<DelegatedFrameData> frame =
- CreateFrameData(gfx::Rect(0, 0, 1, 1),
- gfx::Rect(0, 0, 1, 1));
- SetFrameData(frame.Pass());
-
- PostSetNeedsCommitToMainThread();
- }
-
- virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- EXPECT_FALSE(host_impl->offscreen_context_provider());
- EndTest();
- }
-};
-
-SINGLE_AND_MULTI_THREAD_TEST_F(
- LayerTreeHostDelegatedTestOffscreenContext_NoFilters);
-
-class LayerTreeHostDelegatedTestOffscreenContext_Filters
- : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
- protected:
- virtual void BeginTest() OVERRIDE {
- scoped_ptr<DelegatedFrameData> frame =
- CreateFrameData(gfx::Rect(0, 0, 1, 1),
- gfx::Rect(0, 0, 1, 1));
-
- FilterOperations filters;
- filters.Append(FilterOperation::CreateGrayscaleFilter(0.5f));
- AddRenderPass(frame.get(),
- RenderPass::Id(2, 1),
- gfx::Rect(0, 0, 1, 1),
- gfx::Rect(0, 0, 1, 1),
- filters,
- FilterOperations());
- SetFrameData(frame.Pass());
-
- PostSetNeedsCommitToMainThread();
- }
-
- virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- bool expect_context = !delegating_renderer();
- EXPECT_EQ(expect_context, !!host_impl->offscreen_context_provider());
- EndTest();
- }
-};
-
-SINGLE_AND_MULTI_THREAD_TEST_F(
- LayerTreeHostDelegatedTestOffscreenContext_Filters);
-
-class LayerTreeHostDelegatedTestOffscreenContext_BackgroundFilters
- : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
- protected:
- virtual void BeginTest() OVERRIDE {
- scoped_ptr<DelegatedFrameData> frame =
- CreateFrameData(gfx::Rect(0, 0, 1, 1),
- gfx::Rect(0, 0, 1, 1));
-
- FilterOperations filters;
- filters.Append(FilterOperation::CreateGrayscaleFilter(0.5f));
- AddRenderPass(frame.get(),
- RenderPass::Id(2, 1),
- gfx::Rect(0, 0, 1, 1),
- gfx::Rect(0, 0, 1, 1),
- FilterOperations(),
- filters);
- SetFrameData(frame.Pass());
-
- PostSetNeedsCommitToMainThread();
- }
-
- virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- bool expect_context = !delegating_renderer();
- EXPECT_EQ(expect_context, !!host_impl->offscreen_context_provider());
- EndTest();
- }
-};
-
-SINGLE_AND_MULTI_THREAD_TEST_F(
- LayerTreeHostDelegatedTestOffscreenContext_BackgroundFilters);
-
-class LayerTreeHostDelegatedTestOffscreenContext_Filters_AddedToTree
- : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
- protected:
- virtual void BeginTest() OVERRIDE {
- scoped_ptr<DelegatedFrameData> frame_no_filters =
- CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
-
- scoped_ptr<DelegatedFrameData> frame_with_filters =
- CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
-
- FilterOperations filters;
- filters.Append(FilterOperation::CreateGrayscaleFilter(0.5f));
- AddRenderPass(frame_with_filters.get(),
- RenderPass::Id(2, 1),
- gfx::Rect(0, 0, 1, 1),
- gfx::Rect(0, 0, 1, 1),
- filters,
- FilterOperations());
-
- SetFrameData(frame_no_filters.Pass());
- delegated_->RemoveFromParent();
- SetFrameData(frame_with_filters.Pass());
- layer_tree_host()->root_layer()->AddChild(delegated_);
-
- PostSetNeedsCommitToMainThread();
- }
-
- virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
- bool expect_context = !delegating_renderer();
- EXPECT_EQ(expect_context, !!host_impl->offscreen_context_provider());
- EndTest();
- }
-};
-
-SINGLE_AND_MULTI_THREAD_TEST_F(
- LayerTreeHostDelegatedTestOffscreenContext_Filters_AddedToTree);
-
class LayerTreeHostDelegatedTestLayerUsesFrameDamage
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
: LayerTreeHostDelegatedTestCaseSingleDelegatedLayer(),
first_draw_for_source_frame_(true) {}
- virtual void DidCommit() OVERRIDE {
+ void DidCommit() override {
int next_source_frame_number = layer_tree_host()->source_frame_number();
switch (next_source_frame_number) {
case 1:
CreateFrameData(gfx::Rect(0, 0, 20, 20), gfx::Rect(0, 0, 0, 0)));
break;
case 3:
- // Should create a total amount of gfx::Rect(2, 2, 10, 6) damage.
- // The frame size is 20x20 while the layer is 10x10, so this should
- // produce a gfx::Rect(1, 1, 5, 3) damage rect.
+ // Should create a total amount of gfx::Rect(2, 2, 8, 6) damage:
+ // (2, 2, 10, 6) clamped to the root output rect.
SetFrameData(
CreateFrameData(gfx::Rect(0, 0, 20, 20), gfx::Rect(2, 2, 5, 5)));
SetFrameData(
layer_tree_host()->SetNeedsCommit();
break;
case 9:
- // Should damage the full layer.
- delegated_->SetDisplaySize(gfx::Size(10, 10));
- break;
- case 10:
// Should create zero damage.
layer_tree_host()->SetNeedsCommit();
break;
- case 11:
+ case 10:
// Changing the frame size damages the full layer.
SetFrameData(
CreateFrameData(gfx::Rect(0, 0, 5, 5), gfx::Rect(4, 4, 1, 1)));
break;
- case 12:
+ case 11:
// An invalid frame isn't used, so it should not cause damage.
SetFrameData(CreateInvalidFrameData(gfx::Rect(0, 0, 5, 5),
gfx::Rect(4, 4, 1, 1)));
break;
- case 13:
- // Should create gfx::Rect(1, 1, 2, 2) of damage. The frame size is
- // 5x5 and the display size is now set to 10x10, so this should result
- // in a gfx::Rect(2, 2, 4, 4) damage rect.
+ case 12:
+ // Should create gfx::Rect(1, 1, 2, 2) of damage.
SetFrameData(
CreateFrameData(gfx::Rect(0, 0, 5, 5), gfx::Rect(1, 1, 2, 2)));
break;
- case 14:
+ case 13:
// Should create zero damage.
layer_tree_host()->SetNeedsCommit();
break;
- case 15:
+ case 14:
// Moving the layer out of the tree and back in will damage the whole
// impl layer.
delegated_->RemoveFromParent();
layer_tree_host()->root_layer()->AddChild(delegated_);
break;
- case 16:
+ case 15:
// Make a larger frame with lots of damage. Then a frame smaller than
// the first frame's damage. The entire layer should be damaged, but
// nothing more.
SetFrameData(
CreateFrameData(gfx::Rect(0, 0, 5, 5), gfx::Rect(1, 1, 2, 2)));
break;
- case 17:
+ case 16:
// Make a frame with lots of damage. Then replace it with a frame with
// no damage. The entire layer should be damaged, but nothing more.
SetFrameData(
SetFrameData(
CreateFrameData(gfx::Rect(0, 0, 10, 10), gfx::Rect(0, 0, 0, 0)));
break;
- case 18:
+ case 17:
// Make another layer that uses the same frame provider. The new layer
// should be damaged.
- delegated_copy_ = CreateDelegatedLayer(frame_provider_);
+ delegated_copy_ = CreateDelegatedLayer(frame_provider_.get());
delegated_copy_->SetPosition(gfx::Point(5, 0));
// Also set a new frame.
SetFrameData(
CreateFrameData(gfx::Rect(0, 0, 10, 10), gfx::Rect(4, 0, 1, 1)));
break;
- case 19:
+ case 18:
// Set another new frame, both layers should be damaged in the same
// ways.
SetFrameData(
CreateFrameData(gfx::Rect(0, 0, 10, 10), gfx::Rect(3, 3, 1, 1)));
+ break;
}
first_draw_for_source_frame_ = true;
}
- virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
- LayerTreeHostImpl* host_impl,
- LayerTreeHostImpl::FrameData* frame,
- DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
- EXPECT_EQ(DrawSwapReadbackResult::DRAW_SUCCESS, draw_result);
+ DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
+ LayerTreeHostImpl::FrameData* frame,
+ DrawResult draw_result) override {
+ EXPECT_EQ(DRAW_SUCCESS, draw_result);
if (!first_draw_for_source_frame_)
return draw_result;
- gfx::RectF damage_rect;
+ gfx::Rect damage_rect;
if (!frame->has_no_damage) {
damage_rect = frame->render_passes.back()->damage_rect;
} else {
switch (host_impl->active_tree()->source_frame_number()) {
case 0:
// First frame is damaged because of viewport resize.
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 10.f, 10.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect(15, 15).ToString(), damage_rect.ToString());
break;
case 1:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 10.f, 10.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString());
break;
case 2:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 10.f, 10.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString());
break;
case 3:
- EXPECT_EQ(gfx::RectF(1.f, 1.f, 5.f, 3.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect(2, 2, 8, 6).ToString(), damage_rect.ToString());
break;
case 4:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect().ToString(), damage_rect.ToString());
break;
case 5:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 10.f, 10.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString());
break;
case 6:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect().ToString(), damage_rect.ToString());
break;
case 7:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 6.f, 6.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect(6, 6).ToString(), damage_rect.ToString());
break;
case 8:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect().ToString(), damage_rect.ToString());
break;
case 9:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 6.f, 6.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect().ToString(), damage_rect.ToString());
break;
case 10:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString());
break;
case 11:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 10.f, 10.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect().ToString(), damage_rect.ToString());
break;
case 12:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect(1, 1, 2, 2).ToString(), damage_rect.ToString());
break;
case 13:
- EXPECT_EQ(gfx::RectF(2.f, 2.f, 4.f, 4.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect().ToString(), damage_rect.ToString());
break;
case 14:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 0.f, 0.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString());
break;
case 15:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 10.f, 10.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString());
break;
case 16:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 10.f, 10.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect(10, 10).ToString(), damage_rect.ToString());
break;
case 17:
- EXPECT_EQ(gfx::RectF(0.f, 0.f, 10.f, 10.f).ToString(),
+ EXPECT_EQ(gfx::UnionRects(gfx::Rect(5, 0, 10, 10),
+ gfx::Rect(4, 0, 1, 1)).ToString(),
damage_rect.ToString());
break;
case 18:
- EXPECT_EQ(gfx::UnionRects(gfx::RectF(5.f, 0.f, 10.f, 10.f),
- gfx::RectF(4.f, 0.f, 1.f, 1.f)).ToString(),
- damage_rect.ToString());
- break;
- case 19:
- EXPECT_EQ(gfx::RectF(3.f, 3.f, 6.f, 1.f).ToString(),
- damage_rect.ToString());
+ EXPECT_EQ(gfx::Rect(3, 3, 6, 1).ToString(), damage_rect.ToString());
EndTest();
break;
}
class LayerTreeHostDelegatedTestMergeResources
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE {
+ void BeginTest() override {
// Push two frames to the delegated renderer layer with no commit between.
// The first frame has resource 999.
PostSetNeedsCommitToMainThread();
}
- virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+ void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
class LayerTreeHostDelegatedTestRemapResourcesInQuads
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE {
+ void BeginTest() override {
// Generate a frame with two resources in it.
scoped_ptr<DelegatedFrameData> frame =
CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
PostSetNeedsCommitToMainThread();
}
- virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+ void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
LayerImpl* root_impl = host_impl->active_tree()->root_layer();
FakeDelegatedRendererLayerImpl* delegated_impl =
static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
// The resources in the quads should be remapped to the parent's namespace.
const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
- delegated_impl->RenderPassesInDrawOrder()[0]->quad_list[0]);
+ delegated_impl->RenderPassesInDrawOrder()[0]->quad_list.ElementAt(0));
EXPECT_EQ(parent_resource_id1, quad1->resource_id);
const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast(
- delegated_impl->RenderPassesInDrawOrder()[0]->quad_list[1]);
+ delegated_impl->RenderPassesInDrawOrder()[0]->quad_list.ElementAt(1));
EXPECT_EQ(parent_resource_id2, quad2->resource_id);
EndTest();
class LayerTreeHostDelegatedTestReturnUnusedResources
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE {
- PostSetNeedsCommitToMainThread();
- }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DidCommitAndDrawFrame() OVERRIDE {
+ void DidCommitAndDrawFrame() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
EXPECT_FALSE(TestAndResetAvailable());
}
- virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
- bool result) OVERRIDE {
+ void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
ReturnUnusedResourcesFromParent(host_impl);
}
};
class LayerTreeHostDelegatedTestReusedResources
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE {
- PostSetNeedsCommitToMainThread();
- }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DidCommitAndDrawFrame() OVERRIDE {
+ void DidCommitAndDrawFrame() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
}
}
- virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
- bool result) OVERRIDE {
+ void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
ReturnUnusedResourcesFromParent(host_impl);
}
};
class LayerTreeHostDelegatedTestFrameBeforeAck
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE {
- PostSetNeedsCommitToMainThread();
- }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DidCommitAndDrawFrame() OVERRIDE {
+ void DidCommitAndDrawFrame() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
}
}
- virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+ void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
if (host_impl->active_tree()->source_frame_number() != 3)
return;
const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
EXPECT_EQ(1u, pass->quad_list.size());
- const TextureDrawQuad* quad = TextureDrawQuad::MaterialCast(
- pass->quad_list[0]);
+ const TextureDrawQuad* quad =
+ TextureDrawQuad::MaterialCast(pass->quad_list.front());
EXPECT_EQ(map.find(999)->second, quad->resource_id);
EndTest();
}
- virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
- bool result) OVERRIDE {
+ void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
ReturnUnusedResourcesFromParent(host_impl);
}
};
class LayerTreeHostDelegatedTestFrameBeforeTakeResources
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE {
- PostSetNeedsCommitToMainThread();
- }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DidCommitAndDrawFrame() OVERRIDE {
+ void DidCommitAndDrawFrame() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
}
}
- virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+ void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
if (host_impl->active_tree()->source_frame_number() != 3)
return;
const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
EXPECT_EQ(3u, pass->quad_list.size());
- const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
- pass->quad_list[0]);
+ const TextureDrawQuad* quad1 =
+ TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(0));
EXPECT_EQ(map.find(999)->second, quad1->resource_id);
- const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast(
- pass->quad_list[1]);
+ const TextureDrawQuad* quad2 =
+ TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(1));
EXPECT_EQ(map.find(555)->second, quad2->resource_id);
- const TextureDrawQuad* quad3 = TextureDrawQuad::MaterialCast(
- pass->quad_list[2]);
+ const TextureDrawQuad* quad3 =
+ TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(2));
EXPECT_EQ(map.find(444)->second, quad3->resource_id);
}
- virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
- bool result) OVERRIDE {
+ void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
ReturnUnusedResourcesFromParent(host_impl);
}
};
class LayerTreeHostDelegatedTestBadFrame
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE {
- PostSetNeedsCommitToMainThread();
- }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DidCommitAndDrawFrame() OVERRIDE {
+ void DidCommitAndDrawFrame() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
}
}
- virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
- bool result) OVERRIDE {
+ void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
if (host_impl->active_tree()->source_frame_number() < 1)
return;
const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
EXPECT_EQ(2u, pass->quad_list.size());
- const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
- pass->quad_list[0]);
+ const TextureDrawQuad* quad1 =
+ TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(0));
EXPECT_EQ(map.find(999)->second, quad1->resource_id);
- const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast(
- pass->quad_list[1]);
+ const TextureDrawQuad* quad2 =
+ TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(1));
EXPECT_EQ(map.find(555)->second, quad2->resource_id);
break;
}
// 555 in it.
const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
EXPECT_EQ(2u, pass->quad_list.size());
- const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
- pass->quad_list[0]);
+ const TextureDrawQuad* quad1 =
+ TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(0));
EXPECT_EQ(map.find(999)->second, quad1->resource_id);
- const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast(
- pass->quad_list[1]);
+ const TextureDrawQuad* quad2 =
+ TextureDrawQuad::MaterialCast(pass->quad_list.ElementAt(1));
EXPECT_EQ(map.find(555)->second, quad2->resource_id);
break;
}
const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
EXPECT_EQ(1u, pass->quad_list.size());
- const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
- pass->quad_list[0]);
+ const TextureDrawQuad* quad1 =
+ TextureDrawQuad::MaterialCast(pass->quad_list.front());
EXPECT_EQ(map.find(999)->second, quad1->resource_id);
break;
}
class LayerTreeHostDelegatedTestUnnamedResource
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE {
- PostSetNeedsCommitToMainThread();
- }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DidCommit() OVERRIDE {
+ void DidCommit() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
}
}
- virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+ void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
if (host_impl->active_tree()->source_frame_number() != 1)
return;
class LayerTreeHostDelegatedTestDontLeakResource
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE {
- PostSetNeedsCommitToMainThread();
- }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DidCommitAndDrawFrame() OVERRIDE {
+ void DidCommitAndDrawFrame() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
}
}
- virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+ void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
if (host_impl->active_tree()->source_frame_number() != 1)
return;
EXPECT_EQ(1u, delegated_impl->Resources().count(555));
}
- virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
- bool result) OVERRIDE {
+ void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
ReturnUnusedResourcesFromParent(host_impl);
}
};
class LayerTreeHostDelegatedTestResourceSentToParent
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void DidCommitAndDrawFrame() OVERRIDE {
+ void DidCommitAndDrawFrame() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
CompositorFrameAck ack;
output_surface()->ReturnResource(map.find(999)->second, &ack);
host_impl->ReclaimResources(&ack);
- host_impl->OnSwapBuffersComplete();
}
- virtual void UnusedResourcesAreAvailable() OVERRIDE {
+ void UnusedResourcesAreAvailable() override {
EXPECT_EQ(3, layer_tree_host()->source_frame_number());
ReturnedResourceArray resources;
EndTest();
}
- virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+ void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
if (host_impl->active_tree()->source_frame_number() < 1)
return;
class LayerTreeHostDelegatedTestCommitWithoutTake
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE {
+ void BeginTest() override {
// Prevent drawing with resources that are sent to the grandparent.
layer_tree_host()->SetViewportSize(gfx::Size());
PostSetNeedsCommitToMainThread();
}
- virtual void DidCommit() OVERRIDE {
+ void DidCommit() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
}
}
- virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+ void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
if (host_impl->active_tree()->source_frame_number() < 1)
return;
protected:
DelegatedFrameIsActivatedDuringCommit() : returned_resource_count_(0) {}
- virtual void BeginTest() OVERRIDE {
+ void BeginTest() override {
activate_count_ = 0;
scoped_ptr<DelegatedFrameData> frame =
PostSetNeedsCommitToMainThread();
}
- virtual void WillActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void WillActivateTreeOnThread(LayerTreeHostImpl* impl) override {
++activate_count_;
}
- virtual void DidCommit() OVERRIDE {
+ void DidCommit() override {
switch (layer_tree_host()->source_frame_number()) {
case 1: {
// The first frame has been activated. Set a new frame, and
}
}
- virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
+ void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
switch (host_impl->active_tree()->source_frame_number()) {
- case 2: {
+ case 0: {
+ // The activate for the 1st frame should have happened before now.
+ EXPECT_EQ(1, activate_count_);
+ break;
+ }
+ case 1: {
// The activate for the 2nd frame should have happened before now.
EXPECT_EQ(2, activate_count_);
break;
}
- case 3: {
+ case 2: {
// The activate to remove the layer should have happened before now.
EXPECT_EQ(3, activate_count_);
break;
}
+ case 3: {
+ NOTREACHED();
+ break;
+ }
}
}
- virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
- bool result) OVERRIDE {
+ void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
ReturnUnusedResourcesFromParent(host_impl);
}
- virtual void UnusedResourcesAreAvailable() OVERRIDE {
+ void UnusedResourcesAreAvailable() override {
LayerTreeHostDelegatedTestCaseSingleDelegatedLayer::
UnusedResourcesAreAvailable();
ReturnedResourceArray resources;
class LayerTreeHostDelegatedTestTwoImplLayers
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DidCommitAndDrawFrame() OVERRIDE {
+ void DidCommitAndDrawFrame() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
}
}
- virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
- bool result) OVERRIDE {
+ void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
ReturnUnusedResourcesFromParent(host_impl);
}
};
class LayerTreeHostDelegatedTestTwoImplLayersTwoFrames
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DidCommitAndDrawFrame() OVERRIDE {
+ void DidCommitAndDrawFrame() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
}
}
- virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
- bool result) OVERRIDE {
+ void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
ReturnUnusedResourcesFromParent(host_impl);
}
};
class LayerTreeHostDelegatedTestTwoLayers
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DidCommitAndDrawFrame() OVERRIDE {
+ void DidCommitAndDrawFrame() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
}
}
- virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
- bool result) OVERRIDE {
+ void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
ReturnUnusedResourcesFromParent(host_impl);
}
class LayerTreeHostDelegatedTestRemoveAndAddToTree
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DidCommitAndDrawFrame() OVERRIDE {
+ void DidCommitAndDrawFrame() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
}
}
- virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
- bool result) OVERRIDE {
+ void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
ReturnUnusedResourcesFromParent(host_impl);
}
class LayerTreeHostDelegatedTestRemoveAndChangeResources
: public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
public:
- virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DidCommitAndDrawFrame() OVERRIDE {
+ void DidCommitAndDrawFrame() override {
scoped_ptr<DelegatedFrameData> frame;
ReturnedResourceArray resources;
}
}
- virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
- bool result) OVERRIDE {
+ void SwapBuffersOnThread(LayerTreeHostImpl* host_impl, bool result) override {
ReturnUnusedResourcesFromParent(host_impl);
}
projects / platform / framework / web / crosswalk.git / blobdiff