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/layers/delegated_renderer_layer_impl.h"
6
7 #include <algorithm>
8 #include <utility>
9
10 #include "base/bind.h"
11 #include "base/containers/hash_tables.h"
12 #include "cc/base/math_util.h"
13 #include "cc/layers/append_quads_data.h"
14 #include "cc/layers/quad_sink.h"
15 #include "cc/layers/render_pass_sink.h"
16 #include "cc/output/delegated_frame_data.h"
17 #include "cc/quads/render_pass_draw_quad.h"
18 #include "cc/quads/solid_color_draw_quad.h"
19 #include "cc/trees/layer_tree_impl.h"
20
21 namespace cc {
22
DelegatedRendererLayerImpl(LayerTreeImpl * tree_impl,int id)23 DelegatedRendererLayerImpl::DelegatedRendererLayerImpl(LayerTreeImpl* tree_impl,
24 int id)
25 : LayerImpl(tree_impl, id),
26 have_render_passes_to_push_(false),
27 inverse_device_scale_factor_(1.0f),
28 child_id_(0),
29 own_child_id_(false) {
30 }
31
~DelegatedRendererLayerImpl()32 DelegatedRendererLayerImpl::~DelegatedRendererLayerImpl() {
33 ClearRenderPasses();
34 ClearChildId();
35 }
36
HasDelegatedContent() const37 bool DelegatedRendererLayerImpl::HasDelegatedContent() const { return true; }
38
HasContributingDelegatedRenderPasses() const39 bool DelegatedRendererLayerImpl::HasContributingDelegatedRenderPasses() const {
40 // The root RenderPass for the layer is merged with its target
41 // RenderPass in each frame. So we only have extra RenderPasses
42 // to merge when we have a non-root RenderPass present.
43 return render_passes_in_draw_order_.size() > 1;
44 }
45
ResourceRemapHelper(bool * invalid_frame,const ResourceProvider::ResourceIdMap & child_to_parent_map,ResourceProvider::ResourceIdArray * resources_in_frame,ResourceProvider::ResourceId id)46 static ResourceProvider::ResourceId ResourceRemapHelper(
47 bool* invalid_frame,
48 const ResourceProvider::ResourceIdMap& child_to_parent_map,
49 ResourceProvider::ResourceIdArray* resources_in_frame,
50 ResourceProvider::ResourceId id) {
51
52 ResourceProvider::ResourceIdMap::const_iterator it =
53 child_to_parent_map.find(id);
54 if (it == child_to_parent_map.end()) {
55 *invalid_frame = true;
56 return 0;
57 }
58
59 DCHECK_EQ(it->first, id);
60 ResourceProvider::ResourceId remapped_id = it->second;
61 resources_in_frame->push_back(id);
62 return remapped_id;
63 }
64
PushPropertiesTo(LayerImpl * layer)65 void DelegatedRendererLayerImpl::PushPropertiesTo(LayerImpl* layer) {
66 LayerImpl::PushPropertiesTo(layer);
67
68 DelegatedRendererLayerImpl* delegated_layer =
69 static_cast<DelegatedRendererLayerImpl*>(layer);
70
71 // If we have a new child_id to give to the active layer, it should
72 // have already deleted its old child_id.
73 DCHECK(delegated_layer->child_id_ == 0 ||
74 delegated_layer->child_id_ == child_id_);
75 delegated_layer->inverse_device_scale_factor_ = inverse_device_scale_factor_;
76 delegated_layer->child_id_ = child_id_;
77 delegated_layer->own_child_id_ = true;
78 own_child_id_ = false;
79
80 if (have_render_passes_to_push_) {
81 // This passes ownership of the render passes to the active tree.
82 delegated_layer->SetRenderPasses(&render_passes_in_draw_order_);
83 DCHECK(render_passes_in_draw_order_.empty());
84 have_render_passes_to_push_ = false;
85 }
86
87 // This is just a copy for testing, since resources are added to the
88 // ResourceProvider in the pending tree.
89 delegated_layer->resources_ = resources_;
90 }
91
CreateChildIdIfNeeded(const ReturnCallback & return_callback)92 void DelegatedRendererLayerImpl::CreateChildIdIfNeeded(
93 const ReturnCallback& return_callback) {
94 if (child_id_)
95 return;
96
97 ResourceProvider* resource_provider = layer_tree_impl()->resource_provider();
98 child_id_ = resource_provider->CreateChild(return_callback);
99 own_child_id_ = true;
100 }
101
SetFrameData(const DelegatedFrameData * frame_data,const gfx::RectF & damage_in_frame)102 void DelegatedRendererLayerImpl::SetFrameData(
103 const DelegatedFrameData* frame_data,
104 const gfx::RectF& damage_in_frame) {
105 DCHECK(child_id_) << "CreateChildIdIfNeeded must be called first.";
106 DCHECK(frame_data);
107 DCHECK(!frame_data->render_pass_list.empty());
108 // A frame with an empty root render pass is invalid.
109 DCHECK(!frame_data->render_pass_list.back()->output_rect.IsEmpty());
110
111 ResourceProvider* resource_provider = layer_tree_impl()->resource_provider();
112 const ResourceProvider::ResourceIdMap& resource_map =
113 resource_provider->GetChildToParentMap(child_id_);
114
115 resource_provider->ReceiveFromChild(child_id_, frame_data->resource_list);
116
117 ScopedPtrVector<RenderPass> render_pass_list;
118 RenderPass::CopyAll(frame_data->render_pass_list, &render_pass_list);
119
120 bool invalid_frame = false;
121 ResourceProvider::ResourceIdArray resources_in_frame;
122 DrawQuad::ResourceIteratorCallback remap_resources_to_parent_callback =
123 base::Bind(&ResourceRemapHelper,
124 &invalid_frame,
125 resource_map,
126 &resources_in_frame);
127 for (size_t i = 0; i < render_pass_list.size(); ++i) {
128 RenderPass* pass = render_pass_list[i];
129 for (size_t j = 0; j < pass->quad_list.size(); ++j) {
130 DrawQuad* quad = pass->quad_list[j];
131 quad->IterateResources(remap_resources_to_parent_callback);
132 }
133 }
134
135 if (invalid_frame) {
136 // Declare we are still using the last frame's resources.
137 resource_provider->DeclareUsedResourcesFromChild(child_id_, resources_);
138 return;
139 }
140
141 // Declare we are using the new frame's resources.
142 resources_.swap(resources_in_frame);
143 resource_provider->DeclareUsedResourcesFromChild(child_id_, resources_);
144
145 inverse_device_scale_factor_ = 1.0f / frame_data->device_scale_factor;
146 // Display size is already set so we can compute what the damage rect
147 // will be in layer space. The damage may exceed the visible portion of
148 // the frame, so intersect the damage to the layer's bounds.
149 RenderPass* new_root_pass = render_pass_list.back();
150 gfx::Size frame_size = new_root_pass->output_rect.size();
151 gfx::RectF damage_in_layer = damage_in_frame;
152 damage_in_layer.Scale(inverse_device_scale_factor_);
153 SetUpdateRect(gfx::IntersectRects(
154 gfx::UnionRects(update_rect(), damage_in_layer), gfx::Rect(bounds())));
155
156 SetRenderPasses(&render_pass_list);
157 have_render_passes_to_push_ = true;
158 }
159
SetRenderPasses(ScopedPtrVector<RenderPass> * render_passes_in_draw_order)160 void DelegatedRendererLayerImpl::SetRenderPasses(
161 ScopedPtrVector<RenderPass>* render_passes_in_draw_order) {
162 ClearRenderPasses();
163
164 for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
165 ScopedPtrVector<RenderPass>::iterator to_take =
166 render_passes_in_draw_order->begin() + i;
167 render_passes_index_by_id_.insert(
168 std::pair<RenderPass::Id, int>((*to_take)->id, i));
169 scoped_ptr<RenderPass> taken_render_pass =
170 render_passes_in_draw_order->take(to_take);
171 render_passes_in_draw_order_.push_back(taken_render_pass.Pass());
172 }
173
174 // Give back an empty array instead of nulls.
175 render_passes_in_draw_order->clear();
176 }
177
ClearRenderPasses()178 void DelegatedRendererLayerImpl::ClearRenderPasses() {
179 render_passes_index_by_id_.clear();
180 render_passes_in_draw_order_.clear();
181 }
182
CreateLayerImpl(LayerTreeImpl * tree_impl)183 scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::CreateLayerImpl(
184 LayerTreeImpl* tree_impl) {
185 return DelegatedRendererLayerImpl::Create(
186 tree_impl, id()).PassAs<LayerImpl>();
187 }
188
ReleaseResources()189 void DelegatedRendererLayerImpl::ReleaseResources() {
190 ClearRenderPasses();
191 ClearChildId();
192 }
193
IndexToId(int index)194 static inline int IndexToId(int index) { return index + 1; }
IdToIndex(int id)195 static inline int IdToIndex(int id) { return id - 1; }
196
FirstContributingRenderPassId() const197 RenderPass::Id DelegatedRendererLayerImpl::FirstContributingRenderPassId()
198 const {
199 return RenderPass::Id(id(), IndexToId(0));
200 }
201
NextContributingRenderPassId(RenderPass::Id previous) const202 RenderPass::Id DelegatedRendererLayerImpl::NextContributingRenderPassId(
203 RenderPass::Id previous) const {
204 return RenderPass::Id(previous.layer_id, previous.index + 1);
205 }
206
ConvertDelegatedRenderPassId(RenderPass::Id delegated_render_pass_id,RenderPass::Id * output_render_pass_id) const207 bool DelegatedRendererLayerImpl::ConvertDelegatedRenderPassId(
208 RenderPass::Id delegated_render_pass_id,
209 RenderPass::Id* output_render_pass_id) const {
210 base::hash_map<RenderPass::Id, int>::const_iterator found =
211 render_passes_index_by_id_.find(delegated_render_pass_id);
212 if (found == render_passes_index_by_id_.end()) {
213 // Be robust against a RenderPass id that isn't part of the frame.
214 return false;
215 }
216 unsigned delegated_render_pass_index = found->second;
217 *output_render_pass_id =
218 RenderPass::Id(id(), IndexToId(delegated_render_pass_index));
219 return true;
220 }
221
AppendContributingRenderPasses(RenderPassSink * render_pass_sink)222 void DelegatedRendererLayerImpl::AppendContributingRenderPasses(
223 RenderPassSink* render_pass_sink) {
224 DCHECK(HasContributingDelegatedRenderPasses());
225
226 const RenderPass* root_delegated_render_pass =
227 render_passes_in_draw_order_.back();
228 gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
229 gfx::Transform delegated_frame_to_root_transform = screen_space_transform();
230 delegated_frame_to_root_transform.Scale(inverse_device_scale_factor_,
231 inverse_device_scale_factor_);
232
233 for (size_t i = 0; i < render_passes_in_draw_order_.size() - 1; ++i) {
234 RenderPass::Id output_render_pass_id(-1, -1);
235 bool present =
236 ConvertDelegatedRenderPassId(render_passes_in_draw_order_[i]->id,
237 &output_render_pass_id);
238
239 // Don't clash with the RenderPass we generate if we own a RenderSurface.
240 DCHECK(present) << render_passes_in_draw_order_[i]->id.layer_id << ", "
241 << render_passes_in_draw_order_[i]->id.index;
242 DCHECK_GT(output_render_pass_id.index, 0);
243
244 scoped_ptr<RenderPass> copy_pass =
245 render_passes_in_draw_order_[i]->Copy(output_render_pass_id);
246 copy_pass->transform_to_root_target.ConcatTransform(
247 delegated_frame_to_root_transform);
248 render_pass_sink->AppendRenderPass(copy_pass.Pass());
249 }
250 }
251
WillDraw(DrawMode draw_mode,ResourceProvider * resource_provider)252 bool DelegatedRendererLayerImpl::WillDraw(DrawMode draw_mode,
253 ResourceProvider* resource_provider) {
254 if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
255 return false;
256 return LayerImpl::WillDraw(draw_mode, resource_provider);
257 }
258
AppendQuads(QuadSink * quad_sink,AppendQuadsData * append_quads_data)259 void DelegatedRendererLayerImpl::AppendQuads(
260 QuadSink* quad_sink,
261 AppendQuadsData* append_quads_data) {
262 AppendRainbowDebugBorder(quad_sink, append_quads_data);
263
264 // This list will be empty after a lost context until a new frame arrives.
265 if (render_passes_in_draw_order_.empty())
266 return;
267
268 RenderPass::Id target_render_pass_id = append_quads_data->render_pass_id;
269
270 const RenderPass* root_delegated_render_pass =
271 render_passes_in_draw_order_.back();
272
273 DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin());
274 gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
275
276 // If the index of the RenderPassId is 0, then it is a RenderPass generated
277 // for a layer in this compositor, not the delegating renderer. Then we want
278 // to merge our root RenderPass with the target RenderPass. Otherwise, it is
279 // some RenderPass which we added from the delegating renderer.
280 bool should_merge_root_render_pass_with_target = !target_render_pass_id.index;
281 if (should_merge_root_render_pass_with_target) {
282 // Verify that the RenderPass we are appending to is created by our
283 // render_target.
284 DCHECK(target_render_pass_id.layer_id == render_target()->id());
285
286 AppendRenderPassQuads(
287 quad_sink, append_quads_data, root_delegated_render_pass, frame_size);
288 } else {
289 // Verify that the RenderPass we are appending to was created by us.
290 DCHECK(target_render_pass_id.layer_id == id());
291
292 int render_pass_index = IdToIndex(target_render_pass_id.index);
293 const RenderPass* delegated_render_pass =
294 render_passes_in_draw_order_[render_pass_index];
295 AppendRenderPassQuads(
296 quad_sink, append_quads_data, delegated_render_pass, frame_size);
297 }
298 }
299
AppendRainbowDebugBorder(QuadSink * quad_sink,AppendQuadsData * append_quads_data)300 void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
301 QuadSink* quad_sink,
302 AppendQuadsData* append_quads_data) {
303 if (!ShowDebugBorders())
304 return;
305
306 SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
307 PopulateSharedQuadState(shared_quad_state);
308
309 SkColor color;
310 float border_width;
311 GetDebugBorderProperties(&color, &border_width);
312
313 SkColor colors[] = {
314 0x80ff0000, // Red.
315 0x80ffa500, // Orange.
316 0x80ffff00, // Yellow.
317 0x80008000, // Green.
318 0x800000ff, // Blue.
319 0x80ee82ee, // Violet.
320 };
321 const int kNumColors = arraysize(colors);
322
323 const int kStripeWidth = 300;
324 const int kStripeHeight = 300;
325
326 for (size_t i = 0; ; ++i) {
327 // For horizontal lines.
328 int x = kStripeWidth * i;
329 int width = std::min(kStripeWidth, content_bounds().width() - x - 1);
330
331 // For vertical lines.
332 int y = kStripeHeight * i;
333 int height = std::min(kStripeHeight, content_bounds().height() - y - 1);
334
335 gfx::Rect top(x, 0, width, border_width);
336 gfx::Rect bottom(x,
337 content_bounds().height() - border_width,
338 width,
339 border_width);
340 gfx::Rect left(0, y, border_width, height);
341 gfx::Rect right(content_bounds().width() - border_width,
342 y,
343 border_width,
344 height);
345
346 if (top.IsEmpty() && left.IsEmpty())
347 break;
348
349 if (!top.IsEmpty()) {
350 scoped_ptr<SolidColorDrawQuad> top_quad = SolidColorDrawQuad::Create();
351 top_quad->SetNew(
352 shared_quad_state, top, top, colors[i % kNumColors], false);
353 quad_sink->Append(top_quad.PassAs<DrawQuad>());
354
355 scoped_ptr<SolidColorDrawQuad> bottom_quad = SolidColorDrawQuad::Create();
356 bottom_quad->SetNew(shared_quad_state,
357 bottom,
358 bottom,
359 colors[kNumColors - 1 - (i % kNumColors)],
360 false);
361 quad_sink->Append(bottom_quad.PassAs<DrawQuad>());
362 }
363 if (!left.IsEmpty()) {
364 scoped_ptr<SolidColorDrawQuad> left_quad = SolidColorDrawQuad::Create();
365 left_quad->SetNew(shared_quad_state,
366 left,
367 left,
368 colors[kNumColors - 1 - (i % kNumColors)],
369 false);
370 quad_sink->Append(left_quad.PassAs<DrawQuad>());
371
372 scoped_ptr<SolidColorDrawQuad> right_quad = SolidColorDrawQuad::Create();
373 right_quad->SetNew(
374 shared_quad_state, right, right, colors[i % kNumColors], false);
375 quad_sink->Append(right_quad.PassAs<DrawQuad>());
376 }
377 }
378 }
379
AppendRenderPassQuads(QuadSink * quad_sink,AppendQuadsData * append_quads_data,const RenderPass * delegated_render_pass,const gfx::Size & frame_size) const380 void DelegatedRendererLayerImpl::AppendRenderPassQuads(
381 QuadSink* quad_sink,
382 AppendQuadsData* append_quads_data,
383 const RenderPass* delegated_render_pass,
384 const gfx::Size& frame_size) const {
385
386 const SharedQuadState* delegated_shared_quad_state = NULL;
387 SharedQuadState* output_shared_quad_state = NULL;
388
389 for (size_t i = 0; i < delegated_render_pass->quad_list.size(); ++i) {
390 const DrawQuad* delegated_quad = delegated_render_pass->quad_list[i];
391
392 bool is_root_delegated_render_pass =
393 delegated_render_pass == render_passes_in_draw_order_.back();
394
395 if (delegated_quad->shared_quad_state != delegated_shared_quad_state) {
396 delegated_shared_quad_state = delegated_quad->shared_quad_state;
397 output_shared_quad_state = quad_sink->CreateSharedQuadState();
398 output_shared_quad_state->CopyFrom(delegated_shared_quad_state);
399
400 if (is_root_delegated_render_pass) {
401 gfx::Transform delegated_frame_to_target_transform = draw_transform();
402 delegated_frame_to_target_transform.Scale(inverse_device_scale_factor_,
403 inverse_device_scale_factor_);
404
405 output_shared_quad_state->content_to_target_transform.ConcatTransform(
406 delegated_frame_to_target_transform);
407
408 if (render_target() == this) {
409 DCHECK(!is_clipped());
410 DCHECK(render_surface());
411 DCHECK_EQ(0, num_unclipped_descendants());
412 output_shared_quad_state->clip_rect =
413 MathUtil::MapEnclosingClippedRect(
414 delegated_frame_to_target_transform,
415 output_shared_quad_state->clip_rect);
416 } else {
417 gfx::Rect clip_rect = drawable_content_rect();
418 if (output_shared_quad_state->is_clipped) {
419 clip_rect.Intersect(MathUtil::MapEnclosingClippedRect(
420 delegated_frame_to_target_transform,
421 output_shared_quad_state->clip_rect));
422 }
423 output_shared_quad_state->clip_rect = clip_rect;
424 output_shared_quad_state->is_clipped = true;
425 }
426
427 output_shared_quad_state->opacity *= draw_opacity();
428 }
429 }
430 DCHECK(output_shared_quad_state);
431
432 gfx::Transform quad_content_to_delegated_target_space =
433 output_shared_quad_state->content_to_target_transform;
434 if (!is_root_delegated_render_pass) {
435 quad_content_to_delegated_target_space.ConcatTransform(
436 quad_sink->render_pass()->transform_to_root_target);
437 quad_content_to_delegated_target_space.ConcatTransform(draw_transform());
438 }
439
440 gfx::Rect quad_visible_rect = quad_sink->UnoccludedContentRect(
441 delegated_quad->visible_rect, quad_content_to_delegated_target_space);
442
443 if (quad_visible_rect.IsEmpty())
444 continue;
445
446 scoped_ptr<DrawQuad> output_quad;
447 if (delegated_quad->material != DrawQuad::RENDER_PASS) {
448 output_quad = delegated_quad->Copy(output_shared_quad_state);
449 output_quad->visible_rect = quad_visible_rect;
450 } else {
451 RenderPass::Id delegated_contributing_render_pass_id =
452 RenderPassDrawQuad::MaterialCast(delegated_quad)->render_pass_id;
453 RenderPass::Id output_contributing_render_pass_id(-1, -1);
454
455 bool present =
456 ConvertDelegatedRenderPassId(delegated_contributing_render_pass_id,
457 &output_contributing_render_pass_id);
458
459 // The frame may have a RenderPassDrawQuad that points to a RenderPass not
460 // part of the frame. Just ignore these quads.
461 if (present) {
462 DCHECK(output_contributing_render_pass_id !=
463 append_quads_data->render_pass_id);
464
465 output_quad = RenderPassDrawQuad::MaterialCast(delegated_quad)->Copy(
466 output_shared_quad_state,
467 output_contributing_render_pass_id).PassAs<DrawQuad>();
468 output_quad->visible_rect = quad_visible_rect;
469 }
470 }
471
472 if (output_quad)
473 quad_sink->Append(output_quad.Pass());
474 }
475 }
476
LayerTypeAsString() const477 const char* DelegatedRendererLayerImpl::LayerTypeAsString() const {
478 return "cc::DelegatedRendererLayerImpl";
479 }
480
ClearChildId()481 void DelegatedRendererLayerImpl::ClearChildId() {
482 if (!child_id_)
483 return;
484
485 if (own_child_id_) {
486 ResourceProvider* provider = layer_tree_impl()->resource_provider();
487 provider->DestroyChild(child_id_);
488 }
489
490 resources_.clear();
491 child_id_ = 0;
492 }
493
494 } // namespace cc
495