-
Notifications
You must be signed in to change notification settings - Fork 1.3k
/
RenderLayer.h
1318 lines (1034 loc) · 62.4 KB
/
RenderLayer.h
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
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Copyright (C) 2003, 2009, 2012, 2015 Apple Inc. All rights reserved.
* Copyright (c) 2020 Igalia S.L.
*
* Portions are Copyright (C) 1998 Netscape Communications Corporation.
*
* Other contributors:
* Robert O'Callahan <roc+@cs.cmu.edu>
* David Baron <dbaron@fas.harvard.edu>
* Christian Biesinger <cbiesinger@web.de>
* Randall Jesup <rjesup@wgate.com>
* Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
* Josh Soref <timeless@mac.com>
* Boris Zbarsky <bzbarsky@mit.edu>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Alternatively, the contents of this file may be used under the terms
* of either the Mozilla Public License Version 1.1, found at
* http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
* License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
* (the "GPL"), in which case the provisions of the MPL or the GPL are
* applicable instead of those above. If you wish to allow use of your
* version of this file only under the terms of one of those two
* licenses (the MPL or the GPL) and not to allow others to use your
* version of this file under the LGPL, indicate your decision by
* deletingthe provisions above and replace them with the notice and
* other provisions required by the MPL or the GPL, as the case may be.
* If you do not delete the provisions above, a recipient may use your
* version of this file under any of the LGPL, the MPL or the GPL.
*/
#pragma once
#include "ClipRect.h"
#include "GraphicsLayer.h"
#include "LayerFragment.h"
#include "PaintFrequencyTracker.h"
#include "PaintInfo.h"
#include "RenderBox.h"
#include "RenderPtr.h"
#include "RenderSVGModelObject.h"
#include "ScrollBehavior.h"
#include <memory>
#include <wtf/Markable.h>
#include <wtf/WeakPtr.h>
namespace WTF {
class TextStream;
}
namespace WebCore {
class CSSFilter;
class ClipRects;
class ClipRectsCache;
class EventRegionContext;
class HitTestRequest;
class HitTestResult;
class HitTestingTransformState;
class Region;
class RenderFragmentedFlow;
class RenderGeometryMap;
class RenderLayerBacking;
class RenderLayerCompositor;
class RenderLayerFilters;
class RenderLayerScrollableArea;
class RenderMarquee;
class RenderReplica;
class RenderScrollbarPart;
class RenderStyle;
class RenderView;
class Scrollbar;
class TransformationMatrix;
enum BorderRadiusClippingRule { IncludeSelfForBorderRadius, DoNotIncludeSelfForBorderRadius };
enum IncludeSelfOrNot { IncludeSelf, ExcludeSelf };
enum CrossFrameBoundaries { No, Yes };
enum RepaintStatus {
NeedsNormalRepaint,
NeedsFullRepaint,
NeedsFullRepaintForPositionedMovementLayout
};
enum ClipRectsType {
PaintingClipRects, // Relative to painting ancestor. Used for painting.
RootRelativeClipRects, // Relative to the ancestor treated as the root (e.g. transformed layer). Used for hit testing.
AbsoluteClipRects, // Relative to the RenderView's layer. Used for compositing overlap testing.
NumCachedClipRectsTypes,
AllClipRectTypes,
TemporaryClipRects
};
enum ShouldRespectOverflowClip {
IgnoreOverflowClip,
RespectOverflowClip
};
enum ShouldApplyRootOffsetToFragments {
ApplyRootOffsetToFragments,
IgnoreRootOffsetForFragments
};
enum class RequestState {
Unknown,
DontCare,
False,
True,
Undetermined
};
enum class IndirectCompositingReason {
None,
Clipping,
Stacking,
OverflowScrollPositioning,
Overlap,
BackgroundLayer,
GraphicalEffect, // opacity, mask, filter, transform etc.
Perspective,
Preserve3D
};
enum class ShouldAllowCrossOriginScrolling { No, Yes };
struct ScrollRectToVisibleOptions {
SelectionRevealMode revealMode { SelectionRevealMode::Reveal };
const ScrollAlignment& alignX { ScrollAlignment::alignCenterIfNeeded };
const ScrollAlignment& alignY { ScrollAlignment::alignCenterIfNeeded };
ShouldAllowCrossOriginScrolling shouldAllowCrossOriginScrolling { ShouldAllowCrossOriginScrolling::No };
ScrollBehavior behavior { ScrollBehavior::Auto };
};
using ScrollingScope = uint64_t;
DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(RenderLayer);
class RenderLayer : public CanMakeWeakPtr<RenderLayer> {
WTF_MAKE_FAST_ALLOCATED_WITH_HEAP_IDENTIFIER(RenderLayer);
public:
friend class RenderReplica;
friend class RenderLayerFilters;
friend class RenderLayerBacking;
friend class RenderLayerCompositor;
friend class RenderLayerScrollableArea;
explicit RenderLayer(RenderLayerModelObject&);
~RenderLayer();
WEBCORE_EXPORT RenderLayerScrollableArea* scrollableArea() const;
WEBCORE_EXPORT RenderLayerScrollableArea* ensureLayerScrollableArea();
#if PLATFORM(IOS_FAMILY)
// Called before the renderer's widget (if any) has been nulled out.
void willBeDestroyed();
#endif
String name() const;
Page& page() const { return renderer().page(); }
RenderLayerModelObject& renderer() const { return m_renderer; }
RenderBox* renderBox() const { return dynamicDowncast<RenderBox>(renderer()); }
RenderLayer* parent() const { return m_parent; }
RenderLayer* previousSibling() const { return m_previous; }
RenderLayer* nextSibling() const { return m_next; }
RenderLayer* firstChild() const { return m_first; }
RenderLayer* lastChild() const { return m_last; }
bool isDescendantOf(const RenderLayer&) const;
RenderLayer* commonAncestorWithLayer(const RenderLayer&) const;
// This does an ancestor tree walk. Avoid it!
const RenderLayer* root() const
{
const RenderLayer* curr = this;
while (curr->parent())
curr = curr->parent();
return curr;
}
void addChild(RenderLayer& newChild, RenderLayer* beforeChild = nullptr);
void removeChild(RenderLayer&);
enum class LayerChangeTiming {
StyleChange,
RenderTreeConstruction,
};
void insertOnlyThisLayer(LayerChangeTiming);
void removeOnlyThisLayer(LayerChangeTiming);
bool isNormalFlowOnly() const { return m_isNormalFlowOnly; }
// isStackingContext is true for layers that we've determined should be stacking contexts for painting.
// Not all stacking contexts are CSS stacking contexts.
bool isStackingContext() const { return isCSSStackingContext() || m_isOpportunisticStackingContext; }
// isCSSStackingContext is true for layers that are stacking contexts from a CSS perspective.
// isCSSStackingContext() => isStackingContext().
// FIXME: m_forcedStackingContext should affect isStackingContext(), not isCSSStackingContext(), but doing so breaks media control mix-blend-mode.
bool isCSSStackingContext() const { return m_isCSSStackingContext || m_forcedStackingContext; }
// Gets the enclosing stacking context for this layer, excluding this layer itself.
RenderLayer* stackingContext() const;
// Gets the enclosing stacking container for this layer, possibly the layer
// itself, if it is a stacking container.
RenderLayer* enclosingStackingContext() { return isStackingContext() ? this : stackingContext(); }
RenderLayer* paintOrderParent() const;
std::optional<LayerRepaintRects> repaintRects() const
{
if (m_repaintRectsValid)
return m_repaintRects;
return { };
}
void dirtyNormalFlowList();
void dirtyZOrderLists();
void dirtyStackingContextZOrderLists();
bool normalFlowListDirty() const { return m_normalFlowListDirty; }
bool zOrderListsDirty() const { return m_zOrderListsDirty; }
#if ASSERT_ENABLED
bool layerListMutationAllowed() const { return m_layerListMutationAllowed; }
void setLayerListMutationAllowed(bool flag) { m_layerListMutationAllowed = flag; }
#endif
bool willCompositeClipPath() const;
protected:
void destroy();
private:
// These flags propagate in paint order (z-order tree).
enum class Compositing {
HasDescendantNeedingRequirementsTraversal = 1 << 0, // Need to do the overlap-testing tree walk because hierarchy or geometry changed.
HasDescendantNeedingBackingOrHierarchyTraversal = 1 << 1, // Need to update geometry, configuration and update the GraphicsLayer tree.
// Things that trigger HasDescendantNeedingRequirementsTraversal
NeedsPaintOrderChildrenUpdate = 1 << 2, // The paint order children of this layer changed (gained/lost child, order change).
NeedsPostLayoutUpdate = 1 << 3, // Needs compositing to be re-evaluated after layout (it depends on geometry).
DescendantsNeedRequirementsTraversal = 1 << 4, // Something changed that forces computeCompositingRequirements to traverse all descendant layers.
SubsequentLayersNeedRequirementsTraversal = 1 << 5, // Something changed that forces computeCompositingRequirements to traverse all layers later in paint order.
// Things that trigger HasDescendantNeedingBackingOrHierarchyTraversal
NeedsGeometryUpdate = 1 << 6, // This layer needs a geometry update.
NeedsConfigurationUpdate = 1 << 7, // This layer needs a configuration update (updating its internal compositing hierarchy).
NeedsScrollingTreeUpdate = 1 << 8, // Something changed that requires this layer's scrolling tree node to be updated.
NeedsLayerConnection = 1 << 9, // This layer needs hookup with its parents or children.
ChildrenNeedGeometryUpdate = 1 << 10, // This layer's composited children need a geometry update.
DescendantsNeedBackingAndHierarchyTraversal = 1 << 11, // Something changed that forces us to traverse all descendant layers in updateBackingAndHierarchy.
};
static constexpr OptionSet<Compositing> computeCompositingRequirementsFlags()
{
return {
Compositing::NeedsPaintOrderChildrenUpdate,
Compositing::NeedsPostLayoutUpdate,
Compositing::DescendantsNeedRequirementsTraversal,
Compositing::SubsequentLayersNeedRequirementsTraversal,
};
}
static constexpr OptionSet<Compositing> updateBackingOrHierarchyFlags()
{
return {
Compositing::NeedsLayerConnection,
Compositing::NeedsGeometryUpdate,
Compositing::NeedsConfigurationUpdate,
Compositing::NeedsScrollingTreeUpdate,
Compositing::ChildrenNeedGeometryUpdate,
Compositing::DescendantsNeedBackingAndHierarchyTraversal,
};
}
void setAncestorsHaveCompositingDirtyFlag(Compositing);
public:
bool hasDescendantNeedingCompositingRequirementsTraversal() const { return m_compositingDirtyBits.contains(Compositing::HasDescendantNeedingRequirementsTraversal); }
bool hasDescendantNeedingUpdateBackingOrHierarchyTraversal() const { return m_compositingDirtyBits.contains(Compositing::HasDescendantNeedingBackingOrHierarchyTraversal); }
bool needsCompositingPaintOrderChildrenUpdate() const { return m_compositingDirtyBits.contains(Compositing::NeedsPaintOrderChildrenUpdate); }
bool needsPostLayoutCompositingUpdate() const { return m_compositingDirtyBits.contains(Compositing::NeedsPostLayoutUpdate); }
bool descendantsNeedCompositingRequirementsTraversal() const { return m_compositingDirtyBits.contains(Compositing::DescendantsNeedRequirementsTraversal); }
bool subsequentLayersNeedCompositingRequirementsTraversal() const { return m_compositingDirtyBits.contains(Compositing::SubsequentLayersNeedRequirementsTraversal); }
bool needsCompositingLayerConnection() const { return m_compositingDirtyBits.contains(Compositing::NeedsLayerConnection); }
bool needsCompositingGeometryUpdate() const { return m_compositingDirtyBits.contains(Compositing::NeedsGeometryUpdate); }
bool needsCompositingConfigurationUpdate() const { return m_compositingDirtyBits.contains(Compositing::NeedsConfigurationUpdate); }
bool needsScrollingTreeUpdate() const { return m_compositingDirtyBits.contains(Compositing::NeedsScrollingTreeUpdate); }
bool childrenNeedCompositingGeometryUpdate() const { return m_compositingDirtyBits.contains(Compositing::ChildrenNeedGeometryUpdate); }
bool descendantsNeedUpdateBackingAndHierarchyTraversal() const { return m_compositingDirtyBits.contains(Compositing::DescendantsNeedBackingAndHierarchyTraversal); }
template<Compositing V>
void setRequirementsTraversalDirtyBit()
{
m_compositingDirtyBits.add(V);
setAncestorsHaveCompositingDirtyFlag(Compositing::HasDescendantNeedingRequirementsTraversal);
}
void setNeedsCompositingPaintOrderChildrenUpdate() { setRequirementsTraversalDirtyBit<Compositing::NeedsPaintOrderChildrenUpdate>(); }
void setNeedsPostLayoutCompositingUpdate() { setRequirementsTraversalDirtyBit<Compositing::NeedsPostLayoutUpdate>(); }
void setDescendantsNeedCompositingRequirementsTraversal() { setRequirementsTraversalDirtyBit<Compositing::DescendantsNeedRequirementsTraversal>(); }
void setSubsequentLayersNeedCompositingRequirementsTraversal() { setRequirementsTraversalDirtyBit<Compositing::SubsequentLayersNeedRequirementsTraversal>(); }
void setNeedsPostLayoutCompositingUpdateOnAncestors() { setAncestorsHaveCompositingDirtyFlag(Compositing::NeedsPostLayoutUpdate); }
template<Compositing V>
void setBackingAndHierarchyTraversalDirtyBit()
{
m_compositingDirtyBits.add(V);
setAncestorsHaveCompositingDirtyFlag(Compositing::HasDescendantNeedingBackingOrHierarchyTraversal);
}
void setNeedsCompositingLayerConnection() { setBackingAndHierarchyTraversalDirtyBit<Compositing::NeedsLayerConnection>(); }
void setNeedsCompositingGeometryUpdate() { setBackingAndHierarchyTraversalDirtyBit<Compositing::NeedsGeometryUpdate>(); }
void setNeedsCompositingConfigurationUpdate() { setBackingAndHierarchyTraversalDirtyBit<Compositing::NeedsConfigurationUpdate>(); }
void setNeedsScrollingTreeUpdate() { setBackingAndHierarchyTraversalDirtyBit<Compositing::NeedsScrollingTreeUpdate>(); }
void setChildrenNeedCompositingGeometryUpdate() { setBackingAndHierarchyTraversalDirtyBit<Compositing::ChildrenNeedGeometryUpdate>(); }
void setDescendantsNeedUpdateBackingAndHierarchyTraversal() { setBackingAndHierarchyTraversalDirtyBit<Compositing::DescendantsNeedBackingAndHierarchyTraversal>(); }
void setNeedsCompositingGeometryUpdateOnAncestors() { setAncestorsHaveCompositingDirtyFlag(Compositing::NeedsGeometryUpdate); }
bool needsCompositingRequirementsTraversal() const { return m_compositingDirtyBits.containsAny(computeCompositingRequirementsFlags()); }
void clearCompositingRequirementsTraversalState()
{
m_compositingDirtyBits.remove(Compositing::HasDescendantNeedingRequirementsTraversal);
m_compositingDirtyBits.remove(computeCompositingRequirementsFlags());
}
bool needsUpdateBackingOrHierarchyTraversal() const { return m_compositingDirtyBits.containsAny(updateBackingOrHierarchyFlags()); }
void clearUpdateBackingOrHierarchyTraversalState()
{
m_compositingDirtyBits.remove(Compositing::HasDescendantNeedingBackingOrHierarchyTraversal);
m_compositingDirtyBits.remove(updateBackingOrHierarchyFlags());
}
bool needsAnyCompositingTraversal() const { return !m_compositingDirtyBits.isEmpty(); }
void clearCompositingPaintOrderState() { m_compositingDirtyBits = { }; }
class LayerList {
friend class RenderLayer;
public:
using iterator = RenderLayer**;
using const_iterator = RenderLayer * const *;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
iterator begin() { return m_layerList ? m_layerList->begin() : nullptr; }
iterator end() { return m_layerList ? m_layerList->end() : nullptr; }
reverse_iterator rbegin() { return reverse_iterator(end()); }
reverse_iterator rend() { return reverse_iterator(begin()); }
const_iterator begin() const { return m_layerList ? m_layerList->begin() : nullptr; }
const_iterator end() const { return m_layerList ? m_layerList->end() : nullptr; }
const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); }
const_reverse_iterator rend() const { return const_reverse_iterator(begin()); }
size_t size() const { return m_layerList ? m_layerList->size() : 0; }
private:
LayerList(Vector<RenderLayer*>* layerList)
: m_layerList(layerList)
{
}
Vector<RenderLayer*>* m_layerList;
};
LayerList normalFlowLayers() const
{
ASSERT(!m_normalFlowListDirty);
return LayerList(m_normalFlowList.get());
}
LayerList positiveZOrderLayers() const
{
ASSERT(!m_zOrderListsDirty);
ASSERT(isStackingContext() || !m_posZOrderList);
return LayerList(m_posZOrderList.get());
}
bool hasNegativeZOrderLayers() const
{
return m_negZOrderList && m_negZOrderList->size();
}
LayerList negativeZOrderLayers() const
{
ASSERT(!m_zOrderListsDirty);
ASSERT(isStackingContext() || !m_negZOrderList);
return LayerList(m_negZOrderList.get());
}
// Update our normal and z-index lists.
void updateLayerListsIfNeeded();
void updateDescendantDependentFlags();
bool descendantDependentFlagsAreDirty() const
{
return m_visibleDescendantStatusDirty || m_visibleContentStatusDirty || m_hasSelfPaintingLayerDescendantDirty
#if ENABLE(CSS_COMPOSITING)
|| m_hasNotIsolatedBlendingDescendantsStatusDirty
#endif
;
}
void repaintIncludingDescendants();
// Indicate that the layer contents need to be repainted. Only has an effect
// if layer compositing is being used.
void setBackingNeedsRepaint(GraphicsLayer::ShouldClipToLayer = GraphicsLayer::ClipToLayer);
// The rect is in the coordinate space of the layer's render object.
void setBackingNeedsRepaintInRect(const LayoutRect&, GraphicsLayer::ShouldClipToLayer = GraphicsLayer::ClipToLayer);
void repaintIncludingNonCompositingDescendants(const RenderLayerModelObject* repaintContainer);
void styleChanged(StyleDifference, const RenderStyle* oldStyle);
bool isSelfPaintingLayer() const { return m_isSelfPaintingLayer; }
bool cannotBlitToWindow() const;
bool isTransparent() const { return renderer().isTransparent() || renderer().hasMask(); }
bool hasReflection() const { return renderer().hasReflection(); }
bool isReflection() const { return renderer().isReplica(); }
RenderLayer* reflectionLayer() const;
bool isReflectionLayer(const RenderLayer&) const;
const LayoutPoint& location() const { return m_topLeft; }
void setLocation(const LayoutPoint& p) { m_topLeft = p; }
const IntSize& size() const { return m_layerSize; }
void setSize(const IntSize& size) { m_layerSize = size; } // Only public for RenderTreeAsText.
LayoutRect rect() const { return LayoutRect(location(), size()); }
IntSize visibleSize() const;
int scrollWidth() const;
int scrollHeight() const;
// Returns the nearest enclosing layer that is scrollable.
// FIXME: This can return the RenderView's layer when callers probably want the FrameView as a ScrollableArea.
RenderLayer* enclosingScrollableLayer(IncludeSelfOrNot, CrossFrameBoundaries) const;
// "absoluteRect" is in scaled document coordinates.
void scrollRectToVisible(const LayoutRect& absoluteRect, bool insideFixed, const ScrollRectToVisibleOptions&);
// Returns true when the layer could do touch scrolling, but doesn't look at whether there is actually scrollable overflow.
bool canUseCompositedScrolling() const;
// Returns true when there is actually scrollable overflow (requires layout to be up-to-date).
bool hasCompositedScrollableOverflow() const;
bool hasOverlayScrollbars() const;
bool isPointInResizeControl(IntPoint localPoint) const;
IntSize offsetFromResizeCorner(const IntPoint& localPoint) const;
void updateScrollInfoAfterLayout();
void updateScrollbarSteps();
void autoscroll(const IntPoint&);
bool canResize() const;
LayoutSize minimumSizeForResizing(float zoomFactor) const;
void resize(const PlatformMouseEvent&, const LayoutSize&);
bool inResizeMode() const { return m_inResizeMode; }
void setInResizeMode(bool b) { m_inResizeMode = b; }
bool isRenderViewLayer() const { return m_isRenderViewLayer; }
bool isForcedStackingContext() const { return m_forcedStackingContext; }
bool isOpportunisticStackingContext() const { return m_isOpportunisticStackingContext; }
RenderLayerCompositor& compositor() const;
// Notification from the renderer that its content changed (e.g. current frame of image changed).
// Allows updates of layer content without repainting.
void contentChanged(ContentChangeType);
bool canRender3DTransforms() const;
void updateLayerPositionsAfterStyleChange();
void updateLayerPositionsAfterLayout(bool isRelayoutingSubtree, bool didFullRepaint);
void updateLayerPositionsAfterOverflowScroll();
void updateLayerPositionsAfterDocumentScroll();
bool hasCompositedLayerInEnclosingPaginationChain() const;
enum PaginationInclusionMode { ExcludeCompositedPaginatedLayers, IncludeCompositedPaginatedLayers };
RenderLayer* enclosingPaginationLayer(PaginationInclusionMode mode) const
{
if (mode == ExcludeCompositedPaginatedLayers && hasCompositedLayerInEnclosingPaginationChain())
return nullptr;
return m_enclosingPaginationLayer.get();
}
void setReferenceBoxForPathOperations();
void updateTransform();
#if ENABLE(CSS_COMPOSITING)
void updateBlendMode();
void willRemoveChildWithBlendMode();
#endif
const LayoutSize& offsetForInFlowPosition() const { return m_offsetForPosition; }
void clearClipRectsIncludingDescendants(ClipRectsType typeToClear = AllClipRectTypes);
void clearClipRects(ClipRectsType typeToClear = AllClipRectTypes);
void addBlockSelectionGapsBounds(const LayoutRect&);
void clearBlockSelectionGapsBounds();
void repaintBlockSelectionGaps();
// FIXME: We should ASSERT(!m_visibleContentStatusDirty) here, but see https://bugs.webkit.org/show_bug.cgi?id=71044
// ditto for hasVisibleDescendant(), see https://bugs.webkit.org/show_bug.cgi?id=71277
bool hasVisibleContent() const { return m_hasVisibleContent; }
bool hasVisibleDescendant() const { return m_hasVisibleDescendant; }
void setHasVisibleContent();
void dirtyVisibleContentStatus();
bool hasVisibleBoxDecorationsOrBackground() const;
bool hasVisibleBoxDecorations() const;
bool behavesAsFixed() const { return m_behavesAsFixed; }
struct PaintedContentRequest {
void makeStatesUndetermined()
{
if (hasPaintedContent == RequestState::Unknown)
hasPaintedContent = RequestState::Undetermined;
if (hasSubpixelAntialiasedText == RequestState::Unknown)
hasSubpixelAntialiasedText = RequestState::Undetermined;
}
void setHasPaintedContent() { hasPaintedContent = RequestState::True; }
void setHasSubpixelAntialiasedText() { hasSubpixelAntialiasedText = RequestState::True; }
bool needToDeterminePaintedContentState() const { return hasPaintedContent == RequestState::Unknown; }
bool needToDetermineSubpixelAntialiasedTextState() const { return hasSubpixelAntialiasedText == RequestState::Unknown; }
bool probablyHasPaintedContent() const { return hasPaintedContent == RequestState::True || hasPaintedContent == RequestState::Undetermined; }
bool probablyHasSubpixelAntialiasedText() const { return hasSubpixelAntialiasedText == RequestState::True || hasSubpixelAntialiasedText == RequestState::Undetermined; }
bool isSatisfied() const { return hasPaintedContent != RequestState::Unknown && hasSubpixelAntialiasedText != RequestState::Unknown; }
RequestState hasPaintedContent { RequestState::Unknown };
RequestState hasSubpixelAntialiasedText { RequestState::DontCare };
};
// Returns true if this layer has visible content (ignoring any child layers).
bool isVisuallyNonEmpty(PaintedContentRequest* = nullptr) const;
// True if this layer container renderers that paint.
bool hasNonEmptyChildRenderers(PaintedContentRequest&) const;
// FIXME: We should ASSERT(!m_hasSelfPaintingLayerDescendantDirty); here but we hit the same bugs as visible content above.
// Part of the issue is with subtree relayout: we don't check if our ancestors have some descendant flags dirty, missing some updates.
bool hasSelfPaintingLayerDescendant() const { return m_hasSelfPaintingLayerDescendant; }
bool ancestorLayerIsInContainingBlockChain(const RenderLayer& ancestor, const RenderLayer* checkLimit = nullptr) const;
// Gets the nearest enclosing positioned ancestor layer (also includes
// the <html> layer and the root layer).
RenderLayer* enclosingAncestorForPosition(PositionType) const;
RenderLayer* enclosingLayerInContainingBlockOrder() const;
RenderLayer* enclosingContainingBlockLayer(CrossFrameBoundaries) const;
RenderLayer* enclosingFrameRenderLayer() const;
// The layer relative to which clipping rects for this layer are computed.
RenderLayer* clippingRootForPainting() const;
RenderLayer* enclosingOverflowClipLayer(IncludeSelfOrNot) const;
// Enclosing compositing layer; if includeSelf is true, may return this.
RenderLayer* enclosingCompositingLayer(IncludeSelfOrNot = IncludeSelf) const;
RenderLayer* enclosingCompositingLayerForRepaint(IncludeSelfOrNot = IncludeSelf) const;
// Ancestor compositing layer, excluding this.
RenderLayer* ancestorCompositingLayer() const { return enclosingCompositingLayer(ExcludeSelf); }
RenderLayer* enclosingFilterLayer(IncludeSelfOrNot = IncludeSelf) const;
RenderLayer* enclosingFilterRepaintLayer() const;
void setFilterBackendNeedsRepaintingInRect(const LayoutRect&);
bool hasAncestorWithFilterOutsets() const;
bool canUseOffsetFromAncestor() const
{
// FIXME: This really needs to know if there are transforms on this layer and any of the layers
// between it and the ancestor in question.
return !renderer().hasTransform() && !renderer().isSVGRootOrLegacySVGRoot();
}
// FIXME: adjustForColumns allows us to position compositing layers in columns correctly, but eventually they need to be split across columns too.
enum ColumnOffsetAdjustment { DontAdjustForColumns, AdjustForColumns };
void convertToPixelSnappedLayerCoords(const RenderLayer* ancestorLayer, IntPoint& location, ColumnOffsetAdjustment adjustForColumns = DontAdjustForColumns) const;
LayoutPoint convertToLayerCoords(const RenderLayer* ancestorLayer, const LayoutPoint&, ColumnOffsetAdjustment adjustForColumns = DontAdjustForColumns) const;
LayoutSize offsetFromAncestor(const RenderLayer*, ColumnOffsetAdjustment = DontAdjustForColumns) const;
int zIndex() const { return renderer().style().usedZIndex(); }
enum class PaintLayerFlag : uint16_t {
HaveTransparency = 1 << 0,
AppliedTransform = 1 << 1,
TemporaryClipRects = 1 << 2,
PaintingReflection = 1 << 3,
PaintingOverlayScrollbars = 1 << 4,
PaintingCompositingBackgroundPhase = 1 << 5,
PaintingCompositingForegroundPhase = 1 << 6,
PaintingCompositingMaskPhase = 1 << 7,
PaintingCompositingClipPathPhase = 1 << 8,
PaintingCompositingScrollingPhase = 1 << 9,
PaintingOverflowContents = 1 << 10,
PaintingRootBackgroundOnly = 1 << 11,
PaintingSkipRootBackground = 1 << 12,
PaintingChildClippingMaskPhase = 1 << 13,
CollectingEventRegion = 1 << 14,
};
static constexpr OptionSet<PaintLayerFlag> paintLayerPaintingCompositingAllPhasesFlags() { return { PaintLayerFlag::PaintingCompositingBackgroundPhase, PaintLayerFlag::PaintingCompositingForegroundPhase }; }
enum class SecurityOriginPaintPolicy { AnyOrigin, AccessibleOriginOnly };
// The two main functions that use the layer system. The paint method
// paints the layers that intersect the damage rect from back to
// front. The hitTest method looks for mouse events by walking
// layers that intersect the point from front to back.
void paint(GraphicsContext&, const LayoutRect& damageRect, const LayoutSize& subpixelOffset = LayoutSize(), OptionSet<PaintBehavior> = PaintBehavior::Normal,
RenderObject* subtreePaintRoot = nullptr, OptionSet<PaintLayerFlag> = { }, SecurityOriginPaintPolicy = SecurityOriginPaintPolicy::AnyOrigin, EventRegionContext* = nullptr);
bool hitTest(const HitTestRequest&, HitTestResult&);
bool hitTest(const HitTestRequest&, const HitTestLocation&, HitTestResult&);
struct ClipRectsContext {
ClipRectsContext(const RenderLayer* inRootLayer, ClipRectsType inClipRectsType, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize, ShouldRespectOverflowClip inRespectOverflowClip = RespectOverflowClip)
: rootLayer(inRootLayer)
, clipRectsType(inClipRectsType)
, overlayScrollbarSizeRelevancy(inOverlayScrollbarSizeRelevancy)
, respectOverflowClip(inRespectOverflowClip)
{ }
const RenderLayer* rootLayer;
ClipRectsType clipRectsType;
OverlayScrollbarSizeRelevancy overlayScrollbarSizeRelevancy;
ShouldRespectOverflowClip respectOverflowClip;
};
// This method figures out our layerBounds in coordinates relative to
// |rootLayer|. It also computes our background and foreground clip rects
// for painting/event handling.
// Pass offsetFromRoot if known.
void calculateRects(const ClipRectsContext&, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
ClipRect& backgroundRect, ClipRect& foregroundRect, const LayoutSize& offsetFromRoot) const;
// Public just for RenderTreeAsText.
void collectFragments(LayerFragments&, const RenderLayer* rootLayer, const LayoutRect& dirtyRect,
PaginationInclusionMode,
ClipRectsType, OverlayScrollbarSizeRelevancy inOverlayScrollbarSizeRelevancy, ShouldRespectOverflowClip, const LayoutSize& offsetFromRoot,
const LayoutRect* layerBoundingBox = nullptr, ShouldApplyRootOffsetToFragments = IgnoreRootOffsetForFragments);
LayoutRect childrenClipRect() const; // Returns the foreground clip rect of the layer in the document's coordinate space.
LayoutRect selfClipRect() const; // Returns the background clip rect of the layer in the document's coordinate space.
LayoutRect localClipRect(bool& clipExceedsBounds) const; // Returns the background clip rect of the layer in the local coordinate space.
bool clipCrossesPaintingBoundary() const;
// Pass offsetFromRoot if known.
bool intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer, const LayoutSize& offsetFromRoot, const std::optional<LayoutRect>& cachedBoundingBox = std::nullopt) const;
enum CalculateLayerBoundsFlag {
IncludeSelfTransform = 1 << 0,
UseLocalClipRectIfPossible = 1 << 1,
IncludeFilterOutsets = 1 << 2,
IncludePaintedFilterOutsets = 1 << 3,
ExcludeHiddenDescendants = 1 << 4,
DontConstrainForMask = 1 << 5,
IncludeCompositedDescendants = 1 << 6,
UseFragmentBoxesExcludingCompositing = 1 << 7,
UseFragmentBoxesIncludingCompositing = 1 << 8,
};
static constexpr OptionSet<CalculateLayerBoundsFlag> defaultCalculateLayerBoundsFlags() { return { IncludeSelfTransform, UseLocalClipRectIfPossible, IncludePaintedFilterOutsets, UseFragmentBoxesExcludingCompositing }; }
// Bounding box relative to some ancestor layer. Pass offsetFromRoot if known.
LayoutRect boundingBox(const RenderLayer* rootLayer, const LayoutSize& offsetFromRoot = LayoutSize(), OptionSet<CalculateLayerBoundsFlag> = { }) const;
// Bounding box in the coordinates of this layer.
LayoutRect localBoundingBox(OptionSet<CalculateLayerBoundsFlag> = { }) const;
// Deprecated: Pixel snapped bounding box relative to the root.
WEBCORE_EXPORT IntRect absoluteBoundingBox() const;
// Device pixel snapped bounding box relative to the root. absoluteBoundingBox() callers will be directed to this.
FloatRect absoluteBoundingBoxForPainting() const;
// Returns the 'reference box' used for clip-path handling (different rules for inlines, wrt. to boxes).
FloatRect referenceBoxRectForClipPath(CSSBoxType, const LayoutSize& offsetFromRoot, const LayoutRect& rootRelativeBounds) const;
// Bounds used for layer overlap testing in RenderLayerCompositor.
LayoutRect overlapBounds() const;
// Takes transform animations into account, returning true if they could be cheaply computed.
// Unlike overlapBounds, these bounds include descendant layers.
bool getOverlapBoundsIncludingChildrenAccountingForTransformAnimations(LayoutRect&, OptionSet<CalculateLayerBoundsFlag> additionalFlags = { }) const;
// If true, this layer's children are included in its bounds for overlap testing.
// We can't rely on the children's positions if this layer has a filter that could have moved the children's pixels around.
bool overlapBoundsIncludeChildren() const { return hasFilter() && renderer().style().filter().hasFilterThatMovesPixels(); }
// Can pass offsetFromRoot if known.
LayoutRect calculateLayerBounds(const RenderLayer* ancestorLayer, const LayoutSize& offsetFromRoot, OptionSet<CalculateLayerBoundsFlag> = defaultCalculateLayerBoundsFlags()) const;
LayoutRect repaintRectIncludingNonCompositingDescendants() const;
void setRepaintStatus(RepaintStatus status) { m_repaintStatus = status; }
RepaintStatus repaintStatus() const { return static_cast<RepaintStatus>(m_repaintStatus); }
LayoutUnit staticInlinePosition() const { return m_offsetForPosition.width(); }
LayoutUnit staticBlockPosition() const { return m_offsetForPosition.height(); }
void setStaticInlinePosition(LayoutUnit position) { m_offsetForPosition.setWidth(position); }
void setStaticBlockPosition(LayoutUnit position) { m_offsetForPosition.setHeight(position); }
bool hasTransform() const { return renderer().hasTransform(); }
// Note that this transform has the transform-origin baked in.
TransformationMatrix* transform() const { return m_transform.get(); }
// updateTransformFromStyle computes a transform according to the passed options (e.g. transform-origin baked in or excluded) and the given style.
void updateTransformFromStyle(TransformationMatrix&, const RenderStyle&, OptionSet<RenderStyle::TransformOperationOption>) const;
// currentTransform computes a transform which takes accelerated animations into account. The
// resulting transform has transform-origin baked in, unless non-default options are given. If
// the layer does not have a transform, the identity matrix is returned.
TransformationMatrix currentTransform(OptionSet<RenderStyle::TransformOperationOption> = RenderStyle::allTransformOperations) const;
TransformationMatrix renderableTransform(OptionSet<PaintBehavior>) const;
// Get the children transform (to apply a perspective on children), which is applied to transformed sublayers, but not this layer.
// Returns true if the layer has a perspective.
// Note that this transform has the perspective-origin baked in.
TransformationMatrix perspectiveTransform() const;
FloatPoint perspectiveOrigin() const;
FloatPoint3D transformOriginPixelSnappedIfNeeded() const;
bool preserves3D() const { return renderer().style().preserves3D(); }
bool has3DTransform() const { return m_transform && !m_transform->isAffine(); }
bool hasTransformedAncestor() const { return m_hasTransformedAncestor; }
bool hasFilter() const { return renderer().hasFilter(); }
bool hasFilterOutsets() const { return !filterOutsets().isZero(); }
IntOutsets filterOutsets() const;
bool hasBackdropFilter() const
{
#if ENABLE(FILTERS_LEVEL_2)
return renderer().hasBackdropFilter();
#else
return false;
#endif
}
#if ENABLE(CSS_COMPOSITING)
bool hasBlendMode() const { return renderer().hasBlendMode(); }
BlendMode blendMode() const { return static_cast<BlendMode>(m_blendMode); }
bool isolatesCompositedBlending() const { return m_hasNotIsolatedCompositedBlendingDescendants && isCSSStackingContext(); }
bool hasNotIsolatedCompositedBlendingDescendants() const { return m_hasNotIsolatedCompositedBlendingDescendants; }
void setHasNotIsolatedCompositedBlendingDescendants(bool hasNotIsolatedCompositedBlendingDescendants)
{
m_hasNotIsolatedCompositedBlendingDescendants = hasNotIsolatedCompositedBlendingDescendants;
}
bool isolatesBlending() const { return hasNotIsolatedBlendingDescendants() && isCSSStackingContext(); }
// FIXME: We should ASSERT(!m_hasNotIsolatedBlendingDescendantsStatusDirty); here but we hit the same bugs as visible content above.
bool hasNotIsolatedBlendingDescendants() const { return m_hasNotIsolatedBlendingDescendants; }
bool hasNotIsolatedBlendingDescendantsStatusDirty() const { return m_hasNotIsolatedBlendingDescendantsStatusDirty; }
#else
bool hasBlendMode() const { return false; }
bool isolatesCompositedBlending() const { return false; }
bool isolatesBlending() const { return false; }
bool hasNotIsolatedBlendingDescendantsStatusDirty() const { return false; }
#endif
bool isComposited() const { return m_backing != nullptr; }
bool hasCompositingDescendant() const { return m_hasCompositingDescendant; }
bool hasCompositedMask() const;
bool hasCompositedNonContainedDescendants() const { return m_hasCompositedNonContainedDescendants; }
// If non-null, a non-ancestor composited layer that this layer paints into (it is sharing its backing store with this layer).
RenderLayer* backingProviderLayer() const { return m_backingProviderLayer.get(); }
void setBackingProviderLayer(RenderLayer*);
void disconnectFromBackingProviderLayer();
bool paintsIntoProvidedBacking() const { return !!m_backingProviderLayer; }
RenderLayerBacking* backing() const { return m_backing.get(); }
RenderLayerBacking* ensureBacking();
void clearBacking(bool layerBeingDestroyed = false);
bool hasCompositedScrollingAncestor() const { return m_hasCompositedScrollingAncestor; }
void setHasCompositedScrollingAncestor(bool hasCompositedScrollingAncestor) { m_hasCompositedScrollingAncestor = hasCompositedScrollingAncestor; }
bool usesCompositedScrolling() const;
// Layers with the same ScrollingScope are scrolled by some common ancestor scroller. Used for async scrolling.
std::optional<ScrollingScope> boxScrollingScope() const { return m_boxScrollingScope; }
std::optional<ScrollingScope> contentsScrollingScope() const { return m_contentsScrollingScope; }
bool paintsWithTransparency(OptionSet<PaintBehavior> paintBehavior) const
{
return (isTransparent() || hasBlendMode() || (isolatesBlending() && !renderer().isDocumentElementRenderer())) && ((paintBehavior & PaintBehavior::FlattenCompositingLayers) || !isComposited());
}
bool paintsWithTransform(OptionSet<PaintBehavior>) const;
bool shouldPaintMask(OptionSet<PaintBehavior>, OptionSet<PaintLayerFlag>) const;
bool shouldApplyClipPath(OptionSet<PaintBehavior>, OptionSet<PaintLayerFlag>) const;
// Returns true if background phase is painted opaque in the given rect.
// The query rect is given in local coordinates.
bool backgroundIsKnownToBeOpaqueInRect(const LayoutRect&) const;
bool paintsWithFilters() const;
bool requiresFullLayerImageForFilters() const;
Element* enclosingElement() const;
static Vector<RenderLayer*> topLayerRenderLayers(RenderView&);
bool establishesTopLayer() const;
void establishesTopLayerWillChange();
void establishesTopLayerDidChange();
enum ViewportConstrainedNotCompositedReason {
NoNotCompositedReason,
NotCompositedForBoundsOutOfView,
NotCompositedForNonViewContainer,
NotCompositedForNoVisibleContent,
};
void setViewportConstrainedNotCompositedReason(ViewportConstrainedNotCompositedReason reason) { m_viewportConstrainedNotCompositedReason = reason; }
ViewportConstrainedNotCompositedReason viewportConstrainedNotCompositedReason() const { return static_cast<ViewportConstrainedNotCompositedReason>(m_viewportConstrainedNotCompositedReason); }
IndirectCompositingReason indirectCompositingReason() const { return static_cast<IndirectCompositingReason>(m_indirectCompositingReason); }
bool isRenderFragmentedFlow() const { return renderer().isRenderFragmentedFlow(); }
bool isInsideFragmentedFlow() const { return renderer().fragmentedFlowState() != RenderObject::NotInsideFragmentedFlow; }
bool isDirtyRenderFragmentedFlow() const
{
ASSERT(isRenderFragmentedFlow());
return zOrderListsDirty() || normalFlowListDirty();
}
RenderLayer* enclosingFragmentedFlowAncestor() const;
WEBCORE_EXPORT void simulateFrequentPaint();
bool paintingFrequently() const { return m_paintFrequencyTracker.paintingFrequently(); }
WEBCORE_EXPORT bool isTransparentRespectingParentFrames() const;
// Invalidation can fail if there is no enclosing compositing layer (e.g. nested iframe)
// or the layer does not maintain an event region.
enum class EventRegionInvalidationReason { Paint, SettingDidChange, Style, NonCompositedFrame };
bool invalidateEventRegion(EventRegionInvalidationReason);
String debugDescription() const;
private:
void setNextSibling(RenderLayer* next) { m_next = next; }
void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
void setParent(RenderLayer*);
void setFirstChild(RenderLayer* first) { m_first = first; }
void setLastChild(RenderLayer* last) { m_last = last; }
void updateAncestorDependentState();
void dirtyPaintOrderListsOnChildChange(RenderLayer&);
bool shouldBeNormalFlowOnly() const;
bool shouldBeCSSStackingContext() const;
// Return true if changed.
bool setIsNormalFlowOnly(bool);
bool setIsOpportunisticStackingContext(bool);
bool setIsCSSStackingContext(bool);
void isStackingContextChanged();
bool isDirtyStackingContext() const { return m_zOrderListsDirty && isStackingContext(); }
void updateZOrderLists();
void rebuildZOrderLists();
void rebuildZOrderLists(std::unique_ptr<Vector<RenderLayer*>>&, std::unique_ptr<Vector<RenderLayer*>>&, OptionSet<Compositing>&);
void collectLayers(bool includeHiddenLayers, std::unique_ptr<Vector<RenderLayer*>>&, std::unique_ptr<Vector<RenderLayer*>>&, OptionSet<Compositing>&);
void clearZOrderLists();
void updateNormalFlowList();
struct LayerPaintingInfo {
LayerPaintingInfo(RenderLayer* inRootLayer, const LayoutRect& inDirtyRect, OptionSet<PaintBehavior> inPaintBehavior, const LayoutSize& inSubpixelOffset, RenderObject* inSubtreePaintRoot = nullptr, OverlapTestRequestMap* inOverlapTestRequests = nullptr, bool inRequireSecurityOriginAccessForWidgets = false)
: rootLayer(inRootLayer)
, subtreePaintRoot(inSubtreePaintRoot)
, paintDirtyRect(inDirtyRect)
, subpixelOffset(inSubpixelOffset)
, overlapTestRequests(inOverlapTestRequests)
, paintBehavior(inPaintBehavior)
, requireSecurityOriginAccessForWidgets(inRequireSecurityOriginAccessForWidgets)
{ }
RenderLayer* rootLayer;
RenderObject* subtreePaintRoot; // Only paint descendants of this object.
LayoutRect paintDirtyRect; // Relative to rootLayer;
LayoutSize subpixelOffset;
OverlapTestRequestMap* overlapTestRequests; // May be null.
OptionSet<PaintBehavior> paintBehavior;
bool requireSecurityOriginAccessForWidgets;
bool clipToDirtyRect { true };
EventRegionContext* eventRegionContext { nullptr };
};
LayoutPoint paintOffsetForRenderer(const LayerFragment& fragment, const LayerPaintingInfo& paintingInfo) const
{
return toLayoutPoint(fragment.layerBounds.location() - rendererLocation() + paintingInfo.subpixelOffset);
}
// Compute, cache and return clip rects computed with the given layer as the root.
Ref<ClipRects> updateClipRects(const ClipRectsContext&);
// Compute and return the clip rects. If useCached is true, will used previously computed clip rects on ancestors
// (rather than computing them all from scratch up the parent chain).
void calculateClipRects(const ClipRectsContext&, ClipRects&) const;
ClipRects* clipRects(const ClipRectsContext&) const;
void setAncestorChainHasSelfPaintingLayerDescendant();
void dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
void computeRepaintRects(const RenderLayerModelObject* repaintContainer, const RenderGeometryMap* = nullptr);
void computeRepaintRectsIncludingDescendants();
void setRepaintRects(const LayerRepaintRects&);
void clearRepaintRects();
LayoutRect clipRectRelativeToAncestor(RenderLayer* ancestor, LayoutSize offsetFromAncestor, const LayoutRect& constrainingRect) const;
void clipToRect(GraphicsContext&, GraphicsContextStateSaver&, EventRegionContextStateSaver&, const LayerPaintingInfo&, OptionSet<PaintBehavior>, const ClipRect&, BorderRadiusClippingRule = IncludeSelfForBorderRadius);
bool shouldRepaintAfterLayout() const;
void updateSelfPaintingLayer();
void willUpdateLayerPositions();
enum UpdateLayerPositionsFlag {
CheckForRepaint = 1 << 0,
NeedsFullRepaintInBacking = 1 << 1,
ContainingClippingLayerChangedSize = 1 << 2,
UpdatePagination = 1 << 3,
SeenFixedLayer = 1 << 4,
SeenTransformedLayer = 1 << 5,
Seen3DTransformedLayer = 1 << 6,
SeenCompositedScrollingLayer = 1 << 7,
};
static OptionSet<UpdateLayerPositionsFlag> flagsForUpdateLayerPositions(RenderLayer& startingLayer);
// Returns true if the position changed.
bool updateLayerPosition(OptionSet<UpdateLayerPositionsFlag>* = nullptr);
void recursiveUpdateLayerPositions(RenderGeometryMap*, OptionSet<UpdateLayerPositionsFlag>);
enum UpdateLayerPositionsAfterScrollFlag {
IsOverflowScroll = 1 << 0,
HasSeenViewportConstrainedAncestor = 1 << 1,
HasSeenAncestorWithOverflowClip = 1 << 2,
HasChangedAncestor = 1 << 3,
};
void recursiveUpdateLayerPositionsAfterScroll(RenderGeometryMap*, OptionSet<UpdateLayerPositionsAfterScrollFlag> = { });
RenderLayer* enclosingPaginationLayerInSubtree(const RenderLayer* rootLayer, PaginationInclusionMode) const;
LayoutPoint rendererLocation() const
{
if (is<RenderBox>(renderer()))
return downcast<RenderBox>(renderer()).location();
#if ENABLE(LAYER_BASED_SVG_ENGINE)
if (is<RenderSVGModelObject>(renderer()))
return downcast<RenderSVGModelObject>(renderer()).currentSVGLayoutLocation();
#endif
return LayoutPoint();
}
LayoutRect rendererBorderBoxRect() const
{
if (is<RenderBox>(renderer()))
return downcast<RenderBox>(renderer()).borderBoxRect();
#if ENABLE(LAYER_BASED_SVG_ENGINE)
if (is<RenderSVGModelObject>(renderer()))