delegated_renderer_layer_impl.cc revision 68043e1e95eeb07d5cae7aca370b26518b0867d6 
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(
24    LayerTreeImpl* tree_impl, int id)
25    : LayerImpl(tree_impl, id),
26      have_render_passes_to_push_(false),
27      child_id_(0),
28      own_child_id_(false) {
29}
30
31DelegatedRendererLayerImpl::~DelegatedRendererLayerImpl() {
32  ClearRenderPasses();
33  ClearChildId();
34}
35
36bool DelegatedRendererLayerImpl::HasDelegatedContent() const {
37  return !render_passes_in_draw_order_.empty();
38}
39
40bool DelegatedRendererLayerImpl::HasContributingDelegatedRenderPasses() const {
41  // The root RenderPass for the layer is merged with its target
42  // RenderPass in each frame. So we only have extra RenderPasses
43  // to merge when we have a non-root RenderPass present.
44  return render_passes_in_draw_order_.size() > 1;
45}
46
47static ResourceProvider::ResourceId ResourceRemapHelper(
48    bool* invalid_frame,
49    const ResourceProvider::ResourceIdMap& child_to_parent_map,
50    ResourceProvider::ResourceIdArray* resources_in_frame,
51    ResourceProvider::ResourceId id) {
52
53  ResourceProvider::ResourceIdMap::const_iterator it =
54      child_to_parent_map.find(id);
55  if (it == child_to_parent_map.end()) {
56    *invalid_frame = true;
57    return 0;
58  }
59
60  DCHECK_EQ(it->first, id);
61  ResourceProvider::ResourceId remapped_id = it->second;
62  resources_in_frame->push_back(id);
63  return remapped_id;
64}
65
66void DelegatedRendererLayerImpl::PushPropertiesTo(LayerImpl* layer) {
67  LayerImpl::PushPropertiesTo(layer);
68
69  DelegatedRendererLayerImpl* delegated_layer =
70      static_cast<DelegatedRendererLayerImpl*>(layer);
71
72  // If we have a new child_id to give to the active layer, it should
73  // have already deleted its old child_id.
74  DCHECK(delegated_layer->child_id_ == 0 ||
75         delegated_layer->child_id_ == child_id_);
76  delegated_layer->child_id_ = child_id_;
77  delegated_layer->own_child_id_ = true;
78  own_child_id_ = false;
79
80  delegated_layer->SetDisplaySize(display_size_);
81  if (have_render_passes_to_push_) {
82    // This passes ownership of the render passes to the active tree.
83    delegated_layer->SetRenderPasses(&render_passes_in_draw_order_);
84    DCHECK(render_passes_in_draw_order_.empty());
85    have_render_passes_to_push_ = false;
86  }
87
88  // This is just a copy for testing, since resources are added to the
89  // ResourceProvider in the pending tree.
90  delegated_layer->resources_ = resources_;
91}
92
93void DelegatedRendererLayerImpl::CreateChildIdIfNeeded(
94    const ReturnCallback& return_callback) {
95  if (child_id_)
96    return;
97
98  ResourceProvider* resource_provider = layer_tree_impl()->resource_provider();
99  child_id_ = resource_provider->CreateChild(return_callback);
100  own_child_id_ = true;
101}
102
103void DelegatedRendererLayerImpl::SetFrameData(
104    scoped_ptr<DelegatedFrameData> frame_data,
105    gfx::RectF damage_in_frame) {
106  DCHECK(frame_data);
107  DCHECK(child_id_) << "CreateChildIdIfNeeded must be called first.";
108
109  // A frame with an empty root render pass is invalid.
110  DCHECK(frame_data->render_pass_list.empty() ||
111         !frame_data->render_pass_list.back()->output_rect.IsEmpty());
112
113  ResourceProvider* resource_provider = layer_tree_impl()->resource_provider();
114    const ResourceProvider::ResourceIdMap& resource_map =
115        resource_provider->GetChildToParentMap(child_id_);
116
117  resource_provider->ReceiveFromChild(child_id_, frame_data->resource_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 < frame_data->render_pass_list.size(); ++i) {
127    RenderPass* pass = frame_data->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  // Display size is already set so we can compute what the damage rect
145  // will be in layer space.
146  if (!frame_data->render_pass_list.empty()) {
147    RenderPass* new_root_pass = frame_data->render_pass_list.back();
148    gfx::RectF damage_in_layer = MathUtil::MapClippedRect(
149        DelegatedFrameToLayerSpaceTransform(
150            new_root_pass->output_rect.size()),
151        damage_in_frame);
152    set_update_rect(gfx::UnionRects(update_rect(), damage_in_layer));
153  }
154
155  // Save the remapped quads on the layer. This steals the quads and render
156  // passes from the frame_data.
157  SetRenderPasses(&frame_data->render_pass_list);
158  have_render_passes_to_push_ = true;
159}
160
161void DelegatedRendererLayerImpl::SetDisplaySize(gfx::Size size) {
162  if (display_size_ == size)
163    return;
164  display_size_ = size;
165  NoteLayerPropertyChanged();
166}
167
168void DelegatedRendererLayerImpl::SetRenderPasses(
169    ScopedPtrVector<RenderPass>* render_passes_in_draw_order) {
170  ClearRenderPasses();
171
172  for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
173    ScopedPtrVector<RenderPass>::iterator to_take =
174        render_passes_in_draw_order->begin() + i;
175    render_passes_index_by_id_.insert(
176        std::pair<RenderPass::Id, int>((*to_take)->id, i));
177    scoped_ptr<RenderPass> taken_render_pass =
178        render_passes_in_draw_order->take(to_take);
179    render_passes_in_draw_order_.push_back(taken_render_pass.Pass());
180  }
181
182  // Give back an empty array instead of nulls.
183  render_passes_in_draw_order->clear();
184}
185
186void DelegatedRendererLayerImpl::ClearRenderPasses() {
187  // TODO(danakj): Release the resources back to the nested compositor.
188  render_passes_index_by_id_.clear();
189  render_passes_in_draw_order_.clear();
190}
191
192scoped_ptr<LayerImpl> DelegatedRendererLayerImpl::CreateLayerImpl(
193    LayerTreeImpl* tree_impl) {
194  return DelegatedRendererLayerImpl::Create(
195      tree_impl, id()).PassAs<LayerImpl>();
196}
197
198void DelegatedRendererLayerImpl::DidLoseOutputSurface() {
199  ClearRenderPasses();
200  ClearChildId();
201}
202
203gfx::Transform DelegatedRendererLayerImpl::DelegatedFrameToLayerSpaceTransform(
204    gfx::Size frame_size) const {
205  gfx::Size display_size = display_size_.IsEmpty() ? bounds() : display_size_;
206
207  gfx::Transform delegated_frame_to_layer_space_transform;
208  delegated_frame_to_layer_space_transform.Scale(
209      static_cast<double>(display_size.width()) / frame_size.width(),
210      static_cast<double>(display_size.height()) / frame_size.height());
211  return delegated_frame_to_layer_space_transform;
212}
213
214static inline int IndexToId(int index) { return index + 1; }
215static inline int IdToIndex(int id) { return id - 1; }
216
217RenderPass::Id DelegatedRendererLayerImpl::FirstContributingRenderPassId()
218    const {
219  return RenderPass::Id(id(), IndexToId(0));
220}
221
222RenderPass::Id DelegatedRendererLayerImpl::NextContributingRenderPassId(
223    RenderPass::Id previous) const {
224  return RenderPass::Id(previous.layer_id, previous.index + 1);
225}
226
227bool DelegatedRendererLayerImpl::ConvertDelegatedRenderPassId(
228    RenderPass::Id delegated_render_pass_id,
229    RenderPass::Id* output_render_pass_id) const {
230  base::hash_map<RenderPass::Id, int>::const_iterator found =
231      render_passes_index_by_id_.find(delegated_render_pass_id);
232  if (found == render_passes_index_by_id_.end()) {
233    // Be robust against a RenderPass id that isn't part of the frame.
234    return false;
235  }
236  unsigned delegated_render_pass_index = found->second;
237  *output_render_pass_id =
238      RenderPass::Id(id(), IndexToId(delegated_render_pass_index));
239  return true;
240}
241
242void DelegatedRendererLayerImpl::AppendContributingRenderPasses(
243    RenderPassSink* render_pass_sink) {
244  DCHECK(HasContributingDelegatedRenderPasses());
245
246  for (size_t i = 0; i < render_passes_in_draw_order_.size() - 1; ++i) {
247    RenderPass::Id output_render_pass_id(-1, -1);
248    bool present =
249        ConvertDelegatedRenderPassId(render_passes_in_draw_order_[i]->id,
250                                     &output_render_pass_id);
251
252    // Don't clash with the RenderPass we generate if we own a RenderSurface.
253    DCHECK(present) << render_passes_in_draw_order_[i]->id.layer_id << ", "
254                    << render_passes_in_draw_order_[i]->id.index;
255    DCHECK_GT(output_render_pass_id.index, 0);
256
257    render_pass_sink->AppendRenderPass(
258        render_passes_in_draw_order_[i]->Copy(output_render_pass_id));
259  }
260}
261
262bool DelegatedRendererLayerImpl::WillDraw(DrawMode draw_mode,
263                                          ResourceProvider* resource_provider) {
264  if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
265    return false;
266  return LayerImpl::WillDraw(draw_mode, resource_provider);
267}
268
269void DelegatedRendererLayerImpl::AppendQuads(
270    QuadSink* quad_sink,
271    AppendQuadsData* append_quads_data) {
272  AppendRainbowDebugBorder(quad_sink, append_quads_data);
273
274  if (render_passes_in_draw_order_.empty())
275    return;
276
277  RenderPass::Id target_render_pass_id = append_quads_data->render_pass_id;
278
279  const RenderPass* root_delegated_render_pass =
280      render_passes_in_draw_order_.back();
281
282  DCHECK(root_delegated_render_pass->output_rect.origin().IsOrigin());
283  gfx::Size frame_size = root_delegated_render_pass->output_rect.size();
284
285  // If the index of the RenderPassId is 0, then it is a RenderPass generated
286  // for a layer in this compositor, not the delegating renderer. Then we want
287  // to merge our root RenderPass with the target RenderPass. Otherwise, it is
288  // some RenderPass which we added from the delegating renderer.
289  bool should_merge_root_render_pass_with_target = !target_render_pass_id.index;
290  if (should_merge_root_render_pass_with_target) {
291    // Verify that the RenderPass we are appending to is created by our
292    // render_target.
293    DCHECK(target_render_pass_id.layer_id == render_target()->id());
294
295    AppendRenderPassQuads(
296        quad_sink, append_quads_data, root_delegated_render_pass, frame_size);
297  } else {
298    // Verify that the RenderPass we are appending to was created by us.
299    DCHECK(target_render_pass_id.layer_id == id());
300
301    int render_pass_index = IdToIndex(target_render_pass_id.index);
302    const RenderPass* delegated_render_pass =
303        render_passes_in_draw_order_[render_pass_index];
304    AppendRenderPassQuads(
305        quad_sink, append_quads_data, delegated_render_pass, frame_size);
306  }
307}
308
309void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
310    QuadSink* quad_sink,
311    AppendQuadsData* append_quads_data) {
312  if (!ShowDebugBorders())
313    return;
314
315  SharedQuadState* shared_quad_state =
316      quad_sink->UseSharedQuadState(CreateSharedQuadState());
317
318  SkColor color;
319  float border_width;
320  GetDebugBorderProperties(&color, &border_width);
321
322  SkColor colors[] = {
323    0x80ff0000,  // Red.
324    0x80ffa500,  // Orange.
325    0x80ffff00,  // Yellow.
326    0x80008000,  // Green.
327    0x800000ff,  // Blue.
328    0x80ee82ee,  // Violet.
329  };
330  const int kNumColors = arraysize(colors);
331
332  const int kStripeWidth = 300;
333  const int kStripeHeight = 300;
334
335  for (size_t i = 0; ; ++i) {
336    // For horizontal lines.
337    int x =  kStripeWidth * i;
338    int width = std::min(kStripeWidth, content_bounds().width() - x - 1);
339
340    // For vertical lines.
341    int y = kStripeHeight * i;
342    int height = std::min(kStripeHeight, content_bounds().height() - y - 1);
343
344    gfx::Rect top(x, 0, width, border_width);
345    gfx::Rect bottom(x,
346                     content_bounds().height() - border_width,
347                     width,
348                     border_width);
349    gfx::Rect left(0, y, border_width, height);
350    gfx::Rect right(content_bounds().width() - border_width,
351                    y,
352                    border_width,
353                    height);
354
355    if (top.IsEmpty() && left.IsEmpty())
356      break;
357
358    if (!top.IsEmpty()) {
359      scoped_ptr<SolidColorDrawQuad> top_quad = SolidColorDrawQuad::Create();
360      top_quad->SetNew(shared_quad_state, top, colors[i % kNumColors], false);
361      quad_sink->Append(top_quad.PassAs<DrawQuad>(), append_quads_data);
362
363      scoped_ptr<SolidColorDrawQuad> bottom_quad = SolidColorDrawQuad::Create();
364      bottom_quad->SetNew(shared_quad_state,
365                          bottom,
366                          colors[kNumColors - 1 - (i % kNumColors)],
367                          false);
368      quad_sink->Append(bottom_quad.PassAs<DrawQuad>(), append_quads_data);
369    }
370    if (!left.IsEmpty()) {
371      scoped_ptr<SolidColorDrawQuad> left_quad = SolidColorDrawQuad::Create();
372      left_quad->SetNew(shared_quad_state,
373                        left,
374                        colors[kNumColors - 1 - (i % kNumColors)],
375                        false);
376      quad_sink->Append(left_quad.PassAs<DrawQuad>(), append_quads_data);
377
378      scoped_ptr<SolidColorDrawQuad> right_quad = SolidColorDrawQuad::Create();
379      right_quad->SetNew(
380          shared_quad_state, right, colors[i % kNumColors], false);
381      quad_sink->Append(right_quad.PassAs<DrawQuad>(), append_quads_data);
382    }
383  }
384}
385
386void DelegatedRendererLayerImpl::AppendRenderPassQuads(
387    QuadSink* quad_sink,
388    AppendQuadsData* append_quads_data,
389    const RenderPass* delegated_render_pass,
390    gfx::Size frame_size) const {
391
392  const SharedQuadState* delegated_shared_quad_state = NULL;
393  SharedQuadState* output_shared_quad_state = NULL;
394
395  for (size_t i = 0; i < delegated_render_pass->quad_list.size(); ++i) {
396    const DrawQuad* delegated_quad = delegated_render_pass->quad_list[i];
397
398    if (delegated_quad->shared_quad_state != delegated_shared_quad_state) {
399      delegated_shared_quad_state = delegated_quad->shared_quad_state;
400      output_shared_quad_state = quad_sink->UseSharedQuadState(
401          delegated_shared_quad_state->Copy());
402
403      bool is_root_delegated_render_pass =
404          delegated_render_pass == render_passes_in_draw_order_.back();
405      if (is_root_delegated_render_pass) {
406        // Don't allow areas inside the bounds that are empty.
407        DCHECK(display_size_.IsEmpty() ||
408               gfx::Rect(display_size_).Contains(gfx::Rect(bounds())));
409        gfx::Transform delegated_frame_to_target_transform =
410            draw_transform() * DelegatedFrameToLayerSpaceTransform(frame_size);
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 = MathUtil::MapClippedRect(
420              delegated_frame_to_target_transform,
421              output_shared_quad_state->clip_rect);
422        } else {
423          gfx::Rect clip_rect = drawable_content_rect();
424          if (output_shared_quad_state->is_clipped) {
425            clip_rect.Intersect(MathUtil::MapClippedRect(
426                delegated_frame_to_target_transform,
427                output_shared_quad_state->clip_rect));
428          }
429          output_shared_quad_state->clip_rect = clip_rect;
430          output_shared_quad_state->is_clipped = true;
431        }
432
433        output_shared_quad_state->opacity *= draw_opacity();
434      }
435    }
436    DCHECK(output_shared_quad_state);
437
438    scoped_ptr<DrawQuad> output_quad;
439    if (delegated_quad->material != DrawQuad::RENDER_PASS) {
440      output_quad = delegated_quad->Copy(output_shared_quad_state);
441    } else {
442      RenderPass::Id delegated_contributing_render_pass_id =
443          RenderPassDrawQuad::MaterialCast(delegated_quad)->render_pass_id;
444      RenderPass::Id output_contributing_render_pass_id(-1, -1);
445
446      bool present =
447          ConvertDelegatedRenderPassId(delegated_contributing_render_pass_id,
448                                       &output_contributing_render_pass_id);
449
450      // The frame may have a RenderPassDrawQuad that points to a RenderPass not
451      // part of the frame. Just ignore these quads.
452      if (present) {
453        DCHECK(output_contributing_render_pass_id !=
454               append_quads_data->render_pass_id);
455
456        output_quad = RenderPassDrawQuad::MaterialCast(delegated_quad)->Copy(
457            output_shared_quad_state,
458            output_contributing_render_pass_id).PassAs<DrawQuad>();
459      }
460    }
461
462    if (output_quad)
463      quad_sink->Append(output_quad.Pass(), append_quads_data);
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  child_id_ = 0;
481}
482
483}  // namespace cc
484