Paint collapsed borders of a table as one display item

third_party/WebKit/Source/core/paint/PaintLayerPainter.cpp

 // Copyright 2014 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.
 
 #include "core/paint/PaintLayerPainter.h"
 
 #include "core/frame/LocalFrame.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ClipPathClipper.h"
@@ skipping 46 matching lines @@
 static ShouldRespectOverflowClipType shouldRespectOverflowClip(
     PaintLayerFlags paintFlags,
     const LayoutObject* layoutObject) {
   return (paintFlags & PaintLayerPaintingOverflowContents ||
           (paintFlags & PaintLayerPaintingChildClippingMaskPhase &&
            layoutObject->hasClipPath()))
              ? IgnoreOverflowClip
              : RespectOverflowClip;
 }
 
-PaintLayerPainter::PaintResult PaintLayerPainter::paintLayer(
+PaintResult PaintLayerPainter::paintLayer(
     GraphicsContext& context,
     const PaintLayerPaintingInfo& paintingInfo,
     PaintLayerFlags paintFlags) {
   // https://code.google.com/p/chromium/issues/detail?id=343772
   DisableCompositingQueryAsserts disabler;
 
   if (m_paintLayer.compositingState() != NotComposited) {
     if (paintingInfo.getGlobalPaintFlags() &
         GlobalPaintFlattenCompositingLayers) {
       // FIXME: ok, but what about GlobalPaintFlattenCompositingLayers? That's
@@ skipping 26 matching lines @@
     paintFlags |= PaintLayerHaveTransparency;
 
   if (m_paintLayer.paintsWithTransform(paintingInfo.getGlobalPaintFlags()) &&
       !(paintFlags & PaintLayerAppliedTransform))
     return paintLayerWithTransform(context, paintingInfo, paintFlags);
 
   return paintLayerContentsCompositingAllPhases(context, paintingInfo,
                                                 paintFlags);
 }
 
-PaintLayerPainter::PaintResult
-PaintLayerPainter::paintLayerContentsCompositingAllPhases(
+PaintResult PaintLayerPainter::paintLayerContentsCompositingAllPhases(
     GraphicsContext& context,
     const PaintLayerPaintingInfo& paintingInfo,
     PaintLayerFlags paintFlags,
     FragmentPolicy fragmentPolicy) {
   DCHECK(m_paintLayer.isSelfPaintingLayer() ||
          m_paintLayer.hasSelfPaintingLayerDescendant());
 
   PaintLayerFlags localPaintFlags = paintFlags & ~(PaintLayerAppliedTransform);
   localPaintFlags |= PaintLayerPaintingCompositingAllPhases;
   return paintLayerContents(context, paintingInfo, localPaintFlags,
@@ skipping 75 matching lines @@
     if (&clipRects != previousClipRects &&
         (!previousClipRects || clipRects != *previousClipRects)) {
       needsRepaint = true;
       shouldClearEmptyPaintPhaseFlags = true;
     }
     paintLayer.setPreviousPaintingClipRects(clipRects);
   }
 
   // Repaint if previously the layer might be clipped by paintDirtyRect and
   // paintDirtyRect changes.
-  if (paintLayer.previousPaintResult() ==
-          PaintLayerPainter::MayBeClippedByPaintDirtyRect &&
+  if (paintLayer.previousPaintResult() == MayBeClippedByPaintDirtyRect &&
       paintLayer.previousPaintDirtyRect() != paintingInfo.paintDirtyRect) {
     needsRepaint = true;
     shouldClearEmptyPaintPhaseFlags = true;
   }
   paintLayer.setPreviousPaintDirtyRect(paintingInfo.paintDirtyRect);
 
   // Repaint if scroll offset accumulation changes.
   if (paintingInfo.scrollOffsetAccumulation !=
       paintLayer.previousScrollOffsetAccumulationForPainting()) {
     needsRepaint = true;
     shouldClearEmptyPaintPhaseFlags = true;
   }
   paintLayer.setPreviousScrollOffsetAccumulationForPainting(
       paintingInfo.scrollOffsetAccumulation);
 
   return needsRepaint;
 }
 
-PaintLayerPainter::PaintResult PaintLayerPainter::paintLayerContents(
+PaintResult PaintLayerPainter::paintLayerContents(
     GraphicsContext& context,
     const PaintLayerPaintingInfo& paintingInfoArg,
     PaintLayerFlags paintFlags,
     FragmentPolicy fragmentPolicy) {
   DCHECK(m_paintLayer.isSelfPaintingLayer() ||
          m_paintLayer.hasSelfPaintingLayerDescendant());
   DCHECK(!(paintFlags & PaintLayerAppliedTransform));
 
   bool isSelfPaintingLayer = m_paintLayer.isSelfPaintingLayer();
   bool isPaintingOverlayScrollbars =
@@ skipping 301 matching lines @@
     // fragment.layerBounds is set to the border box, not the bounding box, of
     // the layer.
     if (m_paintLayer.intersectsDamageRect(fragment.layerBounds,
                                           fragment.backgroundRect.rect(),
                                           newOffsetFromRoot))
       return true;
   }
   return false;
 }
 
-PaintLayerPainter::PaintResult PaintLayerPainter::paintLayerWithTransform(
+PaintResult PaintLayerPainter::paintLayerWithTransform(
     GraphicsContext& context,
     const PaintLayerPaintingInfo& paintingInfo,
     PaintLayerFlags paintFlags) {
   TransformationMatrix layerTransform =
       m_paintLayer.renderableTransform(paintingInfo.getGlobalPaintFlags());
   // If the transform can't be inverted, then don't paint anything.
   if (!layerTransform.isInvertible())
     return FullyPainted;
 
   // FIXME: We should make sure that we don't walk past paintingInfo.rootLayer
@@ skipping 109 matching lines @@
       }
     }
     if (paintFragmentByApplyingTransform(context, paintingInfo, paintFlags,
                                          fragment.paginationOffset) ==
         MayBeClippedByPaintDirtyRect)
       result = MayBeClippedByPaintDirtyRect;
   }
   return result;
 }
 
-PaintLayerPainter::PaintResult
-PaintLayerPainter::paintFragmentByApplyingTransform(
+PaintResult PaintLayerPainter::paintFragmentByApplyingTransform(
     GraphicsContext& context,
     const PaintLayerPaintingInfo& paintingInfo,
     PaintLayerFlags paintFlags,
     const LayoutPoint& fragmentTranslation) {
   // This involves subtracting out the position of the layer in our current
   // coordinate space, but preserving the accumulated error for sub-pixel
   // layout.
   LayoutPoint delta;
   m_paintLayer.convertToLayerCoords(paintingInfo.rootLayer, delta);
   delta.moveBy(fragmentTranslation);
@@ skipping 20 matching lines @@
       paintingInfo.ancestorHasClipPathClipping;
 
   // Remove skip root background flag when we're painting with a new root.
   if (&m_paintLayer != paintingInfo.rootLayer)
     paintFlags &= ~PaintLayerPaintingSkipRootBackground;
 
   return paintLayerContentsCompositingAllPhases(
       context, transformedPaintingInfo, paintFlags, ForceSingleFragment);
 }
 
-PaintLayerPainter::PaintResult PaintLayerPainter::paintChildren(
+PaintResult PaintLayerPainter::paintChildren(
     unsigned childrenToVisit,
     GraphicsContext& context,
     const PaintLayerPaintingInfo& paintingInfo,
     PaintLayerFlags paintFlags) {
   PaintResult result = FullyPainted;
   if (!m_paintLayer.hasSelfPaintingLayerDescendant())
     return result;
 
 #if ENABLE(ASSERT)
   LayerListMutationDetector mutationChecker(m_paintLayer.stackingNode());
@@ skipping 335 matching lines @@
 
   PaintLayerPaintingInfo paintingInfo(&m_paintLayer,
                                       LayoutRect(enclosingIntRect(damageRect)),
                                       paintFlags, LayoutSize());
   paintLayer(context, paintingInfo, PaintLayerPaintingOverlayScrollbars);
 
   m_paintLayer.setContainsDirtyOverlayScrollbars(false);
 }
 
 }  // namespace blink