reflow comments in core/layout/[M-Z]*.{cpp,h}

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

 /*
  * Copyright (C) 2013 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 136 matching lines @@
 }
 
 static bool isPotentialClusterRoot(const LayoutObject* layoutObject) {
   // "Potential cluster roots" are the smallest unit for which we can
   // enable/disable text autosizing.
   // - Must have children.
   //   An exception is made for LayoutView which should create a root to
   //   maintain consistency with documents that have no child nodes but may
   //   still have LayoutObject children.
   // - Must not be inline, as different multipliers on one line looks terrible.
-  //   Exceptions are inline-block and alike elements (inline-table, -webkit-inline-*),
-  //   as they often contain entire multi-line columns of text.
+  //   Exceptions are inline-block and alike elements (inline-table,
+  //   -webkit-inline-*), as they often contain entire multi-line columns of
+  //   text.
   // - Must not be normal list items, as items in the same list should look
   //   consistent, unless they are floating or position:absolute/fixed.
   Node* node = layoutObject->generatingNode();
   if (node && !node->hasChildren() && !layoutObject->isLayoutView())
     return false;
   if (!layoutObject->isLayoutBlock())
     return false;
   if (layoutObject->isInline() &&
       !layoutObject->style()->isDisplayReplacedType())
     return false;
@@ skipping 51 matching lines @@
       layoutObject = layoutObject->nextInPreOrderAfterChildren(block);
       continue;
     }
     layoutObject = layoutObject->nextInPreOrder(block);
   }
 
   return (linkCount >= 3);
 }
 
 static bool blockHeightConstrained(const LayoutBlock* block) {
-  // FIXME: Propagate constrainedness down the tree, to avoid inefficiently walking back up from each box.
+  // FIXME: Propagate constrainedness down the tree, to avoid inefficiently
+  // walking back up from each box.
   // FIXME: This code needs to take into account vertical writing modes.
-  // FIXME: Consider additional heuristics, such as ignoring fixed heights if the content is already overflowing before autosizing kicks in.
+  // FIXME: Consider additional heuristics, such as ignoring fixed heights if
+  // the content is already overflowing before autosizing kicks in.
   for (; block; block = block->containingBlock()) {
     const ComputedStyle& style = block->styleRef();
     if (style.overflowY() >= OverflowScroll)
       return false;
     if (style.height().isSpecified() || style.maxHeight().isSpecified() ||
         block->isOutOfFlowPositioned()) {
-      // Some sites (e.g. wikipedia) set their html and/or body elements to height:100%,
-      // without intending to constrain the height of the content within them.
+      // Some sites (e.g. wikipedia) set their html and/or body elements to
+      // height:100%, without intending to constrain the height of the content
+      // within them.
       return !block->isDocumentElement() && !block->isBody() &&
              !block->isLayoutView();
     }
     if (block->isFloating())
       return false;
   }
   return false;
 }
 
 static bool blockOrImmediateChildrenAreFormControls(const LayoutBlock* block) {
@@ skipping 22 matching lines @@
   if (!block->style()->autoWrap())
     return true;
 
   if (blockHeightConstrained(block))
     return true;
 
   return false;
 }
 
 static bool hasExplicitWidth(const LayoutBlock* block) {
-  // FIXME: This heuristic may need to be expanded to other ways a block can be wider or narrower
-  //        than its parent containing block.
+  // FIXME: This heuristic may need to be expanded to other ways a block can be
+  // wider or narrower than its parent containing block.
   return block->style() && block->style()->width().isSpecified();
 }
 
 TextAutosizer::TextAutosizer(const Document* document)
     : m_document(document),
       m_firstBlockToBeginLayout(nullptr),
 #if ENABLE(ASSERT)
       m_blocksThatHaveBegunLayout(),
 #endif
       m_superclusters(),
@@ skipping 91 matching lines @@
 
 void TextAutosizer::inflateAutoTable(LayoutTable* table) {
   ASSERT(table);
   ASSERT(!table->style()->isFixedTableLayout());
   ASSERT(table->containingBlock());
 
   Cluster* cluster = currentCluster();
   if (cluster->m_root != table)
     return;
 
-  // Pre-inflate cells that have enough text so that their inflated preferred widths will be used
-  // for column sizing.
+  // Pre-inflate cells that have enough text so that their inflated preferred
+  // widths will be used for column sizing.
   for (LayoutObject* section = table->firstChild(); section;
        section = section->nextSibling()) {
     if (!section->isTableSection())
       continue;
     for (LayoutTableRow* row = toLayoutTableSection(section)->firstRow(); row;
          row = row->nextRow()) {
       for (LayoutTableCell* cell = row->firstCell(); cell;
            cell = cell->nextCell()) {
         if (!cell->needsLayout())
           continue;
@@ skipping 34 matching lines @@
   LayoutObject* child = nullptr;
   if (parent->isLayoutBlock() &&
       (parent->childrenInline() || behavior == DescendToInnerBlocks))
     child = toLayoutBlock(parent)->firstChild();
   else if (parent->isLayoutInline())
     child = toLayoutInline(parent)->firstChild();
 
   while (child) {
     if (child->isText()) {
       hasTextChild = true;
-      // We only calculate this multiplier on-demand to ensure the parent block of this text
-      // has entered layout.
+      // We only calculate this multiplier on-demand to ensure the parent block
+      // of this text has entered layout.
       if (!multiplier)
         multiplier =
             cluster->m_flags & SUPPRESSING ? 1.0f : clusterMultiplier(cluster);
       applyMultiplier(child, multiplier, layouter);
 
       // FIXME: Investigate why MarkOnlyThis is sufficient.
       if (parent->isLayoutInline())
         child->setPreferredLogicalWidthsDirty(MarkOnlyThis);
     } else if (child->isLayoutInline()) {
       multiplier = inflate(child, layouter, behavior, multiplier);
     } else if (child->isLayoutBlock() && behavior == DescendToInnerBlocks &&
                !classifyBlock(child,
                               INDEPENDENT | EXPLICIT_WIDTH | SUPPRESSING)) {
       multiplier = inflate(child, layouter, behavior, multiplier);
     }
     child = child->nextSibling();
   }
 
   if (hasTextChild) {
     applyMultiplier(parent, multiplier,
                     layouter);  // Parent handles line spacing.
   } else if (!parent->isListItem()) {
-    // For consistency, a block with no immediate text child should always have a
-    // multiplier of 1.
+    // For consistency, a block with no immediate text child should always have
+    // a multiplier of 1.
     applyMultiplier(parent, 1, layouter);
   }
 
   if (parent->isListItem()) {
     float multiplier = clusterMultiplier(cluster);
     applyMultiplier(parent, multiplier, layouter);
 
-    // The list item has to be treated special because we can have a tree such that you have
-    // a list item for a form inside it. The list marker then ends up inside the form and when
-    // we try to get the clusterMultiplier we have the wrong cluster root to work from and get
-    // the wrong value.
+    // The list item has to be treated special because we can have a tree such
+    // that you have a list item for a form inside it. The list marker then ends
+    // up inside the form and when we try to get the clusterMultiplier we have
+    // the wrong cluster root to work from and get the wrong value.
     LayoutListItem* item = toLayoutListItem(parent);
     if (LayoutListMarker* marker = item->marker()) {
       applyMultiplier(marker, multiplier, layouter);
       marker->setPreferredLogicalWidthsDirty(MarkOnlyThis);
     }
   }
 
   if (m_pageInfo.m_hasAutosized)
     UseCounter::count(*m_document, UseCounter::TextAutosizing);
 
@@ skipping 53 matching lines @@
     if (frameSize.isEmpty())
       frameSize = windowSize();
 
     m_pageInfo.m_frameWidth =
         horizontalWritingMode ? frameSize.width() : frameSize.height();
 
     IntSize layoutSize = mainFrame->view()->layoutSize();
     m_pageInfo.m_layoutWidth =
         horizontalWritingMode ? layoutSize.width() : layoutSize.height();
 
-    // TODO(pdr): Accessibility should be moved out of the text autosizer. See: crbug.com/645717.
+    // TODO(pdr): Accessibility should be moved out of the text autosizer. See:
+    // crbug.com/645717.
     m_pageInfo.m_accessibilityFontScaleFactor =
         m_document->settings()->accessibilityFontScaleFactor();
 
-    // If the page has a meta viewport or @viewport, don't apply the device scale adjustment.
+    // If the page has a meta viewport or @viewport, don't apply the device
+    // scale adjustment.
     if (!mainFrame->document()->viewportDescription().isSpecifiedByAuthor())
       m_pageInfo.m_deviceScaleAdjustment =
           m_document->settings()->deviceScaleAdjustment();
     else
       m_pageInfo.m_deviceScaleAdjustment = 1.0f;
 
-    // TODO(pdr): pageNeedsAutosizing should take into account whether text-size-adjust is used
-    // anywhere on the page because that also needs to trigger autosizing. See: crbug.com/646237.
+    // TODO(pdr): pageNeedsAutosizing should take into account whether
+    // text-size-adjust is used anywhere on the page because that also needs to
+    // trigger autosizing. See: crbug.com/646237.
     m_pageInfo.m_pageNeedsAutosizing =
         !!m_pageInfo.m_frameWidth &&
         (m_pageInfo.m_accessibilityFontScaleFactor *
              m_pageInfo.m_deviceScaleAdjustment *
              (static_cast<float>(m_pageInfo.m_layoutWidth) /
               m_pageInfo.m_frameWidth) >
          1.0f);
   }
 
   if (m_pageInfo.m_pageNeedsAutosizing) {
-    // If page info has changed, multipliers may have changed. Force a layout to recompute them.
+    // If page info has changed, multipliers may have changed. Force a layout to
+    // recompute them.
     if (m_pageInfo.m_frameWidth != previousPageInfo.m_frameWidth ||
         m_pageInfo.m_layoutWidth != previousPageInfo.m_layoutWidth ||
         m_pageInfo.m_accessibilityFontScaleFactor !=
             previousPageInfo.m_accessibilityFontScaleFactor ||
         m_pageInfo.m_deviceScaleAdjustment !=
             previousPageInfo.m_deviceScaleAdjustment ||
         m_pageInfo.m_settingEnabled != previousPageInfo.m_settingEnabled)
       setAllTextNeedsLayout();
   } else if (previousPageInfo.m_hasAutosized) {
-    // If we are no longer autosizing the page, we won't do anything during the next layout.
-    // Set all the multipliers back to 1 now.
+    // If we are no longer autosizing the page, we won't do anything during the
+    // next layout. Set all the multipliers back to 1 now.
     resetMultipliers();
     m_pageInfo.m_hasAutosized = false;
   }
 }
 
 IntSize TextAutosizer::windowSize() const {
   Page* page = m_document->page();
   ASSERT(page);
   return page->frameHost().visualViewport().size();
 }
@@ skipping 56 matching lines @@
 bool TextAutosizer::clusterHasEnoughTextToAutosize(
     Cluster* cluster,
     const LayoutBlock* widthProvider) {
   if (cluster->m_hasEnoughTextToAutosize != UnknownAmountOfText)
     return cluster->m_hasEnoughTextToAutosize == HasEnoughText;
 
   const LayoutBlock* root = cluster->m_root;
   if (!widthProvider)
     widthProvider = clusterWidthProvider(root);
 
-  // TextAreas and user-modifiable areas get a free pass to autosize regardless of text content.
+  // TextAreas and user-modifiable areas get a free pass to autosize regardless
+  // of text content.
   if (root->isTextArea() ||
       (root->style() && root->style()->userModify() != READ_ONLY)) {
     cluster->m_hasEnoughTextToAutosize = HasEnoughText;
     return true;
   }
 
   if (cluster->m_flags & SUPPRESSING) {
     cluster->m_hasEnoughTextToAutosize = NotEnoughText;
     return false;
   }
 
   // 4 lines of text is considered enough to autosize.
   float minimumTextLengthToAutosize = widthFromBlock(widthProvider) * 4;
 
   float length = 0;
   LayoutObject* descendant = root->firstChild();
   while (descendant) {
     if (descendant->isLayoutBlock()) {
       if (classifyBlock(descendant, INDEPENDENT | SUPPRESSING)) {
         descendant = descendant->nextInPreOrderAfterChildren(root);
         continue;
       }
     } else if (descendant->isText()) {
-      // Note: Using text().stripWhiteSpace().length() instead of resolvedTextLength() because
-      // the lineboxes will not be built until layout. These values can be different.
+      // Note: Using text().stripWhiteSpace().length() instead of
+      // resolvedTextLength() because the lineboxes will not be built until
+      // layout. These values can be different.
       // Note: This is an approximation assuming each character is 1em wide.
       length += toLayoutText(descendant)->text().stripWhiteSpace().length() *
                 descendant->style()->specifiedFontSize();
 
       if (length >= minimumTextLengthToAutosize) {
         cluster->m_hasEnoughTextToAutosize = HasEnoughText;
         return true;
       }
     }
     descendant = descendant->nextInPreOrder(root);
@@ skipping 55 matching lines @@
 TextAutosizer::Cluster* TextAutosizer::maybeCreateCluster(
     const LayoutBlock* block) {
   BlockFlags flags = classifyBlock(block);
   if (!(flags & POTENTIAL_ROOT))
     return nullptr;
 
   Cluster* parentCluster =
       m_clusterStack.isEmpty() ? nullptr : currentCluster();
   ASSERT(parentCluster || block->isLayoutView());
 
-  // If a non-independent block would not alter the SUPPRESSING flag, it doesn't need to be a cluster.
+  // If a non-independent block would not alter the SUPPRESSING flag, it doesn't
+  // need to be a cluster.
   bool parentSuppresses =
       parentCluster && (parentCluster->m_flags & SUPPRESSING);
   if (!(flags & INDEPENDENT) && !(flags & EXPLICIT_WIDTH) &&
       !!(flags & SUPPRESSING) == parentSuppresses)
     return nullptr;
 
   Cluster* cluster =
       new Cluster(block, flags, parentCluster, getSupercluster(block));
 #ifdef AUTOSIZING_DOM_DEBUG_INFO
   // Non-SUPPRESSING clusters are annotated in clusterMultiplier.
@@ skipping 114 matching lines @@
 float TextAutosizer::widthFromBlock(const LayoutBlock* block) const {
   RELEASE_ASSERT(block);
   RELEASE_ASSERT(block->style());
 
   if (!(block->isTable() || block->isTableCell() || block->isListItem()))
     return block->contentLogicalWidth().toFloat();
 
   if (!block->containingBlock())
     return 0;
 
-  // Tables may be inflated before computing their preferred widths. Try several methods to
-  // obtain a width, and fall back on a containing block's width.
+  // Tables may be inflated before computing their preferred widths. Try several
+  // methods to obtain a width, and fall back on a containing block's width.
   for (; block; block = block->containingBlock()) {
     float width;
     Length specifiedWidth =
         block->isTableCell()
             ? toLayoutTableCell(block)->styleOrColLogicalWidth()
             : block->style()->logicalWidth();
     if (specifiedWidth.isFixed()) {
       if ((width = specifiedWidth.value()) > 0)
         return width;
     }
     if (specifiedWidth.isPercentOrCalc()) {
       if (float containerWidth =
               block->containingBlock()->contentLogicalWidth().toFloat()) {
         if ((width = floatValueForLength(specifiedWidth, containerWidth)) > 0)
           return width;
       }
     }
     if ((width = block->contentLogicalWidth().toFloat()) > 0)
       return width;
   }
   return 0;
 }
 
 float TextAutosizer::multiplierFromBlock(const LayoutBlock* block) {
-  // If block->needsLayout() is false, it does not need to be in m_blocksThatHaveBegunLayout.
-  // This can happen during layout of a positioned object if the cluster's DBCAT is deeper
-  // than the positioned object's containing block, and wasn't marked as needing layout.
+  // If block->needsLayout() is false, it does not need to be in
+  // m_blocksThatHaveBegunLayout. This can happen during layout of a positioned
+  // object if the cluster's DBCAT is deeper than the positioned object's
+  // containing block, and wasn't marked as needing layout.
   ASSERT(m_blocksThatHaveBegunLayout.contains(block) || !block->needsLayout());
 
   // Block width, in CSS pixels.
   float blockWidth = widthFromBlock(block);
   float layoutWidth =
       std::min(blockWidth, static_cast<float>(m_pageInfo.m_layoutWidth));
   float multiplier =
       m_pageInfo.m_frameWidth ? layoutWidth / m_pageInfo.m_frameWidth : 1.0f;
   multiplier *= m_pageInfo.m_accessibilityFontScaleFactor *
                 m_pageInfo.m_deviceScaleAdjustment;
@@ skipping 14 matching lines @@
     const LayoutBlock* root) const {
   size_t firstDepth = 0;
   const LayoutObject* firstTextLeaf = findTextLeaf(root, firstDepth, First);
   if (!firstTextLeaf)
     return root;
 
   size_t lastDepth = 0;
   const LayoutObject* lastTextLeaf = findTextLeaf(root, lastDepth, Last);
   ASSERT(lastTextLeaf);
 
-  // Equalize the depths if necessary. Only one of the while loops below will get executed.
+  // Equalize the depths if necessary. Only one of the while loops below will
+  // get executed.
   const LayoutObject* firstNode = firstTextLeaf;
   const LayoutObject* lastNode = lastTextLeaf;
   while (firstDepth > lastDepth) {
     firstNode = firstNode->parent();
     --firstDepth;
   }
   while (lastDepth > firstDepth) {
     lastNode = lastNode->parent();
     --lastDepth;
   }
 
-  // Go up from both nodes until the parent is the same. Both pointers will point to the LCA then.
+  // Go up from both nodes until the parent is the same. Both pointers will
+  // point to the LCA then.
   while (firstNode != lastNode) {
     firstNode = firstNode->parent();
     lastNode = lastNode->parent();
   }
 
   if (firstNode->isLayoutBlock())
     return toLayoutBlock(firstNode);
 
-  // containingBlock() should never leave the cluster, since it only skips ancestors when finding
-  // the container of position:absolute/fixed blocks, and those cannot exist between a cluster and
-  // its text node's lowest common ancestor as isAutosizingCluster would have made them into their
-  // own independent cluster.
+  // containingBlock() should never leave the cluster, since it only skips
+  // ancestors when finding the container of position:absolute/fixed blocks, and
+  // those cannot exist between a cluster and its text node's lowest common
+  // ancestor as isAutosizingCluster would have made them into their own
+  // independent cluster.
   const LayoutBlock* containingBlock = firstNode->containingBlock();
   if (!containingBlock)
     return root;
 
   ASSERT(containingBlock->isDescendantOf(root));
   return containingBlock;
 }
 
 const LayoutObject* TextAutosizer::findTextLeaf(
     const LayoutObject* parent,
     size_t& depth,
     TextLeafSearch firstOrLast) const {
   // List items are treated as text due to the marker.
   if (parent->isListItem())
     return parent;
 
   if (parent->isText())
     return parent;
 
   ++depth;
   const LayoutObject* child = (firstOrLast == First) ? parent->slowFirstChild()
                                                      : parent->slowLastChild();
   while (child) {
-    // Note: At this point clusters may not have been created for these blocks so we cannot rely
-    //       on m_clusters. Instead, we use a best-guess about whether the block will become a cluster.
+    // Note: At this point clusters may not have been created for these blocks
+    // so we cannot rely on m_clusters. Instead, we use a best-guess about
+    // whether the block will become a cluster.
     if (!classifyBlock(child, INDEPENDENT)) {
       if (const LayoutObject* leaf = findTextLeaf(child, depth, firstOrLast))
         return leaf;
     }
     child = (firstOrLast == First) ? child->nextSibling()
                                    : child->previousSibling();
   }
   --depth;
 
   return nullptr;
 }
 
 void TextAutosizer::applyMultiplier(LayoutObject* layoutObject,
                                     float multiplier,
                                     SubtreeLayoutScope* layouter,
                                     RelayoutBehavior relayoutBehavior) {
   ASSERT(layoutObject);
   ComputedStyle& currentStyle = layoutObject->mutableStyleRef();
   if (!currentStyle.getTextSizeAdjust().isAuto()) {
-    // The accessibility font scale factor is applied by the autosizer so we need to apply that
-    // scale factor on top of the text-size-adjust multiplier.
+    // The accessibility font scale factor is applied by the autosizer so we
+    // need to apply that scale factor on top of the text-size-adjust
+    // multiplier.
     multiplier = currentStyle.getTextSizeAdjust().multiplier() *
                  m_pageInfo.m_accessibilityFontScaleFactor;
   } else if (multiplier < 1) {
     // Unlike text-size-adjust, the text autosizer should only inflate fonts.
     multiplier = 1;
   }
 
   if (currentStyle.textAutosizingMultiplier() == multiplier)
     return;
 
   // We need to clone the layoutObject style to avoid breaking style sharing.
   RefPtr<ComputedStyle> style = ComputedStyle::clone(currentStyle);
   style->setTextAutosizingMultiplier(multiplier);
   style->setUnique();
 
   switch (relayoutBehavior) {
     case AlreadyInLayout:
-      // Don't free currentStyle until the end of the layout pass. This allows other parts of the system
-      // to safely hold raw ComputedStyle* pointers during layout, e.g. BreakingContext::m_currentStyle.
+      // Don't free currentStyle until the end of the layout pass. This allows
+      // other parts of the system to safely hold raw ComputedStyle* pointers
+      // during layout, e.g. BreakingContext::m_currentStyle.
       m_stylesRetainedDuringLayout.append(&currentStyle);
 
       layoutObject->setStyleInternal(style.release());
       DCHECK(!layouter || layoutObject->isDescendantOf(&layouter->root()));
       layoutObject->setNeedsLayoutAndFullPaintInvalidation(
           LayoutInvalidationReason::TextAutosizing, MarkContainerChain,
           layouter);
       break;
 
     case LayoutNeeded:
@@ skipping 16 matching lines @@
   const LayoutBlock* parentDeepestBlockContainingAllText =
       deepestBlockContainingAllText(cluster->m_parent);
   ASSERT(m_blocksThatHaveBegunLayout.contains(cluster->m_root));
   ASSERT(m_blocksThatHaveBegunLayout.contains(
       parentDeepestBlockContainingAllText));
 
   float contentWidth = cluster->m_root->contentLogicalWidth().toFloat();
   float clusterTextWidth =
       parentDeepestBlockContainingAllText->contentLogicalWidth().toFloat();
 
-  // Clusters with a root that is wider than the deepestBlockContainingAllText of their parent
-  // autosize independently of their parent.
+  // Clusters with a root that is wider than the deepestBlockContainingAllText
+  // of their parent autosize independently of their parent.
   if (contentWidth > clusterTextWidth)
     return true;
 
-  // Clusters with a root that is significantly narrower than the deepestBlockContainingAllText of
-  // their parent autosize independently of their parent.
+  // Clusters with a root that is significantly narrower than the
+  // deepestBlockContainingAllText of their parent autosize independently of
+  // their parent.
   static float narrowWidthDifference = 200;
   if (clusterTextWidth - contentWidth > narrowWidthDifference)
     return true;
 
   return false;
 }
 
 TextAutosizer::Cluster* TextAutosizer::currentCluster() const {
   ASSERT_WITH_SECURITY_IMPLICATION(!m_clusterStack.isEmpty());
   return m_clusterStack.last().get();
 }
 
 TextAutosizer::Cluster::Cluster(const LayoutBlock* root,
                                 BlockFlags flags,
                                 Cluster* parent,
                                 Supercluster* supercluster)
     : m_root(root),
       m_flags(flags),
       m_deepestBlockContainingAllText(nullptr),
       m_parent(parent),
       m_multiplier(0),
       m_hasEnoughTextToAutosize(UnknownAmountOfText),
       m_supercluster(supercluster),
       m_hasTableAncestor(root->isTableCell() ||
                          (m_parent && m_parent->m_hasTableAncestor)) {}
 
 #if ENABLE(ASSERT)
 void TextAutosizer::FingerprintMapper::assertMapsAreConsistent() {
-  // For each fingerprint -> block mapping in m_blocksForFingerprint we should have an associated
-  // map from block -> fingerprint in m_fingerprints.
+  // For each fingerprint -> block mapping in m_blocksForFingerprint we should
+  // have an associated map from block -> fingerprint in m_fingerprints.
   ReverseFingerprintMap::iterator end = m_blocksForFingerprint.end();
   for (ReverseFingerprintMap::iterator fingerprintIt =
            m_blocksForFingerprint.begin();
        fingerprintIt != end; ++fingerprintIt) {
     Fingerprint fingerprint = fingerprintIt->key;
     BlockSet* blocks = fingerprintIt->value.get();
     for (BlockSet::iterator blockIt = blocks->begin(); blockIt != blocks->end();
          ++blockIt) {
       const LayoutBlock* block = (*blockIt);
       ASSERT(m_fingerprints.get(block) == fingerprint);
@@ skipping 113 matching lines @@
   // multiplier; hence for specifiedSize == pleasantSize, computedSize will be
   // multiplier * pleasantSize. For greater specifiedSizes we want to
   // gradually fade out the multiplier, so for every 1px increase in
   // specifiedSize beyond pleasantSize we will only increase computedSize
   // by gradientAfterPleasantSize px until we meet the
   // computedSize = specifiedSize line, after which we stay on that line (so
   // then every 1px increase in specifiedSize increases computedSize by 1px).
   const float gradientAfterPleasantSize = 0.5;
 
   float computedSize;
-  // Skip linear backoff for multipliers that shrink the size or when the font sizes are small.
+  // Skip linear backoff for multipliers that shrink the size or when the font
+  // sizes are small.
   if (multiplier <= 1 || specifiedSize <= pleasantSize) {
     computedSize = multiplier * specifiedSize;
   } else {
     computedSize = multiplier * pleasantSize +
                    gradientAfterPleasantSize * (specifiedSize - pleasantSize);
     if (computedSize < specifiedSize)
       computedSize = specifiedSize;
   }
   return computedSize;
 }
 
 DEFINE_TRACE(TextAutosizer) {
   visitor->trace(m_document);
 }
 
 }  // namespace blink