1// Copyright 2010 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.h" 6 7#include <algorithm> 8 9#include "base/debug/trace_event.h" 10#include "base/location.h" 11#include "base/metrics/histogram.h" 12#include "base/single_thread_task_runner.h" 13#include "cc/animation/animation.h" 14#include "cc/animation/animation_events.h" 15#include "cc/animation/keyframed_animation_curve.h" 16#include "cc/animation/layer_animation_controller.h" 17#include "cc/layers/layer_client.h" 18#include "cc/layers/layer_impl.h" 19#include "cc/output/copy_output_request.h" 20#include "cc/output/copy_output_result.h" 21#include "cc/trees/layer_tree_host.h" 22#include "cc/trees/layer_tree_impl.h" 23#include "third_party/skia/include/core/SkImageFilter.h" 24#include "ui/gfx/rect_conversions.h" 25 26namespace cc { 27 28static int s_next_layer_id = 1; 29 30scoped_refptr<Layer> Layer::Create() { 31 return make_scoped_refptr(new Layer()); 32} 33 34Layer::Layer() 35 : needs_push_properties_(false), 36 num_dependents_need_push_properties_(false), 37 stacking_order_changed_(false), 38 layer_id_(s_next_layer_id++), 39 ignore_set_needs_commit_(false), 40 parent_(NULL), 41 layer_tree_host_(NULL), 42 scrollable_(false), 43 should_scroll_on_main_thread_(false), 44 have_wheel_event_handlers_(false), 45 user_scrollable_horizontal_(true), 46 user_scrollable_vertical_(true), 47 is_root_for_isolated_group_(false), 48 is_container_for_fixed_position_layers_(false), 49 is_drawable_(false), 50 hide_layer_and_subtree_(false), 51 masks_to_bounds_(false), 52 contents_opaque_(false), 53 double_sided_(true), 54 preserves_3d_(false), 55 use_parent_backface_visibility_(false), 56 draw_checkerboard_for_missing_tiles_(false), 57 force_render_surface_(false), 58 anchor_point_(0.5f, 0.5f), 59 background_color_(0), 60 compositing_reasons_(kCompositingReasonUnknown), 61 opacity_(1.f), 62 blend_mode_(SkXfermode::kSrcOver_Mode), 63 anchor_point_z_(0.f), 64 scroll_parent_(NULL), 65 clip_parent_(NULL), 66 replica_layer_(NULL), 67 raster_scale_(0.f), 68 client_(NULL) { 69 if (layer_id_ < 0) { 70 s_next_layer_id = 1; 71 layer_id_ = s_next_layer_id++; 72 } 73 74 layer_animation_controller_ = LayerAnimationController::Create(layer_id_); 75 layer_animation_controller_->AddValueObserver(this); 76 layer_animation_controller_->set_value_provider(this); 77} 78 79Layer::~Layer() { 80 // Our parent should be holding a reference to us so there should be no 81 // way for us to be destroyed while we still have a parent. 82 DCHECK(!parent()); 83 // Similarly we shouldn't have a layer tree host since it also keeps a 84 // reference to us. 85 DCHECK(!layer_tree_host()); 86 87 layer_animation_controller_->RemoveValueObserver(this); 88 layer_animation_controller_->remove_value_provider(this); 89 90 // Remove the parent reference from all children and dependents. 91 RemoveAllChildren(); 92 if (mask_layer_.get()) { 93 DCHECK_EQ(this, mask_layer_->parent()); 94 mask_layer_->RemoveFromParent(); 95 } 96 if (replica_layer_.get()) { 97 DCHECK_EQ(this, replica_layer_->parent()); 98 replica_layer_->RemoveFromParent(); 99 } 100 101 RemoveFromScrollTree(); 102 RemoveFromClipTree(); 103} 104 105void Layer::SetLayerTreeHost(LayerTreeHost* host) { 106 if (layer_tree_host_ == host) 107 return; 108 109 layer_tree_host_ = host; 110 111 // When changing hosts, the layer needs to commit its properties to the impl 112 // side for the new host. 113 SetNeedsPushProperties(); 114 115 for (size_t i = 0; i < children_.size(); ++i) 116 children_[i]->SetLayerTreeHost(host); 117 118 if (mask_layer_.get()) 119 mask_layer_->SetLayerTreeHost(host); 120 if (replica_layer_.get()) 121 replica_layer_->SetLayerTreeHost(host); 122 123 if (host) { 124 layer_animation_controller_->SetAnimationRegistrar( 125 host->animation_registrar()); 126 127 if (host->settings().layer_transforms_should_scale_layer_contents) 128 reset_raster_scale_to_unknown(); 129 } 130 131 if (host && layer_animation_controller_->has_any_animation()) 132 host->SetNeedsCommit(); 133 SetNeedsFilterContextIfNeeded(); 134} 135 136void Layer::SetNeedsUpdate() { 137 if (layer_tree_host_ && !ignore_set_needs_commit_) 138 layer_tree_host_->SetNeedsUpdateLayers(); 139} 140 141void Layer::SetNeedsCommit() { 142 if (!layer_tree_host_) 143 return; 144 145 SetNeedsPushProperties(); 146 147 if (ignore_set_needs_commit_) 148 return; 149 150 layer_tree_host_->SetNeedsCommit(); 151} 152 153void Layer::SetNeedsFullTreeSync() { 154 if (!layer_tree_host_) 155 return; 156 157 layer_tree_host_->SetNeedsFullTreeSync(); 158} 159 160void Layer::SetNextCommitWaitsForActivation() { 161 if (!layer_tree_host_) 162 return; 163 164 layer_tree_host_->SetNextCommitWaitsForActivation(); 165} 166 167void Layer::SetNeedsFilterContextIfNeeded() { 168 if (!layer_tree_host_) 169 return; 170 171 if (!filters_.IsEmpty() || !background_filters_.IsEmpty() || 172 !uses_default_blend_mode()) 173 layer_tree_host_->set_needs_filter_context(); 174} 175 176void Layer::SetNeedsPushProperties() { 177 if (needs_push_properties_) 178 return; 179 if (!parent_should_know_need_push_properties() && parent_) 180 parent_->AddDependentNeedsPushProperties(); 181 needs_push_properties_ = true; 182} 183 184void Layer::AddDependentNeedsPushProperties() { 185 DCHECK_GE(num_dependents_need_push_properties_, 0); 186 187 if (!parent_should_know_need_push_properties() && parent_) 188 parent_->AddDependentNeedsPushProperties(); 189 190 num_dependents_need_push_properties_++; 191} 192 193void Layer::RemoveDependentNeedsPushProperties() { 194 num_dependents_need_push_properties_--; 195 DCHECK_GE(num_dependents_need_push_properties_, 0); 196 197 if (!parent_should_know_need_push_properties() && parent_) 198 parent_->RemoveDependentNeedsPushProperties(); 199} 200 201bool Layer::IsPropertyChangeAllowed() const { 202 if (!layer_tree_host_) 203 return true; 204 205 if (!layer_tree_host_->settings().strict_layer_property_change_checking) 206 return true; 207 208 return !layer_tree_host_->in_paint_layer_contents(); 209} 210 211gfx::Rect Layer::LayerRectToContentRect(const gfx::RectF& layer_rect) const { 212 gfx::RectF content_rect = 213 gfx::ScaleRect(layer_rect, contents_scale_x(), contents_scale_y()); 214 // Intersect with content rect to avoid the extra pixel because for some 215 // values x and y, ceil((x / y) * y) may be x + 1. 216 content_rect.Intersect(gfx::Rect(content_bounds())); 217 return gfx::ToEnclosingRect(content_rect); 218} 219 220skia::RefPtr<SkPicture> Layer::GetPicture() const { 221 return skia::RefPtr<SkPicture>(); 222} 223 224void Layer::SetParent(Layer* layer) { 225 DCHECK(!layer || !layer->HasAncestor(this)); 226 227 if (parent_should_know_need_push_properties()) { 228 if (parent_) 229 parent_->RemoveDependentNeedsPushProperties(); 230 if (layer) 231 layer->AddDependentNeedsPushProperties(); 232 } 233 234 parent_ = layer; 235 SetLayerTreeHost(parent_ ? parent_->layer_tree_host() : NULL); 236 237 if (!layer_tree_host_) 238 return; 239 const LayerTreeSettings& settings = layer_tree_host_->settings(); 240 if (!settings.layer_transforms_should_scale_layer_contents) 241 return; 242 243 reset_raster_scale_to_unknown(); 244 if (mask_layer_.get()) 245 mask_layer_->reset_raster_scale_to_unknown(); 246 if (replica_layer_.get() && replica_layer_->mask_layer_.get()) 247 replica_layer_->mask_layer_->reset_raster_scale_to_unknown(); 248} 249 250void Layer::AddChild(scoped_refptr<Layer> child) { 251 InsertChild(child, children_.size()); 252} 253 254void Layer::InsertChild(scoped_refptr<Layer> child, size_t index) { 255 DCHECK(IsPropertyChangeAllowed()); 256 child->RemoveFromParent(); 257 child->SetParent(this); 258 child->stacking_order_changed_ = true; 259 260 index = std::min(index, children_.size()); 261 children_.insert(children_.begin() + index, child); 262 SetNeedsFullTreeSync(); 263} 264 265void Layer::RemoveFromParent() { 266 DCHECK(IsPropertyChangeAllowed()); 267 if (parent_) 268 parent_->RemoveChildOrDependent(this); 269} 270 271void Layer::RemoveChildOrDependent(Layer* child) { 272 if (mask_layer_.get() == child) { 273 mask_layer_->SetParent(NULL); 274 mask_layer_ = NULL; 275 SetNeedsFullTreeSync(); 276 return; 277 } 278 if (replica_layer_.get() == child) { 279 replica_layer_->SetParent(NULL); 280 replica_layer_ = NULL; 281 SetNeedsFullTreeSync(); 282 return; 283 } 284 285 for (LayerList::iterator iter = children_.begin(); 286 iter != children_.end(); 287 ++iter) { 288 if (iter->get() != child) 289 continue; 290 291 child->SetParent(NULL); 292 children_.erase(iter); 293 SetNeedsFullTreeSync(); 294 return; 295 } 296} 297 298void Layer::ReplaceChild(Layer* reference, scoped_refptr<Layer> new_layer) { 299 DCHECK(reference); 300 DCHECK_EQ(reference->parent(), this); 301 DCHECK(IsPropertyChangeAllowed()); 302 303 if (reference == new_layer.get()) 304 return; 305 306 int reference_index = IndexOfChild(reference); 307 if (reference_index == -1) { 308 NOTREACHED(); 309 return; 310 } 311 312 reference->RemoveFromParent(); 313 314 if (new_layer.get()) { 315 new_layer->RemoveFromParent(); 316 InsertChild(new_layer, reference_index); 317 } 318} 319 320int Layer::IndexOfChild(const Layer* reference) { 321 for (size_t i = 0; i < children_.size(); ++i) { 322 if (children_[i].get() == reference) 323 return i; 324 } 325 return -1; 326} 327 328void Layer::SetBounds(gfx::Size size) { 329 DCHECK(IsPropertyChangeAllowed()); 330 if (bounds() == size) 331 return; 332 333 bounds_ = size; 334 SetNeedsCommit(); 335} 336 337Layer* Layer::RootLayer() { 338 Layer* layer = this; 339 while (layer->parent()) 340 layer = layer->parent(); 341 return layer; 342} 343 344void Layer::RemoveAllChildren() { 345 DCHECK(IsPropertyChangeAllowed()); 346 while (children_.size()) { 347 Layer* layer = children_[0].get(); 348 DCHECK_EQ(this, layer->parent()); 349 layer->RemoveFromParent(); 350 } 351} 352 353void Layer::SetChildren(const LayerList& children) { 354 DCHECK(IsPropertyChangeAllowed()); 355 if (children == children_) 356 return; 357 358 RemoveAllChildren(); 359 for (size_t i = 0; i < children.size(); ++i) 360 AddChild(children[i]); 361} 362 363bool Layer::HasAncestor(const Layer* ancestor) const { 364 for (const Layer* layer = parent(); layer; layer = layer->parent()) { 365 if (layer == ancestor) 366 return true; 367 } 368 return false; 369} 370 371void Layer::RequestCopyOfOutput( 372 scoped_ptr<CopyOutputRequest> request) { 373 DCHECK(IsPropertyChangeAllowed()); 374 if (request->IsEmpty()) 375 return; 376 copy_requests_.push_back(request.Pass()); 377 SetNeedsCommit(); 378} 379 380void Layer::SetAnchorPoint(gfx::PointF anchor_point) { 381 DCHECK(IsPropertyChangeAllowed()); 382 if (anchor_point_ == anchor_point) 383 return; 384 anchor_point_ = anchor_point; 385 SetNeedsCommit(); 386} 387 388void Layer::SetAnchorPointZ(float anchor_point_z) { 389 DCHECK(IsPropertyChangeAllowed()); 390 if (anchor_point_z_ == anchor_point_z) 391 return; 392 anchor_point_z_ = anchor_point_z; 393 SetNeedsCommit(); 394} 395 396void Layer::SetBackgroundColor(SkColor background_color) { 397 DCHECK(IsPropertyChangeAllowed()); 398 if (background_color_ == background_color) 399 return; 400 background_color_ = background_color; 401 SetNeedsCommit(); 402} 403 404SkColor Layer::SafeOpaqueBackgroundColor() const { 405 SkColor color = background_color(); 406 if (SkColorGetA(color) == 255 && !contents_opaque()) { 407 color = SK_ColorTRANSPARENT; 408 } else if (SkColorGetA(color) != 255 && contents_opaque()) { 409 for (const Layer* layer = parent(); layer; 410 layer = layer->parent()) { 411 color = layer->background_color(); 412 if (SkColorGetA(color) == 255) 413 break; 414 } 415 if (SkColorGetA(color) != 255) 416 color = layer_tree_host_->background_color(); 417 if (SkColorGetA(color) != 255) 418 color = SkColorSetA(color, 255); 419 } 420 return color; 421} 422 423void Layer::CalculateContentsScale( 424 float ideal_contents_scale, 425 float device_scale_factor, 426 float page_scale_factor, 427 bool animating_transform_to_screen, 428 float* contents_scale_x, 429 float* contents_scale_y, 430 gfx::Size* content_bounds) { 431 DCHECK(layer_tree_host_); 432 433 *contents_scale_x = 1; 434 *contents_scale_y = 1; 435 *content_bounds = bounds(); 436} 437 438void Layer::SetMasksToBounds(bool masks_to_bounds) { 439 DCHECK(IsPropertyChangeAllowed()); 440 if (masks_to_bounds_ == masks_to_bounds) 441 return; 442 masks_to_bounds_ = masks_to_bounds; 443 SetNeedsCommit(); 444} 445 446void Layer::SetMaskLayer(Layer* mask_layer) { 447 DCHECK(IsPropertyChangeAllowed()); 448 if (mask_layer_.get() == mask_layer) 449 return; 450 if (mask_layer_.get()) { 451 DCHECK_EQ(this, mask_layer_->parent()); 452 mask_layer_->RemoveFromParent(); 453 } 454 mask_layer_ = mask_layer; 455 if (mask_layer_.get()) { 456 DCHECK(!mask_layer_->parent()); 457 mask_layer_->RemoveFromParent(); 458 mask_layer_->SetParent(this); 459 mask_layer_->SetIsMask(true); 460 } 461 SetNeedsFullTreeSync(); 462} 463 464void Layer::SetReplicaLayer(Layer* layer) { 465 DCHECK(IsPropertyChangeAllowed()); 466 if (replica_layer_.get() == layer) 467 return; 468 if (replica_layer_.get()) { 469 DCHECK_EQ(this, replica_layer_->parent()); 470 replica_layer_->RemoveFromParent(); 471 } 472 replica_layer_ = layer; 473 if (replica_layer_.get()) { 474 DCHECK(!replica_layer_->parent()); 475 replica_layer_->RemoveFromParent(); 476 replica_layer_->SetParent(this); 477 } 478 SetNeedsFullTreeSync(); 479} 480 481void Layer::SetFilters(const FilterOperations& filters) { 482 DCHECK(IsPropertyChangeAllowed()); 483 if (filters_ == filters) 484 return; 485 filters_ = filters; 486 SetNeedsCommit(); 487 SetNeedsFilterContextIfNeeded(); 488} 489 490bool Layer::FilterIsAnimating() const { 491 return layer_animation_controller_->IsAnimatingProperty(Animation::Filter); 492} 493 494void Layer::SetBackgroundFilters(const FilterOperations& filters) { 495 DCHECK(IsPropertyChangeAllowed()); 496 if (background_filters_ == filters) 497 return; 498 background_filters_ = filters; 499 SetNeedsCommit(); 500 SetNeedsFilterContextIfNeeded(); 501} 502 503void Layer::SetOpacity(float opacity) { 504 DCHECK(IsPropertyChangeAllowed()); 505 if (opacity_ == opacity) 506 return; 507 opacity_ = opacity; 508 SetNeedsCommit(); 509} 510 511bool Layer::OpacityIsAnimating() const { 512 return layer_animation_controller_->IsAnimatingProperty(Animation::Opacity); 513} 514 515bool Layer::OpacityCanAnimateOnImplThread() const { 516 return false; 517} 518 519void Layer::SetBlendMode(SkXfermode::Mode blend_mode) { 520 DCHECK(IsPropertyChangeAllowed()); 521 if (blend_mode_ == blend_mode) 522 return; 523 524 // Allowing only blend modes that are defined in the CSS Compositing standard: 525 // http://dev.w3.org/fxtf/compositing-1/#blending 526 switch (blend_mode) { 527 case SkXfermode::kSrcOver_Mode: 528 case SkXfermode::kScreen_Mode: 529 case SkXfermode::kOverlay_Mode: 530 case SkXfermode::kDarken_Mode: 531 case SkXfermode::kLighten_Mode: 532 case SkXfermode::kColorDodge_Mode: 533 case SkXfermode::kColorBurn_Mode: 534 case SkXfermode::kHardLight_Mode: 535 case SkXfermode::kSoftLight_Mode: 536 case SkXfermode::kDifference_Mode: 537 case SkXfermode::kExclusion_Mode: 538 case SkXfermode::kMultiply_Mode: 539 case SkXfermode::kHue_Mode: 540 case SkXfermode::kSaturation_Mode: 541 case SkXfermode::kColor_Mode: 542 case SkXfermode::kLuminosity_Mode: 543 // supported blend modes 544 break; 545 case SkXfermode::kClear_Mode: 546 case SkXfermode::kSrc_Mode: 547 case SkXfermode::kDst_Mode: 548 case SkXfermode::kDstOver_Mode: 549 case SkXfermode::kSrcIn_Mode: 550 case SkXfermode::kDstIn_Mode: 551 case SkXfermode::kSrcOut_Mode: 552 case SkXfermode::kDstOut_Mode: 553 case SkXfermode::kSrcATop_Mode: 554 case SkXfermode::kDstATop_Mode: 555 case SkXfermode::kXor_Mode: 556 case SkXfermode::kPlus_Mode: 557 case SkXfermode::kModulate_Mode: 558 // Porter Duff Compositing Operators are not yet supported 559 // http://dev.w3.org/fxtf/compositing-1/#porterduffcompositingoperators 560 NOTREACHED(); 561 return; 562 } 563 564 blend_mode_ = blend_mode; 565 SetNeedsCommit(); 566 SetNeedsFilterContextIfNeeded(); 567} 568 569void Layer::SetIsRootForIsolatedGroup(bool root) { 570 DCHECK(IsPropertyChangeAllowed()); 571 if (is_root_for_isolated_group_ == root) 572 return; 573 is_root_for_isolated_group_ = root; 574 SetNeedsCommit(); 575} 576 577void Layer::SetContentsOpaque(bool opaque) { 578 DCHECK(IsPropertyChangeAllowed()); 579 if (contents_opaque_ == opaque) 580 return; 581 contents_opaque_ = opaque; 582 SetNeedsCommit(); 583} 584 585void Layer::SetPosition(gfx::PointF position) { 586 DCHECK(IsPropertyChangeAllowed()); 587 if (position_ == position) 588 return; 589 position_ = position; 590 SetNeedsCommit(); 591} 592 593bool Layer::IsContainerForFixedPositionLayers() const { 594 if (!transform_.IsIdentityOrTranslation()) 595 return true; 596 if (parent_ && !parent_->sublayer_transform_.IsIdentityOrTranslation()) 597 return true; 598 return is_container_for_fixed_position_layers_; 599} 600 601void Layer::SetSublayerTransform(const gfx::Transform& sublayer_transform) { 602 DCHECK(IsPropertyChangeAllowed()); 603 if (sublayer_transform_ == sublayer_transform) 604 return; 605 sublayer_transform_ = sublayer_transform; 606 SetNeedsCommit(); 607} 608 609void Layer::SetTransform(const gfx::Transform& transform) { 610 DCHECK(IsPropertyChangeAllowed()); 611 if (transform_ == transform) 612 return; 613 transform_ = transform; 614 SetNeedsCommit(); 615} 616 617bool Layer::TransformIsAnimating() const { 618 return layer_animation_controller_->IsAnimatingProperty(Animation::Transform); 619} 620 621void Layer::SetScrollParent(Layer* parent) { 622 DCHECK(IsPropertyChangeAllowed()); 623 if (scroll_parent_ == parent) 624 return; 625 626 if (scroll_parent_) 627 scroll_parent_->RemoveScrollChild(this); 628 629 scroll_parent_ = parent; 630 631 if (scroll_parent_) 632 scroll_parent_->AddScrollChild(this); 633 634 SetNeedsCommit(); 635} 636 637void Layer::AddScrollChild(Layer* child) { 638 if (!scroll_children_) 639 scroll_children_.reset(new std::set<Layer*>); 640 scroll_children_->insert(child); 641 SetNeedsCommit(); 642} 643 644void Layer::RemoveScrollChild(Layer* child) { 645 scroll_children_->erase(child); 646 if (scroll_children_->empty()) 647 scroll_children_.reset(); 648 SetNeedsCommit(); 649} 650 651void Layer::SetClipParent(Layer* ancestor) { 652 DCHECK(IsPropertyChangeAllowed()); 653 if (clip_parent_ == ancestor) 654 return; 655 656 if (clip_parent_) 657 clip_parent_->RemoveClipChild(this); 658 659 clip_parent_ = ancestor; 660 661 if (clip_parent_) 662 clip_parent_->AddClipChild(this); 663 664 SetNeedsCommit(); 665} 666 667void Layer::AddClipChild(Layer* child) { 668 if (!clip_children_) 669 clip_children_.reset(new std::set<Layer*>); 670 clip_children_->insert(child); 671 SetNeedsCommit(); 672} 673 674void Layer::RemoveClipChild(Layer* child) { 675 clip_children_->erase(child); 676 if (clip_children_->empty()) 677 clip_children_.reset(); 678 SetNeedsCommit(); 679} 680 681void Layer::SetScrollOffset(gfx::Vector2d scroll_offset) { 682 DCHECK(IsPropertyChangeAllowed()); 683 if (scroll_offset_ == scroll_offset) 684 return; 685 scroll_offset_ = scroll_offset; 686 SetNeedsCommit(); 687} 688 689void Layer::SetScrollOffsetFromImplSide(gfx::Vector2d scroll_offset) { 690 DCHECK(IsPropertyChangeAllowed()); 691 // This function only gets called during a BeginMainFrame, so there 692 // is no need to call SetNeedsUpdate here. 693 DCHECK(layer_tree_host_ && layer_tree_host_->CommitRequested()); 694 if (scroll_offset_ == scroll_offset) 695 return; 696 scroll_offset_ = scroll_offset; 697 SetNeedsPushProperties(); 698 if (!did_scroll_callback_.is_null()) 699 did_scroll_callback_.Run(); 700 // The callback could potentially change the layer structure: 701 // "this" may have been destroyed during the process. 702} 703 704void Layer::SetMaxScrollOffset(gfx::Vector2d max_scroll_offset) { 705 DCHECK(IsPropertyChangeAllowed()); 706 if (max_scroll_offset_ == max_scroll_offset) 707 return; 708 max_scroll_offset_ = max_scroll_offset; 709 SetNeedsCommit(); 710} 711 712void Layer::SetScrollable(bool scrollable) { 713 DCHECK(IsPropertyChangeAllowed()); 714 if (scrollable_ == scrollable) 715 return; 716 scrollable_ = scrollable; 717 SetNeedsCommit(); 718} 719 720void Layer::SetUserScrollable(bool horizontal, bool vertical) { 721 DCHECK(IsPropertyChangeAllowed()); 722 if (user_scrollable_horizontal_ == horizontal && 723 user_scrollable_vertical_ == vertical) 724 return; 725 user_scrollable_horizontal_ = horizontal; 726 user_scrollable_vertical_ = vertical; 727 SetNeedsCommit(); 728} 729 730void Layer::SetShouldScrollOnMainThread(bool should_scroll_on_main_thread) { 731 DCHECK(IsPropertyChangeAllowed()); 732 if (should_scroll_on_main_thread_ == should_scroll_on_main_thread) 733 return; 734 should_scroll_on_main_thread_ = should_scroll_on_main_thread; 735 SetNeedsCommit(); 736} 737 738void Layer::SetHaveWheelEventHandlers(bool have_wheel_event_handlers) { 739 DCHECK(IsPropertyChangeAllowed()); 740 if (have_wheel_event_handlers_ == have_wheel_event_handlers) 741 return; 742 have_wheel_event_handlers_ = have_wheel_event_handlers; 743 SetNeedsCommit(); 744} 745 746void Layer::SetNonFastScrollableRegion(const Region& region) { 747 DCHECK(IsPropertyChangeAllowed()); 748 if (non_fast_scrollable_region_ == region) 749 return; 750 non_fast_scrollable_region_ = region; 751 SetNeedsCommit(); 752} 753 754void Layer::SetTouchEventHandlerRegion(const Region& region) { 755 DCHECK(IsPropertyChangeAllowed()); 756 if (touch_event_handler_region_ == region) 757 return; 758 touch_event_handler_region_ = region; 759 SetNeedsCommit(); 760} 761 762void Layer::SetDrawCheckerboardForMissingTiles(bool checkerboard) { 763 DCHECK(IsPropertyChangeAllowed()); 764 if (draw_checkerboard_for_missing_tiles_ == checkerboard) 765 return; 766 draw_checkerboard_for_missing_tiles_ = checkerboard; 767 SetNeedsCommit(); 768} 769 770void Layer::SetForceRenderSurface(bool force) { 771 DCHECK(IsPropertyChangeAllowed()); 772 if (force_render_surface_ == force) 773 return; 774 force_render_surface_ = force; 775 SetNeedsCommit(); 776} 777 778void Layer::SetDoubleSided(bool double_sided) { 779 DCHECK(IsPropertyChangeAllowed()); 780 if (double_sided_ == double_sided) 781 return; 782 double_sided_ = double_sided; 783 SetNeedsCommit(); 784} 785 786void Layer::SetIsDrawable(bool is_drawable) { 787 DCHECK(IsPropertyChangeAllowed()); 788 if (is_drawable_ == is_drawable) 789 return; 790 791 is_drawable_ = is_drawable; 792 SetNeedsCommit(); 793} 794 795void Layer::SetHideLayerAndSubtree(bool hide) { 796 DCHECK(IsPropertyChangeAllowed()); 797 if (hide_layer_and_subtree_ == hide) 798 return; 799 800 hide_layer_and_subtree_ = hide; 801 SetNeedsCommit(); 802} 803 804void Layer::SetNeedsDisplayRect(const gfx::RectF& dirty_rect) { 805 if (dirty_rect.IsEmpty()) 806 return; 807 808 SetNeedsPushProperties(); 809 update_rect_.Union(dirty_rect); 810 811 if (DrawsContent()) 812 SetNeedsUpdate(); 813} 814 815bool Layer::DescendantIsFixedToContainerLayer() const { 816 for (size_t i = 0; i < children_.size(); ++i) { 817 if (children_[i]->position_constraint_.is_fixed_position() || 818 children_[i]->DescendantIsFixedToContainerLayer()) 819 return true; 820 } 821 return false; 822} 823 824void Layer::SetIsContainerForFixedPositionLayers(bool container) { 825 if (is_container_for_fixed_position_layers_ == container) 826 return; 827 is_container_for_fixed_position_layers_ = container; 828 829 if (layer_tree_host_ && layer_tree_host_->CommitRequested()) 830 return; 831 832 // Only request a commit if we have a fixed positioned descendant. 833 if (DescendantIsFixedToContainerLayer()) 834 SetNeedsCommit(); 835} 836 837void Layer::SetPositionConstraint(const LayerPositionConstraint& constraint) { 838 DCHECK(IsPropertyChangeAllowed()); 839 if (position_constraint_ == constraint) 840 return; 841 position_constraint_ = constraint; 842 SetNeedsCommit(); 843} 844 845static void RunCopyCallbackOnMainThread(scoped_ptr<CopyOutputRequest> request, 846 scoped_ptr<CopyOutputResult> result) { 847 request->SendResult(result.Pass()); 848} 849 850static void PostCopyCallbackToMainThread( 851 scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner, 852 scoped_ptr<CopyOutputRequest> request, 853 scoped_ptr<CopyOutputResult> result) { 854 main_thread_task_runner->PostTask(FROM_HERE, 855 base::Bind(&RunCopyCallbackOnMainThread, 856 base::Passed(&request), 857 base::Passed(&result))); 858} 859 860void Layer::PushPropertiesTo(LayerImpl* layer) { 861 DCHECK(layer_tree_host_); 862 863 // If we did not SavePaintProperties() for the layer this frame, then push the 864 // real property values, not the paint property values. 865 bool use_paint_properties = paint_properties_.source_frame_number == 866 layer_tree_host_->source_frame_number(); 867 868 layer->SetAnchorPoint(anchor_point_); 869 layer->SetAnchorPointZ(anchor_point_z_); 870 layer->SetBackgroundColor(background_color_); 871 layer->SetBounds(use_paint_properties ? paint_properties_.bounds 872 : bounds_); 873 layer->SetContentBounds(content_bounds()); 874 layer->SetContentsScale(contents_scale_x(), contents_scale_y()); 875 876 bool is_tracing; 877 TRACE_EVENT_CATEGORY_GROUP_ENABLED(TRACE_DISABLED_BY_DEFAULT("cc.debug"), 878 &is_tracing); 879 if (is_tracing) { 880 layer->SetDebugName(DebugName()); 881 layer->SetDebugInfo(TakeDebugInfo()); 882 } else { 883 layer->SetDebugName(std::string()); 884 } 885 886 layer->SetCompositingReasons(compositing_reasons_); 887 layer->SetDoubleSided(double_sided_); 888 layer->SetDrawCheckerboardForMissingTiles( 889 draw_checkerboard_for_missing_tiles_); 890 layer->SetForceRenderSurface(force_render_surface_); 891 layer->SetDrawsContent(DrawsContent()); 892 layer->SetHideLayerAndSubtree(hide_layer_and_subtree_); 893 if (!layer->FilterIsAnimatingOnImplOnly() && !FilterIsAnimating()) 894 layer->SetFilters(filters_); 895 DCHECK(!(FilterIsAnimating() && layer->FilterIsAnimatingOnImplOnly())); 896 layer->SetBackgroundFilters(background_filters()); 897 layer->SetMasksToBounds(masks_to_bounds_); 898 layer->SetShouldScrollOnMainThread(should_scroll_on_main_thread_); 899 layer->SetHaveWheelEventHandlers(have_wheel_event_handlers_); 900 layer->SetNonFastScrollableRegion(non_fast_scrollable_region_); 901 layer->SetTouchEventHandlerRegion(touch_event_handler_region_); 902 layer->SetContentsOpaque(contents_opaque_); 903 if (!layer->OpacityIsAnimatingOnImplOnly() && !OpacityIsAnimating()) 904 layer->SetOpacity(opacity_); 905 DCHECK(!(OpacityIsAnimating() && layer->OpacityIsAnimatingOnImplOnly())); 906 layer->SetBlendMode(blend_mode_); 907 layer->SetIsRootForIsolatedGroup(is_root_for_isolated_group_); 908 layer->SetPosition(position_); 909 layer->SetIsContainerForFixedPositionLayers( 910 IsContainerForFixedPositionLayers()); 911 layer->SetFixedContainerSizeDelta(gfx::Vector2dF()); 912 layer->SetPositionConstraint(position_constraint_); 913 layer->SetPreserves3d(preserves_3d()); 914 layer->SetUseParentBackfaceVisibility(use_parent_backface_visibility_); 915 layer->SetSublayerTransform(sublayer_transform_); 916 if (!layer->TransformIsAnimatingOnImplOnly() && !TransformIsAnimating()) 917 layer->SetTransform(transform_); 918 DCHECK(!(TransformIsAnimating() && layer->TransformIsAnimatingOnImplOnly())); 919 920 layer->SetScrollable(scrollable_); 921 layer->set_user_scrollable_horizontal(user_scrollable_horizontal_); 922 layer->set_user_scrollable_vertical(user_scrollable_vertical_); 923 layer->SetMaxScrollOffset(max_scroll_offset_); 924 925 LayerImpl* scroll_parent = NULL; 926 if (scroll_parent_) 927 scroll_parent = layer->layer_tree_impl()->LayerById(scroll_parent_->id()); 928 929 layer->SetScrollParent(scroll_parent); 930 if (scroll_children_) { 931 std::set<LayerImpl*>* scroll_children = new std::set<LayerImpl*>; 932 for (std::set<Layer*>::iterator it = scroll_children_->begin(); 933 it != scroll_children_->end(); ++it) 934 scroll_children->insert(layer->layer_tree_impl()->LayerById((*it)->id())); 935 layer->SetScrollChildren(scroll_children); 936 } 937 938 LayerImpl* clip_parent = NULL; 939 if (clip_parent_) { 940 clip_parent = 941 layer->layer_tree_impl()->LayerById(clip_parent_->id()); 942 } 943 944 layer->SetClipParent(clip_parent); 945 if (clip_children_) { 946 std::set<LayerImpl*>* clip_children = new std::set<LayerImpl*>; 947 for (std::set<Layer*>::iterator it = clip_children_->begin(); 948 it != clip_children_->end(); ++it) { 949 LayerImpl* clip_child = layer->layer_tree_impl()->LayerById((*it)->id()); 950 DCHECK(clip_child); 951 clip_children->insert(clip_child); 952 } 953 layer->SetClipChildren(clip_children); 954 } 955 956 // Adjust the scroll delta to be just the scrolls that have happened since 957 // the BeginMainFrame was sent. This happens for impl-side painting 958 // in LayerImpl::ApplyScrollDeltasSinceBeginMainFrame in a separate tree walk. 959 if (layer->layer_tree_impl()->settings().impl_side_painting) { 960 layer->SetScrollOffset(scroll_offset_); 961 } else { 962 layer->SetScrollOffsetAndDelta( 963 scroll_offset_, layer->ScrollDelta() - layer->sent_scroll_delta()); 964 layer->SetSentScrollDelta(gfx::Vector2d()); 965 } 966 967 // Wrap the copy_requests_ in a PostTask to the main thread. 968 ScopedPtrVector<CopyOutputRequest> main_thread_copy_requests; 969 for (ScopedPtrVector<CopyOutputRequest>::iterator it = copy_requests_.begin(); 970 it != copy_requests_.end(); 971 ++it) { 972 scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner = 973 layer_tree_host()->proxy()->MainThreadTaskRunner(); 974 scoped_ptr<CopyOutputRequest> original_request = copy_requests_.take(it); 975 const CopyOutputRequest& original_request_ref = *original_request; 976 scoped_ptr<CopyOutputRequest> main_thread_request = 977 CopyOutputRequest::CreateRelayRequest( 978 original_request_ref, 979 base::Bind(&PostCopyCallbackToMainThread, 980 main_thread_task_runner, 981 base::Passed(&original_request))); 982 main_thread_copy_requests.push_back(main_thread_request.Pass()); 983 } 984 copy_requests_.clear(); 985 layer->PassCopyRequests(&main_thread_copy_requests); 986 987 // If the main thread commits multiple times before the impl thread actually 988 // draws, then damage tracking will become incorrect if we simply clobber the 989 // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e. 990 // union) any update changes that have occurred on the main thread. 991 update_rect_.Union(layer->update_rect()); 992 layer->set_update_rect(update_rect_); 993 994 layer->SetStackingOrderChanged(stacking_order_changed_); 995 996 layer_animation_controller_->PushAnimationUpdatesTo( 997 layer->layer_animation_controller()); 998 999 // Reset any state that should be cleared for the next update. 1000 stacking_order_changed_ = false; 1001 update_rect_ = gfx::RectF(); 1002 1003 needs_push_properties_ = false; 1004 num_dependents_need_push_properties_ = 0; 1005} 1006 1007scoped_ptr<LayerImpl> Layer::CreateLayerImpl(LayerTreeImpl* tree_impl) { 1008 return LayerImpl::Create(tree_impl, layer_id_); 1009} 1010 1011bool Layer::DrawsContent() const { 1012 return is_drawable_; 1013} 1014 1015void Layer::SavePaintProperties() { 1016 DCHECK(layer_tree_host_); 1017 1018 // TODO(reveman): Save all layer properties that we depend on not 1019 // changing until PushProperties() has been called. crbug.com/231016 1020 paint_properties_.bounds = bounds_; 1021 paint_properties_.source_frame_number = 1022 layer_tree_host_->source_frame_number(); 1023} 1024 1025bool Layer::Update(ResourceUpdateQueue* queue, 1026 const OcclusionTracker* occlusion) { 1027 DCHECK(layer_tree_host_); 1028 DCHECK_EQ(layer_tree_host_->source_frame_number(), 1029 paint_properties_.source_frame_number) << 1030 "SavePaintProperties must be called for any layer that is painted."; 1031 return false; 1032} 1033 1034bool Layer::NeedMoreUpdates() { 1035 return false; 1036} 1037 1038std::string Layer::DebugName() { 1039 return client_ ? client_->DebugName() : std::string(); 1040} 1041 1042scoped_refptr<base::debug::ConvertableToTraceFormat> Layer::TakeDebugInfo() { 1043 if (client_) 1044 return client_->TakeDebugInfo(); 1045 else 1046 return NULL; 1047} 1048 1049 1050void Layer::SetCompositingReasons(CompositingReasons reasons) { 1051 compositing_reasons_ = reasons; 1052} 1053 1054void Layer::CreateRenderSurface() { 1055 DCHECK(!draw_properties_.render_surface); 1056 draw_properties_.render_surface = make_scoped_ptr(new RenderSurface(this)); 1057 draw_properties_.render_target = this; 1058} 1059 1060void Layer::ClearRenderSurface() { 1061 draw_properties_.render_surface.reset(); 1062} 1063 1064gfx::Vector2dF Layer::ScrollOffsetForAnimation() const { 1065 return TotalScrollOffset(); 1066} 1067 1068// On<Property>Animated is called due to an ongoing accelerated animation. 1069// Since this animation is also being run on the compositor thread, there 1070// is no need to request a commit to push this value over, so the value is 1071// set directly rather than by calling Set<Property>. 1072void Layer::OnFilterAnimated(const FilterOperations& filters) { 1073 filters_ = filters; 1074} 1075 1076void Layer::OnOpacityAnimated(float opacity) { 1077 opacity_ = opacity; 1078} 1079 1080void Layer::OnTransformAnimated(const gfx::Transform& transform) { 1081 transform_ = transform; 1082} 1083 1084void Layer::OnScrollOffsetAnimated(gfx::Vector2dF scroll_offset) { 1085 // Do nothing. Scroll deltas will be sent from the compositor thread back 1086 // to the main thread in the same manner as during non-animated 1087 // compositor-driven scrolling. 1088} 1089 1090void Layer::OnAnimationWaitingForDeletion() { 1091 // Animations are only deleted during PushProperties. 1092 SetNeedsPushProperties(); 1093} 1094 1095bool Layer::IsActive() const { 1096 return true; 1097} 1098 1099bool Layer::AddAnimation(scoped_ptr <Animation> animation) { 1100 if (!layer_animation_controller_->animation_registrar()) 1101 return false; 1102 1103 UMA_HISTOGRAM_BOOLEAN("Renderer.AnimationAddedToOrphanLayer", 1104 !layer_tree_host_); 1105 layer_animation_controller_->AddAnimation(animation.Pass()); 1106 SetNeedsCommit(); 1107 return true; 1108} 1109 1110void Layer::PauseAnimation(int animation_id, double time_offset) { 1111 layer_animation_controller_->PauseAnimation(animation_id, time_offset); 1112 SetNeedsCommit(); 1113} 1114 1115void Layer::RemoveAnimation(int animation_id) { 1116 layer_animation_controller_->RemoveAnimation(animation_id); 1117 SetNeedsCommit(); 1118} 1119 1120void Layer::SetLayerAnimationControllerForTest( 1121 scoped_refptr<LayerAnimationController> controller) { 1122 layer_animation_controller_->RemoveValueObserver(this); 1123 layer_animation_controller_ = controller; 1124 layer_animation_controller_->AddValueObserver(this); 1125 SetNeedsCommit(); 1126} 1127 1128bool Layer::HasActiveAnimation() const { 1129 return layer_animation_controller_->HasActiveAnimation(); 1130} 1131 1132void Layer::AddLayerAnimationEventObserver( 1133 LayerAnimationEventObserver* animation_observer) { 1134 layer_animation_controller_->AddEventObserver(animation_observer); 1135} 1136 1137void Layer::RemoveLayerAnimationEventObserver( 1138 LayerAnimationEventObserver* animation_observer) { 1139 layer_animation_controller_->RemoveEventObserver(animation_observer); 1140} 1141 1142Region Layer::VisibleContentOpaqueRegion() const { 1143 if (contents_opaque()) 1144 return visible_content_rect(); 1145 return Region(); 1146} 1147 1148ScrollbarLayerInterface* Layer::ToScrollbarLayer() { 1149 return NULL; 1150} 1151 1152RenderingStatsInstrumentation* Layer::rendering_stats_instrumentation() const { 1153 return layer_tree_host_->rendering_stats_instrumentation(); 1154} 1155 1156bool Layer::SupportsLCDText() const { 1157 return false; 1158} 1159 1160void Layer::RemoveFromScrollTree() { 1161 if (scroll_children_.get()) { 1162 for (std::set<Layer*>::iterator it = scroll_children_->begin(); 1163 it != scroll_children_->end(); ++it) 1164 (*it)->scroll_parent_ = NULL; 1165 } 1166 1167 if (scroll_parent_) 1168 scroll_parent_->RemoveScrollChild(this); 1169 1170 scroll_parent_ = NULL; 1171} 1172 1173void Layer::RemoveFromClipTree() { 1174 if (clip_children_.get()) { 1175 for (std::set<Layer*>::iterator it = clip_children_->begin(); 1176 it != clip_children_->end(); ++it) 1177 (*it)->clip_parent_ = NULL; 1178 } 1179 1180 if (clip_parent_) 1181 clip_parent_->RemoveClipChild(this); 1182 1183 clip_parent_ = NULL; 1184} 1185 1186void Layer::RunMicroBenchmark(MicroBenchmark* benchmark) { 1187 benchmark->RunOnLayer(this); 1188} 1189 1190} // namespace cc 1191