OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "config.h" | 5 #include "config.h" |
6 #include "core/paint/LayerPainter.h" | 6 #include "core/paint/LayerPainter.h" |
7 | 7 |
8 #include "core/frame/Settings.h" | 8 #include "core/frame/Settings.h" |
9 #include "core/page/Page.h" | 9 #include "core/page/Page.h" |
10 #include "core/rendering/ClipPathOperation.h" | 10 #include "core/rendering/ClipPathOperation.h" |
(...skipping 655 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
666 | 666 |
667 // Move to the next position. | 667 // Move to the next position. |
668 LayoutUnit blockDelta = isHorizontal ? colRect.height() : colRect.width(
); | 668 LayoutUnit blockDelta = isHorizontal ? colRect.height() : colRect.width(
); |
669 if (columnBlock->style()->slowIsFlippedBlocksWritingMode()) | 669 if (columnBlock->style()->slowIsFlippedBlocksWritingMode()) |
670 currLogicalTopOffset += blockDelta; | 670 currLogicalTopOffset += blockDelta; |
671 else | 671 else |
672 currLogicalTopOffset -= blockDelta; | 672 currLogicalTopOffset -= blockDelta; |
673 } | 673 } |
674 } | 674 } |
675 | 675 |
| 676 void LayerPainter::paintFragmentWithPhase(PaintPhase phase, const LayerFragment&
fragment, GraphicsContext* context, const ClipRect& clipRect, const LayerPainti
ngInfo& paintingInfo, PaintBehavior paintBehavior, RenderObject* paintingRootFor
Renderer, PaintLayerFlags paintFlags, ClipState clipState) |
| 677 { |
| 678 OwnPtr<ClipRecorder> clipRecorder; |
| 679 if (clipState != HasClipped && paintingInfo.clipToDirtyRect && needsToClip(p
aintingInfo, clipRect)) { |
| 680 BorderRadiusClippingRule clippingRule = IncludeSelfForBorderRadius; |
| 681 DisplayItem::Type clipType = DisplayItem::ClipLayerFragmentFloat; |
| 682 switch (phase) { |
| 683 case PaintPhaseFloat: |
| 684 break; |
| 685 case PaintPhaseForeground: |
| 686 clipType = DisplayItem::ClipLayerFragmentForeground; |
| 687 break; |
| 688 case PaintPhaseChildOutlines: |
| 689 clipType = DisplayItem::ClipLayerFragmentChildOutline; |
| 690 break; |
| 691 case PaintPhaseSelection: |
| 692 clipType = DisplayItem::ClipLayerFragmentSelection; |
| 693 break; |
| 694 case PaintPhaseChildBlockBackgrounds: |
| 695 clipType = DisplayItem::ClipLayerFragmentChildBlockBackgrounds; |
| 696 break; |
| 697 case PaintPhaseBlockBackground: |
| 698 clipType = DisplayItem::ClipLayerBackground; |
| 699 clippingRule = DoNotIncludeSelfForBorderRadius; // Background painti
ng will handle clipping to self. |
| 700 break; |
| 701 case PaintPhaseSelfOutline: |
| 702 clipType = DisplayItem::ClipLayerFragmentOutline; |
| 703 clippingRule = DoNotIncludeSelfForBorderRadius; |
| 704 break; |
| 705 case PaintPhaseMask: |
| 706 clipType = DisplayItem::ClipLayerFragmentMask; |
| 707 clippingRule = DoNotIncludeSelfForBorderRadius; // Mask painting wil
l handle clipping to self. |
| 708 break; |
| 709 case PaintPhaseClippingMask: |
| 710 clipType = DisplayItem::ClipLayerFragmentClippingMask; |
| 711 break; |
| 712 default: |
| 713 ASSERT_NOT_REACHED(); |
| 714 } |
| 715 |
| 716 clipRecorder = adoptPtr(new ClipRecorder(&m_renderLayer, context, clipTy
pe, clipRect)); |
| 717 applyRoundedRectClips(paintingInfo, context, clipRect, paintFlags, *clip
Recorder, clippingRule); |
| 718 } |
| 719 |
| 720 PaintInfo paintInfo(context, pixelSnappedIntRect(clipRect.rect()), phase, pa
intBehavior, paintingRootForRenderer, 0, paintingInfo.rootLayer->renderer()); |
| 721 m_renderLayer.renderer()->paint(paintInfo, toPoint(fragment.layerBounds.loca
tion() - m_renderLayer.renderBoxLocation() + subPixelAccumulationIfNeeded(painti
ngInfo.subPixelAccumulation, m_renderLayer.compositingState()))); |
| 722 } |
| 723 |
676 void LayerPainter::paintBackgroundForFragments(const LayerFragments& layerFragme
nts, GraphicsContext* context, | 724 void LayerPainter::paintBackgroundForFragments(const LayerFragments& layerFragme
nts, GraphicsContext* context, |
677 const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const L
ayerPaintingInfo& localPaintingInfo, PaintBehavior paintBehavior, | 725 const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const L
ayerPaintingInfo& localPaintingInfo, PaintBehavior paintBehavior, |
678 RenderObject* paintingRootForRenderer, PaintLayerFlags paintFlags) | 726 RenderObject* paintingRootForRenderer, PaintLayerFlags paintFlags) |
679 { | 727 { |
680 for (size_t i = 0; i < layerFragments.size(); ++i) { | 728 for (const auto& fragment: layerFragments) { |
681 const LayerFragment& fragment = layerFragments.at(i); | |
682 | |
683 // Begin transparency layers lazily now that we know we have to paint so
mething. | 729 // Begin transparency layers lazily now that we know we have to paint so
mething. |
684 if (haveTransparency) | 730 if (haveTransparency) |
685 beginTransparencyLayers(context, localPaintingInfo.rootLayer, transp
arencyPaintDirtyRect, localPaintingInfo.subPixelAccumulation, localPaintingInfo.
paintBehavior); | 731 beginTransparencyLayers(context, localPaintingInfo.rootLayer, transp
arencyPaintDirtyRect, localPaintingInfo.subPixelAccumulation, localPaintingInfo.
paintBehavior); |
686 | 732 |
687 OwnPtr<ClipRecorder> clipRecorder; | 733 paintFragmentWithPhase(PaintPhaseBlockBackground, fragment, context, fra
gment.backgroundRect, localPaintingInfo, paintBehavior, paintingRootForRenderer,
paintFlags, HasNotClipped); |
688 | |
689 if (localPaintingInfo.clipToDirtyRect && needsToClip(localPaintingInfo,
fragment.backgroundRect)) { | |
690 clipRecorder = adoptPtr(new ClipRecorder(&m_renderLayer, context, Di
splayItem::ClipLayerBackground, fragment.backgroundRect)); | |
691 applyRoundedRectClips(localPaintingInfo, context, fragment.backgroun
dRect, paintFlags, *clipRecorder, DoNotIncludeSelfForBorderRadius); // Backgroun
d painting will handle clipping to self. | |
692 } | |
693 | |
694 // Paint the background. | |
695 // FIXME: Eventually we will collect the region from the fragment itself
instead of just from the paint info. | |
696 PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.backgroundRect
.rect()), PaintPhaseBlockBackground, paintBehavior, paintingRootForRenderer, 0,
localPaintingInfo.rootLayer->renderer()); | |
697 m_renderLayer.renderer()->paint(paintInfo, toPoint(fragment.layerBounds.
location() - m_renderLayer.renderBoxLocation() + subPixelAccumulationIfNeeded(lo
calPaintingInfo.subPixelAccumulation, m_renderLayer.compositingState()))); | |
698 } | 734 } |
699 } | 735 } |
700 | 736 |
701 void LayerPainter::paintForegroundForFragments(const LayerFragments& layerFragme
nts, GraphicsContext* context, | 737 void LayerPainter::paintForegroundForFragments(const LayerFragments& layerFragme
nts, GraphicsContext* context, |
702 const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const L
ayerPaintingInfo& localPaintingInfo, PaintBehavior paintBehavior, | 738 const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const L
ayerPaintingInfo& localPaintingInfo, PaintBehavior paintBehavior, |
703 RenderObject* paintingRootForRenderer, bool selectionOnly, PaintLayerFlags p
aintFlags) | 739 RenderObject* paintingRootForRenderer, bool selectionOnly, PaintLayerFlags p
aintFlags) |
704 { | 740 { |
705 // Begin transparency if we have something to paint. | 741 // Begin transparency if we have something to paint. |
706 if (haveTransparency) { | 742 if (haveTransparency) { |
707 for (size_t i = 0; i < layerFragments.size(); ++i) { | 743 for (size_t i = 0; i < layerFragments.size(); ++i) { |
708 const LayerFragment& fragment = layerFragments.at(i); | 744 const LayerFragment& fragment = layerFragments.at(i); |
709 if (!fragment.foregroundRect.isEmpty()) { | 745 if (!fragment.foregroundRect.isEmpty()) { |
710 beginTransparencyLayers(context, localPaintingInfo.rootLayer, tr
ansparencyPaintDirtyRect, localPaintingInfo.subPixelAccumulation, localPaintingI
nfo.paintBehavior); | 746 beginTransparencyLayers(context, localPaintingInfo.rootLayer, tr
ansparencyPaintDirtyRect, localPaintingInfo.subPixelAccumulation, localPaintingI
nfo.paintBehavior); |
711 break; | 747 break; |
712 } | 748 } |
713 } | 749 } |
714 } | 750 } |
715 | 751 |
716 // Optimize clipping for the single fragment case. | 752 // Optimize clipping for the single fragment case. |
717 bool shouldClip = localPaintingInfo.clipToDirtyRect && layerFragments.size()
== 1 && !layerFragments[0].foregroundRect.isEmpty(); | 753 bool shouldClip = localPaintingInfo.clipToDirtyRect && layerFragments.size()
== 1 && !layerFragments[0].foregroundRect.isEmpty(); |
718 | 754 ClipState clipState = HasNotClipped; |
719 OwnPtr<ClipRecorder> clipRecorder; | 755 OwnPtr<ClipRecorder> clipRecorder; |
720 if (shouldClip && needsToClip(localPaintingInfo, layerFragments[0].foregroun
dRect)) { | 756 if (shouldClip && needsToClip(localPaintingInfo, layerFragments[0].foregroun
dRect)) { |
721 clipRecorder = adoptPtr(new ClipRecorder(&m_renderLayer, context, Displa
yItem::ClipLayerForeground, layerFragments[0].foregroundRect)); | 757 clipRecorder = adoptPtr(new ClipRecorder(&m_renderLayer, context, Displa
yItem::ClipLayerForeground, layerFragments[0].foregroundRect)); |
722 applyRoundedRectClips(localPaintingInfo, context, layerFragments[0].fore
groundRect, paintFlags, *clipRecorder); | 758 applyRoundedRectClips(localPaintingInfo, context, layerFragments[0].fore
groundRect, paintFlags, *clipRecorder); |
| 759 clipState = HasClipped; |
723 } | 760 } |
724 | 761 |
725 // We have to loop through every fragment multiple times, since we have to i
ssue paint invalidations in each specific phase in order for | 762 // We have to loop through every fragment multiple times, since we have to i
ssue paint invalidations in each specific phase in order for |
726 // interleaving of the fragments to work properly. | 763 // interleaving of the fragments to work properly. |
727 paintForegroundForFragmentsWithPhase(selectionOnly ? PaintPhaseSelection : P
aintPhaseChildBlockBackgrounds, layerFragments, | 764 paintForegroundForFragmentsWithPhase(selectionOnly ? PaintPhaseSelection : P
aintPhaseChildBlockBackgrounds, layerFragments, |
728 context, localPaintingInfo, paintBehavior, paintingRootForRenderer, pain
tFlags); | 765 context, localPaintingInfo, paintBehavior, paintingRootForRenderer, pain
tFlags, clipState); |
729 | 766 |
730 if (!selectionOnly) { | 767 if (!selectionOnly) { |
731 paintForegroundForFragmentsWithPhase(PaintPhaseFloat, layerFragments, co
ntext, localPaintingInfo, paintBehavior, paintingRootForRenderer, paintFlags); | 768 paintForegroundForFragmentsWithPhase(PaintPhaseFloat, layerFragments, co
ntext, localPaintingInfo, paintBehavior, paintingRootForRenderer, paintFlags, cl
ipState); |
732 paintForegroundForFragmentsWithPhase(PaintPhaseForeground, layerFragment
s, context, localPaintingInfo, paintBehavior, paintingRootForRenderer, paintFlag
s); | 769 paintForegroundForFragmentsWithPhase(PaintPhaseForeground, layerFragment
s, context, localPaintingInfo, paintBehavior, paintingRootForRenderer, paintFlag
s, clipState); |
733 paintForegroundForFragmentsWithPhase(PaintPhaseChildOutlines, layerFragm
ents, context, localPaintingInfo, paintBehavior, paintingRootForRenderer, paintF
lags); | 770 paintForegroundForFragmentsWithPhase(PaintPhaseChildOutlines, layerFragm
ents, context, localPaintingInfo, paintBehavior, paintingRootForRenderer, paintF
lags, clipState); |
734 } | 771 } |
735 } | 772 } |
736 | 773 |
737 void LayerPainter::paintForegroundForFragmentsWithPhase(PaintPhase phase, const
LayerFragments& layerFragments, GraphicsContext* context, | 774 void LayerPainter::paintForegroundForFragmentsWithPhase(PaintPhase phase, const
LayerFragments& layerFragments, GraphicsContext* context, |
738 const LayerPaintingInfo& localPaintingInfo, PaintBehavior paintBehavior, Ren
derObject* paintingRootForRenderer, PaintLayerFlags paintFlags) | 775 const LayerPaintingInfo& localPaintingInfo, PaintBehavior paintBehavior, Ren
derObject* paintingRootForRenderer, PaintLayerFlags paintFlags, ClipState clipSt
ate) |
739 { | 776 { |
740 bool shouldClip = localPaintingInfo.clipToDirtyRect && layerFragments.size()
> 1; | 777 for (const auto& fragment: layerFragments) { |
741 | 778 if (!fragment.foregroundRect.isEmpty()) |
742 for (size_t i = 0; i < layerFragments.size(); ++i) { | 779 paintFragmentWithPhase(phase, fragment, context, fragment.foreground
Rect, localPaintingInfo, paintBehavior, paintingRootForRenderer, paintFlags, cli
pState); |
743 const LayerFragment& fragment = layerFragments.at(i); | |
744 if (fragment.foregroundRect.isEmpty()) | |
745 continue; | |
746 | |
747 OwnPtr<ClipRecorder> clipRecorder; | |
748 if (shouldClip && needsToClip(localPaintingInfo, fragment.foregroundRect
)) { | |
749 // Note: this method only clips when there is more than one fragment
. | |
750 DisplayItem::Type clipType = DisplayItem::ClipLayerFragmentFloat; | |
751 switch (phase) { | |
752 case PaintPhaseFloat: | |
753 break; | |
754 case PaintPhaseForeground: | |
755 clipType = DisplayItem::ClipLayerFragmentForeground; | |
756 break; | |
757 case PaintPhaseChildOutlines: | |
758 clipType = DisplayItem::ClipLayerFragmentChildOutline; | |
759 break; | |
760 case PaintPhaseSelection: | |
761 clipType = DisplayItem::ClipLayerFragmentSelection; | |
762 break; | |
763 case PaintPhaseChildBlockBackgrounds: | |
764 clipType = DisplayItem::ClipLayerFragmentChildBlockBackgrounds; | |
765 break; | |
766 default: | |
767 ASSERT_NOT_REACHED(); | |
768 } | |
769 | |
770 clipRecorder = adoptPtr(new ClipRecorder(&m_renderLayer, context, cl
ipType, fragment.foregroundRect)); | |
771 applyRoundedRectClips(localPaintingInfo, context, fragment.foregroun
dRect, paintFlags, *clipRecorder); | |
772 } | |
773 | |
774 PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.foregroundRect
.rect()), phase, paintBehavior, paintingRootForRenderer, 0, localPaintingInfo.ro
otLayer->renderer()); | |
775 m_renderLayer.renderer()->paint(paintInfo, toPoint(fragment.layerBounds.
location() - m_renderLayer.renderBoxLocation() + subPixelAccumulationIfNeeded(lo
calPaintingInfo.subPixelAccumulation, m_renderLayer.compositingState()))); | |
776 } | 780 } |
777 } | 781 } |
778 | 782 |
779 void LayerPainter::paintOutlineForFragments(const LayerFragments& layerFragments
, GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo, | 783 void LayerPainter::paintOutlineForFragments(const LayerFragments& layerFragments
, GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo, |
780 PaintBehavior paintBehavior, RenderObject* paintingRootForRenderer, PaintLay
erFlags paintFlags) | 784 PaintBehavior paintBehavior, RenderObject* paintingRootForRenderer, PaintLay
erFlags paintFlags) |
781 { | 785 { |
782 for (size_t i = 0; i < layerFragments.size(); ++i) { | 786 for (const auto& fragment: layerFragments) { |
783 const LayerFragment& fragment = layerFragments.at(i); | 787 if (!fragment.outlineRect.isEmpty()) |
784 if (fragment.outlineRect.isEmpty()) | 788 paintFragmentWithPhase(PaintPhaseSelfOutline, fragment, context, fra
gment.outlineRect, localPaintingInfo, paintBehavior, paintingRootForRenderer, pa
intFlags, HasNotClipped); |
785 continue; | |
786 | |
787 OwnPtr<ClipRecorder> clipRecorder; | |
788 if (needsToClip(localPaintingInfo, fragment.outlineRect)) { | |
789 clipRecorder = adoptPtr(new ClipRecorder(&m_renderLayer, context, Di
splayItem::ClipLayerFragmentOutline, fragment.outlineRect)); | |
790 applyRoundedRectClips(localPaintingInfo, context, fragment.outlineRe
ct, paintFlags, *clipRecorder, DoNotIncludeSelfForBorderRadius); | |
791 } | |
792 | |
793 // Paint our own outline | |
794 PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.outlineRect.re
ct()), PaintPhaseSelfOutline, paintBehavior, paintingRootForRenderer, 0, localPa
intingInfo.rootLayer->renderer()); | |
795 m_renderLayer.renderer()->paint(paintInfo, toPoint(fragment.layerBounds.
location() - m_renderLayer.renderBoxLocation() + subPixelAccumulationIfNeeded(lo
calPaintingInfo.subPixelAccumulation, m_renderLayer.compositingState()))); | |
796 } | 789 } |
797 } | 790 } |
798 | 791 |
799 void LayerPainter::paintMaskForFragments(const LayerFragments& layerFragments, G
raphicsContext* context, const LayerPaintingInfo& localPaintingInfo, | 792 void LayerPainter::paintMaskForFragments(const LayerFragments& layerFragments, G
raphicsContext* context, const LayerPaintingInfo& localPaintingInfo, |
800 RenderObject* paintingRootForRenderer, PaintLayerFlags paintFlags) | 793 RenderObject* paintingRootForRenderer, PaintLayerFlags paintFlags) |
801 { | 794 { |
802 for (size_t i = 0; i < layerFragments.size(); ++i) { | 795 for (const auto& fragment: layerFragments) |
803 const LayerFragment& fragment = layerFragments.at(i); | 796 paintFragmentWithPhase(PaintPhaseMask, fragment, context, fragment.backg
roundRect, localPaintingInfo, PaintBehaviorNormal, paintingRootForRenderer, pain
tFlags, HasNotClipped); |
804 OwnPtr<ClipRecorder> clipRecorder; | |
805 if (localPaintingInfo.clipToDirtyRect && needsToClip(localPaintingInfo,
fragment.backgroundRect)) { | |
806 clipRecorder = adoptPtr(new ClipRecorder(&m_renderLayer, context, Di
splayItem::ClipLayerFragmentMask, fragment.backgroundRect)); | |
807 applyRoundedRectClips(localPaintingInfo, context, fragment.backgroun
dRect, paintFlags, *clipRecorder, DoNotIncludeSelfForBorderRadius); // Mask pain
ting will handle clipping to self. | |
808 } | |
809 | |
810 // Paint the mask. | |
811 // FIXME: Eventually we will collect the region from the fragment itself
instead of just from the paint info. | |
812 PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.backgroundRect
.rect()), PaintPhaseMask, PaintBehaviorNormal, paintingRootForRenderer, 0, local
PaintingInfo.rootLayer->renderer()); | |
813 m_renderLayer.renderer()->paint(paintInfo, toPoint(fragment.layerBounds.
location() - m_renderLayer.renderBoxLocation() + subPixelAccumulationIfNeeded(lo
calPaintingInfo.subPixelAccumulation, m_renderLayer.compositingState()))); | |
814 } | |
815 } | 797 } |
816 | 798 |
817 void LayerPainter::paintChildClippingMaskForFragments(const LayerFragments& laye
rFragments, GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo
, | 799 void LayerPainter::paintChildClippingMaskForFragments(const LayerFragments& laye
rFragments, GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo
, |
818 RenderObject* paintingRootForRenderer, PaintLayerFlags paintFlags) | 800 RenderObject* paintingRootForRenderer, PaintLayerFlags paintFlags) |
819 { | 801 { |
820 for (size_t i = 0; i < layerFragments.size(); ++i) { | 802 for (const auto& fragment: layerFragments) |
821 const LayerFragment& fragment = layerFragments.at(i); | 803 paintFragmentWithPhase(PaintPhaseClippingMask, fragment, context, fragme
nt.foregroundRect, localPaintingInfo, PaintBehaviorNormal, paintingRootForRender
er, paintFlags, HasNotClipped); |
822 OwnPtr<ClipRecorder> clipRecorder; | |
823 if (localPaintingInfo.clipToDirtyRect && needsToClip(localPaintingInfo,
fragment.foregroundRect)) { | |
824 clipRecorder = adoptPtr(new ClipRecorder(&m_renderLayer, context, Di
splayItem::ClipLayerFragmentClippingMask, fragment.foregroundRect)); | |
825 applyRoundedRectClips(localPaintingInfo, context, fragment.foregroun
dRect, paintFlags, *clipRecorder, IncludeSelfForBorderRadius); | |
826 } | |
827 | |
828 // Paint the the clipped mask. | |
829 PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.foregroundRect
.rect()), PaintPhaseClippingMask, PaintBehaviorNormal, paintingRootForRenderer,
0, localPaintingInfo.rootLayer->renderer()); | |
830 m_renderLayer.renderer()->paint(paintInfo, toPoint(fragment.layerBounds.
location() - m_renderLayer.renderBoxLocation() + subPixelAccumulationIfNeeded(lo
calPaintingInfo.subPixelAccumulation, m_renderLayer.compositingState()))); | |
831 } | |
832 } | 804 } |
833 | 805 |
834 void LayerPainter::paintOverlayScrollbars(GraphicsContext* context, const Layout
Rect& damageRect, PaintBehavior paintBehavior, RenderObject* paintingRoot) | 806 void LayerPainter::paintOverlayScrollbars(GraphicsContext* context, const Layout
Rect& damageRect, PaintBehavior paintBehavior, RenderObject* paintingRoot) |
835 { | 807 { |
836 if (!m_renderLayer.containsDirtyOverlayScrollbars()) | 808 if (!m_renderLayer.containsDirtyOverlayScrollbars()) |
837 return; | 809 return; |
838 | 810 |
839 LayerPaintingInfo paintingInfo(&m_renderLayer, enclosingIntRect(damageRect),
paintBehavior, LayoutSize(), paintingRoot); | 811 LayerPaintingInfo paintingInfo(&m_renderLayer, enclosingIntRect(damageRect),
paintBehavior, LayoutSize(), paintingRoot); |
840 paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars); | 812 paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars); |
841 | 813 |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
875 clipRecorder = adoptPtr(new ClipRecorder(m_renderLayer.parent(), con
text, DisplayItem::ClipLayerFragmentParent, clipRect)); | 847 clipRecorder = adoptPtr(new ClipRecorder(m_renderLayer.parent(), con
text, DisplayItem::ClipLayerFragmentParent, clipRect)); |
876 // FIXME: why should we have to deal with rounded rect clips here at
all? | 848 // FIXME: why should we have to deal with rounded rect clips here at
all? |
877 LayerPainter(*m_renderLayer.parent()).applyRoundedRectClips(painting
Info, context, clipRect, paintFlags, *clipRecorder); | 849 LayerPainter(*m_renderLayer.parent()).applyRoundedRectClips(painting
Info, context, clipRect, paintFlags, *clipRecorder); |
878 } | 850 } |
879 | 851 |
880 paintLayerByApplyingTransform(context, paintingInfo, paintFlags, fragmen
t.paginationOffset); | 852 paintLayerByApplyingTransform(context, paintingInfo, paintFlags, fragmen
t.paginationOffset); |
881 } | 853 } |
882 } | 854 } |
883 | 855 |
884 } // namespace blink | 856 } // namespace blink |
OLD | NEW |