Reformat comments in core/layout up until LayoutMultiColumnFlowThread

third_party/WebKit/Source/core/layout/LayoutGeometryMap.cpp

 /*
  * Copyright (C) 2012 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 34 matching lines @@
       m_nonUniformStepsCount(0),
       m_transformedStepsCount(0),
       m_fixedStepsCount(0),
       m_mapCoordinatesFlags(flags) {}
 
 LayoutGeometryMap::~LayoutGeometryMap() {}
 
 void LayoutGeometryMap::mapToAncestor(
     TransformState& transformState,
     const LayoutBoxModelObject* ancestor) const {
-  // If the mapping includes something like columns, we have to go via layoutObjects.
+  // If the mapping includes something like columns, we have to go via
+  // layoutObjects.
   if (hasNonUniformStep()) {
     m_mapping.last().m_layoutObject->mapLocalToAncestor(
         ancestor, transformState, ApplyContainerFlip | m_mapCoordinatesFlags);
     transformState.flatten();
     return;
   }
 
   bool inFixed = false;
 #if ENABLE(ASSERT)
   bool foundAncestor = !ancestor || (m_mapping.size() &&
                                      m_mapping[0].m_layoutObject == ancestor);
 #endif
 
   for (int i = m_mapping.size() - 1; i >= 0; --i) {
     const LayoutGeometryMapStep& currentStep = m_mapping[i];
 
-    // If container is the root LayoutView (step 0) we want to apply its fixed position offset.
+    // If container is the root LayoutView (step 0) we want to apply its fixed
+    // position offset.
     if (i > 0 && currentStep.m_layoutObject == ancestor) {
 #if ENABLE(ASSERT)
       foundAncestor = true;
 #endif
       break;
     }
 
     // If this box has a transform, it acts as a fixed position container
     // for fixed descendants, which prevents the propagation of 'fixed'
     // unless the layer itself is also fixed position.
     if (i && currentStep.m_flags & ContainsFixedPosition &&
         !(currentStep.m_flags & IsFixedPosition))
       inFixed = false;
     else if (currentStep.m_flags & IsFixedPosition)
       inFixed = true;
 
     ASSERT(!i == isTopmostLayoutView(currentStep.m_layoutObject));
 
     if (!i) {
-      // A null container indicates mapping through the root LayoutView, so including its transform (the page scale).
+      // A null container indicates mapping through the root LayoutView, so
+      // including its transform (the page scale).
       if (!ancestor && currentStep.m_transform)
         transformState.applyTransform(*currentStep.m_transform.get());
     } else {
       TransformState::TransformAccumulation accumulate =
           currentStep.m_flags & AccumulatingTransform
               ? TransformState::AccumulateTransform
               : TransformState::FlattenTransform;
       if (currentStep.m_transform)
         transformState.applyTransform(*currentStep.m_transform.get(),
                                       accumulate);
@@ skipping 49 matching lines @@
 
 #if ENABLE(ASSERT)
   if (m_mapping.size() > 0) {
     const LayoutObject* lastLayoutObject = m_mapping.last().m_layoutObject;
 
     FloatRect layoutObjectMappedResult =
         lastLayoutObject
             ->localToAncestorQuad(rect, ancestor, m_mapCoordinatesFlags)
             .boundingBox();
 
-    // Inspector creates layoutObjects with negative width <https://bugs.webkit.org/show_bug.cgi?id=87194>.
+    // Inspector creates layoutObjects with negative width
+    // <https://bugs.webkit.org/show_bug.cgi?id=87194>.
     // Taking FloatQuad bounds avoids spurious assertions because of that.
     ASSERT(enclosingIntRect(layoutObjectMappedResult) ==
                enclosingIntRect(result.boundingBox()) ||
            layoutObjectMappedResult.mayNotHaveExactIntRectRepresentation() ||
            result.boundingBox().mayNotHaveExactIntRectRepresentation());
   }
 #endif
 
   return result;
 }
 
 void LayoutGeometryMap::pushMappingsToAncestor(
     const LayoutObject* layoutObject,
     const LayoutBoxModelObject* ancestorLayoutObject) {
-  // We need to push mappings in reverse order here, so do insertions rather than appends.
+  // We need to push mappings in reverse order here, so do insertions rather
+  // than appends.
   AutoReset<size_t> positionChange(&m_insertionPosition, m_mapping.size());
   do {
     layoutObject =
         layoutObject->pushMappingToContainer(ancestorLayoutObject, *this);
   } while (layoutObject && layoutObject != ancestorLayoutObject);
 
   ASSERT(m_mapping.isEmpty() ||
          isTopmostLayoutView(m_mapping[0].m_layoutObject));
 }
 
@@ skipping 19 matching lines @@
 void LayoutGeometryMap::pushMappingsToAncestor(
     const PaintLayer* layer,
     const PaintLayer* ancestorLayer) {
   const LayoutObject* layoutObject = layer->layoutObject();
 
   bool crossDocument =
       ancestorLayer &&
       layer->layoutObject()->frame() != ancestorLayer->layoutObject()->frame();
   ASSERT(!crossDocument || m_mapCoordinatesFlags & TraverseDocumentBoundaries);
 
-  // We have to visit all the layoutObjects to detect flipped blocks. This might defeat the gains
-  // from mapping via layers.
+  // We have to visit all the layoutObjects to detect flipped blocks. This might
+  // defeat the gains from mapping via layers.
   bool canConvertInLayerTree =
       (ancestorLayer && !crossDocument)
           ? canMapBetweenLayoutObjects(layer->layoutObject(),
                                        ancestorLayer->layoutObject())
           : false;
 
   LAYOUT_GEOMETRY_MAP_LOG(
       "LayoutGeometryMap::pushMappingsToAncestor from layer %p to layer %p, "
       "canConvertInLayerTree=%d\n",
       layer, ancestorLayer, canConvertInLayerTree);
@@ skipping 135 matching lines @@
   // If we're not working with multiple LayoutViews, then any view is considered
   // "topmost" (to preserve original behavior).
   if (!(m_mapCoordinatesFlags & TraverseDocumentBoundaries))
     return true;
 
   return layoutObject->frame()->isMainFrame();
 }
 #endif
 
 }  // namespace blink