• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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