delegated_renderer_layer_impl.cc revision 116680a4aac90f2aa7413d9095a592090648e557 
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/render_pass_sink.h"
15#include "cc/output/delegated_frame_data.h"
16#include "cc/quads/render_pass_draw_quad.h"
17#include "cc/quads/solid_color_draw_quad.h"
18#include "cc/trees/layer_tree_impl.h"
19#include "cc/trees/occlusion_tracker.h"
20
21namespace cc {
22
23DelegatedRendererLayerImpl::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
32DelegatedRendererLayerImpl::~DelegatedRendererLayerImpl() {
33  ClearRenderPasses();
34  ClearChildId();
35}
36
37bool DelegatedRendererLayerImpl::HasDelegatedContent() const { return true; }
38
39bool 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
46static 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
65void 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
92void 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
102void 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  RenderPassList 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
160void DelegatedRendererLayerImpl::SetRenderPasses(
161    RenderPassList* render_passes_in_draw_order) {
162  ClearRenderPasses();
163
164  for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
165    RenderPassList::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
178void DelegatedRendererLayerImpl::ClearRenderPasses() {
179  render_passes_index_by_id_.clear();
180  render_passes_in_draw_order_.clear();
181}
182
183scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::CreateLayerImpl(
184    LayerTreeImpl* tree_impl) {
185  return DelegatedRendererLayerImpl::Create(
186      tree_impl, id()).PassAs<LayerImpl>();
187}
188
189void DelegatedRendererLayerImpl::ReleaseResources() {
190  ClearRenderPasses();
191  ClearChildId();
192}
193
194static inline int IndexToId(int index) { return index + 1; }
195static inline int IdToIndex(int id) { return id - 1; }
196
197RenderPass::Id DelegatedRendererLayerImpl::FirstContributingRenderPassId()
198    const {
199  return RenderPass::Id(id(), IndexToId(0));
200}
201
202RenderPass::Id DelegatedRendererLayerImpl::NextContributingRenderPassId(
203    RenderPass::Id previous) const {
204  return RenderPass::Id(previous.layer_id, previous.index + 1);
205}
206
207bool 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
222void 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
252bool 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
259void DelegatedRendererLayerImpl::AppendQuads(
260    RenderPass* render_pass,
261    const OcclusionTracker<LayerImpl>& occlusion_tracker,
262    AppendQuadsData* append_quads_data) {
263  AppendRainbowDebugBorder(render_pass, append_quads_data);
264
265  // This list will be empty after a lost context until a new frame arrives.
266  if (render_passes_in_draw_order_.empty())
267    return;
268
269  RenderPass::Id target_render_pass_id = append_quads_data->render_pass_id;
270
271  const RenderPass* root_delegated_render_pass =
272      render_passes_in_draw_order_.back();
273
274  DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin());
275  gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
276
277  // If the index of the RenderPassId is 0, then it is a RenderPass generated
278  // for a layer in this compositor, not the delegating renderer. Then we want
279  // to merge our root RenderPass with the target RenderPass. Otherwise, it is
280  // some RenderPass which we added from the delegating renderer.
281  bool should_merge_root_render_pass_with_target = !target_render_pass_id.index;
282  if (should_merge_root_render_pass_with_target) {
283    // Verify that the RenderPass we are appending to is created by our
284    // render_target.
285    DCHECK(target_render_pass_id.layer_id == render_target()->id());
286
287    AppendRenderPassQuads(render_pass,
288                          occlusion_tracker,
289                          append_quads_data,
290                          root_delegated_render_pass,
291                          frame_size);
292  } else {
293    // Verify that the RenderPass we are appending to was created by us.
294    DCHECK(target_render_pass_id.layer_id == id());
295
296    int render_pass_index = IdToIndex(target_render_pass_id.index);
297    const RenderPass* delegated_render_pass =
298        render_passes_in_draw_order_[render_pass_index];
299    AppendRenderPassQuads(render_pass,
300                          occlusion_tracker,
301                          append_quads_data,
302                          delegated_render_pass,
303                          frame_size);
304  }
305}
306
307void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
308    RenderPass* render_pass,
309    AppendQuadsData* append_quads_data) {
310  if (!ShowDebugBorders())
311    return;
312
313  SharedQuadState* shared_quad_state =
314      render_pass->CreateAndAppendSharedQuadState();
315  PopulateSharedQuadState(shared_quad_state);
316
317  SkColor color;
318  float border_width;
319  GetDebugBorderProperties(&color, &border_width);
320
321  SkColor colors[] = {
322    0x80ff0000,  // Red.
323    0x80ffa500,  // Orange.
324    0x80ffff00,  // Yellow.
325    0x80008000,  // Green.
326    0x800000ff,  // Blue.
327    0x80ee82ee,  // Violet.
328  };
329  const int kNumColors = arraysize(colors);
330
331  const int kStripeWidth = 300;
332  const int kStripeHeight = 300;
333
334  for (size_t i = 0; ; ++i) {
335    // For horizontal lines.
336    int x =  kStripeWidth * i;
337    int width = std::min(kStripeWidth, content_bounds().width() - x - 1);
338
339    // For vertical lines.
340    int y = kStripeHeight * i;
341    int height = std::min(kStripeHeight, content_bounds().height() - y - 1);
342
343    gfx::Rect top(x, 0, width, border_width);
344    gfx::Rect bottom(x,
345                     content_bounds().height() - border_width,
346                     width,
347                     border_width);
348    gfx::Rect left(0, y, border_width, height);
349    gfx::Rect right(content_bounds().width() - border_width,
350                    y,
351                    border_width,
352                    height);
353
354    if (top.IsEmpty() && left.IsEmpty())
355      break;
356
357    if (!top.IsEmpty()) {
358      SolidColorDrawQuad* top_quad =
359          render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
360      top_quad->SetNew(
361          shared_quad_state, top, top, colors[i % kNumColors], false);
362
363      SolidColorDrawQuad* bottom_quad =
364          render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
365      bottom_quad->SetNew(shared_quad_state,
366                          bottom,
367                          bottom,
368                          colors[kNumColors - 1 - (i % kNumColors)],
369                          false);
370    }
371    if (!left.IsEmpty()) {
372      SolidColorDrawQuad* left_quad =
373          render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
374      left_quad->SetNew(shared_quad_state,
375                        left,
376                        left,
377                        colors[kNumColors - 1 - (i % kNumColors)],
378                        false);
379
380      SolidColorDrawQuad* right_quad =
381          render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
382      right_quad->SetNew(
383          shared_quad_state, right, right, colors[i % kNumColors], false);
384    }
385  }
386}
387
388void DelegatedRendererLayerImpl::AppendRenderPassQuads(
389    RenderPass* render_pass,
390    const OcclusionTracker<LayerImpl>& occlusion_tracker,
391    AppendQuadsData* append_quads_data,
392    const RenderPass* delegated_render_pass,
393    const gfx::Size& frame_size) const {
394  const SharedQuadState* delegated_shared_quad_state = NULL;
395  SharedQuadState* output_shared_quad_state = NULL;
396
397  for (size_t i = 0; i < delegated_render_pass->quad_list.size(); ++i) {
398    const DrawQuad* delegated_quad = delegated_render_pass->quad_list[i];
399
400    if (delegated_quad->shared_quad_state != delegated_shared_quad_state) {
401      delegated_shared_quad_state = delegated_quad->shared_quad_state;
402      output_shared_quad_state = render_pass->CreateAndAppendSharedQuadState();
403      output_shared_quad_state->CopyFrom(delegated_shared_quad_state);
404
405      bool is_root_delegated_render_pass =
406          delegated_render_pass == render_passes_in_draw_order_.back();
407      if (is_root_delegated_render_pass) {
408        gfx::Transform delegated_frame_to_target_transform = draw_transform();
409        delegated_frame_to_target_transform.Scale(inverse_device_scale_factor_,
410                                                  inverse_device_scale_factor_);
411
412        output_shared_quad_state->content_to_target_transform.ConcatTransform(
413            delegated_frame_to_target_transform);
414
415        if (render_target() == this) {
416          DCHECK(!is_clipped());
417          DCHECK(render_surface());
418          DCHECK_EQ(0, num_unclipped_descendants());
419          output_shared_quad_state->clip_rect =
420              MathUtil::MapEnclosingClippedRect(
421                  delegated_frame_to_target_transform,
422                  output_shared_quad_state->clip_rect);
423        } else {
424          gfx::Rect clip_rect = drawable_content_rect();
425          if (output_shared_quad_state->is_clipped) {
426            clip_rect.Intersect(MathUtil::MapEnclosingClippedRect(
427                delegated_frame_to_target_transform,
428                output_shared_quad_state->clip_rect));
429          }
430          output_shared_quad_state->clip_rect = clip_rect;
431          output_shared_quad_state->is_clipped = true;
432        }
433
434        output_shared_quad_state->opacity *= draw_opacity();
435      }
436    }
437    DCHECK(output_shared_quad_state);
438
439    gfx::Rect quad_visible_rect = occlusion_tracker.UnoccludedContentRect(
440        delegated_quad->visible_rect,
441        output_shared_quad_state->content_to_target_transform);
442    if (quad_visible_rect.IsEmpty())
443      continue;
444
445    if (delegated_quad->material != DrawQuad::RENDER_PASS) {
446      DrawQuad* output_quad = render_pass->CopyFromAndAppendDrawQuad(
447          delegated_quad, output_shared_quad_state);
448      output_quad->visible_rect = quad_visible_rect;
449    } else {
450      RenderPass::Id delegated_contributing_render_pass_id =
451          RenderPassDrawQuad::MaterialCast(delegated_quad)->render_pass_id;
452      RenderPass::Id output_contributing_render_pass_id(-1, -1);
453
454      bool present =
455          ConvertDelegatedRenderPassId(delegated_contributing_render_pass_id,
456                                       &output_contributing_render_pass_id);
457
458      // The frame may have a RenderPassDrawQuad that points to a RenderPass not
459      // part of the frame. Just ignore these quads.
460      if (present) {
461        DCHECK(output_contributing_render_pass_id !=
462               append_quads_data->render_pass_id);
463
464        RenderPassDrawQuad* output_quad =
465            render_pass->CopyFromAndAppendRenderPassDrawQuad(
466                RenderPassDrawQuad::MaterialCast(delegated_quad),
467                output_shared_quad_state,
468                output_contributing_render_pass_id);
469        output_quad->visible_rect = quad_visible_rect;
470      }
471    }
472  }
473}
474
475const char* DelegatedRendererLayerImpl::LayerTypeAsString() const {
476  return "cc::DelegatedRendererLayerImpl";
477}
478
479void DelegatedRendererLayerImpl::ClearChildId() {
480  if (!child_id_)
481    return;
482
483  if (own_child_id_) {
484    ResourceProvider* provider = layer_tree_impl()->resource_provider();
485    provider->DestroyChild(child_id_);
486  }
487
488  resources_.clear();
489  child_id_ = 0;
490}
491
492}  // namespace cc
493