render_surface_impl.cc revision a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7 
1// Copyright 2011 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/render_surface_impl.h"
6
7#include <algorithm>
8
9#include "base/logging.h"
10#include "base/strings/stringprintf.h"
11#include "cc/base/math_util.h"
12#include "cc/debug/debug_colors.h"
13#include "cc/layers/delegated_renderer_layer_impl.h"
14#include "cc/layers/layer_impl.h"
15#include "cc/layers/quad_sink.h"
16#include "cc/layers/render_pass_sink.h"
17#include "cc/quads/debug_border_draw_quad.h"
18#include "cc/quads/render_pass.h"
19#include "cc/quads/render_pass_draw_quad.h"
20#include "cc/quads/shared_quad_state.h"
21#include "cc/trees/damage_tracker.h"
22#include "third_party/skia/include/core/SkImageFilter.h"
23#include "ui/gfx/rect_conversions.h"
24#include "ui/gfx/transform.h"
25
26namespace cc {
27
28RenderSurfaceImpl::RenderSurfaceImpl(LayerImpl* owning_layer)
29    : owning_layer_(owning_layer),
30      surface_property_changed_(false),
31      draw_opacity_is_animating_(false),
32      target_surface_transforms_are_animating_(false),
33      screen_space_transforms_are_animating_(false),
34      is_clipped_(false),
35      contributes_to_drawn_surface_(false),
36      draw_opacity_(1),
37      nearest_occlusion_immune_ancestor_(NULL),
38      target_render_surface_layer_index_history_(0),
39      current_layer_index_history_(0) {
40  damage_tracker_ = DamageTracker::Create();
41}
42
43RenderSurfaceImpl::~RenderSurfaceImpl() {}
44
45gfx::RectF RenderSurfaceImpl::DrawableContentRect() const {
46  gfx::RectF drawable_content_rect =
47      MathUtil::MapClippedRect(draw_transform_, content_rect_);
48  if (owning_layer_->has_replica()) {
49    drawable_content_rect.Union(
50        MathUtil::MapClippedRect(replica_draw_transform_, content_rect_));
51  }
52
53  return drawable_content_rect;
54}
55
56std::string RenderSurfaceImpl::Name() const {
57  return base::StringPrintf("RenderSurfaceImpl(id=%i,owner=%s)",
58                            owning_layer_->id(),
59                            owning_layer_->debug_name().data());
60}
61
62int RenderSurfaceImpl::OwningLayerId() const {
63  return owning_layer_ ? owning_layer_->id() : 0;
64}
65
66
67void RenderSurfaceImpl::SetClipRect(gfx::Rect clip_rect) {
68  if (clip_rect_ == clip_rect)
69    return;
70
71  surface_property_changed_ = true;
72  clip_rect_ = clip_rect;
73}
74
75bool RenderSurfaceImpl::ContentsChanged() const {
76  return !damage_tracker_->current_damage_rect().IsEmpty();
77}
78
79void RenderSurfaceImpl::SetContentRect(gfx::Rect content_rect) {
80  if (content_rect_ == content_rect)
81    return;
82
83  surface_property_changed_ = true;
84  content_rect_ = content_rect;
85}
86
87bool RenderSurfaceImpl::SurfacePropertyChanged() const {
88  // Surface property changes are tracked as follows:
89  //
90  // - surface_property_changed_ is flagged when the clip_rect or content_rect
91  //   change. As of now, these are the only two properties that can be affected
92  //   by descendant layers.
93  //
94  // - all other property changes come from the owning layer (or some ancestor
95  //   layer that propagates its change to the owning layer).
96  //
97  DCHECK(owning_layer_);
98  return surface_property_changed_ || owning_layer_->LayerPropertyChanged();
99}
100
101bool RenderSurfaceImpl::SurfacePropertyChangedOnlyFromDescendant() const {
102  return surface_property_changed_ && !owning_layer_->LayerPropertyChanged();
103}
104
105void RenderSurfaceImpl::AddContributingDelegatedRenderPassLayer(
106    LayerImpl* layer) {
107  DCHECK(std::find(layer_list_.begin(), layer_list_.end(), layer) !=
108         layer_list_.end());
109  DelegatedRendererLayerImpl* delegated_renderer_layer =
110      static_cast<DelegatedRendererLayerImpl*>(layer);
111  contributing_delegated_render_pass_layer_list_.push_back(
112      delegated_renderer_layer);
113}
114
115void RenderSurfaceImpl::ClearLayerLists() {
116  layer_list_.clear();
117  contributing_delegated_render_pass_layer_list_.clear();
118}
119
120RenderPass::Id RenderSurfaceImpl::RenderPassId() {
121  int layer_id = owning_layer_->id();
122  int sub_id = 0;
123  DCHECK_GT(layer_id, 0);
124  return RenderPass::Id(layer_id, sub_id);
125}
126
127void RenderSurfaceImpl::AppendRenderPasses(RenderPassSink* pass_sink) {
128  for (size_t i = 0;
129       i < contributing_delegated_render_pass_layer_list_.size();
130       ++i) {
131    DelegatedRendererLayerImpl* delegated_renderer_layer =
132        contributing_delegated_render_pass_layer_list_[i];
133    delegated_renderer_layer->AppendContributingRenderPasses(pass_sink);
134  }
135
136  scoped_ptr<RenderPass> pass = RenderPass::Create(layer_list_.size());
137  pass->SetNew(RenderPassId(),
138               content_rect_,
139               damage_tracker_->current_damage_rect(),
140               screen_space_transform_);
141  pass_sink->AppendRenderPass(pass.Pass());
142}
143
144void RenderSurfaceImpl::AppendQuads(QuadSink* quad_sink,
145                                    AppendQuadsData* append_quads_data,
146                                    bool for_replica,
147                                    RenderPass::Id render_pass_id) {
148  DCHECK(!for_replica || owning_layer_->has_replica());
149
150  const gfx::Transform& draw_transform =
151      for_replica ? replica_draw_transform_ : draw_transform_;
152  SharedQuadState* shared_quad_state =
153      quad_sink->UseSharedQuadState(SharedQuadState::Create());
154  shared_quad_state->SetAll(draw_transform,
155                            content_rect_.size(),
156                            content_rect_,
157                            clip_rect_,
158                            is_clipped_,
159                            draw_opacity_,
160                            owning_layer_->blend_mode());
161
162  if (owning_layer_->ShowDebugBorders()) {
163    SkColor color = for_replica ?
164                    DebugColors::SurfaceReplicaBorderColor() :
165                    DebugColors::SurfaceBorderColor();
166    float width = for_replica ?
167                  DebugColors::SurfaceReplicaBorderWidth(
168                      owning_layer_->layer_tree_impl()) :
169                  DebugColors::SurfaceBorderWidth(
170                      owning_layer_->layer_tree_impl());
171    scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
172        DebugBorderDrawQuad::Create();
173    debug_border_quad->SetNew(shared_quad_state, content_rect_, color, width);
174    quad_sink->Append(debug_border_quad.PassAs<DrawQuad>(), append_quads_data);
175  }
176
177  // TODO(shawnsingh): By using the same RenderSurfaceImpl for both the content
178  // and its reflection, it's currently not possible to apply a separate mask to
179  // the reflection layer or correctly handle opacity in reflections (opacity
180  // must be applied after drawing both the layer and its reflection). The
181  // solution is to introduce yet another RenderSurfaceImpl to draw the layer
182  // and its reflection in. For now we only apply a separate reflection mask if
183  // the contents don't have a mask of their own.
184  LayerImpl* mask_layer = owning_layer_->mask_layer();
185  if (mask_layer &&
186      (!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
187    mask_layer = NULL;
188
189  if (!mask_layer && for_replica) {
190    mask_layer = owning_layer_->replica_layer()->mask_layer();
191    if (mask_layer &&
192        (!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
193      mask_layer = NULL;
194  }
195
196  gfx::RectF mask_uv_rect(0.f, 0.f, 1.f, 1.f);
197  if (mask_layer) {
198    gfx::Vector2dF owning_layer_draw_scale =
199        MathUtil::ComputeTransform2dScaleComponents(
200            owning_layer_->draw_transform(), 1.f);
201    gfx::SizeF unclipped_mask_target_size = gfx::ScaleSize(
202        owning_layer_->content_bounds(),
203        owning_layer_draw_scale.x(),
204        owning_layer_draw_scale.y());
205
206    float uv_scale_x =
207        content_rect_.width() / unclipped_mask_target_size.width();
208    float uv_scale_y =
209        content_rect_.height() / unclipped_mask_target_size.height();
210
211    mask_uv_rect = gfx::RectF(
212        uv_scale_x * content_rect_.x() / content_rect_.width(),
213        uv_scale_y * content_rect_.y() / content_rect_.height(),
214        uv_scale_x,
215        uv_scale_y);
216  }
217
218  ResourceProvider::ResourceId mask_resource_id =
219      mask_layer ? mask_layer->ContentsResourceId() : 0;
220  gfx::Rect contents_changed_since_last_frame =
221      ContentsChanged() ? content_rect_ : gfx::Rect();
222
223  scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
224  quad->SetNew(shared_quad_state,
225               content_rect_,
226               render_pass_id,
227               for_replica,
228               mask_resource_id,
229               contents_changed_since_last_frame,
230               mask_uv_rect,
231               owning_layer_->filters(),
232               owning_layer_->background_filters());
233  quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
234}
235
236}  // namespace cc
237