reflow comments in core/paint

third_party/WebKit/Source/core/paint/InlineFlowBoxPainter.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/InlineFlowBoxPainter.h"
 
 #include "core/layout/api/LineLayoutAPIShim.h"
 #include "core/layout/line/RootInlineBox.h"
 #include "core/paint/BoxPainter.h"
 #include "core/paint/PaintInfo.h"
@@ skipping 44 matching lines @@
         !curr->boxModelObject().hasSelfPaintingLayer())
       curr->paint(childInfo, paintOffset, lineTop, lineBottom);
   }
 }
 
 void InlineFlowBoxPainter::paintFillLayers(const PaintInfo& paintInfo,
                                            const Color& c,
                                            const FillLayer& fillLayer,
                                            const LayoutRect& rect,
                                            SkXfermode::Mode op) {
-  // FIXME: This should be a for loop or similar. It's a little non-trivial to do so, however, since the layers need to be
-  // painted in reverse order.
+  // FIXME: This should be a for loop or similar. It's a little non-trivial to
+  // do so, however, since the layers need to be painted in reverse order.
   if (fillLayer.next())
     paintFillLayers(paintInfo, c, *fillLayer.next(), rect, op);
   paintFillLayer(paintInfo, c, fillLayer, rect, op);
 }
 
 void InlineFlowBoxPainter::paintFillLayer(const PaintInfo& paintInfo,
                                           const Color& c,
                                           const FillLayer& fillLayer,
                                           const LayoutRect& rect,
                                           SkXfermode::Mode op) {
@@ skipping 33 matching lines @@
 }
 
 void InlineFlowBoxPainter::paintBoxShadow(const PaintInfo& info,
                                           const ComputedStyle& s,
                                           ShadowStyle shadowStyle,
                                           const LayoutRect& paintRect) {
   if ((!m_inlineFlowBox.prevLineBox() && !m_inlineFlowBox.nextLineBox()) ||
       !m_inlineFlowBox.parent()) {
     BoxPainter::paintBoxShadow(info, paintRect, s, shadowStyle);
   } else {
-    // FIXME: We can do better here in the multi-line case. We want to push a clip so that the shadow doesn't
-    // protrude incorrectly at the edges, and we want to possibly include shadows cast from the previous/following lines
+    // FIXME: We can do better here in the multi-line case. We want to push a
+    // clip so that the shadow doesn't protrude incorrectly at the edges, and we
+    // want to possibly include shadows cast from the previous/following lines
     BoxPainter::paintBoxShadow(info, paintRect, s, shadowStyle,
                                m_inlineFlowBox.includeLogicalLeftEdge(),
                                m_inlineFlowBox.includeLogicalRightEdge());
   }
 }
 
 static LayoutRect clipRectForNinePieceImageStrip(const InlineFlowBox& box,
                                                  const NinePieceImage& image,
                                                  const LayoutRect& paintRect) {
   LayoutRect clipRect(paintRect);
@@ skipping 20 matching lines @@
   }
   return clipRect;
 }
 
 LayoutRect InlineFlowBoxPainter::paintRectForImageStrip(
     const LayoutPoint& paintOffset,
     const LayoutSize& frameSize,
     TextDirection direction) const {
   // We have a fill/border/mask image that spans multiple lines.
   // We need to adjust the offset by the width of all previous lines.
-  // Think of background painting on inlines as though you had one long line, a single continuous
-  // strip. Even though that strip has been broken up across multiple lines, you still paint it
-  // as though you had one single line. This means each line has to pick up the background where
-  // the previous line left off.
+  // Think of background painting on inlines as though you had one long line, a
+  // single continuous strip. Even though that strip has been broken up across
+  // multiple lines, you still paint it as though you had one single line. This
+  // means each line has to pick up the background where the previous line left
+  // off.
   LayoutUnit logicalOffsetOnLine;
   LayoutUnit totalLogicalWidth;
   if (direction == LTR) {
     for (const InlineFlowBox* curr = m_inlineFlowBox.prevLineBox(); curr;
          curr = curr->prevLineBox())
       logicalOffsetOnLine += curr->logicalWidth();
     totalLogicalWidth = logicalOffsetOnLine;
     for (const InlineFlowBox* curr = &m_inlineFlowBox; curr;
          curr = curr->nextLineBox())
       totalLogicalWidth += curr->logicalWidth();
@@ skipping 25 matching lines @@
   adjustedClipRect = pixelSnappedIntRect(adjustedFrameRect);
   if (m_inlineFlowBox.parent() &&
       m_inlineFlowBox.getLineLayoutItem().style()->hasBorderDecoration()) {
     const NinePieceImage& borderImage =
         m_inlineFlowBox.getLineLayoutItem().style()->borderImage();
     StyleImage* borderImageSource = borderImage.image();
     bool hasBorderImage = borderImageSource && borderImageSource->canRender();
     if (hasBorderImage && !borderImageSource->isLoaded())
       return DontPaintBorders;
 
-    // The simple case is where we either have no border image or we are the only box for this object.
-    // In those cases only a single call to draw is required.
+    // The simple case is where we either have no border image or we are the
+    // only box for this object.  In those cases only a single call to draw is
+    // required.
     if (!hasBorderImage ||
         (!m_inlineFlowBox.prevLineBox() && !m_inlineFlowBox.nextLineBox()))
       return PaintBordersWithoutClip;
 
     // We have a border image that spans multiple lines.
     adjustedClipRect = pixelSnappedIntRect(clipRectForNinePieceImageStrip(
         m_inlineFlowBox, borderImage, adjustedFrameRect));
     return PaintBordersWithClip;
   }
   return DontPaintBorders;
 }
 
 void InlineFlowBoxPainter::paintBoxDecorationBackground(
     const PaintInfo& paintInfo,
     const LayoutPoint& paintOffset,
     const LayoutRect& cullRect) {
   ASSERT(paintInfo.phase == PaintPhaseForeground);
   if (m_inlineFlowBox.getLineLayoutItem().style()->visibility() !=
       EVisibility::Visible)
     return;
 
-  // You can use p::first-line to specify a background. If so, the root line boxes for
-  // a line may actually have to paint a background.
+  // You can use p::first-line to specify a background. If so, the root line
+  // boxes for a line may actually have to paint a background.
   LayoutObject* inlineFlowBoxLayoutObject =
       LineLayoutAPIShim::layoutObjectFrom(m_inlineFlowBox.getLineLayoutItem());
   const ComputedStyle* styleToUse = m_inlineFlowBox.getLineLayoutItem().style(
       m_inlineFlowBox.isFirstLineStyle());
   bool shouldPaintBoxDecorationBackground;
   if (m_inlineFlowBox.parent())
     shouldPaintBoxDecorationBackground =
         inlineFlowBoxLayoutObject->hasBoxDecorationBackground();
   else
     shouldPaintBoxDecorationBackground =
@@ skipping 44 matching lines @@
       BoxPainter::paintBorder(
           *toLayoutBoxModelObject(LineLayoutAPIShim::layoutObjectFrom(
               m_inlineFlowBox.boxModelObject())),
           paintInfo, adjustedFrameRect,
           m_inlineFlowBox.getLineLayoutItem().styleRef(
               m_inlineFlowBox.isFirstLineStyle()),
           BackgroundBleedNone, m_inlineFlowBox.includeLogicalLeftEdge(),
           m_inlineFlowBox.includeLogicalRightEdge());
       break;
     case PaintBordersWithClip:
-      // FIXME: What the heck do we do with RTL here? The math we're using is obviously not right,
-      // but it isn't even clear how this should work at all.
+      // FIXME: What the heck do we do with RTL here? The math we're using is
+      // obviously not right, but it isn't even clear how this should work at
+      // all.
       LayoutRect imageStripPaintRect =
           paintRectForImageStrip(adjustedPaintOffset, frameRect.size(), LTR);
       GraphicsContextStateSaver stateSaver(paintInfo.context);
       paintInfo.context.clip(adjustedClipRect);
       BoxPainter::paintBorder(
           *toLayoutBoxModelObject(LineLayoutAPIShim::layoutObjectFrom(
               m_inlineFlowBox.boxModelObject())),
           paintInfo, imageStripPaintRect,
           m_inlineFlowBox.getLineLayoutItem().styleRef(
               m_inlineFlowBox.isFirstLineStyle()));
@@ skipping 31 matching lines @@
   if (!compositedMask || flattenCompositingLayers) {
     if ((maskBoxImage &&
          m_inlineFlowBox.getLineLayoutItem()
              .style()
              ->maskLayers()
              .hasImage()) ||
         m_inlineFlowBox.getLineLayoutItem().style()->maskLayers().next()) {
       pushTransparencyLayer = true;
       paintInfo.context.beginLayer(1.0f, SkXfermode::kDstIn_Mode);
     } else {
-      // TODO(fmalita): passing a dst-in xfer mode down to paintFillLayers/paintNinePieceImage
-      //   seems dangerous: it is only correct if applied atomically (single draw call). While
-      //   the heuristic above presumably ensures that is the case, this approach seems super
-      //   fragile. We should investigate dropping this optimization in favour of the more
-      //   robust layer branch above.
+      // TODO(fmalita): passing a dst-in xfer mode down to
+      // paintFillLayers/paintNinePieceImage seems dangerous: it is only correct
+      // if applied atomically (single draw call). While the heuristic above
+      // presumably ensures that is the case, this approach seems super fragile.
+      // We should investigate dropping this optimization in favour of the more
+      // robust layer branch above.
       compositeOp = SkXfermode::kDstIn_Mode;
     }
   }
 
   LayoutRect paintRect = LayoutRect(adjustedPaintOffset, frameRect.size());
   paintFillLayers(paintInfo, Color::transparent,
                   m_inlineFlowBox.getLineLayoutItem().style()->maskLayers(),
                   paintRect, compositeOp);
 
   bool hasBoxImage = maskBoxImage && maskBoxImage->canRender();
   if (!hasBoxImage || !maskBoxImage->isLoaded()) {
     if (pushTransparencyLayer)
       paintInfo.context.endLayer();
     return;  // Don't paint anything while we wait for the image to load.
   }
 
   LayoutBoxModelObject* boxModel = toLayoutBoxModelObject(
       LineLayoutAPIShim::layoutObjectFrom(m_inlineFlowBox.boxModelObject()));
   // The simple case is where we are the only box for this object. In those
   // cases only a single call to draw is required.
   if (!m_inlineFlowBox.prevLineBox() && !m_inlineFlowBox.nextLineBox()) {
     BoxPainter::paintNinePieceImage(
         *boxModel, paintInfo.context, paintRect,
         m_inlineFlowBox.getLineLayoutItem().styleRef(), maskNinePieceImage,
         compositeOp);
   } else {
     // We have a mask image that spans multiple lines.
-    // FIXME: What the heck do we do with RTL here? The math we're using is obviously not right,
-    // but it isn't even clear how this should work at all.
+    // FIXME: What the heck do we do with RTL here? The math we're using is
+    // obviously not right, but it isn't even clear how this should work at all.
     LayoutRect imageStripPaintRect =
         paintRectForImageStrip(adjustedPaintOffset, frameRect.size(), LTR);
     FloatRect clipRect(clipRectForNinePieceImageStrip(
         m_inlineFlowBox, maskNinePieceImage, paintRect));
     GraphicsContextStateSaver stateSaver(paintInfo.context);
     // TODO(chrishtr): this should be pixel-snapped.
     paintInfo.context.clip(clipRect);
     BoxPainter::paintNinePieceImage(
         *boxModel, paintInfo.context, imageStripPaintRect,
         m_inlineFlowBox.getLineLayoutItem().styleRef(), maskNinePieceImage,
@@ skipping 28 matching lines @@
       rect.setHeight(logicalHeight);
     } else {
       rect.setX(logicalTop);
       rect.setWidth(logicalHeight);
     }
   }
   return rect;
 }
 
 }  // namespace blink