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
26 namespace cc {
27
RenderSurfaceImpl(LayerImpl * owning_layer)28 RenderSurfaceImpl::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
~RenderSurfaceImpl()43 RenderSurfaceImpl::~RenderSurfaceImpl() {}
44
DrawableContentRect() const45 gfx::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
Name() const56 std::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
OwningLayerId() const62 int RenderSurfaceImpl::OwningLayerId() const {
63 return owning_layer_ ? owning_layer_->id() : 0;
64 }
65
66
SetClipRect(gfx::Rect clip_rect)67 void 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
ContentsChanged() const75 bool RenderSurfaceImpl::ContentsChanged() const {
76 return !damage_tracker_->current_damage_rect().IsEmpty();
77 }
78
SetContentRect(gfx::Rect content_rect)79 void 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
SurfacePropertyChanged() const87 bool 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
SurfacePropertyChangedOnlyFromDescendant() const101 bool RenderSurfaceImpl::SurfacePropertyChangedOnlyFromDescendant() const {
102 return surface_property_changed_ && !owning_layer_->LayerPropertyChanged();
103 }
104
AddContributingDelegatedRenderPassLayer(LayerImpl * layer)105 void 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
ClearLayerLists()115 void RenderSurfaceImpl::ClearLayerLists() {
116 layer_list_.clear();
117 contributing_delegated_render_pass_layer_list_.clear();
118 }
119
RenderPassId()120 RenderPass::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
AppendRenderPasses(RenderPassSink * pass_sink)127 void 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
AppendQuads(QuadSink * quad_sink,AppendQuadsData * append_quads_data,bool for_replica,RenderPass::Id render_pass_id)144 void 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