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.
5 #ifndef UI_COMPOSITOR_LAYER_H_
6 #define UI_COMPOSITOR_LAYER_H_
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"
35 class CopyOutputRequest
;
36 class DelegatedFrameProvider
;
37 class DelegatedRendererLayer
;
39 class ResourceUpdateQueue
;
40 class SolidColorLayer
;
42 struct ReturnedResource
;
43 typedef std::vector
<ReturnedResource
> ReturnedResourceArray
;
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.
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.
62 class 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
) {
70 explicit Layer(LayerType type
);
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();
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
);
81 LayerDelegate
* delegate() { return delegate_
; }
82 void set_delegate(LayerDelegate
* delegate
) { delegate_
= delegate
; }
84 // Adds a new Layer to this Layer.
85 void Add(Layer
* child
);
87 // Removes a Layer from this Layer.
88 void Remove(Layer
* child
);
90 // Stacks |child| above all other children.
91 void StackAtTop(Layer
* child
);
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
);
98 // Stacks |child| below all other children.
99 void StackAtBottom(Layer
* child
);
101 // Stacks |child| directly below |other|. Both must be children of this
103 void StackBelow(Layer
* child
, Layer
* other
);
105 // Returns the child Layers.
106 const std::vector
<Layer
*>& children() const { return children_
; }
109 const Layer
* parent() const { return parent_
; }
110 Layer
* parent() { return parent_
; }
112 LayerType
type() const { return type_
; }
114 // Returns true if this Layer contains |other| somewhere in its children.
115 bool Contains(const Layer
* other
) const;
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
);
122 // Returns the layer's animator. Creates a default animator of one has not
123 // been set. Will not return NULL.
124 LayerAnimator
* GetAnimator();
126 // The transform, relative to the parent.
127 void SetTransform(const gfx::Transform
& transform
);
128 gfx::Transform
transform() const;
130 // Return the target transform if animator is running, or the current
131 // transform otherwise.
132 gfx::Transform
GetTargetTransform() const;
134 // The bounds, relative to the parent.
135 void SetBounds(const gfx::Rect
& bounds
);
136 const gfx::Rect
& bounds() const { return bounds_
; }
138 // Return the target bounds if animator is running, or the current bounds
140 gfx::Rect
GetTargetBounds() const;
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;
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
);
152 // Returns the actual opacity, which the opacity of this layer multipled by
153 // the combined opacity of the parent.
154 float GetCombinedOpacity() const;
156 // Blur pixels by this amount in anything below the layer and visible through
158 int background_blur() const { return background_blur_radius_
; }
159 void SetBackgroundBlur(int blur_radius
);
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
);
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
);
173 // Return the target brightness if animator is running, or the current
174 // brightness otherwise.
175 float GetTargetBrightness() const;
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
);
183 // Return the target grayscale if animator is running, or the current
184 // grayscale otherwise.
185 float GetTargetGrayscale() const;
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
);
192 bool layer_inverted() const { return layer_inverted_
; }
193 void SetLayerInverted(bool inverted
);
195 // Return the target opacity if animator is running, or the current opacity
197 float GetTargetOpacity() const;
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_
; }
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_
; }
212 // Returns the target visibility if the animator is running. Otherwise, it
213 // returns the current visibility.
214 bool GetTargetVisibility() const;
216 // Returns true if this Layer is drawn. A Layer is drawn only if all ancestors
218 bool IsDrawn() const;
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;
224 // Converts a point from the coordinates of |source| to the coordinates of
225 // |target|. Necessarily, |source| and |target| must inhabit the same Layer
227 static void ConvertPointToLayer(const Layer
* source
,
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;
237 // Converts a ui::Layer's transform to the transform on the corresponding
239 static gfx::Transform
ConvertTransformToCCTransform(
240 const gfx::Transform
& transform
,
241 float device_scale_factor
);
243 // See description in View for details
244 void SetFillsBoundsOpaquely(bool fills_bounds_opaquely
);
245 bool fills_bounds_opaquely() const { return fills_bounds_opaquely_
; }
247 const std::string
& name() const { return name_
; }
248 void set_name(const std::string
& name
) { name_
= name
; }
250 const ui::Texture
* texture() const { return texture_
.get(); }
252 // Assigns a new external texture. |texture| can be NULL to disable external
254 void SetExternalTexture(ui::Texture
* texture
);
255 ui::Texture
* external_texture() { return texture_
.get(); }
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
,
260 scoped_ptr
<cc::SingleReleaseCallback
> release_callback
,
262 cc::TextureMailbox
GetTextureMailbox(float* scale_factor
);
264 // Begins showing delegated frames from the |frame_provider|.
265 void SetShowDelegatedContent(cc::DelegatedFrameProvider
* frame_provider
,
266 gfx::Size frame_size_in_dip
);
268 bool has_external_content() {
269 return texture_layer_
.get() || delegated_renderer_layer_
.get();
272 void SetShowPaintedContent();
274 // Sets the layer's fill color. May only be called for LAYER_SOLID_COLOR.
275 void SetColor(SkColor color
);
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
);
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.
286 // Sends damaged rectangles recorded in |damaged_region_| to
287 // |compostior_| to repaint the content.
288 void SendDamagedRects();
290 // Suppresses painting the content by disgarding damaged region and ignoring
291 // new paint requests.
292 void SuppressPaint();
294 // Notifies the layer that the device scale factor has changed.
295 void OnDeviceScaleFactorChanged(float device_scale_factor
);
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
; }
305 // Returns true if the layer scales its content.
306 bool scale_content() const { return scale_content_
; }
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_
; }
312 // Requets a copy of the layer's output as a texture or bitmap.
313 void RequestCopyOfOutput(scoped_ptr
<cc::CopyOutputRequest
> request
);
315 // ContentLayerClient
316 virtual void PaintContents(
317 SkCanvas
* canvas
, gfx::Rect clip
, gfx::RectF
* opaque
) OVERRIDE
;
318 virtual void DidChangeLayerCanUseLCDText() OVERRIDE
{}
320 cc::Layer
* cc_layer() { return cc_layer_
; }
322 // TextureLayerClient
323 virtual unsigned PrepareTexture() OVERRIDE
;
324 virtual WebKit::WebGraphicsContext3D
* Context3d() OVERRIDE
;
325 virtual bool PrepareTextureMailbox(
326 cc::TextureMailbox
* mailbox
,
327 scoped_ptr
<cc::SingleReleaseCallback
>* release_callback
,
328 bool use_shared_memory
) OVERRIDE
;
330 float device_scale_factor() const { return device_scale_factor_
; }
332 // Forces a render surface to be used on this layer. This has no positive
333 // impact, and is only used for benchmarking/testing purpose.
334 void SetForceRenderSurface(bool force
);
335 bool force_render_surface() const { return force_render_surface_
; }
338 virtual std::string
DebugName() OVERRIDE
;
340 // LayerAnimationEventObserver
341 virtual void OnAnimationStarted(const cc::AnimationEvent
& event
) OVERRIDE
;
343 // Whether this layer has animations waiting to get sent to its cc::Layer.
344 bool HasPendingThreadedAnimations() {
345 return pending_threaded_animations_
.size() != 0;
348 // Triggers a call to SwitchToLayer.
349 void SwitchCCLayerForTest();
352 // Stacks |child| above or below |other|. Helper method for StackAbove() and
354 void StackRelativeTo(Layer
* child
, Layer
* other
, bool above
);
356 bool ConvertPointForAncestor(const Layer
* ancestor
, gfx::Point
* point
) const;
357 bool ConvertPointFromAncestor(const Layer
* ancestor
, gfx::Point
* point
) const;
359 // Following are invoked from the animation or if no animation exists to
360 // update the values immediately.
361 void SetBoundsImmediately(const gfx::Rect
& bounds
);
362 void SetTransformImmediately(const gfx::Transform
& transform
);
363 void SetOpacityImmediately(float opacity
);
364 void SetVisibilityImmediately(bool visibility
);
365 void SetBrightnessImmediately(float brightness
);
366 void SetGrayscaleImmediately(float grayscale
);
367 void SetColorImmediately(SkColor color
);
369 // Implementation of LayerAnimatorDelegate
370 virtual void SetBoundsFromAnimation(const gfx::Rect
& bounds
) OVERRIDE
;
371 virtual void SetTransformFromAnimation(
372 const gfx::Transform
& transform
) OVERRIDE
;
373 virtual void SetOpacityFromAnimation(float opacity
) OVERRIDE
;
374 virtual void SetVisibilityFromAnimation(bool visibility
) OVERRIDE
;
375 virtual void SetBrightnessFromAnimation(float brightness
) OVERRIDE
;
376 virtual void SetGrayscaleFromAnimation(float grayscale
) OVERRIDE
;
377 virtual void SetColorFromAnimation(SkColor color
) OVERRIDE
;
378 virtual void ScheduleDrawForAnimation() OVERRIDE
;
379 virtual const gfx::Rect
& GetBoundsForAnimation() const OVERRIDE
;
380 virtual gfx::Transform
GetTransformForAnimation() const OVERRIDE
;
381 virtual float GetOpacityForAnimation() const OVERRIDE
;
382 virtual bool GetVisibilityForAnimation() const OVERRIDE
;
383 virtual float GetBrightnessForAnimation() const OVERRIDE
;
384 virtual float GetGrayscaleForAnimation() const OVERRIDE
;
385 virtual SkColor
GetColorForAnimation() const OVERRIDE
;
386 virtual float GetDeviceScaleFactor() const OVERRIDE
;
387 virtual void AddThreadedAnimation(
388 scoped_ptr
<cc::Animation
> animation
) OVERRIDE
;
389 virtual void RemoveThreadedAnimation(int animation_id
) OVERRIDE
;
391 void CreateWebLayer();
392 void RecomputeCCTransformFromTransform(const gfx::Transform
& transform
);
393 void RecomputeDrawsContentAndUVRect();
394 void RecomputePosition();
396 // Set all filters which got applied to the layer.
397 void SetLayerFilters();
399 // Set all filters which got applied to the layer background.
400 void SetLayerBackgroundFilters();
402 void UpdateIsDrawn();
404 void SwitchToLayer(scoped_refptr
<cc::Layer
> new_layer
);
406 // We cannot send animations to our cc_layer_ until we have been added to a
407 // layer tree. Instead, we hold on to these animations in
408 // pending_threaded_animations_, and expect SendPendingThreadedAnimations to
409 // be called once we have been added to a tree.
410 void SendPendingThreadedAnimations();
412 const LayerType type_
;
414 Compositor
* compositor_
;
416 scoped_refptr
<ui::Texture
> texture_
;
420 // This layer's children, in bottom-to-top stacking order.
421 std::vector
<Layer
*> children_
;
425 // Visibility of this layer. See SetVisible/IsDrawn for more details.
428 bool force_render_surface_
;
430 bool fills_bounds_opaquely_
;
432 // If true the layer is always up to date.
433 bool layer_updated_externally_
;
435 // Union of damaged rects, in pixel coordinates, to be used when
436 // compositor is ready to paint the content.
437 SkRegion damaged_region_
;
439 int background_blur_radius_
;
441 // Several variables which will change the visible representation of
443 float layer_saturation_
;
444 float layer_brightness_
;
445 float layer_grayscale_
;
446 bool layer_inverted_
;
448 // The associated mask layer with this layer.
450 // The back link from the mask layer to it's associated masked layer.
451 // We keep this reference for the case that if the mask layer gets deleted
452 // while attached to the main layer before the main layer is deleted.
453 Layer
* layer_mask_back_link_
;
455 // The zoom factor to scale the layer by. Zooming is disabled when this is
459 // Width of the border in pixels, where the scaling is blended.
464 LayerDelegate
* delegate_
;
466 scoped_refptr
<LayerAnimator
> animator_
;
468 // Animations that are passed to AddThreadedAnimation before this layer is
470 cc::ScopedPtrVector
<cc::Animation
> pending_threaded_animations_
;
472 // Ownership of the layer is held through one of the strongly typed layer
473 // pointers, depending on which sort of layer this is.
474 scoped_refptr
<cc::ContentLayer
> content_layer_
;
475 scoped_refptr
<cc::TextureLayer
> texture_layer_
;
476 scoped_refptr
<cc::SolidColorLayer
> solid_color_layer_
;
477 scoped_refptr
<cc::DelegatedRendererLayer
> delegated_renderer_layer_
;
478 cc::Layer
* cc_layer_
;
480 // If true, the layer scales the canvas and the texture with the device scale
481 // factor as apporpriate. When true, the texture size is in DIP.
484 // A cached copy of |Compositor::device_scale_factor()|.
485 float device_scale_factor_
;
487 // A cached copy of the TextureMailbox given texture_layer_.
488 cc::TextureMailbox mailbox_
;
490 // Device scale factor in which mailbox_ was rendered in.
491 float mailbox_scale_factor_
;
493 // The size of the delegated frame in DIP, set when SetShowDelegatedContent
495 gfx::Size delegated_frame_size_in_dip_
;
497 DISALLOW_COPY_AND_ASSIGN(Layer
);
502 #endif // UI_COMPOSITOR_LAYER_H_