layer.h revision 46d4c2bc3267f3f028f39e7e311b0f89aba2e4fd
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#ifndef CC_LAYERS_LAYER_H_ 6#define CC_LAYERS_LAYER_H_ 7 8#include <set> 9#include <string> 10 11#include "base/callback.h" 12#include "base/memory/ref_counted.h" 13#include "base/observer_list.h" 14#include "cc/animation/layer_animation_controller.h" 15#include "cc/animation/layer_animation_value_observer.h" 16#include "cc/animation/layer_animation_value_provider.h" 17#include "cc/base/cc_export.h" 18#include "cc/base/region.h" 19#include "cc/base/scoped_ptr_vector.h" 20#include "cc/debug/micro_benchmark.h" 21#include "cc/layers/draw_properties.h" 22#include "cc/layers/layer_lists.h" 23#include "cc/layers/layer_position_constraint.h" 24#include "cc/layers/paint_properties.h" 25#include "cc/layers/render_surface.h" 26#include "cc/output/filter_operations.h" 27#include "skia/ext/refptr.h" 28#include "third_party/skia/include/core/SkColor.h" 29#include "third_party/skia/include/core/SkImageFilter.h" 30#include "third_party/skia/include/core/SkPicture.h" 31#include "third_party/skia/include/core/SkXfermode.h" 32#include "ui/gfx/point3_f.h" 33#include "ui/gfx/rect.h" 34#include "ui/gfx/rect_f.h" 35#include "ui/gfx/transform.h" 36 37namespace gfx { 38class BoxF; 39} 40 41namespace base { 42namespace debug { 43class ConvertableToTraceFormat; 44} 45} 46 47namespace cc { 48 49class Animation; 50class AnimationDelegate; 51struct AnimationEvent; 52class CopyOutputRequest; 53class LayerAnimationDelegate; 54class LayerAnimationEventObserver; 55class LayerClient; 56class LayerImpl; 57class LayerTreeHost; 58class LayerTreeImpl; 59class PriorityCalculator; 60class RenderingStatsInstrumentation; 61class ResourceUpdateQueue; 62class ScrollbarLayerInterface; 63struct AnimationEvent; 64template <typename LayerType> 65class OcclusionTracker; 66 67// Base class for composited layers. Special layer types are derived from 68// this class. 69class CC_EXPORT Layer : public base::RefCounted<Layer>, 70 public LayerAnimationValueObserver, 71 public LayerAnimationValueProvider { 72 public: 73 typedef RenderSurfaceLayerList RenderSurfaceListType; 74 typedef LayerList LayerListType; 75 typedef RenderSurface RenderSurfaceType; 76 77 enum LayerIdLabels { 78 INVALID_ID = -1, 79 }; 80 81 static scoped_refptr<Layer> Create(); 82 83 int id() const { return layer_id_; } 84 85 Layer* RootLayer(); 86 Layer* parent() { return parent_; } 87 const Layer* parent() const { return parent_; } 88 void AddChild(scoped_refptr<Layer> child); 89 void InsertChild(scoped_refptr<Layer> child, size_t index); 90 void ReplaceChild(Layer* reference, scoped_refptr<Layer> new_layer); 91 void RemoveFromParent(); 92 void RemoveAllChildren(); 93 void SetChildren(const LayerList& children); 94 bool HasAncestor(const Layer* ancestor) const; 95 96 const LayerList& children() const { return children_; } 97 Layer* child_at(size_t index) { return children_[index].get(); } 98 99 // This requests the layer and its subtree be rendered and given to the 100 // callback. If the copy is unable to be produced (the layer is destroyed 101 // first), then the callback is called with a NULL/empty result. 102 void RequestCopyOfOutput(scoped_ptr<CopyOutputRequest> request); 103 bool HasCopyRequest() const { 104 return !copy_requests_.empty(); 105 } 106 107 virtual void SetBackgroundColor(SkColor background_color); 108 SkColor background_color() const { return background_color_; } 109 // If contents_opaque(), return an opaque color else return a 110 // non-opaque color. Tries to return background_color(), if possible. 111 SkColor SafeOpaqueBackgroundColor() const; 112 113 // A layer's bounds are in logical, non-page-scaled pixels (however, the 114 // root layer's bounds are in physical pixels). 115 void SetBounds(const gfx::Size& bounds); 116 gfx::Size bounds() const { return bounds_; } 117 118 void SetMasksToBounds(bool masks_to_bounds); 119 bool masks_to_bounds() const { return masks_to_bounds_; } 120 121 void SetMaskLayer(Layer* mask_layer); 122 Layer* mask_layer() { return mask_layer_.get(); } 123 const Layer* mask_layer() const { return mask_layer_.get(); } 124 125 virtual void SetNeedsDisplayRect(const gfx::RectF& dirty_rect); 126 void SetNeedsDisplay() { SetNeedsDisplayRect(gfx::RectF(bounds())); } 127 128 void SetOpacity(float opacity); 129 float opacity() const { return opacity_; } 130 bool OpacityIsAnimating() const; 131 virtual bool OpacityCanAnimateOnImplThread() const; 132 133 void SetBlendMode(SkXfermode::Mode blend_mode); 134 SkXfermode::Mode blend_mode() const { return blend_mode_; } 135 136 bool uses_default_blend_mode() const { 137 return blend_mode_ == SkXfermode::kSrcOver_Mode; 138 } 139 140 // A layer is root for an isolated group when it and all its descendants are 141 // drawn over a black and fully transparent background, creating an isolated 142 // group. It should be used along with SetBlendMode(), in order to restrict 143 // layers within the group to blend with layers outside this group. 144 void SetIsRootForIsolatedGroup(bool root); 145 bool is_root_for_isolated_group() const { 146 return is_root_for_isolated_group_; 147 } 148 149 void SetFilters(const FilterOperations& filters); 150 const FilterOperations& filters() const { return filters_; } 151 bool FilterIsAnimating() const; 152 153 // Background filters are filters applied to what is behind this layer, when 154 // they are viewed through non-opaque regions in this layer. They are used 155 // through the WebLayer interface, and are not exposed to HTML. 156 void SetBackgroundFilters(const FilterOperations& filters); 157 const FilterOperations& background_filters() const { 158 return background_filters_; 159 } 160 161 virtual void SetContentsOpaque(bool opaque); 162 bool contents_opaque() const { return contents_opaque_; } 163 164 void SetPosition(const gfx::PointF& position); 165 gfx::PointF position() const { return position_; } 166 167 void SetIsContainerForFixedPositionLayers(bool container); 168 bool IsContainerForFixedPositionLayers() const; 169 170 void SetPositionConstraint(const LayerPositionConstraint& constraint); 171 const LayerPositionConstraint& position_constraint() const { 172 return position_constraint_; 173 } 174 175 void SetTransform(const gfx::Transform& transform); 176 const gfx::Transform& transform() const { return transform_; } 177 bool TransformIsAnimating() const; 178 bool transform_is_invertible() const { return transform_is_invertible_; } 179 180 void SetTransformOrigin(const gfx::Point3F&); 181 gfx::Point3F transform_origin() { return transform_origin_; } 182 183 void SetScrollParent(Layer* parent); 184 185 Layer* scroll_parent() { return scroll_parent_; } 186 const Layer* scroll_parent() const { return scroll_parent_; } 187 188 void AddScrollChild(Layer* child); 189 void RemoveScrollChild(Layer* child); 190 191 std::set<Layer*>* scroll_children() { return scroll_children_.get(); } 192 const std::set<Layer*>* scroll_children() const { 193 return scroll_children_.get(); 194 } 195 196 void SetClipParent(Layer* ancestor); 197 198 Layer* clip_parent() { return clip_parent_; } 199 const Layer* clip_parent() const { 200 return clip_parent_; 201 } 202 203 void AddClipChild(Layer* child); 204 void RemoveClipChild(Layer* child); 205 206 std::set<Layer*>* clip_children() { return clip_children_.get(); } 207 const std::set<Layer*>* clip_children() const { 208 return clip_children_.get(); 209 } 210 211 DrawProperties<Layer>& draw_properties() { return draw_properties_; } 212 const DrawProperties<Layer>& draw_properties() const { 213 return draw_properties_; 214 } 215 216 // The following are shortcut accessors to get various information from 217 // draw_properties_ 218 const gfx::Transform& draw_transform() const { 219 return draw_properties_.target_space_transform; 220 } 221 const gfx::Transform& screen_space_transform() const { 222 return draw_properties_.screen_space_transform; 223 } 224 float draw_opacity() const { return draw_properties_.opacity; } 225 bool draw_opacity_is_animating() const { 226 return draw_properties_.opacity_is_animating; 227 } 228 bool draw_transform_is_animating() const { 229 return draw_properties_.target_space_transform_is_animating; 230 } 231 bool screen_space_transform_is_animating() const { 232 return draw_properties_.screen_space_transform_is_animating; 233 } 234 bool screen_space_opacity_is_animating() const { 235 return draw_properties_.screen_space_opacity_is_animating; 236 } 237 bool can_use_lcd_text() const { return draw_properties_.can_use_lcd_text; } 238 bool is_clipped() const { return draw_properties_.is_clipped; } 239 gfx::Rect clip_rect() const { return draw_properties_.clip_rect; } 240 gfx::Rect drawable_content_rect() const { 241 return draw_properties_.drawable_content_rect; 242 } 243 gfx::Rect visible_content_rect() const { 244 return draw_properties_.visible_content_rect; 245 } 246 Layer* render_target() { 247 DCHECK(!draw_properties_.render_target || 248 draw_properties_.render_target->render_surface()); 249 return draw_properties_.render_target; 250 } 251 const Layer* render_target() const { 252 DCHECK(!draw_properties_.render_target || 253 draw_properties_.render_target->render_surface()); 254 return draw_properties_.render_target; 255 } 256 RenderSurface* render_surface() const { 257 return draw_properties_.render_surface.get(); 258 } 259 int num_unclipped_descendants() const { 260 return draw_properties_.num_unclipped_descendants; 261 } 262 263 void SetScrollOffset(gfx::Vector2d scroll_offset); 264 gfx::Vector2d scroll_offset() const { return scroll_offset_; } 265 void SetScrollOffsetFromImplSide(const gfx::Vector2d& scroll_offset); 266 267 void SetScrollClipLayerId(int clip_layer_id); 268 bool scrollable() const { return scroll_clip_layer_id_ != INVALID_ID; } 269 270 void SetUserScrollable(bool horizontal, bool vertical); 271 bool user_scrollable_horizontal() const { 272 return user_scrollable_horizontal_; 273 } 274 bool user_scrollable_vertical() const { return user_scrollable_vertical_; } 275 276 void SetShouldScrollOnMainThread(bool should_scroll_on_main_thread); 277 bool should_scroll_on_main_thread() const { 278 return should_scroll_on_main_thread_; 279 } 280 281 void SetHaveWheelEventHandlers(bool have_wheel_event_handlers); 282 bool have_wheel_event_handlers() const { return have_wheel_event_handlers_; } 283 284 void SetHaveScrollEventHandlers(bool have_scroll_event_handlers); 285 bool have_scroll_event_handlers() const { 286 return have_scroll_event_handlers_; 287 } 288 289 void SetNonFastScrollableRegion(const Region& non_fast_scrollable_region); 290 const Region& non_fast_scrollable_region() const { 291 return non_fast_scrollable_region_; 292 } 293 294 void SetTouchEventHandlerRegion(const Region& touch_event_handler_region); 295 const Region& touch_event_handler_region() const { 296 return touch_event_handler_region_; 297 } 298 299 void set_did_scroll_callback(const base::Closure& callback) { 300 did_scroll_callback_ = callback; 301 } 302 303 void SetDrawCheckerboardForMissingTiles(bool checkerboard); 304 bool draw_checkerboard_for_missing_tiles() const { 305 return draw_checkerboard_for_missing_tiles_; 306 } 307 308 void SetForceRenderSurface(bool force_render_surface); 309 bool force_render_surface() const { return force_render_surface_; } 310 311 gfx::Vector2d ScrollDelta() const { return gfx::Vector2d(); } 312 gfx::Vector2dF TotalScrollOffset() const { 313 // Floating point to match the LayerImpl version. 314 return scroll_offset() + ScrollDelta(); 315 } 316 317 void SetDoubleSided(bool double_sided); 318 bool double_sided() const { return double_sided_; } 319 320 void SetShouldFlattenTransform(bool flatten); 321 bool should_flatten_transform() const { return should_flatten_transform_; } 322 323 void SetIs3dSorted(bool sorted); 324 bool is_3d_sorted() const { return is_3d_sorted_; } 325 326 void set_use_parent_backface_visibility(bool use) { 327 use_parent_backface_visibility_ = use; 328 } 329 bool use_parent_backface_visibility() const { 330 return use_parent_backface_visibility_; 331 } 332 333 virtual void SetLayerTreeHost(LayerTreeHost* host); 334 335 bool HasDelegatedContent() const { return false; } 336 bool HasContributingDelegatedRenderPasses() const { return false; } 337 338 void SetIsDrawable(bool is_drawable); 339 340 void SetHideLayerAndSubtree(bool hide); 341 bool hide_layer_and_subtree() const { return hide_layer_and_subtree_; } 342 343 void SetReplicaLayer(Layer* layer); 344 Layer* replica_layer() { return replica_layer_.get(); } 345 const Layer* replica_layer() const { return replica_layer_.get(); } 346 347 bool has_mask() const { return !!mask_layer_.get(); } 348 bool has_replica() const { return !!replica_layer_.get(); } 349 bool replica_has_mask() const { 350 return replica_layer_.get() && 351 (mask_layer_.get() || replica_layer_->mask_layer_.get()); 352 } 353 354 // These methods typically need to be overwritten by derived classes. 355 virtual bool DrawsContent() const; 356 virtual void SavePaintProperties(); 357 // Returns true iff any resources were updated that need to be committed. 358 virtual bool Update(ResourceUpdateQueue* queue, 359 const OcclusionTracker<Layer>* occlusion); 360 virtual bool NeedMoreUpdates(); 361 virtual void SetIsMask(bool is_mask) {} 362 virtual void ReduceMemoryUsage() {} 363 virtual void OnOutputSurfaceCreated() {} 364 virtual bool IsSuitableForGpuRasterization() const; 365 366 virtual scoped_refptr<base::debug::ConvertableToTraceFormat> TakeDebugInfo(); 367 368 void SetLayerClient(LayerClient* client) { client_ = client; } 369 370 virtual void PushPropertiesTo(LayerImpl* layer); 371 372 void CreateRenderSurface(); 373 void ClearRenderSurface(); 374 void ClearRenderSurfaceLayerList(); 375 376 // The contents scale converts from logical, non-page-scaled pixels to target 377 // pixels. The contents scale is 1 for the root layer as it is already in 378 // physical pixels. By default contents scale is forced to be 1 except for 379 // subclasses of ContentsScalingLayer. 380 float contents_scale_x() const { return draw_properties_.contents_scale_x; } 381 float contents_scale_y() const { return draw_properties_.contents_scale_y; } 382 gfx::Size content_bounds() const { return draw_properties_.content_bounds; } 383 384 virtual void CalculateContentsScale(float ideal_contents_scale, 385 float device_scale_factor, 386 float page_scale_factor, 387 float maximum_animation_contents_scale, 388 bool animating_transform_to_screen, 389 float* contents_scale_x, 390 float* contents_scale_y, 391 gfx::Size* content_bounds); 392 393 LayerTreeHost* layer_tree_host() { return layer_tree_host_; } 394 const LayerTreeHost* layer_tree_host() const { return layer_tree_host_; } 395 396 // Set the priority of all desired textures in this layer. 397 virtual void SetTexturePriorities(const PriorityCalculator& priority_calc) {} 398 399 bool AddAnimation(scoped_ptr<Animation> animation); 400 void PauseAnimation(int animation_id, double time_offset); 401 void RemoveAnimation(int animation_id); 402 403 LayerAnimationController* layer_animation_controller() { 404 return layer_animation_controller_.get(); 405 } 406 void SetLayerAnimationControllerForTest( 407 scoped_refptr<LayerAnimationController> controller); 408 409 void set_layer_animation_delegate(AnimationDelegate* delegate) { 410 layer_animation_controller_->set_layer_animation_delegate(delegate); 411 } 412 413 bool HasActiveAnimation() const; 414 415 void AddLayerAnimationEventObserver( 416 LayerAnimationEventObserver* animation_observer); 417 void RemoveLayerAnimationEventObserver( 418 LayerAnimationEventObserver* animation_observer); 419 420 virtual Region VisibleContentOpaqueRegion() const; 421 422 virtual ScrollbarLayerInterface* ToScrollbarLayer(); 423 424 gfx::Rect LayerRectToContentRect(const gfx::RectF& layer_rect) const; 425 426 virtual skia::RefPtr<SkPicture> GetPicture() const; 427 428 // Constructs a LayerImpl of the correct runtime type for this Layer type. 429 virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl); 430 431 bool NeedsDisplayForTesting() const { return !update_rect_.IsEmpty(); } 432 void ResetNeedsDisplayForTesting() { update_rect_ = gfx::RectF(); } 433 434 RenderingStatsInstrumentation* rendering_stats_instrumentation() const; 435 436 const PaintProperties& paint_properties() const { 437 return paint_properties_; 438 } 439 440 // The scale at which contents should be rastered, to match the scale at 441 // which they will drawn to the screen. This scale is a component of the 442 // contents scale but does not include page/device scale factors. 443 // TODO(danakj): This goes away when TiledLayer goes away. 444 void set_raster_scale(float scale) { raster_scale_ = scale; } 445 float raster_scale() const { return raster_scale_; } 446 bool raster_scale_is_unknown() const { return raster_scale_ == 0.f; } 447 448 virtual bool SupportsLCDText() const; 449 450 void SetNeedsPushProperties(); 451 bool needs_push_properties() const { return needs_push_properties_; } 452 bool descendant_needs_push_properties() const { 453 return num_dependents_need_push_properties_ > 0; 454 } 455 void reset_needs_push_properties_for_testing() { 456 needs_push_properties_ = false; 457 } 458 459 virtual void RunMicroBenchmark(MicroBenchmark* benchmark); 460 461 protected: 462 friend class LayerImpl; 463 friend class TreeSynchronizer; 464 virtual ~Layer(); 465 466 Layer(); 467 468 // These SetNeeds functions are in order of severity of update: 469 // 470 // Called when this layer has been modified in some way, but isn't sure 471 // that it needs a commit yet. It needs CalcDrawProperties and UpdateLayers 472 // before it knows whether or not a commit is required. 473 void SetNeedsUpdate(); 474 // Called when a property has been modified in a way that the layer 475 // knows immediately that a commit is required. This implies SetNeedsUpdate 476 // as well as SetNeedsPushProperties to push that property. 477 void SetNeedsCommit(); 478 // Called when there's been a change in layer structure. Implies both 479 // SetNeedsUpdate and SetNeedsCommit, but not SetNeedsPushProperties. 480 void SetNeedsFullTreeSync(); 481 482 // Called when the next commit should wait until the pending tree is activated 483 // before finishing the commit and unblocking the main thread. Used to ensure 484 // unused resources on the impl thread are returned before commit completes. 485 void SetNextCommitWaitsForActivation(); 486 487 void AddDependentNeedsPushProperties(); 488 void RemoveDependentNeedsPushProperties(); 489 bool parent_should_know_need_push_properties() const { 490 return needs_push_properties() || descendant_needs_push_properties(); 491 } 492 493 bool IsPropertyChangeAllowed() const; 494 495 // If this layer has a scroll parent, it removes |this| from its list of 496 // scroll children. 497 void RemoveFromScrollTree(); 498 499 // If this layer has a clip parent, it removes |this| from its list of clip 500 // children. 501 void RemoveFromClipTree(); 502 503 void reset_raster_scale_to_unknown() { raster_scale_ = 0.f; } 504 505 // This flag is set when the layer needs to push properties to the impl 506 // side. 507 bool needs_push_properties_; 508 509 // The number of direct children or dependent layers that need to be recursed 510 // to in order for them or a descendent of them to push properties to the impl 511 // side. 512 int num_dependents_need_push_properties_; 513 514 // Tracks whether this layer may have changed stacking order with its 515 // siblings. 516 bool stacking_order_changed_; 517 518 // The update rect is the region of the compositor resource that was 519 // actually updated by the compositor. For layers that may do updating 520 // outside the compositor's control (i.e. plugin layers), this information 521 // is not available and the update rect will remain empty. 522 // Note this rect is in layer space (not content space). 523 gfx::RectF update_rect_; 524 525 scoped_refptr<Layer> mask_layer_; 526 527 int layer_id_; 528 529 // When true, the layer is about to perform an update. Any commit requests 530 // will be handled implicitly after the update completes. 531 bool ignore_set_needs_commit_; 532 533 private: 534 friend class base::RefCounted<Layer>; 535 536 void SetParent(Layer* layer); 537 bool DescendantIsFixedToContainerLayer() const; 538 539 // Returns the index of the child or -1 if not found. 540 int IndexOfChild(const Layer* reference); 541 542 // This should only be called from RemoveFromParent(). 543 void RemoveChildOrDependent(Layer* child); 544 545 // LayerAnimationValueProvider implementation. 546 virtual gfx::Vector2dF ScrollOffsetForAnimation() const OVERRIDE; 547 548 // LayerAnimationValueObserver implementation. 549 virtual void OnFilterAnimated(const FilterOperations& filters) OVERRIDE; 550 virtual void OnOpacityAnimated(float opacity) OVERRIDE; 551 virtual void OnTransformAnimated(const gfx::Transform& transform) OVERRIDE; 552 virtual void OnScrollOffsetAnimated( 553 const gfx::Vector2dF& scroll_offset) OVERRIDE; 554 virtual void OnAnimationWaitingForDeletion() OVERRIDE; 555 virtual bool IsActive() const OVERRIDE; 556 557 LayerList children_; 558 Layer* parent_; 559 560 // Layer instances have a weak pointer to their LayerTreeHost. 561 // This pointer value is nil when a Layer is not in a tree and is 562 // updated via SetLayerTreeHost() if a layer moves between trees. 563 LayerTreeHost* layer_tree_host_; 564 565 scoped_refptr<LayerAnimationController> layer_animation_controller_; 566 567 // Layer properties. 568 gfx::Size bounds_; 569 570 gfx::Vector2d scroll_offset_; 571 // This variable indicates which ancestor layer (if any) whose size, 572 // transformed relative to this layer, defines the maximum scroll offset for 573 // this layer. 574 int scroll_clip_layer_id_; 575 bool should_scroll_on_main_thread_ : 1; 576 bool have_wheel_event_handlers_ : 1; 577 bool have_scroll_event_handlers_ : 1; 578 bool user_scrollable_horizontal_ : 1; 579 bool user_scrollable_vertical_ : 1; 580 bool is_root_for_isolated_group_ : 1; 581 bool is_container_for_fixed_position_layers_ : 1; 582 bool is_drawable_ : 1; 583 bool hide_layer_and_subtree_ : 1; 584 bool masks_to_bounds_ : 1; 585 bool contents_opaque_ : 1; 586 bool double_sided_ : 1; 587 bool should_flatten_transform_ : 1; 588 bool use_parent_backface_visibility_ : 1; 589 bool draw_checkerboard_for_missing_tiles_ : 1; 590 bool force_render_surface_ : 1; 591 bool is_3d_sorted_ : 1; 592 bool transform_is_invertible_ : 1; 593 Region non_fast_scrollable_region_; 594 Region touch_event_handler_region_; 595 gfx::PointF position_; 596 SkColor background_color_; 597 float opacity_; 598 SkXfermode::Mode blend_mode_; 599 FilterOperations filters_; 600 FilterOperations background_filters_; 601 LayerPositionConstraint position_constraint_; 602 Layer* scroll_parent_; 603 scoped_ptr<std::set<Layer*> > scroll_children_; 604 605 Layer* clip_parent_; 606 scoped_ptr<std::set<Layer*> > clip_children_; 607 608 gfx::Transform transform_; 609 gfx::Point3F transform_origin_; 610 611 // Replica layer used for reflections. 612 scoped_refptr<Layer> replica_layer_; 613 614 // Transient properties. 615 float raster_scale_; 616 617 LayerClient* client_; 618 619 ScopedPtrVector<CopyOutputRequest> copy_requests_; 620 621 base::Closure did_scroll_callback_; 622 623 DrawProperties<Layer> draw_properties_; 624 625 PaintProperties paint_properties_; 626 627 DISALLOW_COPY_AND_ASSIGN(Layer); 628}; 629 630} // namespace cc 631 632#endif // CC_LAYERS_LAYER_H_ 633