1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
|
// Copyright 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CC_LAYERS_LAYER_H_
#define CC_LAYERS_LAYER_H_
#include <set>
#include <string>
#include <vector>
#include "base/callback.h"
#include "base/memory/ref_counted.h"
#include "base/observer_list.h"
#include "cc/animation/layer_animation_controller.h"
#include "cc/animation/layer_animation_value_observer.h"
#include "cc/animation/layer_animation_value_provider.h"
#include "cc/base/cc_export.h"
#include "cc/base/region.h"
#include "cc/base/scoped_ptr_vector.h"
#include "cc/debug/frame_timing_request.h"
#include "cc/debug/micro_benchmark.h"
#include "cc/layers/draw_properties.h"
#include "cc/layers/layer_lists.h"
#include "cc/layers/layer_position_constraint.h"
#include "cc/layers/paint_properties.h"
#include "cc/layers/render_surface.h"
#include "cc/layers/scroll_blocks_on.h"
#include "cc/output/filter_operations.h"
#include "cc/trees/property_tree.h"
#include "skia/ext/refptr.h"
#include "third_party/skia/include/core/SkColor.h"
#include "third_party/skia/include/core/SkImageFilter.h"
#include "third_party/skia/include/core/SkPicture.h"
#include "third_party/skia/include/core/SkXfermode.h"
#include "ui/gfx/geometry/point3_f.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/geometry/scroll_offset.h"
#include "ui/gfx/transform.h"
namespace gfx {
class BoxF;
}
namespace base {
namespace trace_event {
class ConvertableToTraceFormat;
}
}
namespace cc {
class Animation;
class AnimationDelegate;
struct AnimationEvent;
class CopyOutputRequest;
class LayerAnimationEventObserver;
class LayerClient;
class LayerImpl;
class LayerSettings;
class LayerTreeHost;
class LayerTreeHostCommon;
class LayerTreeImpl;
class LayerTreeSettings;
class PriorityCalculator;
class RenderingStatsInstrumentation;
class ResourceUpdateQueue;
class ScrollbarLayerInterface;
class SimpleEnclosedRegion;
struct AnimationEvent;
template <typename LayerType>
class OcclusionTracker;
// Base class for composited layers. Special layer types are derived from
// this class.
class CC_EXPORT Layer : public base::RefCounted<Layer>,
public LayerAnimationValueObserver,
public LayerAnimationValueProvider {
public:
typedef RenderSurfaceLayerList RenderSurfaceListType;
typedef LayerList LayerListType;
typedef RenderSurface RenderSurfaceType;
enum LayerIdLabels {
INVALID_ID = -1,
};
static scoped_refptr<Layer> Create(const LayerSettings& settings);
int id() const { return layer_id_; }
Layer* RootLayer();
Layer* parent() { return parent_; }
const Layer* parent() const { return parent_; }
void AddChild(scoped_refptr<Layer> child);
void InsertChild(scoped_refptr<Layer> child, size_t index);
void ReplaceChild(Layer* reference, scoped_refptr<Layer> new_layer);
void RemoveFromParent();
void RemoveAllChildren();
void SetChildren(const LayerList& children);
bool HasAncestor(const Layer* ancestor) const;
const LayerList& children() const { return children_; }
Layer* child_at(size_t index) { return children_[index].get(); }
// This requests the layer and its subtree be rendered and given to the
// callback. If the copy is unable to be produced (the layer is destroyed
// first), then the callback is called with a nullptr/empty result. If the
// request's source property is set, any prior uncommitted requests having the
// same source will be aborted.
void RequestCopyOfOutput(scoped_ptr<CopyOutputRequest> request);
bool HasCopyRequest() const {
return !copy_requests_.empty();
}
virtual void SetBackgroundColor(SkColor background_color);
SkColor background_color() const { return background_color_; }
// If contents_opaque(), return an opaque color else return a
// non-opaque color. Tries to return background_color(), if possible.
SkColor SafeOpaqueBackgroundColor() const;
// A layer's bounds are in logical, non-page-scaled pixels (however, the
// root layer's bounds are in physical pixels).
void SetBounds(const gfx::Size& bounds);
gfx::Size bounds() const { return bounds_; }
void SetMasksToBounds(bool masks_to_bounds);
bool masks_to_bounds() const { return masks_to_bounds_; }
void SetMaskLayer(Layer* mask_layer);
Layer* mask_layer() { return mask_layer_.get(); }
const Layer* mask_layer() const { return mask_layer_.get(); }
virtual void SetNeedsDisplayRect(const gfx::Rect& dirty_rect);
void SetNeedsDisplay() { SetNeedsDisplayRect(gfx::Rect(bounds())); }
void SetOpacity(float opacity);
float opacity() const { return opacity_; }
bool OpacityIsAnimating() const;
virtual bool OpacityCanAnimateOnImplThread() const;
void SetBlendMode(SkXfermode::Mode blend_mode);
SkXfermode::Mode blend_mode() const { return blend_mode_; }
bool uses_default_blend_mode() const {
return blend_mode_ == SkXfermode::kSrcOver_Mode;
}
// A layer is root for an isolated group when it and all its descendants are
// drawn over a black and fully transparent background, creating an isolated
// group. It should be used along with SetBlendMode(), in order to restrict
// layers within the group to blend with layers outside this group.
void SetIsRootForIsolatedGroup(bool root);
bool is_root_for_isolated_group() const {
return is_root_for_isolated_group_;
}
void SetFilters(const FilterOperations& filters);
const FilterOperations& filters() const { return filters_; }
bool FilterIsAnimating() const;
// Background filters are filters applied to what is behind this layer, when
// they are viewed through non-opaque regions in this layer. They are used
// through the WebLayer interface, and are not exposed to HTML.
void SetBackgroundFilters(const FilterOperations& filters);
const FilterOperations& background_filters() const {
return background_filters_;
}
virtual void SetContentsOpaque(bool opaque);
bool contents_opaque() const { return contents_opaque_; }
void SetPosition(const gfx::PointF& position);
gfx::PointF position() const { return position_; }
void SetIsContainerForFixedPositionLayers(bool container);
bool IsContainerForFixedPositionLayers() const;
gfx::Vector2dF FixedContainerSizeDelta() const {
return gfx::Vector2dF();
}
void SetPositionConstraint(const LayerPositionConstraint& constraint);
const LayerPositionConstraint& position_constraint() const {
return position_constraint_;
}
void SetTransform(const gfx::Transform& transform);
const gfx::Transform& transform() const { return transform_; }
bool TransformIsAnimating() const;
bool AnimationsPreserveAxisAlignment() const;
bool transform_is_invertible() const { return transform_is_invertible_; }
void SetTransformOrigin(const gfx::Point3F&);
gfx::Point3F transform_origin() const { return transform_origin_; }
void SetScrollParent(Layer* parent);
Layer* scroll_parent() { return scroll_parent_; }
const Layer* scroll_parent() const { return scroll_parent_; }
void AddScrollChild(Layer* child);
void RemoveScrollChild(Layer* child);
std::set<Layer*>* scroll_children() { return scroll_children_.get(); }
const std::set<Layer*>* scroll_children() const {
return scroll_children_.get();
}
void SetClipParent(Layer* ancestor);
Layer* clip_parent() { return clip_parent_; }
const Layer* clip_parent() const {
return clip_parent_;
}
void AddClipChild(Layer* child);
void RemoveClipChild(Layer* child);
std::set<Layer*>* clip_children() { return clip_children_.get(); }
const std::set<Layer*>* clip_children() const {
return clip_children_.get();
}
DrawProperties<Layer>& draw_properties() { return draw_properties_; }
const DrawProperties<Layer>& draw_properties() const {
return draw_properties_;
}
// The following are shortcut accessors to get various information from
// draw_properties_
const gfx::Transform& draw_transform() const {
return draw_properties_.target_space_transform;
}
const gfx::Transform& screen_space_transform() const {
return draw_properties_.screen_space_transform;
}
float draw_opacity() const { return draw_properties_.opacity; }
bool draw_opacity_is_animating() const {
return draw_properties_.opacity_is_animating;
}
bool draw_transform_is_animating() const {
return draw_properties_.target_space_transform_is_animating;
}
bool screen_space_transform_is_animating() const {
return draw_properties_.screen_space_transform_is_animating;
}
bool screen_space_opacity_is_animating() const {
return draw_properties_.screen_space_opacity_is_animating;
}
bool is_clipped() const { return draw_properties_.is_clipped; }
gfx::Rect clip_rect() const { return draw_properties_.clip_rect; }
gfx::Rect drawable_content_rect() const {
return draw_properties_.drawable_content_rect;
}
gfx::Rect visible_content_rect() const {
return draw_properties_.visible_content_rect;
}
Layer* render_target() {
DCHECK(!draw_properties_.render_target ||
draw_properties_.render_target->render_surface());
return draw_properties_.render_target;
}
const Layer* render_target() const {
DCHECK(!draw_properties_.render_target ||
draw_properties_.render_target->render_surface());
return draw_properties_.render_target;
}
int num_unclipped_descendants() const {
return draw_properties_.num_unclipped_descendants;
}
RenderSurface* render_surface() const { return render_surface_.get(); }
void SetScrollOffset(const gfx::ScrollOffset& scroll_offset);
void SetScrollCompensationAdjustment(
const gfx::Vector2dF& scroll_compensation_adjustment);
gfx::Vector2dF ScrollCompensationAdjustment() const;
gfx::ScrollOffset scroll_offset() const { return scroll_offset_; }
void SetScrollOffsetFromImplSide(const gfx::ScrollOffset& scroll_offset);
void SetScrollClipLayerId(int clip_layer_id);
bool scrollable() const { return scroll_clip_layer_id_ != INVALID_ID; }
void SetUserScrollable(bool horizontal, bool vertical);
bool user_scrollable_horizontal() const {
return user_scrollable_horizontal_;
}
bool user_scrollable_vertical() const { return user_scrollable_vertical_; }
void SetShouldScrollOnMainThread(bool should_scroll_on_main_thread);
bool should_scroll_on_main_thread() const {
return should_scroll_on_main_thread_;
}
void SetHaveWheelEventHandlers(bool have_wheel_event_handlers);
bool have_wheel_event_handlers() const { return have_wheel_event_handlers_; }
void SetHaveScrollEventHandlers(bool have_scroll_event_handlers);
bool have_scroll_event_handlers() const {
return have_scroll_event_handlers_;
}
void SetNonFastScrollableRegion(const Region& non_fast_scrollable_region);
const Region& non_fast_scrollable_region() const {
return non_fast_scrollable_region_;
}
void SetTouchEventHandlerRegion(const Region& touch_event_handler_region);
const Region& touch_event_handler_region() const {
return touch_event_handler_region_;
}
void SetScrollBlocksOn(ScrollBlocksOn scroll_blocks_on);
ScrollBlocksOn scroll_blocks_on() const { return scroll_blocks_on_; }
void set_did_scroll_callback(const base::Closure& callback) {
did_scroll_callback_ = callback;
}
void SetDrawCheckerboardForMissingTiles(bool checkerboard);
bool draw_checkerboard_for_missing_tiles() const {
return draw_checkerboard_for_missing_tiles_;
}
void SetForceRenderSurface(bool force_render_surface);
bool force_render_surface() const { return force_render_surface_; }
gfx::Vector2dF ScrollDelta() const { return gfx::Vector2dF(); }
gfx::ScrollOffset CurrentScrollOffset() const { return scroll_offset_; }
void SetDoubleSided(bool double_sided);
bool double_sided() const { return double_sided_; }
void SetShouldFlattenTransform(bool flatten);
bool should_flatten_transform() const { return should_flatten_transform_; }
bool Is3dSorted() const { return sorting_context_id_ != 0; }
void set_use_parent_backface_visibility(bool use) {
use_parent_backface_visibility_ = use;
}
bool use_parent_backface_visibility() const {
return use_parent_backface_visibility_;
}
virtual void SetLayerTreeHost(LayerTreeHost* host);
virtual bool HasDelegatedContent() const;
bool HasContributingDelegatedRenderPasses() const { return false; }
void SetIsDrawable(bool is_drawable);
void SetHideLayerAndSubtree(bool hide);
bool hide_layer_and_subtree() const { return hide_layer_and_subtree_; }
void SetReplicaLayer(Layer* layer);
Layer* replica_layer() { return replica_layer_.get(); }
const Layer* replica_layer() const { return replica_layer_.get(); }
bool has_mask() const { return !!mask_layer_.get(); }
bool has_replica() const { return !!replica_layer_.get(); }
bool replica_has_mask() const {
return replica_layer_.get() &&
(mask_layer_.get() || replica_layer_->mask_layer_.get());
}
int NumDescendantsThatDrawContent() const;
// This is only virtual for tests.
// TODO(awoloszyn): Remove this once we no longer need it for tests
virtual bool DrawsContent() const;
// This methods typically need to be overwritten by derived classes.
virtual void SavePaintProperties();
// Returns true iff any resources were updated that need to be committed.
virtual bool Update(ResourceUpdateQueue* queue,
const OcclusionTracker<Layer>* occlusion);
virtual bool NeedMoreUpdates();
virtual void SetIsMask(bool is_mask) {}
virtual void ReduceMemoryUsage() {}
virtual void OnOutputSurfaceCreated() {}
virtual bool IsSuitableForGpuRasterization() const;
virtual scoped_refptr<base::trace_event::ConvertableToTraceFormat>
TakeDebugInfo();
void SetLayerClient(LayerClient* client) { client_ = client; }
virtual void PushPropertiesTo(LayerImpl* layer);
void CreateRenderSurface();
void ClearRenderSurface();
void ClearRenderSurfaceLayerList();
// The contents scale converts from logical, non-page-scaled pixels to target
// pixels. The contents scale is 1 for the root layer as it is already in
// physical pixels. By default contents scale is forced to be 1 except for
// subclasses of ContentsScalingLayer.
float contents_scale_x() const { return draw_properties_.contents_scale_x; }
float contents_scale_y() const { return draw_properties_.contents_scale_y; }
gfx::Size content_bounds() const { return draw_properties_.content_bounds; }
virtual void CalculateContentsScale(float ideal_contents_scale,
float* contents_scale_x,
float* contents_scale_y,
gfx::Size* content_bounds);
LayerTreeHost* layer_tree_host() { return layer_tree_host_; }
const LayerTreeHost* layer_tree_host() const { return layer_tree_host_; }
// Set the priority of all desired textures in this layer.
virtual void SetTexturePriorities(const PriorityCalculator& priority_calc) {}
bool AddAnimation(scoped_ptr<Animation> animation);
void PauseAnimation(int animation_id, double time_offset);
void RemoveAnimation(int animation_id);
void RemoveAnimation(int animation_id, Animation::TargetProperty property);
LayerAnimationController* layer_animation_controller() {
return layer_animation_controller_.get();
}
void SetLayerAnimationControllerForTest(
scoped_refptr<LayerAnimationController> controller);
void set_layer_animation_delegate(AnimationDelegate* delegate) {
DCHECK(layer_animation_controller_);
layer_animation_controller_->set_layer_animation_delegate(delegate);
}
bool HasActiveAnimation() const;
void RegisterForAnimations(AnimationRegistrar* registrar);
void AddLayerAnimationEventObserver(
LayerAnimationEventObserver* animation_observer);
void RemoveLayerAnimationEventObserver(
LayerAnimationEventObserver* animation_observer);
virtual SimpleEnclosedRegion VisibleContentOpaqueRegion() const;
virtual ScrollbarLayerInterface* ToScrollbarLayer();
gfx::Rect LayerRectToContentRect(const gfx::Rect& layer_rect) const;
virtual skia::RefPtr<SkPicture> GetPicture() const;
// Constructs a LayerImpl of the correct runtime type for this Layer type.
virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl);
bool NeedsDisplayForTesting() const { return !update_rect_.IsEmpty(); }
void ResetNeedsDisplayForTesting() { update_rect_ = gfx::Rect(); }
RenderingStatsInstrumentation* rendering_stats_instrumentation() const;
const PaintProperties& paint_properties() const {
return paint_properties_;
}
// The scale at which contents should be rastered, to match the scale at
// which they will drawn to the screen. This scale is a component of the
// contents scale but does not include page/device scale factors.
// TODO(danakj): This goes away when TiledLayer goes away.
void set_raster_scale(float scale) { raster_scale_ = scale; }
float raster_scale() const { return raster_scale_; }
bool raster_scale_is_unknown() const { return raster_scale_ == 0.f; }
void SetNeedsPushProperties();
bool needs_push_properties() const { return needs_push_properties_; }
bool descendant_needs_push_properties() const {
return num_dependents_need_push_properties_ > 0;
}
void reset_needs_push_properties_for_testing() {
needs_push_properties_ = false;
}
virtual void RunMicroBenchmark(MicroBenchmark* benchmark);
void Set3dSortingContextId(int id);
int sorting_context_id() const { return sorting_context_id_; }
void set_property_tree_sequence_number(int sequence_number) {
property_tree_sequence_number_ = sequence_number;
}
void SetTransformTreeIndex(int index);
int transform_tree_index() const;
void SetClipTreeIndex(int index);
int clip_tree_index() const;
void SetOpacityTreeIndex(int index);
int opacity_tree_index() const;
void set_offset_to_transform_parent(gfx::Vector2dF offset) {
if (offset_to_transform_parent_ == offset)
return;
offset_to_transform_parent_ = offset;
SetNeedsPushProperties();
}
gfx::Vector2dF offset_to_transform_parent() const {
return offset_to_transform_parent_;
}
// TODO(vollick): Once we transition to transform and clip trees, rename these
// functions and related values. The "from property trees" functions below
// use the transform and clip trees. Eventually, we will use these functions
// to compute the official values, but these functions are retained for
// testing purposes until we've migrated.
const gfx::Rect& visible_rect_from_property_trees() const {
return visible_rect_from_property_trees_;
}
void set_visible_rect_from_property_trees(const gfx::Rect& rect) {
// No push properties here, as this acts like a draw property.
visible_rect_from_property_trees_ = rect;
}
void set_should_flatten_transform_from_property_tree(bool should_flatten) {
if (should_flatten_transform_from_property_tree_ == should_flatten)
return;
should_flatten_transform_from_property_tree_ = should_flatten;
SetNeedsPushProperties();
}
bool should_flatten_transform_from_property_tree() const {
return should_flatten_transform_from_property_tree_;
}
// TODO(vollick): These values are temporary and will be removed as soon as
// render surface determinations are moved out of CDP. They only exist because
// certain logic depends on whether or not a layer would render to a separate
// surface, but CDP destroys surfaces and targets it doesn't need, so without
// this boolean, this is impossible to determine after the fact without
// wastefully recomputing it. This is public for the time being so that it can
// be accessed from CDP.
bool has_render_surface() const {
return has_render_surface_;
}
// Sets new frame timing requests for this layer.
void SetFrameTimingRequests(const std::vector<FrameTimingRequest>& requests);
// Accessor for unit tests
const std::vector<FrameTimingRequest>& FrameTimingRequests() const {
return frame_timing_requests_;
}
void DidBeginTracing();
void set_num_layer_or_descandant_with_copy_request(
int num_layer_or_descendants_with_copy_request) {
num_layer_or_descendants_with_copy_request_ =
num_layer_or_descendants_with_copy_request;
}
void set_num_layer_or_descandant_with_input_handler(
int num_layer_or_descendants_with_input_handler) {
num_layer_or_descendants_with_input_handler_ =
num_layer_or_descendants_with_input_handler;
}
int num_layer_or_descendants_with_input_handler() {
return num_layer_or_descendants_with_input_handler_;
}
void set_num_children_with_scroll_parent(
int num_children_with_scroll_parent) {
num_children_with_scroll_parent_ = num_children_with_scroll_parent;
}
int num_children_with_scroll_parent() {
return num_children_with_scroll_parent_;
}
void set_visited(bool visited);
bool visited();
void set_layer_or_descendant_is_drawn(bool layer_or_descendant_is_drawn);
bool layer_or_descendant_is_drawn();
void set_sorted_for_recursion(bool sorted_for_recursion);
bool sorted_for_recursion();
protected:
friend class LayerImpl;
friend class TreeSynchronizer;
~Layer() override;
explicit Layer(const LayerSettings& settings);
// These SetNeeds functions are in order of severity of update:
//
// Called when this layer has been modified in some way, but isn't sure
// that it needs a commit yet. It needs CalcDrawProperties and UpdateLayers
// before it knows whether or not a commit is required.
void SetNeedsUpdate();
// Called when a property has been modified in a way that the layer
// knows immediately that a commit is required. This implies SetNeedsUpdate
// as well as SetNeedsPushProperties to push that property.
void SetNeedsCommit();
// This is identical to SetNeedsCommit, but the former requests a rebuild of
// the property trees.
void SetNeedsCommitNoRebuild();
// Called when there's been a change in layer structure. Implies both
// SetNeedsUpdate and SetNeedsCommit, but not SetNeedsPushProperties.
void SetNeedsFullTreeSync();
// Called when the next commit should wait until the pending tree is activated
// before finishing the commit and unblocking the main thread. Used to ensure
// unused resources on the impl thread are returned before commit completes.
void SetNextCommitWaitsForActivation();
// Will recalculate whether the layer draws content and set draws_content_
// appropriately.
void UpdateDrawsContent(bool has_drawable_content);
virtual bool HasDrawableContent() const;
// Called when the layer's number of drawable descendants changes.
void AddDrawableDescendants(int num);
void AddDependentNeedsPushProperties();
void RemoveDependentNeedsPushProperties();
bool parent_should_know_need_push_properties() const {
return needs_push_properties() || descendant_needs_push_properties();
}
bool IsPropertyChangeAllowed() const;
void reset_raster_scale_to_unknown() { raster_scale_ = 0.f; }
// This flag is set when the layer needs to push properties to the impl
// side.
bool needs_push_properties_;
// The number of direct children or dependent layers that need to be recursed
// to in order for them or a descendent of them to push properties to the impl
// side.
int num_dependents_need_push_properties_;
// Tracks whether this layer may have changed stacking order with its
// siblings.
bool stacking_order_changed_;
// The update rect is the region of the compositor resource that was
// actually updated by the compositor. For layers that may do updating
// outside the compositor's control (i.e. plugin layers), this information
// is not available and the update rect will remain empty.
// Note this rect is in layer space (not content space).
gfx::Rect update_rect_;
scoped_refptr<Layer> mask_layer_;
int layer_id_;
// When true, the layer is about to perform an update. Any commit requests
// will be handled implicitly after the update completes.
bool ignore_set_needs_commit_;
// Layers that share a sorting context id will be sorted together in 3d
// space. 0 is a special value that means this layer will not be sorted and
// will be drawn in paint order.
int sorting_context_id_;
private:
friend class base::RefCounted<Layer>;
friend class LayerTreeHostCommon;
void SetParent(Layer* layer);
bool DescendantIsFixedToContainerLayer() const;
// This should only be called during BeginMainFrame since it does not
// trigger a Commit.
void SetHasRenderSurface(bool has_render_surface);
// Returns the index of the child or -1 if not found.
int IndexOfChild(const Layer* reference);
// This should only be called from RemoveFromParent().
void RemoveChildOrDependent(Layer* child);
// LayerAnimationValueProvider implementation.
gfx::ScrollOffset ScrollOffsetForAnimation() const override;
// LayerAnimationValueObserver implementation.
void OnFilterAnimated(const FilterOperations& filters) override;
void OnOpacityAnimated(float opacity) override;
void OnTransformAnimated(const gfx::Transform& transform) override;
void OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) override;
void OnAnimationWaitingForDeletion() override;
bool IsActive() const override;
// If this layer has a scroll parent, it removes |this| from its list of
// scroll children.
void RemoveFromScrollTree();
// If this layer has a clip parent, it removes |this| from its list of clip
// children.
void RemoveFromClipTree();
void UpdateNumCopyRequestsForSubtree(bool add);
void UpdateNumInputHandlersForSubtree(bool add);
LayerList children_;
Layer* parent_;
// Layer instances have a weak pointer to their LayerTreeHost.
// This pointer value is nil when a Layer is not in a tree and is
// updated via SetLayerTreeHost() if a layer moves between trees.
LayerTreeHost* layer_tree_host_;
scoped_refptr<LayerAnimationController> layer_animation_controller_;
// Layer properties.
gfx::Size bounds_;
gfx::ScrollOffset scroll_offset_;
gfx::Vector2dF scroll_compensation_adjustment_;
// This variable indicates which ancestor layer (if any) whose size,
// transformed relative to this layer, defines the maximum scroll offset for
// this layer.
int scroll_clip_layer_id_;
int num_descendants_that_draw_content_;
int transform_tree_index_;
int opacity_tree_index_;
int clip_tree_index_;
int property_tree_sequence_number_;
int num_layer_or_descendants_with_copy_request_;
int num_layer_or_descendants_with_input_handler_;
int num_children_with_scroll_parent_;
gfx::Vector2dF offset_to_transform_parent_;
bool should_flatten_transform_from_property_tree_ : 1;
bool should_scroll_on_main_thread_ : 1;
bool have_wheel_event_handlers_ : 1;
bool have_scroll_event_handlers_ : 1;
bool user_scrollable_horizontal_ : 1;
bool user_scrollable_vertical_ : 1;
bool is_root_for_isolated_group_ : 1;
bool is_container_for_fixed_position_layers_ : 1;
bool is_drawable_ : 1;
bool draws_content_ : 1;
bool hide_layer_and_subtree_ : 1;
bool masks_to_bounds_ : 1;
bool contents_opaque_ : 1;
bool double_sided_ : 1;
bool should_flatten_transform_ : 1;
bool use_parent_backface_visibility_ : 1;
bool draw_checkerboard_for_missing_tiles_ : 1;
bool force_render_surface_ : 1;
bool transform_is_invertible_ : 1;
bool has_render_surface_ : 1;
ScrollBlocksOn scroll_blocks_on_ : 3;
Region non_fast_scrollable_region_;
Region touch_event_handler_region_;
gfx::PointF position_;
SkColor background_color_;
float opacity_;
SkXfermode::Mode blend_mode_;
FilterOperations filters_;
FilterOperations background_filters_;
LayerPositionConstraint position_constraint_;
Layer* scroll_parent_;
scoped_ptr<std::set<Layer*>> scroll_children_;
// The following three variables are tracker variables. They are bools
// wrapped inside an integer variable. If true, their value equals the
// LayerTreeHost's meta_information_sequence_number. This wrapping of bools
// inside ints is done to avoid a layer tree treewalk to reset their values.
int layer_or_descendant_is_drawn_tracker_;
int sorted_for_recursion_tracker_;
int visited_tracker_;
Layer* clip_parent_;
scoped_ptr<std::set<Layer*>> clip_children_;
gfx::Transform transform_;
gfx::Point3F transform_origin_;
// Replica layer used for reflections.
scoped_refptr<Layer> replica_layer_;
// Transient properties.
float raster_scale_;
LayerClient* client_;
ScopedPtrVector<CopyOutputRequest> copy_requests_;
base::Closure did_scroll_callback_;
DrawProperties<Layer> draw_properties_;
PaintProperties paint_properties_;
// TODO(awoloszyn): This is redundant with has_render_surface_,
// and should get removed once it is no longer needed on main thread.
scoped_ptr<RenderSurface> render_surface_;
gfx::Rect visible_rect_from_property_trees_;
std::vector<FrameTimingRequest> frame_timing_requests_;
bool frame_timing_requests_dirty_;
DISALLOW_COPY_AND_ASSIGN(Layer);
};
} // namespace cc
#endif // CC_LAYERS_LAYER_H_
|