layer.h revision 424c4d7b64af9d0d8fd9624f381f469654d5e3d2
1// Copyright (c) 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#ifndef UI_COMPOSITOR_LAYER_H_ 6#define UI_COMPOSITOR_LAYER_H_ 7 8#include <string> 9#include <vector> 10 11#include "base/compiler_specific.h" 12#include "base/memory/ref_counted.h" 13#include "base/memory/scoped_ptr.h" 14#include "base/message_loop/message_loop.h" 15#include "cc/animation/animation_events.h" 16#include "cc/animation/layer_animation_event_observer.h" 17#include "cc/base/scoped_ptr_vector.h" 18#include "cc/layers/content_layer_client.h" 19#include "cc/layers/layer_client.h" 20#include "cc/layers/texture_layer_client.h" 21#include "cc/resources/texture_mailbox.h" 22#include "third_party/skia/include/core/SkColor.h" 23#include "third_party/skia/include/core/SkRegion.h" 24#include "ui/compositor/compositor.h" 25#include "ui/compositor/layer_animation_delegate.h" 26#include "ui/compositor/layer_delegate.h" 27#include "ui/compositor/layer_type.h" 28#include "ui/gfx/rect.h" 29#include "ui/gfx/transform.h" 30 31class SkCanvas; 32 33namespace cc { 34class ContentLayer; 35class CopyOutputRequest; 36class DelegatedFrameData; 37class DelegatedRendererLayer; 38class Layer; 39class ResourceUpdateQueue; 40class SolidColorLayer; 41class TextureLayer; 42struct ReturnedResource; 43typedef std::vector<ReturnedResource> ReturnedResourceArray; 44} 45 46namespace ui { 47 48class Compositor; 49class LayerAnimator; 50class Texture; 51 52// Layer manages a texture, transform and a set of child Layers. Any View that 53// has enabled layers ends up creating a Layer to manage the texture. 54// A Layer can also be created without a texture, in which case it renders 55// nothing and is simply used as a node in a hierarchy of layers. 56// Coordinate system used in layers is DIP (Density Independent Pixel) 57// coordinates unless explicitly mentioned as pixel coordinates. 58// 59// NOTE: unlike Views, each Layer does *not* own its children views. If you 60// delete a Layer and it has children, the parent of each child layer is set to 61// NULL, but the children are not deleted. 62class COMPOSITOR_EXPORT Layer 63 : public LayerAnimationDelegate, 64 NON_EXPORTED_BASE(public cc::ContentLayerClient), 65 NON_EXPORTED_BASE(public cc::TextureLayerClient), 66 NON_EXPORTED_BASE(public cc::LayerClient), 67 NON_EXPORTED_BASE(public cc::LayerAnimationEventObserver) { 68 public: 69 Layer(); 70 explicit Layer(LayerType type); 71 virtual ~Layer(); 72 73 // Retrieves the Layer's compositor. The Layer will walk up its parent chain 74 // to locate it. Returns NULL if the Layer is not attached to a compositor. 75 Compositor* GetCompositor(); 76 77 // Called by the compositor when the Layer is set as its root Layer. This can 78 // only ever be called on the root layer. 79 void SetCompositor(Compositor* compositor); 80 81 LayerDelegate* delegate() { return delegate_; } 82 void set_delegate(LayerDelegate* delegate) { delegate_ = delegate; } 83 84 // Adds a new Layer to this Layer. 85 void Add(Layer* child); 86 87 // Removes a Layer from this Layer. 88 void Remove(Layer* child); 89 90 // Stacks |child| above all other children. 91 void StackAtTop(Layer* child); 92 93 // Stacks |child| directly above |other|. Both must be children of this 94 // layer. Note that if |child| is initially stacked even higher, calling this 95 // method will result in |child| being lowered in the stacking order. 96 void StackAbove(Layer* child, Layer* other); 97 98 // Stacks |child| below all other children. 99 void StackAtBottom(Layer* child); 100 101 // Stacks |child| directly below |other|. Both must be children of this 102 // layer. 103 void StackBelow(Layer* child, Layer* other); 104 105 // Returns the child Layers. 106 const std::vector<Layer*>& children() const { return children_; } 107 108 // The parent. 109 const Layer* parent() const { return parent_; } 110 Layer* parent() { return parent_; } 111 112 LayerType type() const { return type_; } 113 114 // Returns true if this Layer contains |other| somewhere in its children. 115 bool Contains(const Layer* other) const; 116 117 // The layer's animator is responsible for causing automatic animations when 118 // properties are set. It also manages a queue of pending animations and 119 // handles blending of animations. The layer takes ownership of the animator. 120 void SetAnimator(LayerAnimator* animator); 121 122 // Returns the layer's animator. Creates a default animator of one has not 123 // been set. Will not return NULL. 124 LayerAnimator* GetAnimator(); 125 126 // The transform, relative to the parent. 127 void SetTransform(const gfx::Transform& transform); 128 gfx::Transform transform() const; 129 130 // Return the target transform if animator is running, or the current 131 // transform otherwise. 132 gfx::Transform GetTargetTransform() const; 133 134 // The bounds, relative to the parent. 135 void SetBounds(const gfx::Rect& bounds); 136 const gfx::Rect& bounds() const { return bounds_; } 137 138 // Return the target bounds if animator is running, or the current bounds 139 // otherwise. 140 gfx::Rect GetTargetBounds() const; 141 142 // Sets/gets whether or not drawing of child layers should be clipped to the 143 // bounds of this layer. 144 void SetMasksToBounds(bool masks_to_bounds); 145 bool GetMasksToBounds() const; 146 147 // The opacity of the layer. The opacity is applied to each pixel of the 148 // texture (resulting alpha = opacity * alpha). 149 float opacity() const; 150 void SetOpacity(float opacity); 151 152 // Returns the actual opacity, which the opacity of this layer multipled by 153 // the combined opacity of the parent. 154 float GetCombinedOpacity() const; 155 156 // Blur pixels by this amount in anything below the layer and visible through 157 // the layer. 158 int background_blur() const { return background_blur_radius_; } 159 void SetBackgroundBlur(int blur_radius); 160 161 // Saturate all pixels of this layer by this amount. 162 // This effect will get "combined" with the inverted, 163 // brightness and grayscale setting. 164 float layer_saturation() const { return layer_saturation_; } 165 void SetLayerSaturation(float saturation); 166 167 // Change the brightness of all pixels from this layer by this amount. 168 // This effect will get "combined" with the inverted, saturate 169 // and grayscale setting. 170 float layer_brightness() const { return layer_brightness_; } 171 void SetLayerBrightness(float brightness); 172 173 // Return the target brightness if animator is running, or the current 174 // brightness otherwise. 175 float GetTargetBrightness() const; 176 177 // Change the grayscale of all pixels from this layer by this amount. 178 // This effect will get "combined" with the inverted, saturate 179 // and brightness setting. 180 float layer_grayscale() const { return layer_grayscale_; } 181 void SetLayerGrayscale(float grayscale); 182 183 // Return the target grayscale if animator is running, or the current 184 // grayscale otherwise. 185 float GetTargetGrayscale() const; 186 187 // Zoom the background by a factor of |zoom|. The effect is blended along the 188 // edge across |inset| pixels. 189 void SetBackgroundZoom(float zoom, int inset); 190 191 // Invert the layer. 192 bool layer_inverted() const { return layer_inverted_; } 193 void SetLayerInverted(bool inverted); 194 195 // Return the target opacity if animator is running, or the current opacity 196 // otherwise. 197 float GetTargetOpacity() const; 198 199 // Set a layer mask for a layer. 200 // Note the provided layer mask can neither have a layer mask itself nor can 201 // it have any children. The ownership of |layer_mask| will not be 202 // transferred with this call. 203 // Furthermore: A mask layer can only be set to one layer. 204 void SetMaskLayer(Layer* layer_mask); 205 Layer* layer_mask_layer() { return layer_mask_; } 206 207 // Sets the visibility of the Layer. A Layer may be visible but not 208 // drawn. This happens if any ancestor of a Layer is not visible. 209 void SetVisible(bool visible); 210 bool visible() const { return visible_; } 211 212 // Returns the target visibility if the animator is running. Otherwise, it 213 // returns the current visibility. 214 bool GetTargetVisibility() const; 215 216 // Returns true if this Layer is drawn. A Layer is drawn only if all ancestors 217 // are visible. 218 bool IsDrawn() const; 219 220 // Returns true if this layer can have a texture (has_texture_ is true) 221 // and is not completely obscured by a child. 222 bool ShouldDraw() const; 223 224 // Converts a point from the coordinates of |source| to the coordinates of 225 // |target|. Necessarily, |source| and |target| must inhabit the same Layer 226 // tree. 227 static void ConvertPointToLayer(const Layer* source, 228 const Layer* target, 229 gfx::Point* point); 230 231 // Converts a transform to be relative to the given |ancestor|. Returns 232 // whether success (that is, whether the given ancestor was really an 233 // ancestor of this layer). 234 bool GetTargetTransformRelativeTo(const Layer* ancestor, 235 gfx::Transform* transform) const; 236 237 // Converts a ui::Layer's transform to the transform on the corresponding 238 // cc::Layer. 239 static gfx::Transform ConvertTransformToCCTransform( 240 const gfx::Transform& transform, 241 float device_scale_factor); 242 243 // See description in View for details 244 void SetFillsBoundsOpaquely(bool fills_bounds_opaquely); 245 bool fills_bounds_opaquely() const { return fills_bounds_opaquely_; } 246 247 const std::string& name() const { return name_; } 248 void set_name(const std::string& name) { name_ = name; } 249 250 const ui::Texture* texture() const { return texture_.get(); } 251 252 // Assigns a new external texture. |texture| can be NULL to disable external 253 // updates. 254 void SetExternalTexture(ui::Texture* texture); 255 ui::Texture* external_texture() { return texture_.get(); } 256 257 // Set new TextureMailbox for this layer. Note that |mailbox| may hold a 258 // shared memory resource or an actual mailbox for a texture. 259 void SetTextureMailbox(const cc::TextureMailbox& mailbox, float scale_factor); 260 cc::TextureMailbox GetTextureMailbox(float* scale_factor); 261 262 // Sets a delegated frame, coming from a child compositor. 263 void SetDelegatedFrame(scoped_ptr<cc::DelegatedFrameData> frame, 264 gfx::Size frame_size_in_dip); 265 266 bool has_external_content() { 267 return texture_layer_.get() || delegated_renderer_layer_.get(); 268 } 269 270 // Gets unused resources to recycle to the child compositor. 271 void TakeUnusedResourcesForChildCompositor( 272 cc::ReturnedResourceArray* array); 273 274 // Sets the layer's fill color. May only be called for LAYER_SOLID_COLOR. 275 void SetColor(SkColor color); 276 277 // Adds |invalid_rect| to the Layer's pending invalid rect and calls 278 // ScheduleDraw(). Returns false if the paint request is ignored. 279 bool SchedulePaint(const gfx::Rect& invalid_rect); 280 281 // Schedules a redraw of the layer tree at the compositor. 282 // Note that this _does not_ invalidate any region of this layer; use 283 // SchedulePaint() for that. 284 void ScheduleDraw(); 285 286 // Sends damaged rectangles recorded in |damaged_region_| to 287 // |compostior_| to repaint the content. 288 void SendDamagedRects(); 289 290 // Suppresses painting the content by disgarding damaged region and ignoring 291 // new paint requests. 292 void SuppressPaint(); 293 294 // Notifies the layer that the device scale factor has changed. 295 void OnDeviceScaleFactorChanged(float device_scale_factor); 296 297 // Sets whether the layer should scale its content. If true, the canvas will 298 // be scaled in software rendering mode before it is passed to 299 // |LayerDelegate::OnPaint|. 300 // Set to false if the delegate handles scaling. 301 // NOTE: if this is called during |LayerDelegate::OnPaint|, the new value will 302 // not apply to the canvas passed to the pending draw. 303 void set_scale_content(bool scale_content) { scale_content_ = scale_content; } 304 305 // Returns true if the layer scales its content. 306 bool scale_content() const { return scale_content_; } 307 308 // Sometimes the Layer is being updated by something other than SetCanvas 309 // (e.g. the GPU process on UI_COMPOSITOR_IMAGE_TRANSPORT). 310 bool layer_updated_externally() const { return layer_updated_externally_; } 311 312 // Requets a copy of the layer's output as a texture or bitmap. 313 void RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request); 314 315 // ContentLayerClient 316 virtual void PaintContents( 317 SkCanvas* canvas, gfx::Rect clip, gfx::RectF* opaque) OVERRIDE; 318 virtual void DidChangeLayerCanUseLCDText() OVERRIDE {} 319 320 cc::Layer* cc_layer() { return cc_layer_; } 321 322 // TextureLayerClient 323 virtual unsigned PrepareTexture() OVERRIDE; 324 virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE; 325 virtual bool PrepareTextureMailbox(cc::TextureMailbox* mailbox, 326 bool use_shared_memory) OVERRIDE; 327 328 float device_scale_factor() const { return device_scale_factor_; } 329 330 // Forces a render surface to be used on this layer. This has no positive 331 // impact, and is only used for benchmarking/testing purpose. 332 void SetForceRenderSurface(bool force); 333 bool force_render_surface() const { return force_render_surface_; } 334 335 // LayerClient 336 virtual std::string DebugName() OVERRIDE; 337 338 // LayerAnimationEventObserver 339 virtual void OnAnimationStarted(const cc::AnimationEvent& event) OVERRIDE; 340 341 // Whether this layer has animations waiting to get sent to its cc::Layer. 342 bool HasPendingThreadedAnimations() { 343 return pending_threaded_animations_.size() != 0; 344 } 345 346 // Triggers a call to SwitchToLayer. 347 void SwitchCCLayerForTest(); 348 349 private: 350 // Stacks |child| above or below |other|. Helper method for StackAbove() and 351 // StackBelow(). 352 void StackRelativeTo(Layer* child, Layer* other, bool above); 353 354 bool ConvertPointForAncestor(const Layer* ancestor, gfx::Point* point) const; 355 bool ConvertPointFromAncestor(const Layer* ancestor, gfx::Point* point) const; 356 357 // Following are invoked from the animation or if no animation exists to 358 // update the values immediately. 359 void SetBoundsImmediately(const gfx::Rect& bounds); 360 void SetTransformImmediately(const gfx::Transform& transform); 361 void SetOpacityImmediately(float opacity); 362 void SetVisibilityImmediately(bool visibility); 363 void SetBrightnessImmediately(float brightness); 364 void SetGrayscaleImmediately(float grayscale); 365 void SetColorImmediately(SkColor color); 366 367 // Implementation of LayerAnimatorDelegate 368 virtual void SetBoundsFromAnimation(const gfx::Rect& bounds) OVERRIDE; 369 virtual void SetTransformFromAnimation( 370 const gfx::Transform& transform) OVERRIDE; 371 virtual void SetOpacityFromAnimation(float opacity) OVERRIDE; 372 virtual void SetVisibilityFromAnimation(bool visibility) OVERRIDE; 373 virtual void SetBrightnessFromAnimation(float brightness) OVERRIDE; 374 virtual void SetGrayscaleFromAnimation(float grayscale) OVERRIDE; 375 virtual void SetColorFromAnimation(SkColor color) OVERRIDE; 376 virtual void ScheduleDrawForAnimation() OVERRIDE; 377 virtual const gfx::Rect& GetBoundsForAnimation() const OVERRIDE; 378 virtual gfx::Transform GetTransformForAnimation() const OVERRIDE; 379 virtual float GetOpacityForAnimation() const OVERRIDE; 380 virtual bool GetVisibilityForAnimation() const OVERRIDE; 381 virtual float GetBrightnessForAnimation() const OVERRIDE; 382 virtual float GetGrayscaleForAnimation() const OVERRIDE; 383 virtual SkColor GetColorForAnimation() const OVERRIDE; 384 virtual float GetDeviceScaleFactor() const OVERRIDE; 385 virtual void AddThreadedAnimation( 386 scoped_ptr<cc::Animation> animation) OVERRIDE; 387 virtual void RemoveThreadedAnimation(int animation_id) OVERRIDE; 388 389 void CreateWebLayer(); 390 void RecomputeCCTransformFromTransform(const gfx::Transform& transform); 391 void RecomputeDrawsContentAndUVRect(); 392 void RecomputePosition(); 393 394 // Set all filters which got applied to the layer. 395 void SetLayerFilters(); 396 397 // Set all filters which got applied to the layer background. 398 void SetLayerBackgroundFilters(); 399 400 void UpdateIsDrawn(); 401 402 void SwitchToLayer(scoped_refptr<cc::Layer> new_layer); 403 404 // We cannot send animations to our cc_layer_ until we have been added to a 405 // layer tree. Instead, we hold on to these animations in 406 // pending_threaded_animations_, and expect SendPendingThreadedAnimations to 407 // be called once we have been added to a tree. 408 void SendPendingThreadedAnimations(); 409 410 const LayerType type_; 411 412 Compositor* compositor_; 413 414 scoped_refptr<ui::Texture> texture_; 415 416 Layer* parent_; 417 418 // This layer's children, in bottom-to-top stacking order. 419 std::vector<Layer*> children_; 420 421 gfx::Rect bounds_; 422 423 // Visibility of this layer. See SetVisible/IsDrawn for more details. 424 bool visible_; 425 426 bool force_render_surface_; 427 428 bool fills_bounds_opaquely_; 429 430 // If true the layer is always up to date. 431 bool layer_updated_externally_; 432 433 // Union of damaged rects, in pixel coordinates, to be used when 434 // compositor is ready to paint the content. 435 SkRegion damaged_region_; 436 437 int background_blur_radius_; 438 439 // Several variables which will change the visible representation of 440 // the layer. 441 float layer_saturation_; 442 float layer_brightness_; 443 float layer_grayscale_; 444 bool layer_inverted_; 445 446 // The associated mask layer with this layer. 447 Layer* layer_mask_; 448 // The back link from the mask layer to it's associated masked layer. 449 // We keep this reference for the case that if the mask layer gets deleted 450 // while attached to the main layer before the main layer is deleted. 451 Layer* layer_mask_back_link_; 452 453 // The zoom factor to scale the layer by. Zooming is disabled when this is 454 // set to 1. 455 float zoom_; 456 457 // Width of the border in pixels, where the scaling is blended. 458 int zoom_inset_; 459 460 std::string name_; 461 462 LayerDelegate* delegate_; 463 464 scoped_refptr<LayerAnimator> animator_; 465 466 // Animations that are passed to AddThreadedAnimation before this layer is 467 // added to a tree. 468 cc::ScopedPtrVector<cc::Animation> pending_threaded_animations_; 469 470 // Ownership of the layer is held through one of the strongly typed layer 471 // pointers, depending on which sort of layer this is. 472 scoped_refptr<cc::ContentLayer> content_layer_; 473 scoped_refptr<cc::TextureLayer> texture_layer_; 474 scoped_refptr<cc::SolidColorLayer> solid_color_layer_; 475 scoped_refptr<cc::DelegatedRendererLayer> delegated_renderer_layer_; 476 cc::Layer* cc_layer_; 477 478 // If true, the layer scales the canvas and the texture with the device scale 479 // factor as appropriate. When true, the texture size is in DIP. 480 bool scale_content_; 481 482 // A cached copy of |Compositor::device_scale_factor()|. 483 float device_scale_factor_; 484 485 // A cached copy of the TextureMailbox given texture_layer_. 486 cc::TextureMailbox mailbox_; 487 488 // Device scale factor in which mailbox_ was rendered in. 489 float mailbox_scale_factor_; 490 491 // The size of the delegated frame in DIP, set when SetDelegatedFrame was 492 // called. 493 gfx::Size delegated_frame_size_in_dip_; 494 495 DISALLOW_COPY_AND_ASSIGN(Layer); 496}; 497 498} // namespace ui 499 500#endif // UI_COMPOSITOR_LAYER_H_ 501