reflow comments in core/paint

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

 // Copyright 2015 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/PaintPropertyTreeBuilder.h"
 
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 45 matching lines @@
   PaintPropertyTreeBuilderContext context;
 
   context.current.clip = context.absolutePosition.clip =
       context.fixedPosition.clip = rootClipNode();
   context.currentEffect = rootEffectNode();
   context.current.transform = context.absolutePosition.transform =
       context.fixedPosition.transform = rootTransformNode();
   context.current.scroll = context.absolutePosition.scroll =
       context.fixedPosition.scroll = rootScrollNode();
 
-  // Ensure scroll tree properties are reset. They will be rebuilt during the tree walk.
+  // Ensure scroll tree properties are reset. They will be rebuilt during the
+  // tree walk.
   rootScrollNode()->clearMainThreadScrollingReasons();
 
   return context;
 }
 
 void createOrUpdateFrameViewPreTranslation(
     FrameView& frameView,
     PassRefPtr<const TransformPaintPropertyNode> parent,
     const TransformationMatrix& matrix,
     const FloatPoint3D& origin) {
@@ skipping 140 matching lines @@
 }
 
 void PaintPropertyTreeBuilder::updatePaintOffsetTranslation(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.isBoxModelObject() &&
       context.current.paintOffset != LayoutPoint()) {
     // TODO(trchen): Eliminate PaintLayer dependency.
     PaintLayer* layer = toLayoutBoxModelObject(object).layer();
     if (layer && layer->paintsWithTransform(GlobalPaintNormalPhase)) {
-      // We should use the same subpixel paint offset values for snapping regardless of whether a
-      // transform is present. If there is a transform we round the paint offset but keep around
-      // the residual fractional component for the transformed content to paint with.
-      // In spv1 this was called "subpixel accumulation". For more information, see
-      // PaintLayer::subpixelAccumulation() and PaintLayerPainter::paintFragmentByApplyingTransform.
+      // We should use the same subpixel paint offset values for snapping
+      // regardless of whether a transform is present. If there is a transform
+      // we round the paint offset but keep around the residual fractional
+      // component for the transformed content to paint with.  In spv1 this was
+      // called "subpixel accumulation". For more information, see
+      // PaintLayer::subpixelAccumulation() and
+      // PaintLayerPainter::paintFragmentByApplyingTransform.
       IntPoint roundedPaintOffset =
           roundedIntPoint(context.current.paintOffset);
       LayoutPoint fractionalPaintOffset =
           LayoutPoint(context.current.paintOffset - roundedPaintOffset);
 
       context.current.transform =
           object.getMutableForPainting()
               .ensureObjectPaintProperties()
               .createOrUpdatePaintOffsetTranslation(
                   context.current.transform,
@@ skipping 25 matching lines @@
 }
 
 void PaintPropertyTreeBuilder::updateTransform(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.isSVG() && !object.isSVGRoot()) {
     // SVG (other than SVGForeignObject) does not use paint offset internally.
     DCHECK(object.isSVGForeignObject() ||
            context.current.paintOffset == LayoutPoint());
 
-    // FIXME(pdr): Check for the presence of a transform instead of the value. Checking for an
-    // identity matrix will cause the property tree structure to change during animations if
-    // the animation passes through the identity matrix.
-    // FIXME(pdr): Refactor this so all non-root SVG objects use the same transform function.
+    // FIXME(pdr): Check for the presence of a transform instead of the value.
+    // Checking for an identity matrix will cause the property tree structure to
+    // change during animations if the animation passes through the identity
+    // matrix.
+    // FIXME(pdr): Refactor this so all non-root SVG objects use the same
+    // transform function.
     const AffineTransform& transform = object.isSVGForeignObject()
                                            ? object.localSVGTransform()
                                            : object.localToSVGParentTransform();
     if (!transform.isIdentity()) {
       // The origin is included in the local transform, so leave origin empty.
       context.current.transform =
           object.getMutableForPainting()
               .ensureObjectPaintProperties()
               .createOrUpdateTransform(context.current.transform,
                                        TransformationMatrix(transform),
@@ skipping 12 matching lines @@
           ComputedStyle::IncludeMotionPath,
           ComputedStyle::IncludeIndependentTransformProperties);
       FloatPoint3D origin = transformOrigin(toLayoutBox(object));
 
       unsigned renderingContextID = context.current.renderingContextID;
       unsigned renderingContextIDForChildren = 0;
       bool flattensInheritedTransform =
           context.current.shouldFlattenInheritedTransform;
       bool childrenFlattenInheritedTransform = true;
 
-      // TODO(trchen): transform-style should only be respected if a PaintLayer is
-      // created.
+      // TODO(trchen): transform-style should only be respected if a PaintLayer
+      // is created.
       if (style.preserves3D()) {
         // If a node with transform-style: preserve-3d does not exist in an
         // existing rendering context, it establishes a new one.
         if (!renderingContextID)
           renderingContextID = PtrHash<const LayoutObject>::hash(&object);
         renderingContextIDForChildren = renderingContextID;
         childrenFlattenInheritedTransform = false;
       }
 
       context.current.transform =
@@ skipping 29 matching lines @@
           .ensureObjectPaintProperties()
           .createOrUpdateEffect(context.currentEffect,
                                 object.styleRef().opacity());
 }
 
 void PaintPropertyTreeBuilder::updateCssClip(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (object.hasClip()) {
     // Create clip node for descendants that are not fixed position.
-    // We don't have to setup context.absolutePosition.clip here because this object must be
-    // a container for absolute position descendants, and will copy from in-flow context later
-    // at updateOutOfFlowContext() step.
+    // We don't have to setup context.absolutePosition.clip here because this
+    // object must be a container for absolute position descendants, and will
+    // copy from in-flow context later at updateOutOfFlowContext() step.
     DCHECK(object.canContainAbsolutePositionObjects());
     LayoutRect clipRect =
         toLayoutBox(object).clipRect(context.current.paintOffset);
     context.current.clip =
         object.getMutableForPainting()
             .ensureObjectPaintProperties()
             .createOrUpdateCssClip(context.current.clip,
                                    context.current.transform,
                                    FloatRoundedRect(FloatRect(clipRect)));
     return;
   }
 
   if (ObjectPaintProperties* properties =
           object.getMutableForPainting().objectPaintProperties())
     properties->clearCssClip();
 }
 
 void PaintPropertyTreeBuilder::updateLocalBorderBoxContext(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
-  // Avoid adding an ObjectPaintProperties for non-boxes to save memory, since we don't need them at the moment.
+  // Avoid adding an ObjectPaintProperties for non-boxes to save memory, since
+  // we don't need them at the moment.
   if (!object.isBox() && !object.hasLayer())
     return;
 
   std::unique_ptr<ObjectPaintProperties::PropertyTreeStateWithOffset>
       borderBoxContext =
           wrapUnique(new ObjectPaintProperties::PropertyTreeStateWithOffset(
               context.current.paintOffset,
               PropertyTreeState(context.current.transform, context.current.clip,
                                 context.currentEffect,
                                 context.current.scroll)));
@@ skipping 49 matching lines @@
   }
 }
 
 void PaintPropertyTreeBuilder::updateOverflowClip(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!object.isBox())
     return;
   const LayoutBox& box = toLayoutBox(object);
 
-  // The <input> elements can't have contents thus CSS overflow property doesn't apply.
-  // However for layout purposes we do generate child layout objects for them, e.g. button label.
-  // We should clip the overflow from those children. This is called control clip and we
-  // technically treat them like overflow clip.
+  // The <input> elements can't have contents thus CSS overflow property doesn't
+  // apply.  However for layout purposes we do generate child layout objects for
+  // them, e.g. button label.  We should clip the overflow from those children.
+  // This is called control clip and we technically treat them like overflow
+  // clip.
   LayoutRect clipRect;
   if (box.hasControlClip()) {
     clipRect = box.controlClipRect(context.current.paintOffset);
   } else if (box.hasOverflowClip() || box.styleRef().containsPaint() ||
              (box.isSVGRoot() &&
               toLayoutSVGRoot(box).shouldApplyViewportClip())) {
     clipRect = box.overflowClipRect(context.current.paintOffset);
   } else {
     if (ObjectPaintProperties* properties =
             object.getMutableForPainting().objectPaintProperties()) {
@@ skipping 63 matching lines @@
 void PaintPropertyTreeBuilder::updateSvgLocalToBorderBoxTransform(
     const LayoutObject& object,
     PaintPropertyTreeBuilderContext& context) {
   if (!object.isSVGRoot())
     return;
 
   AffineTransform transformToBorderBox =
       SVGRootPainter(toLayoutSVGRoot(object))
           .transformToPixelSnappedBorderBox(context.current.paintOffset);
 
-  // The paint offset is included in |transformToBorderBox| so SVG does not need to handle paint
-  // offset internally.
+  // The paint offset is included in |transformToBorderBox| so SVG does not need
+  // to handle paint offset internally.
   context.current.paintOffset = LayoutPoint();
 
   if (transformToBorderBox.isIdentity()) {
     if (ObjectPaintProperties* properties =
             object.getMutableForPainting().objectPaintProperties())
       properties->clearSvgLocalToBorderBoxTransform();
     return;
   }
 
   context.current.transform =
@@ skipping 65 matching lines @@
       context.fixedPosition = context.current;
 
       // Fixed position transform and scroll nodes should not be affected.
       context.fixedPosition.transform = initialFixedTransform;
       context.fixedPosition.scroll = initialFixedScroll;
     }
   } else if (object.canContainFixedPositionObjects()) {
     context.fixedPosition = context.current;
   } else if (object.getMutableForPainting().objectPaintProperties() &&
              object.objectPaintProperties()->cssClip()) {
-    // CSS clip applies to all descendants, even if this object is not a containing block
-    // ancestor of the descendant. It is okay for absolute-position descendants because
-    // having CSS clip implies being absolute position container. However for fixed-position
-    // descendants we need to insert the clip here if we are not a containing block ancestor
-    // of them.
+    // CSS clip applies to all descendants, even if this object is not a
+    // containing block ancestor of the descendant. It is okay for
+    // absolute-position descendants because having CSS clip implies being
+    // absolute position container. However for fixed-position descendants we
+    // need to insert the clip here if we are not a containing block ancestor of
+    // them.
     auto* cssClip =
         object.getMutableForPainting().objectPaintProperties()->cssClip();
 
-    // Before we actually create anything, check whether in-flow context and fixed-position
-    // context has exactly the same clip. Reuse if possible.
+    // Before we actually create anything, check whether in-flow context and
+    // fixed-position context has exactly the same clip. Reuse if possible.
     if (context.fixedPosition.clip == cssClip->parent()) {
       context.fixedPosition.clip = cssClip;
     } else {
       context.fixedPosition.clip =
           object.getMutableForPainting()
               .ensureObjectPaintProperties()
               .createOrUpdateCssClipFixedPosition(
                   context.fixedPosition.clip,
                   const_cast<TransformPaintPropertyNode*>(
                       cssClip->localTransformSpace()),
@@ skipping 17 matching lines @@
 
   switch (object.styleRef().position()) {
     case StaticPosition:
       break;
     case RelativePosition:
       context.current.paintOffset += boxModelObject.offsetForInFlowPosition();
       break;
     case AbsolutePosition: {
       context.current = context.absolutePosition;
 
-      // Absolutely positioned content in an inline should be positioned relative to the inline.
+      // Absolutely positioned content in an inline should be positioned
+      // relative to the inline.
       const LayoutObject* container = context.containerForAbsolutePosition;
       if (container && container->isInFlowPositioned() &&
           container->isLayoutInline()) {
         DCHECK(object.isBox());
         context.current.paintOffset +=
             toLayoutInline(container)->offsetForInFlowPositionedInline(
                 toLayoutBox(object));
       }
       break;
     }
     case StickyPosition:
       context.current.paintOffset += boxModelObject.offsetForInFlowPosition();
       break;
     case FixedPosition:
       context.current = context.fixedPosition;
       break;
     default:
       ASSERT_NOT_REACHED();
   }
 
-  // SVGForeignObject needs paint offset because its viewport offset is baked into its location(),
-  // while its localSVGTransform() doesn't contain the offset.
+  // SVGForeignObject needs paint offset because its viewport offset is baked
+  // into its location(), while its localSVGTransform() doesn't contain the
+  // offset.
   if (boxModelObject.isBox() &&
       (!boxModelObject.isSVG() || boxModelObject.isSVGRoot() ||
        boxModelObject.isSVGForeignObject())) {
-    // TODO(pdr): Several calls in this function walk back up the tree to calculate containers
-    // (e.g., topLeftLocation, offsetForInFlowPosition*). The containing block and other
-    // containers can be stored on PaintPropertyTreeBuilderContext instead of recomputing them.
+    // TODO(pdr): Several calls in this function walk back up the tree to
+    // calculate containers (e.g., topLeftLocation, offsetForInFlowPosition*).
+    // The containing block and other containers can be stored on
+    // PaintPropertyTreeBuilderContext instead of recomputing them.
     context.current.paintOffset.moveBy(
         toLayoutBox(boxModelObject).topLeftLocation());
     // This is a weird quirk that table cells paint as children of table rows,
     // but their location have the row's location baked-in.
     // Similar adjustment is done in LayoutTableCell::offsetFromContainer().
     if (boxModelObject.isTableCell()) {
       LayoutObject* parentRow = boxModelObject.parent();
       ASSERT(parentRow && parentRow->isTableRow());
       context.current.paintOffset.moveBy(
           -toLayoutBox(parentRow)->topLeftLocation());
@@ skipping 25 matching lines @@
     return;
 
   updateOverflowClip(object, context);
   updatePerspective(object, context);
   updateSvgLocalToBorderBoxTransform(object, context);
   updateScrollAndScrollTranslation(object, context);
   updateOutOfFlowContext(object, context);
 }
 
 }  // namespace blink