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