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/layer_impl.h"
6
7 #include "base/debug/trace_event.h"
8 #include "base/json/json_reader.h"
9 #include "base/strings/stringprintf.h"
10 #include "cc/animation/animation_registrar.h"
11 #include "cc/animation/scrollbar_animation_controller.h"
12 #include "cc/animation/scrollbar_animation_controller_linear_fade.h"
13 #include "cc/animation/scrollbar_animation_controller_thinning.h"
14 #include "cc/base/math_util.h"
15 #include "cc/debug/debug_colors.h"
16 #include "cc/debug/layer_tree_debug_state.h"
17 #include "cc/debug/micro_benchmark_impl.h"
18 #include "cc/debug/traced_value.h"
19 #include "cc/input/layer_scroll_offset_delegate.h"
20 #include "cc/layers/painted_scrollbar_layer_impl.h"
21 #include "cc/layers/quad_sink.h"
22 #include "cc/output/copy_output_request.h"
23 #include "cc/quads/debug_border_draw_quad.h"
24 #include "cc/trees/layer_tree_impl.h"
25 #include "cc/trees/layer_tree_settings.h"
26 #include "cc/trees/proxy.h"
27 #include "ui/gfx/box_f.h"
28 #include "ui/gfx/point_conversions.h"
29 #include "ui/gfx/quad_f.h"
30 #include "ui/gfx/rect_conversions.h"
31
32 namespace cc {
LayerImpl(LayerTreeImpl * tree_impl,int id)33 LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
34 : parent_(NULL),
35 scroll_parent_(NULL),
36 clip_parent_(NULL),
37 mask_layer_id_(-1),
38 replica_layer_id_(-1),
39 layer_id_(id),
40 layer_tree_impl_(tree_impl),
41 anchor_point_(0.5f, 0.5f),
42 anchor_point_z_(0.f),
43 scroll_offset_delegate_(NULL),
44 scrollable_(false),
45 should_scroll_on_main_thread_(false),
46 have_wheel_event_handlers_(false),
47 user_scrollable_horizontal_(true),
48 user_scrollable_vertical_(true),
49 stacking_order_changed_(false),
50 double_sided_(true),
51 layer_property_changed_(false),
52 masks_to_bounds_(false),
53 contents_opaque_(false),
54 is_root_for_isolated_group_(false),
55 preserves_3d_(false),
56 use_parent_backface_visibility_(false),
57 draw_checkerboard_for_missing_tiles_(false),
58 draws_content_(false),
59 hide_layer_and_subtree_(false),
60 force_render_surface_(false),
61 is_container_for_fixed_position_layers_(false),
62 background_color_(0),
63 opacity_(1.0),
64 blend_mode_(SkXfermode::kSrcOver_Mode),
65 draw_depth_(0.f),
66 compositing_reasons_(kCompositingReasonUnknown),
67 current_draw_mode_(DRAW_MODE_NONE),
68 horizontal_scrollbar_layer_(NULL),
69 vertical_scrollbar_layer_(NULL) {
70 DCHECK_GT(layer_id_, 0);
71 DCHECK(layer_tree_impl_);
72 layer_tree_impl_->RegisterLayer(this);
73 AnimationRegistrar* registrar = layer_tree_impl_->animationRegistrar();
74 layer_animation_controller_ =
75 registrar->GetAnimationControllerForId(layer_id_);
76 layer_animation_controller_->AddValueObserver(this);
77 if (IsActive())
78 layer_animation_controller_->set_value_provider(this);
79 }
80
~LayerImpl()81 LayerImpl::~LayerImpl() {
82 DCHECK_EQ(DRAW_MODE_NONE, current_draw_mode_);
83
84 layer_animation_controller_->RemoveValueObserver(this);
85 layer_animation_controller_->remove_value_provider(this);
86
87 if (!copy_requests_.empty() && layer_tree_impl_->IsActiveTree())
88 layer_tree_impl()->RemoveLayerWithCopyOutputRequest(this);
89 layer_tree_impl_->UnregisterLayer(this);
90
91 if (scroll_children_) {
92 for (std::set<LayerImpl*>::iterator it = scroll_children_->begin();
93 it != scroll_children_->end(); ++it)
94 (*it)->scroll_parent_ = NULL;
95 }
96
97 if (scroll_parent_)
98 scroll_parent_->RemoveScrollChild(this);
99
100 if (clip_children_) {
101 for (std::set<LayerImpl*>::iterator it = clip_children_->begin();
102 it != clip_children_->end(); ++it)
103 (*it)->clip_parent_ = NULL;
104 }
105
106 if (clip_parent_)
107 clip_parent_->RemoveClipChild(this);
108 }
109
AddChild(scoped_ptr<LayerImpl> child)110 void LayerImpl::AddChild(scoped_ptr<LayerImpl> child) {
111 child->set_parent(this);
112 DCHECK_EQ(layer_tree_impl(), child->layer_tree_impl());
113 children_.push_back(child.Pass());
114 layer_tree_impl()->set_needs_update_draw_properties();
115 }
116
RemoveChild(LayerImpl * child)117 scoped_ptr<LayerImpl> LayerImpl::RemoveChild(LayerImpl* child) {
118 for (OwnedLayerImplList::iterator it = children_.begin();
119 it != children_.end();
120 ++it) {
121 if (*it == child) {
122 scoped_ptr<LayerImpl> ret = children_.take(it);
123 children_.erase(it);
124 layer_tree_impl()->set_needs_update_draw_properties();
125 return ret.Pass();
126 }
127 }
128 return scoped_ptr<LayerImpl>();
129 }
130
ClearChildList()131 void LayerImpl::ClearChildList() {
132 if (children_.empty())
133 return;
134
135 children_.clear();
136 layer_tree_impl()->set_needs_update_draw_properties();
137 }
138
HasAncestor(const LayerImpl * ancestor) const139 bool LayerImpl::HasAncestor(const LayerImpl* ancestor) const {
140 if (!ancestor)
141 return false;
142
143 for (const LayerImpl* layer = this; layer; layer = layer->parent()) {
144 if (layer == ancestor)
145 return true;
146 }
147
148 return false;
149 }
150
SetScrollParent(LayerImpl * parent)151 void LayerImpl::SetScrollParent(LayerImpl* parent) {
152 if (scroll_parent_ == parent)
153 return;
154
155 // Having both a scroll parent and a scroll offset delegate is unsupported.
156 DCHECK(!scroll_offset_delegate_);
157
158 if (scroll_parent_)
159 scroll_parent_->RemoveScrollChild(this);
160
161 scroll_parent_ = parent;
162 }
163
SetDebugInfo(scoped_refptr<base::debug::ConvertableToTraceFormat> other)164 void LayerImpl::SetDebugInfo(
165 scoped_refptr<base::debug::ConvertableToTraceFormat> other) {
166 debug_info_ = other;
167 }
168
SetScrollChildren(std::set<LayerImpl * > * children)169 void LayerImpl::SetScrollChildren(std::set<LayerImpl*>* children) {
170 if (scroll_children_.get() == children)
171 return;
172 scroll_children_.reset(children);
173 }
174
RemoveScrollChild(LayerImpl * child)175 void LayerImpl::RemoveScrollChild(LayerImpl* child) {
176 DCHECK(scroll_children_);
177 scroll_children_->erase(child);
178 if (scroll_children_->empty())
179 scroll_children_.reset();
180 }
181
SetClipParent(LayerImpl * ancestor)182 void LayerImpl::SetClipParent(LayerImpl* ancestor) {
183 if (clip_parent_ == ancestor)
184 return;
185
186 if (clip_parent_)
187 clip_parent_->RemoveClipChild(this);
188
189 clip_parent_ = ancestor;
190 }
191
SetClipChildren(std::set<LayerImpl * > * children)192 void LayerImpl::SetClipChildren(std::set<LayerImpl*>* children) {
193 if (clip_children_.get() == children)
194 return;
195 clip_children_.reset(children);
196 }
197
RemoveClipChild(LayerImpl * child)198 void LayerImpl::RemoveClipChild(LayerImpl* child) {
199 DCHECK(clip_children_);
200 clip_children_->erase(child);
201 if (clip_children_->empty())
202 clip_children_.reset();
203 }
204
PassCopyRequests(ScopedPtrVector<CopyOutputRequest> * requests)205 void LayerImpl::PassCopyRequests(ScopedPtrVector<CopyOutputRequest>* requests) {
206 if (requests->empty())
207 return;
208
209 bool was_empty = copy_requests_.empty();
210 copy_requests_.insert_and_take(copy_requests_.end(), *requests);
211 requests->clear();
212
213 if (was_empty && layer_tree_impl()->IsActiveTree())
214 layer_tree_impl()->AddLayerWithCopyOutputRequest(this);
215 NoteLayerPropertyChangedForSubtree();
216 }
217
TakeCopyRequestsAndTransformToTarget(ScopedPtrVector<CopyOutputRequest> * requests)218 void LayerImpl::TakeCopyRequestsAndTransformToTarget(
219 ScopedPtrVector<CopyOutputRequest>* requests) {
220 if (copy_requests_.empty())
221 return;
222
223 size_t first_inserted_request = requests->size();
224 requests->insert_and_take(requests->end(), copy_requests_);
225 copy_requests_.clear();
226
227 for (size_t i = first_inserted_request; i < requests->size(); ++i) {
228 CopyOutputRequest* request = requests->at(i);
229 if (!request->has_area())
230 continue;
231
232 gfx::Rect request_in_layer_space = request->area();
233 gfx::Rect request_in_content_space =
234 LayerRectToContentRect(request_in_layer_space);
235 request->set_area(
236 MathUtil::MapClippedRect(draw_properties_.target_space_transform,
237 request_in_content_space));
238 }
239
240 if (layer_tree_impl()->IsActiveTree())
241 layer_tree_impl()->RemoveLayerWithCopyOutputRequest(this);
242 }
243
CreateRenderSurface()244 void LayerImpl::CreateRenderSurface() {
245 DCHECK(!draw_properties_.render_surface);
246 draw_properties_.render_surface =
247 make_scoped_ptr(new RenderSurfaceImpl(this));
248 draw_properties_.render_target = this;
249 }
250
ClearRenderSurface()251 void LayerImpl::ClearRenderSurface() {
252 draw_properties_.render_surface.reset();
253 }
254
CreateSharedQuadState() const255 scoped_ptr<SharedQuadState> LayerImpl::CreateSharedQuadState() const {
256 scoped_ptr<SharedQuadState> state = SharedQuadState::Create();
257 state->SetAll(draw_properties_.target_space_transform,
258 draw_properties_.content_bounds,
259 draw_properties_.visible_content_rect,
260 draw_properties_.clip_rect,
261 draw_properties_.is_clipped,
262 draw_properties_.opacity,
263 blend_mode_);
264 return state.Pass();
265 }
266
WillDraw(DrawMode draw_mode,ResourceProvider * resource_provider)267 bool LayerImpl::WillDraw(DrawMode draw_mode,
268 ResourceProvider* resource_provider) {
269 // WillDraw/DidDraw must be matched.
270 DCHECK_NE(DRAW_MODE_NONE, draw_mode);
271 DCHECK_EQ(DRAW_MODE_NONE, current_draw_mode_);
272 current_draw_mode_ = draw_mode;
273 return true;
274 }
275
DidDraw(ResourceProvider * resource_provider)276 void LayerImpl::DidDraw(ResourceProvider* resource_provider) {
277 DCHECK_NE(DRAW_MODE_NONE, current_draw_mode_);
278 current_draw_mode_ = DRAW_MODE_NONE;
279 }
280
ShowDebugBorders() const281 bool LayerImpl::ShowDebugBorders() const {
282 return layer_tree_impl()->debug_state().show_debug_borders;
283 }
284
GetDebugBorderProperties(SkColor * color,float * width) const285 void LayerImpl::GetDebugBorderProperties(SkColor* color, float* width) const {
286 if (draws_content_) {
287 *color = DebugColors::ContentLayerBorderColor();
288 *width = DebugColors::ContentLayerBorderWidth(layer_tree_impl());
289 return;
290 }
291
292 if (masks_to_bounds_) {
293 *color = DebugColors::MaskingLayerBorderColor();
294 *width = DebugColors::MaskingLayerBorderWidth(layer_tree_impl());
295 return;
296 }
297
298 *color = DebugColors::ContainerLayerBorderColor();
299 *width = DebugColors::ContainerLayerBorderWidth(layer_tree_impl());
300 }
301
AppendDebugBorderQuad(QuadSink * quad_sink,const SharedQuadState * shared_quad_state,AppendQuadsData * append_quads_data) const302 void LayerImpl::AppendDebugBorderQuad(
303 QuadSink* quad_sink,
304 const SharedQuadState* shared_quad_state,
305 AppendQuadsData* append_quads_data) const {
306 SkColor color;
307 float width;
308 GetDebugBorderProperties(&color, &width);
309 AppendDebugBorderQuad(
310 quad_sink, shared_quad_state, append_quads_data, color, width);
311 }
312
AppendDebugBorderQuad(QuadSink * quad_sink,const SharedQuadState * shared_quad_state,AppendQuadsData * append_quads_data,SkColor color,float width) const313 void LayerImpl::AppendDebugBorderQuad(QuadSink* quad_sink,
314 const SharedQuadState* shared_quad_state,
315 AppendQuadsData* append_quads_data,
316 SkColor color,
317 float width) const {
318 if (!ShowDebugBorders())
319 return;
320
321 gfx::Rect content_rect(content_bounds());
322 scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
323 DebugBorderDrawQuad::Create();
324 debug_border_quad->SetNew(shared_quad_state, content_rect, color, width);
325 quad_sink->Append(debug_border_quad.PassAs<DrawQuad>(), append_quads_data);
326 }
327
HasDelegatedContent() const328 bool LayerImpl::HasDelegatedContent() const {
329 return false;
330 }
331
HasContributingDelegatedRenderPasses() const332 bool LayerImpl::HasContributingDelegatedRenderPasses() const {
333 return false;
334 }
335
FirstContributingRenderPassId() const336 RenderPass::Id LayerImpl::FirstContributingRenderPassId() const {
337 return RenderPass::Id(0, 0);
338 }
339
NextContributingRenderPassId(RenderPass::Id id) const340 RenderPass::Id LayerImpl::NextContributingRenderPassId(RenderPass::Id id)
341 const {
342 return RenderPass::Id(0, 0);
343 }
344
ContentsResourceId() const345 ResourceProvider::ResourceId LayerImpl::ContentsResourceId() const {
346 NOTREACHED();
347 return 0;
348 }
349
SetSentScrollDelta(gfx::Vector2d sent_scroll_delta)350 void LayerImpl::SetSentScrollDelta(gfx::Vector2d sent_scroll_delta) {
351 // Pending tree never has sent scroll deltas
352 DCHECK(layer_tree_impl()->IsActiveTree());
353
354 if (sent_scroll_delta_ == sent_scroll_delta)
355 return;
356
357 sent_scroll_delta_ = sent_scroll_delta;
358 }
359
ScrollBy(gfx::Vector2dF scroll)360 gfx::Vector2dF LayerImpl::ScrollBy(gfx::Vector2dF scroll) {
361 DCHECK(scrollable());
362 gfx::Vector2dF min_delta = -scroll_offset_;
363 gfx::Vector2dF max_delta = max_scroll_offset_ - scroll_offset_;
364 // Clamp new_delta so that position + delta stays within scroll bounds.
365 gfx::Vector2dF new_delta = (ScrollDelta() + scroll);
366 new_delta.SetToMax(min_delta);
367 new_delta.SetToMin(max_delta);
368 gfx::Vector2dF unscrolled =
369 ScrollDelta() + scroll - new_delta;
370 SetScrollDelta(new_delta);
371 return unscrolled;
372 }
373
ApplySentScrollDeltasFromAbortedCommit()374 void LayerImpl::ApplySentScrollDeltasFromAbortedCommit() {
375 // Pending tree never has sent scroll deltas
376 DCHECK(layer_tree_impl()->IsActiveTree());
377
378 // Apply sent scroll deltas to scroll position / scroll delta as if the
379 // main thread had applied them and then committed those values.
380 //
381 // This function should not change the total scroll offset; it just shifts
382 // some of the scroll delta to the scroll offset. Therefore, adjust these
383 // variables directly rather than calling the scroll offset delegate to
384 // avoid sending it multiple spurious calls.
385 //
386 // Because of the way scroll delta is calculated with a delegate, this will
387 // leave the total scroll offset unchanged on this layer regardless of
388 // whether a delegate is being used.
389 scroll_offset_ += sent_scroll_delta_;
390 scroll_delta_ -= sent_scroll_delta_;
391 sent_scroll_delta_ = gfx::Vector2d();
392 }
393
ApplyScrollDeltasSinceBeginMainFrame()394 void LayerImpl::ApplyScrollDeltasSinceBeginMainFrame() {
395 // Only the pending tree can have missing scrolls.
396 DCHECK(layer_tree_impl()->IsPendingTree());
397 if (!scrollable())
398 return;
399
400 // Pending tree should never have sent scroll deltas.
401 DCHECK(sent_scroll_delta().IsZero());
402
403 LayerImpl* active_twin = layer_tree_impl()->FindActiveTreeLayerById(id());
404 if (active_twin) {
405 // Scrolls that happens after begin frame (where the sent scroll delta
406 // comes from) and commit need to be applied to the pending tree
407 // so that it is up to date with the total scroll.
408 SetScrollDelta(active_twin->ScrollDelta() -
409 active_twin->sent_scroll_delta());
410 }
411 }
412
TryScroll(gfx::PointF screen_space_point,InputHandler::ScrollInputType type) const413 InputHandler::ScrollStatus LayerImpl::TryScroll(
414 gfx::PointF screen_space_point,
415 InputHandler::ScrollInputType type) const {
416 if (should_scroll_on_main_thread()) {
417 TRACE_EVENT0("cc", "LayerImpl::TryScroll: Failed ShouldScrollOnMainThread");
418 return InputHandler::ScrollOnMainThread;
419 }
420
421 if (!screen_space_transform().IsInvertible()) {
422 TRACE_EVENT0("cc", "LayerImpl::TryScroll: Ignored NonInvertibleTransform");
423 return InputHandler::ScrollIgnored;
424 }
425
426 if (!non_fast_scrollable_region().IsEmpty()) {
427 bool clipped = false;
428 gfx::Transform inverse_screen_space_transform(
429 gfx::Transform::kSkipInitialization);
430 if (!screen_space_transform().GetInverse(&inverse_screen_space_transform)) {
431 // TODO(shawnsingh): We shouldn't be applying a projection if screen space
432 // transform is uninvertible here. Perhaps we should be returning
433 // ScrollOnMainThread in this case?
434 }
435
436 gfx::PointF hit_test_point_in_content_space =
437 MathUtil::ProjectPoint(inverse_screen_space_transform,
438 screen_space_point,
439 &clipped);
440 gfx::PointF hit_test_point_in_layer_space =
441 gfx::ScalePoint(hit_test_point_in_content_space,
442 1.f / contents_scale_x(),
443 1.f / contents_scale_y());
444 if (!clipped &&
445 non_fast_scrollable_region().Contains(
446 gfx::ToRoundedPoint(hit_test_point_in_layer_space))) {
447 TRACE_EVENT0("cc",
448 "LayerImpl::tryScroll: Failed NonFastScrollableRegion");
449 return InputHandler::ScrollOnMainThread;
450 }
451 }
452
453 if (type == InputHandler::Wheel && have_wheel_event_handlers()) {
454 TRACE_EVENT0("cc", "LayerImpl::tryScroll: Failed WheelEventHandlers");
455 return InputHandler::ScrollOnMainThread;
456 }
457
458 if (!scrollable()) {
459 TRACE_EVENT0("cc", "LayerImpl::tryScroll: Ignored not scrollable");
460 return InputHandler::ScrollIgnored;
461 }
462
463 if (max_scroll_offset_.x() <= 0 && max_scroll_offset_.y() <= 0) {
464 TRACE_EVENT0("cc",
465 "LayerImpl::tryScroll: Ignored. Technically scrollable,"
466 " but has no affordance in either direction.");
467 return InputHandler::ScrollIgnored;
468 }
469
470 return InputHandler::ScrollStarted;
471 }
472
DrawCheckerboardForMissingTiles() const473 bool LayerImpl::DrawCheckerboardForMissingTiles() const {
474 return draw_checkerboard_for_missing_tiles_ &&
475 !layer_tree_impl()->settings().background_color_instead_of_checkerboard;
476 }
477
LayerRectToContentRect(const gfx::RectF & layer_rect) const478 gfx::Rect LayerImpl::LayerRectToContentRect(
479 const gfx::RectF& layer_rect) const {
480 gfx::RectF content_rect =
481 gfx::ScaleRect(layer_rect, contents_scale_x(), contents_scale_y());
482 // Intersect with content rect to avoid the extra pixel because for some
483 // values x and y, ceil((x / y) * y) may be x + 1.
484 content_rect.Intersect(gfx::Rect(content_bounds()));
485 return gfx::ToEnclosingRect(content_rect);
486 }
487
GetPicture()488 skia::RefPtr<SkPicture> LayerImpl::GetPicture() {
489 return skia::RefPtr<SkPicture>();
490 }
491
AreVisibleResourcesReady() const492 bool LayerImpl::AreVisibleResourcesReady() const {
493 return true;
494 }
495
CreateLayerImpl(LayerTreeImpl * tree_impl)496 scoped_ptr<LayerImpl> LayerImpl::CreateLayerImpl(LayerTreeImpl* tree_impl) {
497 return LayerImpl::Create(tree_impl, layer_id_);
498 }
499
PushPropertiesTo(LayerImpl * layer)500 void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
501 layer->SetAnchorPoint(anchor_point_);
502 layer->SetAnchorPointZ(anchor_point_z_);
503 layer->SetBackgroundColor(background_color_);
504 layer->SetBounds(bounds_);
505 layer->SetContentBounds(content_bounds());
506 layer->SetContentsScale(contents_scale_x(), contents_scale_y());
507 layer->SetDebugName(debug_name_);
508 layer->SetCompositingReasons(compositing_reasons_);
509 layer->SetDoubleSided(double_sided_);
510 layer->SetDrawCheckerboardForMissingTiles(
511 draw_checkerboard_for_missing_tiles_);
512 layer->SetForceRenderSurface(force_render_surface_);
513 layer->SetDrawsContent(DrawsContent());
514 layer->SetHideLayerAndSubtree(hide_layer_and_subtree_);
515 layer->SetFilters(filters());
516 layer->SetBackgroundFilters(background_filters());
517 layer->SetMasksToBounds(masks_to_bounds_);
518 layer->SetShouldScrollOnMainThread(should_scroll_on_main_thread_);
519 layer->SetHaveWheelEventHandlers(have_wheel_event_handlers_);
520 layer->SetNonFastScrollableRegion(non_fast_scrollable_region_);
521 layer->SetTouchEventHandlerRegion(touch_event_handler_region_);
522 layer->SetContentsOpaque(contents_opaque_);
523 layer->SetOpacity(opacity_);
524 layer->SetBlendMode(blend_mode_);
525 layer->SetIsRootForIsolatedGroup(is_root_for_isolated_group_);
526 layer->SetPosition(position_);
527 layer->SetIsContainerForFixedPositionLayers(
528 is_container_for_fixed_position_layers_);
529 layer->SetFixedContainerSizeDelta(fixed_container_size_delta_);
530 layer->SetPositionConstraint(position_constraint_);
531 layer->SetPreserves3d(preserves_3d());
532 layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_);
533 layer->SetSublayerTransform(sublayer_transform_);
534 layer->SetTransform(transform_);
535
536 layer->SetScrollable(scrollable_);
537 layer->set_user_scrollable_horizontal(user_scrollable_horizontal_);
538 layer->set_user_scrollable_vertical(user_scrollable_vertical_);
539 layer->SetScrollOffsetAndDelta(
540 scroll_offset_, layer->ScrollDelta() - layer->sent_scroll_delta());
541 layer->SetSentScrollDelta(gfx::Vector2d());
542
543 layer->SetMaxScrollOffset(max_scroll_offset_);
544
545 LayerImpl* scroll_parent = NULL;
546 if (scroll_parent_)
547 scroll_parent = layer->layer_tree_impl()->LayerById(scroll_parent_->id());
548
549 layer->SetScrollParent(scroll_parent);
550 if (scroll_children_) {
551 std::set<LayerImpl*>* scroll_children = new std::set<LayerImpl*>;
552 for (std::set<LayerImpl*>::iterator it = scroll_children_->begin();
553 it != scroll_children_->end(); ++it)
554 scroll_children->insert(layer->layer_tree_impl()->LayerById((*it)->id()));
555 layer->SetScrollChildren(scroll_children);
556 }
557
558 LayerImpl* clip_parent = NULL;
559 if (clip_parent_) {
560 clip_parent = layer->layer_tree_impl()->LayerById(
561 clip_parent_->id());
562 }
563
564 layer->SetClipParent(clip_parent);
565 if (clip_children_) {
566 std::set<LayerImpl*>* clip_children = new std::set<LayerImpl*>;
567 for (std::set<LayerImpl*>::iterator it = clip_children_->begin();
568 it != clip_children_->end(); ++it)
569 clip_children->insert(layer->layer_tree_impl()->LayerById((*it)->id()));
570 layer->SetClipChildren(clip_children);
571 }
572
573 layer->PassCopyRequests(©_requests_);
574
575 // If the main thread commits multiple times before the impl thread actually
576 // draws, then damage tracking will become incorrect if we simply clobber the
577 // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
578 // union) any update changes that have occurred on the main thread.
579 update_rect_.Union(layer->update_rect());
580 layer->set_update_rect(update_rect_);
581
582 layer->SetStackingOrderChanged(stacking_order_changed_);
583
584 // Reset any state that should be cleared for the next update.
585 stacking_order_changed_ = false;
586 update_rect_ = gfx::RectF();
587
588 layer->SetDebugInfo(debug_info_);
589 }
590
LayerTreeAsJson() const591 base::DictionaryValue* LayerImpl::LayerTreeAsJson() const {
592 base::DictionaryValue* result = new base::DictionaryValue;
593 result->SetString("LayerType", LayerTypeAsString());
594
595 base::ListValue* list = new base::ListValue;
596 list->AppendInteger(bounds().width());
597 list->AppendInteger(bounds().height());
598 result->Set("Bounds", list);
599
600 list = new base::ListValue;
601 list->AppendDouble(position_.x());
602 list->AppendDouble(position_.y());
603 result->Set("Position", list);
604
605 const gfx::Transform& gfx_transform = draw_properties_.target_space_transform;
606 double transform[16];
607 gfx_transform.matrix().asColMajord(transform);
608 list = new base::ListValue;
609 for (int i = 0; i < 16; ++i)
610 list->AppendDouble(transform[i]);
611 result->Set("DrawTransform", list);
612
613 result->SetBoolean("DrawsContent", draws_content_);
614 result->SetDouble("Opacity", opacity());
615 result->SetBoolean("ContentsOpaque", contents_opaque_);
616
617 if (scrollable_)
618 result->SetBoolean("Scrollable", scrollable_);
619
620 if (have_wheel_event_handlers_)
621 result->SetBoolean("WheelHandler", have_wheel_event_handlers_);
622 if (!touch_event_handler_region_.IsEmpty()) {
623 scoped_ptr<base::Value> region = touch_event_handler_region_.AsValue();
624 result->Set("TouchRegion", region.release());
625 }
626
627 list = new base::ListValue;
628 for (size_t i = 0; i < children_.size(); ++i)
629 list->Append(children_[i]->LayerTreeAsJson());
630 result->Set("Children", list);
631
632 return result;
633 }
634
SetStackingOrderChanged(bool stacking_order_changed)635 void LayerImpl::SetStackingOrderChanged(bool stacking_order_changed) {
636 if (stacking_order_changed) {
637 stacking_order_changed_ = true;
638 NoteLayerPropertyChangedForSubtree();
639 }
640 }
641
NoteLayerPropertyChanged()642 void LayerImpl::NoteLayerPropertyChanged() {
643 layer_property_changed_ = true;
644 layer_tree_impl()->set_needs_update_draw_properties();
645 }
646
NoteLayerPropertyChangedForSubtree()647 void LayerImpl::NoteLayerPropertyChangedForSubtree() {
648 NoteLayerPropertyChanged();
649 NoteLayerPropertyChangedForDescendants();
650 }
651
NoteLayerPropertyChangedForDescendants()652 void LayerImpl::NoteLayerPropertyChangedForDescendants() {
653 layer_tree_impl()->set_needs_update_draw_properties();
654 for (size_t i = 0; i < children_.size(); ++i)
655 children_[i]->NoteLayerPropertyChangedForSubtree();
656 }
657
LayerTypeAsString() const658 const char* LayerImpl::LayerTypeAsString() const {
659 return "cc::LayerImpl";
660 }
661
ResetAllChangeTrackingForSubtree()662 void LayerImpl::ResetAllChangeTrackingForSubtree() {
663 layer_property_changed_ = false;
664
665 update_rect_ = gfx::RectF();
666
667 if (draw_properties_.render_surface)
668 draw_properties_.render_surface->ResetPropertyChangedFlag();
669
670 if (mask_layer_)
671 mask_layer_->ResetAllChangeTrackingForSubtree();
672
673 if (replica_layer_) {
674 // This also resets the replica mask, if it exists.
675 replica_layer_->ResetAllChangeTrackingForSubtree();
676 }
677
678 for (size_t i = 0; i < children_.size(); ++i)
679 children_[i]->ResetAllChangeTrackingForSubtree();
680 }
681
LayerIsAlwaysDamaged() const682 bool LayerImpl::LayerIsAlwaysDamaged() const {
683 return false;
684 }
685
ScrollOffsetForAnimation() const686 gfx::Vector2dF LayerImpl::ScrollOffsetForAnimation() const {
687 return TotalScrollOffset();
688 }
689
OnFilterAnimated(const FilterOperations & filters)690 void LayerImpl::OnFilterAnimated(const FilterOperations& filters) {
691 SetFilters(filters);
692 }
693
OnOpacityAnimated(float opacity)694 void LayerImpl::OnOpacityAnimated(float opacity) {
695 SetOpacity(opacity);
696 }
697
OnTransformAnimated(const gfx::Transform & transform)698 void LayerImpl::OnTransformAnimated(const gfx::Transform& transform) {
699 SetTransform(transform);
700 }
701
OnScrollOffsetAnimated(gfx::Vector2dF scroll_offset)702 void LayerImpl::OnScrollOffsetAnimated(gfx::Vector2dF scroll_offset) {
703 // Only layers in the active tree should need to do anything here, since
704 // layers in the pending tree will find out about these changes as a
705 // result of the call to SetScrollDelta.
706 if (!IsActive())
707 return;
708
709 SetScrollDelta(scroll_offset - scroll_offset_);
710
711 layer_tree_impl_->DidAnimateScrollOffset();
712 }
713
OnAnimationWaitingForDeletion()714 void LayerImpl::OnAnimationWaitingForDeletion() {}
715
IsActive() const716 bool LayerImpl::IsActive() const {
717 return layer_tree_impl_->IsActiveTree();
718 }
719
SetBounds(gfx::Size bounds)720 void LayerImpl::SetBounds(gfx::Size bounds) {
721 if (bounds_ == bounds)
722 return;
723
724 bounds_ = bounds;
725
726 if (masks_to_bounds())
727 NoteLayerPropertyChangedForSubtree();
728 else
729 NoteLayerPropertyChanged();
730 }
731
SetMaskLayer(scoped_ptr<LayerImpl> mask_layer)732 void LayerImpl::SetMaskLayer(scoped_ptr<LayerImpl> mask_layer) {
733 int new_layer_id = mask_layer ? mask_layer->id() : -1;
734
735 if (mask_layer) {
736 DCHECK_EQ(layer_tree_impl(), mask_layer->layer_tree_impl());
737 DCHECK_NE(new_layer_id, mask_layer_id_);
738 } else if (new_layer_id == mask_layer_id_) {
739 return;
740 }
741
742 mask_layer_ = mask_layer.Pass();
743 mask_layer_id_ = new_layer_id;
744 if (mask_layer_)
745 mask_layer_->set_parent(this);
746 NoteLayerPropertyChangedForSubtree();
747 }
748
TakeMaskLayer()749 scoped_ptr<LayerImpl> LayerImpl::TakeMaskLayer() {
750 mask_layer_id_ = -1;
751 return mask_layer_.Pass();
752 }
753
SetReplicaLayer(scoped_ptr<LayerImpl> replica_layer)754 void LayerImpl::SetReplicaLayer(scoped_ptr<LayerImpl> replica_layer) {
755 int new_layer_id = replica_layer ? replica_layer->id() : -1;
756
757 if (replica_layer) {
758 DCHECK_EQ(layer_tree_impl(), replica_layer->layer_tree_impl());
759 DCHECK_NE(new_layer_id, replica_layer_id_);
760 } else if (new_layer_id == replica_layer_id_) {
761 return;
762 }
763
764 replica_layer_ = replica_layer.Pass();
765 replica_layer_id_ = new_layer_id;
766 if (replica_layer_)
767 replica_layer_->set_parent(this);
768 NoteLayerPropertyChangedForSubtree();
769 }
770
TakeReplicaLayer()771 scoped_ptr<LayerImpl> LayerImpl::TakeReplicaLayer() {
772 replica_layer_id_ = -1;
773 return replica_layer_.Pass();
774 }
775
ToScrollbarLayer()776 ScrollbarLayerImplBase* LayerImpl::ToScrollbarLayer() {
777 return NULL;
778 }
779
SetDrawsContent(bool draws_content)780 void LayerImpl::SetDrawsContent(bool draws_content) {
781 if (draws_content_ == draws_content)
782 return;
783
784 draws_content_ = draws_content;
785 NoteLayerPropertyChanged();
786 }
787
SetHideLayerAndSubtree(bool hide)788 void LayerImpl::SetHideLayerAndSubtree(bool hide) {
789 if (hide_layer_and_subtree_ == hide)
790 return;
791
792 hide_layer_and_subtree_ = hide;
793 NoteLayerPropertyChangedForSubtree();
794 }
795
SetAnchorPoint(gfx::PointF anchor_point)796 void LayerImpl::SetAnchorPoint(gfx::PointF anchor_point) {
797 if (anchor_point_ == anchor_point)
798 return;
799
800 anchor_point_ = anchor_point;
801 NoteLayerPropertyChangedForSubtree();
802 }
803
SetAnchorPointZ(float anchor_point_z)804 void LayerImpl::SetAnchorPointZ(float anchor_point_z) {
805 if (anchor_point_z_ == anchor_point_z)
806 return;
807
808 anchor_point_z_ = anchor_point_z;
809 NoteLayerPropertyChangedForSubtree();
810 }
811
SetBackgroundColor(SkColor background_color)812 void LayerImpl::SetBackgroundColor(SkColor background_color) {
813 if (background_color_ == background_color)
814 return;
815
816 background_color_ = background_color;
817 NoteLayerPropertyChanged();
818 }
819
SafeOpaqueBackgroundColor() const820 SkColor LayerImpl::SafeOpaqueBackgroundColor() const {
821 SkColor color = background_color();
822 if (SkColorGetA(color) == 255 && !contents_opaque()) {
823 color = SK_ColorTRANSPARENT;
824 } else if (SkColorGetA(color) != 255 && contents_opaque()) {
825 for (const LayerImpl* layer = parent(); layer;
826 layer = layer->parent()) {
827 color = layer->background_color();
828 if (SkColorGetA(color) == 255)
829 break;
830 }
831 if (SkColorGetA(color) != 255)
832 color = layer_tree_impl()->background_color();
833 if (SkColorGetA(color) != 255)
834 color = SkColorSetA(color, 255);
835 }
836 return color;
837 }
838
SetFilters(const FilterOperations & filters)839 void LayerImpl::SetFilters(const FilterOperations& filters) {
840 if (filters_ == filters)
841 return;
842
843 filters_ = filters;
844 NoteLayerPropertyChangedForSubtree();
845 }
846
FilterIsAnimating() const847 bool LayerImpl::FilterIsAnimating() const {
848 return layer_animation_controller_->IsAnimatingProperty(Animation::Filter);
849 }
850
FilterIsAnimatingOnImplOnly() const851 bool LayerImpl::FilterIsAnimatingOnImplOnly() const {
852 Animation* filter_animation =
853 layer_animation_controller_->GetAnimation(Animation::Filter);
854 return filter_animation && filter_animation->is_impl_only();
855 }
856
SetBackgroundFilters(const FilterOperations & filters)857 void LayerImpl::SetBackgroundFilters(
858 const FilterOperations& filters) {
859 if (background_filters_ == filters)
860 return;
861
862 background_filters_ = filters;
863 NoteLayerPropertyChanged();
864 }
865
SetMasksToBounds(bool masks_to_bounds)866 void LayerImpl::SetMasksToBounds(bool masks_to_bounds) {
867 if (masks_to_bounds_ == masks_to_bounds)
868 return;
869
870 masks_to_bounds_ = masks_to_bounds;
871 NoteLayerPropertyChangedForSubtree();
872 }
873
SetContentsOpaque(bool opaque)874 void LayerImpl::SetContentsOpaque(bool opaque) {
875 if (contents_opaque_ == opaque)
876 return;
877
878 contents_opaque_ = opaque;
879 NoteLayerPropertyChangedForSubtree();
880 }
881
SetOpacity(float opacity)882 void LayerImpl::SetOpacity(float opacity) {
883 if (opacity_ == opacity)
884 return;
885
886 opacity_ = opacity;
887 NoteLayerPropertyChangedForSubtree();
888 }
889
OpacityIsAnimating() const890 bool LayerImpl::OpacityIsAnimating() const {
891 return layer_animation_controller_->IsAnimatingProperty(Animation::Opacity);
892 }
893
OpacityIsAnimatingOnImplOnly() const894 bool LayerImpl::OpacityIsAnimatingOnImplOnly() const {
895 Animation* opacity_animation =
896 layer_animation_controller_->GetAnimation(Animation::Opacity);
897 return opacity_animation && opacity_animation->is_impl_only();
898 }
899
SetBlendMode(SkXfermode::Mode blend_mode)900 void LayerImpl::SetBlendMode(SkXfermode::Mode blend_mode) {
901 if (blend_mode_ == blend_mode)
902 return;
903
904 blend_mode_ = blend_mode;
905 NoteLayerPropertyChangedForSubtree();
906 }
907
SetIsRootForIsolatedGroup(bool root)908 void LayerImpl::SetIsRootForIsolatedGroup(bool root) {
909 if (is_root_for_isolated_group_ == root)
910 return;
911
912 is_root_for_isolated_group_ = root;
913 }
914
SetPosition(gfx::PointF position)915 void LayerImpl::SetPosition(gfx::PointF position) {
916 if (position_ == position)
917 return;
918
919 position_ = position;
920 NoteLayerPropertyChangedForSubtree();
921 }
922
SetPreserves3d(bool preserves3_d)923 void LayerImpl::SetPreserves3d(bool preserves3_d) {
924 if (preserves_3d_ == preserves3_d)
925 return;
926
927 preserves_3d_ = preserves3_d;
928 NoteLayerPropertyChangedForSubtree();
929 }
930
SetSublayerTransform(const gfx::Transform & sublayer_transform)931 void LayerImpl::SetSublayerTransform(const gfx::Transform& sublayer_transform) {
932 if (sublayer_transform_ == sublayer_transform)
933 return;
934
935 sublayer_transform_ = sublayer_transform;
936 // Sublayer transform does not affect the current layer; it affects only its
937 // children.
938 NoteLayerPropertyChangedForDescendants();
939 }
940
SetTransform(const gfx::Transform & transform)941 void LayerImpl::SetTransform(const gfx::Transform& transform) {
942 if (transform_ == transform)
943 return;
944
945 transform_ = transform;
946 NoteLayerPropertyChangedForSubtree();
947 }
948
TransformIsAnimating() const949 bool LayerImpl::TransformIsAnimating() const {
950 return layer_animation_controller_->IsAnimatingProperty(Animation::Transform);
951 }
952
TransformIsAnimatingOnImplOnly() const953 bool LayerImpl::TransformIsAnimatingOnImplOnly() const {
954 Animation* transform_animation =
955 layer_animation_controller_->GetAnimation(Animation::Transform);
956 return transform_animation && transform_animation->is_impl_only();
957 }
958
SetContentBounds(gfx::Size content_bounds)959 void LayerImpl::SetContentBounds(gfx::Size content_bounds) {
960 if (this->content_bounds() == content_bounds)
961 return;
962
963 draw_properties_.content_bounds = content_bounds;
964 NoteLayerPropertyChanged();
965 }
966
SetContentsScale(float contents_scale_x,float contents_scale_y)967 void LayerImpl::SetContentsScale(float contents_scale_x,
968 float contents_scale_y) {
969 if (this->contents_scale_x() == contents_scale_x &&
970 this->contents_scale_y() == contents_scale_y)
971 return;
972
973 draw_properties_.contents_scale_x = contents_scale_x;
974 draw_properties_.contents_scale_y = contents_scale_y;
975 NoteLayerPropertyChanged();
976 }
977
CalculateContentsScale(float ideal_contents_scale,float device_scale_factor,float page_scale_factor,bool animating_transform_to_screen,float * contents_scale_x,float * contents_scale_y,gfx::Size * content_bounds)978 void LayerImpl::CalculateContentsScale(
979 float ideal_contents_scale,
980 float device_scale_factor,
981 float page_scale_factor,
982 bool animating_transform_to_screen,
983 float* contents_scale_x,
984 float* contents_scale_y,
985 gfx::Size* content_bounds) {
986 // Base LayerImpl has all of its content scales and content bounds pushed
987 // from its Layer during commit and just reuses those values as-is.
988 *contents_scale_x = this->contents_scale_x();
989 *contents_scale_y = this->contents_scale_y();
990 *content_bounds = this->content_bounds();
991 }
992
UpdateScrollbarPositions()993 void LayerImpl::UpdateScrollbarPositions() {
994 gfx::Vector2dF current_offset = scroll_offset_ + ScrollDelta();
995
996 gfx::RectF viewport(PointAtOffsetFromOrigin(current_offset), bounds_);
997 gfx::SizeF scrollable_size(max_scroll_offset_.x() + bounds_.width(),
998 max_scroll_offset_.y() + bounds_.height());
999 if (horizontal_scrollbar_layer_) {
1000 horizontal_scrollbar_layer_->SetCurrentPos(current_offset.x());
1001 horizontal_scrollbar_layer_->SetMaximum(max_scroll_offset_.x());
1002 horizontal_scrollbar_layer_->SetVisibleToTotalLengthRatio(
1003 viewport.width() / scrollable_size.width());
1004 }
1005 if (vertical_scrollbar_layer_) {
1006 vertical_scrollbar_layer_->SetCurrentPos(current_offset.y());
1007 vertical_scrollbar_layer_->SetMaximum(max_scroll_offset_.y());
1008 vertical_scrollbar_layer_->SetVisibleToTotalLengthRatio(
1009 viewport.height() / scrollable_size.height());
1010 }
1011
1012 if (current_offset == last_scroll_offset_)
1013 return;
1014 last_scroll_offset_ = current_offset;
1015
1016 if (scrollbar_animation_controller_) {
1017 bool should_animate = scrollbar_animation_controller_->DidScrollUpdate(
1018 layer_tree_impl_->CurrentPhysicalTimeTicks());
1019 if (should_animate)
1020 layer_tree_impl_->StartScrollbarAnimation();
1021 }
1022
1023 // Get the current_offset_.y() value for a sanity-check on scrolling
1024 // benchmark metrics. Specifically, we want to make sure
1025 // BasicMouseWheelSmoothScrollGesture has proper scroll curves.
1026 if (layer_tree_impl()->IsActiveTree()) {
1027 TRACE_COUNTER_ID1("gpu", "scroll_offset_y", this->id(), current_offset.y());
1028 }
1029 }
1030
SetScrollOffsetDelegate(LayerScrollOffsetDelegate * scroll_offset_delegate)1031 void LayerImpl::SetScrollOffsetDelegate(
1032 LayerScrollOffsetDelegate* scroll_offset_delegate) {
1033 // Having both a scroll parent and a scroll offset delegate is unsupported.
1034 DCHECK(!scroll_parent_);
1035 if (!scroll_offset_delegate && scroll_offset_delegate_) {
1036 scroll_delta_ =
1037 scroll_offset_delegate_->GetTotalScrollOffset() - scroll_offset_;
1038 }
1039 gfx::Vector2dF total_offset = TotalScrollOffset();
1040 scroll_offset_delegate_ = scroll_offset_delegate;
1041 if (scroll_offset_delegate_) {
1042 scroll_offset_delegate_->SetMaxScrollOffset(max_scroll_offset_);
1043 scroll_offset_delegate_->SetTotalScrollOffset(total_offset);
1044 }
1045 }
1046
IsExternalFlingActive() const1047 bool LayerImpl::IsExternalFlingActive() const {
1048 return scroll_offset_delegate_ &&
1049 scroll_offset_delegate_->IsExternalFlingActive();
1050 }
1051
SetScrollOffset(gfx::Vector2d scroll_offset)1052 void LayerImpl::SetScrollOffset(gfx::Vector2d scroll_offset) {
1053 SetScrollOffsetAndDelta(scroll_offset, ScrollDelta());
1054 }
1055
SetScrollOffsetAndDelta(gfx::Vector2d scroll_offset,gfx::Vector2dF scroll_delta)1056 void LayerImpl::SetScrollOffsetAndDelta(gfx::Vector2d scroll_offset,
1057 gfx::Vector2dF scroll_delta) {
1058 bool changed = false;
1059
1060 if (scroll_offset_ != scroll_offset) {
1061 changed = true;
1062 scroll_offset_ = scroll_offset;
1063
1064 if (scroll_offset_delegate_)
1065 scroll_offset_delegate_->SetTotalScrollOffset(TotalScrollOffset());
1066 }
1067
1068 if (ScrollDelta() != scroll_delta) {
1069 changed = true;
1070 if (layer_tree_impl()->IsActiveTree()) {
1071 LayerImpl* pending_twin =
1072 layer_tree_impl()->FindPendingTreeLayerById(id());
1073 if (pending_twin) {
1074 // The pending twin can't mirror the scroll delta of the active
1075 // layer. Although the delta - sent scroll delta difference is
1076 // identical for both twins, the sent scroll delta for the pending
1077 // layer is zero, as anything that has been sent has been baked
1078 // into the layer's position/scroll offset as a part of commit.
1079 DCHECK(pending_twin->sent_scroll_delta().IsZero());
1080 pending_twin->SetScrollDelta(scroll_delta - sent_scroll_delta());
1081 }
1082 }
1083
1084 if (scroll_offset_delegate_) {
1085 scroll_offset_delegate_->SetTotalScrollOffset(scroll_offset_ +
1086 scroll_delta);
1087 } else {
1088 scroll_delta_ = scroll_delta;
1089 }
1090 }
1091
1092 if (changed) {
1093 NoteLayerPropertyChangedForSubtree();
1094 UpdateScrollbarPositions();
1095 }
1096 }
1097
ScrollDelta() const1098 gfx::Vector2dF LayerImpl::ScrollDelta() const {
1099 if (scroll_offset_delegate_)
1100 return scroll_offset_delegate_->GetTotalScrollOffset() - scroll_offset_;
1101 return scroll_delta_;
1102 }
1103
SetScrollDelta(gfx::Vector2dF scroll_delta)1104 void LayerImpl::SetScrollDelta(gfx::Vector2dF scroll_delta) {
1105 SetScrollOffsetAndDelta(scroll_offset_, scroll_delta);
1106 }
1107
TotalScrollOffset() const1108 gfx::Vector2dF LayerImpl::TotalScrollOffset() const {
1109 return scroll_offset_ + ScrollDelta();
1110 }
1111
SetDoubleSided(bool double_sided)1112 void LayerImpl::SetDoubleSided(bool double_sided) {
1113 if (double_sided_ == double_sided)
1114 return;
1115
1116 double_sided_ = double_sided;
1117 NoteLayerPropertyChangedForSubtree();
1118 }
1119
VisibleContentOpaqueRegion() const1120 Region LayerImpl::VisibleContentOpaqueRegion() const {
1121 if (contents_opaque())
1122 return visible_content_rect();
1123 return Region();
1124 }
1125
DidBeginTracing()1126 void LayerImpl::DidBeginTracing() {}
1127
DidLoseOutputSurface()1128 void LayerImpl::DidLoseOutputSurface() {}
1129
SetMaxScrollOffset(gfx::Vector2d max_scroll_offset)1130 void LayerImpl::SetMaxScrollOffset(gfx::Vector2d max_scroll_offset) {
1131 if (max_scroll_offset_ == max_scroll_offset)
1132 return;
1133 max_scroll_offset_ = max_scroll_offset;
1134
1135 if (scroll_offset_delegate_)
1136 scroll_offset_delegate_->SetMaxScrollOffset(max_scroll_offset_);
1137
1138 layer_tree_impl()->set_needs_update_draw_properties();
1139 UpdateScrollbarPositions();
1140 }
1141
DidBecomeActive()1142 void LayerImpl::DidBecomeActive() {
1143 if (layer_tree_impl_->settings().scrollbar_animator ==
1144 LayerTreeSettings::NoAnimator) {
1145 return;
1146 }
1147
1148 bool need_scrollbar_animation_controller = horizontal_scrollbar_layer_ ||
1149 vertical_scrollbar_layer_;
1150 if (!need_scrollbar_animation_controller) {
1151 scrollbar_animation_controller_.reset();
1152 return;
1153 }
1154
1155 if (scrollbar_animation_controller_)
1156 return;
1157
1158 switch (layer_tree_impl_->settings().scrollbar_animator) {
1159 case LayerTreeSettings::LinearFade: {
1160 base::TimeDelta fadeout_delay = base::TimeDelta::FromMilliseconds(
1161 layer_tree_impl_->settings().scrollbar_linear_fade_delay_ms);
1162 base::TimeDelta fadeout_length = base::TimeDelta::FromMilliseconds(
1163 layer_tree_impl_->settings().scrollbar_linear_fade_length_ms);
1164
1165 scrollbar_animation_controller_ =
1166 ScrollbarAnimationControllerLinearFade::Create(
1167 this, fadeout_delay, fadeout_length)
1168 .PassAs<ScrollbarAnimationController>();
1169 break;
1170 }
1171 case LayerTreeSettings::Thinning: {
1172 scrollbar_animation_controller_ =
1173 ScrollbarAnimationControllerThinning::Create(this)
1174 .PassAs<ScrollbarAnimationController>();
1175 break;
1176 }
1177 case LayerTreeSettings::NoAnimator:
1178 NOTREACHED();
1179 break;
1180 }
1181 }
SetHorizontalScrollbarLayer(ScrollbarLayerImplBase * scrollbar_layer)1182 void LayerImpl::SetHorizontalScrollbarLayer(
1183 ScrollbarLayerImplBase* scrollbar_layer) {
1184 horizontal_scrollbar_layer_ = scrollbar_layer;
1185 if (horizontal_scrollbar_layer_)
1186 horizontal_scrollbar_layer_->set_scroll_layer_id(id());
1187 }
1188
SetVerticalScrollbarLayer(ScrollbarLayerImplBase * scrollbar_layer)1189 void LayerImpl::SetVerticalScrollbarLayer(
1190 ScrollbarLayerImplBase* scrollbar_layer) {
1191 vertical_scrollbar_layer_ = scrollbar_layer;
1192 if (vertical_scrollbar_layer_)
1193 vertical_scrollbar_layer_->set_scroll_layer_id(id());
1194 }
1195
1196 static scoped_ptr<base::Value>
CompositingReasonsAsValue(CompositingReasons reasons)1197 CompositingReasonsAsValue(CompositingReasons reasons) {
1198 scoped_ptr<base::ListValue> reason_list(new base::ListValue());
1199
1200 if (reasons == kCompositingReasonUnknown) {
1201 reason_list->AppendString("No reasons given");
1202 return reason_list.PassAs<base::Value>();
1203 }
1204
1205 if (reasons & kCompositingReason3DTransform)
1206 reason_list->AppendString("Has a 3d Transform");
1207
1208 if (reasons & kCompositingReasonVideo)
1209 reason_list->AppendString("Is accelerated video");
1210
1211 if (reasons & kCompositingReasonCanvas)
1212 reason_list->AppendString("Is accelerated canvas");
1213
1214 if (reasons & kCompositingReasonPlugin)
1215 reason_list->AppendString("Is accelerated plugin");
1216
1217 if (reasons & kCompositingReasonIFrame)
1218 reason_list->AppendString("Is accelerated iframe");
1219
1220 if (reasons & kCompositingReasonBackfaceVisibilityHidden)
1221 reason_list->AppendString("Has backface-visibility: hidden");
1222
1223 if (reasons & kCompositingReasonAnimation)
1224 reason_list->AppendString("Has accelerated animation or transition");
1225
1226 if (reasons & kCompositingReasonFilters)
1227 reason_list->AppendString("Has accelerated filters");
1228
1229 if (reasons & kCompositingReasonPositionFixed)
1230 reason_list->AppendString("Is fixed position");
1231
1232 if (reasons & kCompositingReasonPositionSticky)
1233 reason_list->AppendString("Is sticky position");
1234
1235 if (reasons & kCompositingReasonOverflowScrollingTouch)
1236 reason_list->AppendString("Is a scrollable overflow element");
1237
1238 if (reasons & kCompositingReasonAssumedOverlap)
1239 reason_list->AppendString("Might overlap a composited animation");
1240
1241 if (reasons & kCompositingReasonOverlap)
1242 reason_list->AppendString("Overlaps other composited content");
1243
1244 if (reasons & kCompositingReasonNegativeZIndexChildren) {
1245 reason_list->AppendString("Might overlap negative z-index "
1246 "composited content");
1247 }
1248
1249 if (reasons & kCompositingReasonTransformWithCompositedDescendants) {
1250 reason_list->AppendString("Has transform needed by a "
1251 "composited descendant");
1252 }
1253
1254 if (reasons & kCompositingReasonOpacityWithCompositedDescendants)
1255 reason_list->AppendString("Has opacity needed by a composited descendant");
1256
1257 if (reasons & kCompositingReasonMaskWithCompositedDescendants)
1258 reason_list->AppendString("Has a mask needed by a composited descendant");
1259
1260 if (reasons & kCompositingReasonReflectionWithCompositedDescendants)
1261 reason_list->AppendString("Has a reflection with a composited descendant");
1262
1263 if (reasons & kCompositingReasonFilterWithCompositedDescendants)
1264 reason_list->AppendString("Has filter effect with a composited descendant");
1265
1266 if (reasons & kCompositingReasonBlendingWithCompositedDescendants)
1267 reason_list->AppendString("Has a blend mode with a composited descendant");
1268
1269 if (reasons & kCompositingReasonClipsCompositingDescendants)
1270 reason_list->AppendString("Clips a composited descendant");
1271
1272 if (reasons & kCompositingReasonPerspective) {
1273 reason_list->AppendString("Has a perspective transform needed by a "
1274 "composited 3d descendant");
1275 }
1276
1277 if (reasons & kCompositingReasonPreserve3D) {
1278 reason_list->AppendString("Has preserves-3d style with composited "
1279 "3d descendant");
1280 }
1281
1282 if (reasons & kCompositingReasonReflectionOfCompositedParent)
1283 reason_list->AppendString("Is the reflection of a composited layer");
1284
1285 if (reasons & kCompositingReasonRoot)
1286 reason_list->AppendString("Is the root");
1287
1288 if (reasons & kCompositingReasonLayerForClip)
1289 reason_list->AppendString("Convenience layer, to clip subtree");
1290
1291 if (reasons & kCompositingReasonLayerForScrollbar)
1292 reason_list->AppendString("Convenience layer for rendering scrollbar");
1293
1294 if (reasons & kCompositingReasonLayerForScrollingContainer)
1295 reason_list->AppendString("Convenience layer, the scrolling container");
1296
1297 if (reasons & kCompositingReasonLayerForForeground) {
1298 reason_list->AppendString("Convenience layer, foreground when main layer "
1299 "has negative z-index composited content");
1300 }
1301
1302 if (reasons & kCompositingReasonLayerForBackground) {
1303 reason_list->AppendString("Convenience layer, background when main layer "
1304 "has a composited background");
1305 }
1306
1307 if (reasons & kCompositingReasonLayerForMask)
1308 reason_list->AppendString("Is a mask layer");
1309
1310 if (reasons & kCompositingReasonOverflowScrollingParent)
1311 reason_list->AppendString("Scroll parent is not an ancestor");
1312
1313 if (reasons & kCompositingReasonOutOfFlowClipping)
1314 reason_list->AppendString("Has clipping ancestor");
1315
1316 if (reasons & kCompositingReasonIsolateCompositedDescendants)
1317 reason_list->AppendString("Should isolate composited descendants");
1318
1319 return reason_list.PassAs<base::Value>();
1320 }
1321
AsValueInto(base::DictionaryValue * state) const1322 void LayerImpl::AsValueInto(base::DictionaryValue* state) const {
1323 TracedValue::MakeDictIntoImplicitSnapshot(state, LayerTypeAsString(), this);
1324 state->SetInteger("layer_id", id());
1325 state->SetString("layer_name", debug_name());
1326 state->Set("bounds", MathUtil::AsValue(bounds()).release());
1327 state->SetInteger("draws_content", DrawsContent());
1328 state->SetInteger("gpu_memory_usage", GPUMemoryUsageInBytes());
1329 state->Set("compositing_reasons",
1330 CompositingReasonsAsValue(compositing_reasons_).release());
1331
1332 bool clipped;
1333 gfx::QuadF layer_quad = MathUtil::MapQuad(
1334 screen_space_transform(),
1335 gfx::QuadF(gfx::Rect(content_bounds())),
1336 &clipped);
1337 state->Set("layer_quad", MathUtil::AsValue(layer_quad).release());
1338
1339 if (!touch_event_handler_region_.IsEmpty()) {
1340 state->Set("touch_event_handler_region",
1341 touch_event_handler_region_.AsValue().release());
1342 }
1343 if (have_wheel_event_handlers_) {
1344 gfx::Rect wheel_rect(content_bounds());
1345 Region wheel_region(wheel_rect);
1346 state->Set("wheel_event_handler_region",
1347 wheel_region.AsValue().release());
1348 }
1349 if (!non_fast_scrollable_region_.IsEmpty()) {
1350 state->Set("non_fast_scrollable_region",
1351 non_fast_scrollable_region_.AsValue().release());
1352 }
1353
1354 scoped_ptr<base::ListValue> children_list(new base::ListValue());
1355 for (size_t i = 0; i < children_.size(); ++i)
1356 children_list->Append(children_[i]->AsValue().release());
1357 state->Set("children", children_list.release());
1358 if (mask_layer_)
1359 state->Set("mask_layer", mask_layer_->AsValue().release());
1360 if (replica_layer_)
1361 state->Set("replica_layer", replica_layer_->AsValue().release());
1362
1363 if (scroll_parent_)
1364 state->SetInteger("scroll_parent", scroll_parent_->id());
1365
1366 if (clip_parent_)
1367 state->SetInteger("clip_parent", clip_parent_->id());
1368
1369 state->SetBoolean("can_use_lcd_text", can_use_lcd_text());
1370 state->SetBoolean("contents_opaque", contents_opaque());
1371
1372 if (layer_animation_controller_->IsAnimatingProperty(Animation::Transform) ||
1373 layer_animation_controller_->IsAnimatingProperty(Animation::Filter)) {
1374 gfx::BoxF box(bounds().width(), bounds().height(), 0.f);
1375 gfx::BoxF inflated;
1376 if (layer_animation_controller_->AnimatedBoundsForBox(box, &inflated))
1377 state->Set("animated_bounds", MathUtil::AsValue(inflated).release());
1378 }
1379
1380 if (debug_info_.get()) {
1381 std::string str;
1382 debug_info_->AppendAsTraceFormat(&str);
1383 base::JSONReader json_reader;
1384 // Parsing the JSON and re-encoding it is not very efficient,
1385 // but it's the simplest way to achieve the desired effect, which
1386 // is to output:
1387 // {..., layout_rects: [{geometry_rect: ...}, ...], ...}
1388 // rather than:
1389 // {layout_rects: "[{geometry_rect: ...}, ...]", ...}
1390 state->Set("layout_rects", json_reader.ReadToValue(str));
1391 }
1392 }
1393
GPUMemoryUsageInBytes() const1394 size_t LayerImpl::GPUMemoryUsageInBytes() const { return 0; }
1395
AsValue() const1396 scoped_ptr<base::Value> LayerImpl::AsValue() const {
1397 scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
1398 AsValueInto(state.get());
1399 return state.PassAs<base::Value>();
1400 }
1401
RunMicroBenchmark(MicroBenchmarkImpl * benchmark)1402 void LayerImpl::RunMicroBenchmark(MicroBenchmarkImpl* benchmark) {
1403 benchmark->RunOnLayer(this);
1404 }
1405
1406 } // namespace cc
1407