1 // Copyright 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "cc/test/tiled_layer_test_common.h"
6
7 namespace cc {
8
Resource(FakeLayerUpdater * layer,scoped_ptr<PrioritizedResource> texture)9 FakeLayerUpdater::Resource::Resource(FakeLayerUpdater* layer,
10 scoped_ptr<PrioritizedResource> texture)
11 : LayerUpdater::Resource(texture.Pass()), layer_(layer) {
12 bitmap_.allocN32Pixels(10, 10);
13 }
14
~Resource()15 FakeLayerUpdater::Resource::~Resource() {}
16
Update(ResourceUpdateQueue * queue,const gfx::Rect & source_rect,const gfx::Vector2d & dest_offset,bool partial_update)17 void FakeLayerUpdater::Resource::Update(ResourceUpdateQueue* queue,
18 const gfx::Rect& source_rect,
19 const gfx::Vector2d& dest_offset,
20 bool partial_update) {
21 const gfx::Rect kRect(0, 0, 10, 10);
22 ResourceUpdate upload = ResourceUpdate::Create(
23 texture(), &bitmap_, kRect, kRect, gfx::Vector2d());
24 if (partial_update)
25 queue->AppendPartialUpload(upload);
26 else
27 queue->AppendFullUpload(upload);
28
29 layer_->Update();
30 }
31
FakeLayerUpdater()32 FakeLayerUpdater::FakeLayerUpdater()
33 : prepare_count_(0), update_count_(0), last_contents_width_scale_(0.f) {
34 }
35
~FakeLayerUpdater()36 FakeLayerUpdater::~FakeLayerUpdater() {}
37
PrepareToUpdate(const gfx::Size & content_size,const gfx::Rect & paint_rect,const gfx::Size & tile_size,float contents_width_scale,float contents_height_scale)38 void FakeLayerUpdater::PrepareToUpdate(const gfx::Size& content_size,
39 const gfx::Rect& paint_rect,
40 const gfx::Size& tile_size,
41 float contents_width_scale,
42 float contents_height_scale) {
43 prepare_count_++;
44 last_update_rect_ = paint_rect;
45 last_contents_width_scale_ = contents_width_scale;
46 if (!rect_to_invalidate_.IsEmpty()) {
47 layer_->InvalidateContentRect(rect_to_invalidate_);
48 rect_to_invalidate_ = gfx::Rect();
49 layer_ = NULL;
50 }
51 }
52
SetRectToInvalidate(const gfx::Rect & rect,FakeTiledLayer * layer)53 void FakeLayerUpdater::SetRectToInvalidate(const gfx::Rect& rect,
54 FakeTiledLayer* layer) {
55 rect_to_invalidate_ = rect;
56 layer_ = layer;
57 }
58
CreateResource(PrioritizedResourceManager * manager)59 scoped_ptr<LayerUpdater::Resource> FakeLayerUpdater::CreateResource(
60 PrioritizedResourceManager* manager) {
61 return scoped_ptr<LayerUpdater::Resource>(
62 new Resource(this, PrioritizedResource::Create(manager)));
63 }
64
FakeTiledLayerImpl(LayerTreeImpl * tree_impl,int id)65 FakeTiledLayerImpl::FakeTiledLayerImpl(LayerTreeImpl* tree_impl, int id)
66 : TiledLayerImpl(tree_impl, id) {}
67
~FakeTiledLayerImpl()68 FakeTiledLayerImpl::~FakeTiledLayerImpl() {}
69
FakeTiledLayer(PrioritizedResourceManager * resource_manager)70 FakeTiledLayer::FakeTiledLayer(PrioritizedResourceManager* resource_manager)
71 : TiledLayer(),
72 fake_updater_(make_scoped_refptr(new FakeLayerUpdater)),
73 resource_manager_(resource_manager) {
74 SetTileSize(tile_size());
75 SetTextureFormat(RGBA_8888);
76 SetBorderTexelOption(LayerTilingData::NO_BORDER_TEXELS);
77 // So that we don't get false positives if any of these
78 // tests expect to return false from DrawsContent() for other reasons.
79 SetIsDrawable(true);
80 }
81
FakeTiledLayerWithScaledBounds(PrioritizedResourceManager * resource_manager)82 FakeTiledLayerWithScaledBounds::FakeTiledLayerWithScaledBounds(
83 PrioritizedResourceManager* resource_manager)
84 : FakeTiledLayer(resource_manager) {}
85
~FakeTiledLayerWithScaledBounds()86 FakeTiledLayerWithScaledBounds::~FakeTiledLayerWithScaledBounds() {}
87
~FakeTiledLayer()88 FakeTiledLayer::~FakeTiledLayer() {}
89
SetNeedsDisplayRect(const gfx::RectF & rect)90 void FakeTiledLayer::SetNeedsDisplayRect(const gfx::RectF& rect) {
91 last_needs_display_rect_ = rect;
92 TiledLayer::SetNeedsDisplayRect(rect);
93 }
94
SetTexturePriorities(const PriorityCalculator & calculator)95 void FakeTiledLayer::SetTexturePriorities(
96 const PriorityCalculator& calculator) {
97 // Ensure there is always a target render surface available. If none has been
98 // set (the layer is an orphan for the test), then just set a surface on
99 // itself.
100 bool missing_target_render_surface = !render_target();
101
102 if (missing_target_render_surface)
103 CreateRenderSurface();
104
105 TiledLayer::SetTexturePriorities(calculator);
106
107 if (missing_target_render_surface) {
108 ClearRenderSurface();
109 draw_properties().render_target = 0;
110 }
111 }
112
ResourceManager()113 PrioritizedResourceManager* FakeTiledLayer::ResourceManager() {
114 return resource_manager_;
115 }
116
UpdateContentsScale(float ideal_contents_scale)117 void FakeTiledLayer::UpdateContentsScale(float ideal_contents_scale) {
118 CalculateContentsScale(ideal_contents_scale,
119 &draw_properties().contents_scale_x,
120 &draw_properties().contents_scale_y,
121 &draw_properties().content_bounds);
122 }
123
ResetNumDependentsNeedPushProperties()124 void FakeTiledLayer::ResetNumDependentsNeedPushProperties() {
125 size_t num = 0;
126 if (mask_layer()) {
127 if (mask_layer()->needs_push_properties() ||
128 mask_layer()->descendant_needs_push_properties())
129 ++num;
130 }
131 if (replica_layer()) {
132 if (replica_layer()->needs_push_properties() ||
133 replica_layer()->descendant_needs_push_properties())
134 ++num;
135 }
136 for (size_t i = 0; i < children().size(); ++i) {
137 if (children()[i]->needs_push_properties() ||
138 children()[i]->descendant_needs_push_properties())
139 ++num;
140 }
141 num_dependents_need_push_properties_ = num;
142 }
143
Updater() const144 LayerUpdater* FakeTiledLayer::Updater() const {
145 return fake_updater_.get();
146 }
147
SetContentBounds(const gfx::Size & content_bounds)148 void FakeTiledLayerWithScaledBounds::SetContentBounds(
149 const gfx::Size& content_bounds) {
150 forced_content_bounds_ = content_bounds;
151 draw_properties().content_bounds = forced_content_bounds_;
152 }
153
CalculateContentsScale(float ideal_contents_scale,float * contents_scale_x,float * contents_scale_y,gfx::Size * content_bounds)154 void FakeTiledLayerWithScaledBounds::CalculateContentsScale(
155 float ideal_contents_scale,
156 float* contents_scale_x,
157 float* contents_scale_y,
158 gfx::Size* content_bounds) {
159 *contents_scale_x =
160 static_cast<float>(forced_content_bounds_.width()) / bounds().width();
161 *contents_scale_y =
162 static_cast<float>(forced_content_bounds_.height()) / bounds().height();
163 *content_bounds = forced_content_bounds_;
164 }
165
166 } // namespace cc
167