Reflow comments in core/dom/.

third_party/WebKit/Source/core/dom/FirstLetterPseudoElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
- * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
+ * All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ skipping 16 matching lines @@
 #include "core/layout/LayoutTextFragment.h"
 #include "core/layout/api/LayoutTextFragmentItem.h"
 #include "wtf/text/WTFString.h"
 #include "wtf/text/icu/UnicodeIcu.h"
 
 namespace blink {
 
 using namespace WTF;
 using namespace Unicode;
 
-// CSS 2.1 http://www.w3.org/TR/CSS21/selector.html#first-letter
-// "Punctuation (i.e, characters defined in Unicode [UNICODE] in the "open" (Ps), "close" (Pe),
-// "initial" (Pi). "final" (Pf) and "other" (Po) punctuation classes), that precedes or follows the first letter should be included"
+// CSS 2.1 http://www.w3.org/TR/CSS21/selector.html#first-letter "Punctuation
+// (i.e, characters defined in Unicode [UNICODE] in the "open" (Ps), "close"
+// (Pe), "initial" (Pi). "final" (Pf) and "other" (Po) punctuation classes),
+// that precedes or follows the first letter should be included"
 static inline bool isPunctuationForFirstLetter(UChar c) {
   CharCategory charCategory = category(c);
   return charCategory == Punctuation_Open ||
          charCategory == Punctuation_Close ||
          charCategory == Punctuation_InitialQuote ||
          charCategory == Punctuation_FinalQuote ||
          charCategory == Punctuation_Other;
 }
 
 static inline bool isSpaceForFirstLetter(UChar c) {
   return isSpaceOrNewline(c) || c == noBreakSpaceCharacter;
 }
 
 unsigned FirstLetterPseudoElement::firstLetterLength(const String& text) {
   unsigned length = 0;
   unsigned textLength = text.length();
 
   if (textLength == 0)
     return length;
 
   // Account for leading spaces first.
   while (length < textLength && isSpaceForFirstLetter(text[length]))
     length++;
   // Now account for leading punctuation.
   while (length < textLength && isPunctuationForFirstLetter(text[length]))
     length++;
 
-  // Bail if we didn't find a letter before the end of the text or before a space.
+  // Bail if we didn't find a letter before the end of the text or before a
+  // space.
   if (isSpaceForFirstLetter(text[length]) || length == textLength)
     return 0;
 
   // Account the next character for first letter.
   length++;
 
   // Keep looking for allowed punctuation for the :first-letter.
   for (; length < textLength; ++length) {
     UChar c = text[length];
     if (!isPunctuationForFirstLetter(c))
       break;
   }
   return length;
 }
 
-// Once we see any of these layoutObjects we can stop looking for first-letter as
-// they signal the end of the first line of text.
+// Once we see any of these layoutObjects we can stop looking for first-letter
+// as they signal the end of the first line of text.
 static bool isInvalidFirstLetterLayoutObject(const LayoutObject* obj) {
   return (obj->isBR() || (obj->isText() && toLayoutText(obj)->isWordBreak()));
 }
 
 LayoutObject* FirstLetterPseudoElement::firstLetterTextLayoutObject(
     const Element& element) {
   LayoutObject* parentLayoutObject = 0;
 
   // If we are looking at a first letter element then we need to find the
   // first letter text layoutObject from the parent node, and not ourselves.
   if (element.isFirstLetterPseudoElement())
     parentLayoutObject = element.parentOrShadowHostElement()->layoutObject();
   else
     parentLayoutObject = element.layoutObject();
 
   if (!parentLayoutObject ||
       !parentLayoutObject->style()->hasPseudoStyle(PseudoIdFirstLetter) ||
       !canHaveGeneratedChildren(*parentLayoutObject) ||
       !parentLayoutObject->behavesLikeBlockContainer())
     return nullptr;
 
   // Drill down into our children and look for our first text child.
   LayoutObject* firstLetterTextLayoutObject =
       parentLayoutObject->slowFirstChild();
   while (firstLetterTextLayoutObject) {
-    // This can be called when the first letter layoutObject is already in the tree. We do not
-    // want to consider that layoutObject for our text layoutObject so we go to the sibling (which is
-    // the LayoutTextFragment for the remaining text).
+    // This can be called when the first letter layoutObject is already in the
+    // tree. We do not want to consider that layoutObject for our text
+    // layoutObject so we go to the sibling (which is the LayoutTextFragment for
+    // the remaining text).
     if (firstLetterTextLayoutObject->style() &&
         firstLetterTextLayoutObject->style()->styleType() ==
             PseudoIdFirstLetter) {
       firstLetterTextLayoutObject = firstLetterTextLayoutObject->nextSibling();
     } else if (firstLetterTextLayoutObject->isText()) {
       // FIXME: If there is leading punctuation in a different LayoutText than
       // the first letter, we'll not apply the correct style to it.
       RefPtr<StringImpl> str =
           toLayoutText(firstLetterTextLayoutObject)->isTextFragment()
               ? toLayoutTextFragment(firstLetterTextLayoutObject)
@@ skipping 18 matching lines @@
                firstLetterTextLayoutObject->isMenuList()) {
       return nullptr;
     } else if (firstLetterTextLayoutObject
                    ->isFlexibleBoxIncludingDeprecated() ||
                firstLetterTextLayoutObject->isLayoutGrid()) {
       firstLetterTextLayoutObject = firstLetterTextLayoutObject->nextSibling();
     } else if (!firstLetterTextLayoutObject->isInline() &&
                firstLetterTextLayoutObject->style()->hasPseudoStyle(
                    PseudoIdFirstLetter) &&
                canHaveGeneratedChildren(*firstLetterTextLayoutObject)) {
-      // There is a layoutObject further down the tree which has PseudoIdFirstLetter set. When that node
-      // is attached we will handle setting up the first letter then.
+      // There is a layoutObject further down the tree which has
+      // PseudoIdFirstLetter set. When that node is attached we will handle
+      // setting up the first letter then.
       return nullptr;
     } else {
       firstLetterTextLayoutObject =
           firstLetterTextLayoutObject->slowFirstChild();
     }
   }
 
   // No first letter text to display, we're done.
-  // FIXME: This black-list of disallowed LayoutText subclasses is fragile. crbug.com/422336.
+  // FIXME: This black-list of disallowed LayoutText subclasses is fragile.
+  // crbug.com/422336.
   // Should counter be on this list? What about LayoutTextFragment?
   if (!firstLetterTextLayoutObject || !firstLetterTextLayoutObject->isText() ||
       isInvalidFirstLetterLayoutObject(firstLetterTextLayoutObject))
     return nullptr;
 
   return firstLetterTextLayoutObject;
 }
 
 FirstLetterPseudoElement::FirstLetterPseudoElement(Element* parent)
     : PseudoElement(parent, PseudoIdFirstLetter),
@@ skipping 85 matching lines @@
 
   return pseudoStyle;
 }
 
 void FirstLetterPseudoElement::attachFirstLetterTextLayoutObjects() {
   LayoutObject* nextLayoutObject =
       FirstLetterPseudoElement::firstLetterTextLayoutObject(*this);
   DCHECK(nextLayoutObject);
   DCHECK(nextLayoutObject->isText());
 
-  // The original string is going to be either a generated content string or a DOM node's
-  // string. We want the original string before it got transformed in case first-letter has
-  // no text-transform or a different text-transform applied to it.
+  // The original string is going to be either a generated content string or a
+  // DOM node's string. We want the original string before it got transformed in
+  // case first-letter has no text-transform or a different text-transform
+  // applied to it.
   String oldText = toLayoutText(nextLayoutObject)->isTextFragment()
                        ? toLayoutTextFragment(nextLayoutObject)->completeText()
                        : toLayoutText(nextLayoutObject)->originalText();
   DCHECK(oldText.impl());
 
   ComputedStyle* pseudoStyle = styleForFirstLetter(nextLayoutObject->parent());
   layoutObject()->setStyle(pseudoStyle);
 
-  // FIXME: This would already have been calculated in firstLetterLayoutObject. Can we pass the length through?
+  // FIXME: This would already have been calculated in firstLetterLayoutObject.
+  // Can we pass the length through?
   unsigned length = FirstLetterPseudoElement::firstLetterLength(oldText);
 
   // Construct a text fragment for the text after the first letter.
   // This text fragment might be empty.
   LayoutTextFragment* remainingText = new LayoutTextFragment(
       nextLayoutObject->node() ? nextLayoutObject->node()
                                : &nextLayoutObject->document(),
       oldText.impl(), length, oldText.length() - length);
   remainingText->setFirstLetterPseudoElement(this);
   remainingText->setIsRemainingTextLayoutObject(true);
@@ skipping 14 matching lines @@
   letter->setStyle(pseudoStyle);
   layoutObject()->addChild(letter);
 
   nextLayoutObject->destroy();
 }
 
 void FirstLetterPseudoElement::didRecalcStyle(StyleRecalcChange) {
   if (!layoutObject())
     return;
 
-  // The layoutObjects inside pseudo elements are anonymous so they don't get notified of recalcStyle and must have
-  // the style propagated downward manually similar to LayoutObject::propagateStyleToAnonymousChildren.
+  // The layoutObjects inside pseudo elements are anonymous so they don't get
+  // notified of recalcStyle and must have
+  // the style propagated downward manually similar to
+  // LayoutObject::propagateStyleToAnonymousChildren.
   LayoutObject* layoutObject = this->layoutObject();
   for (LayoutObject* child = layoutObject->nextInPreOrder(layoutObject); child;
        child = child->nextInPreOrder(layoutObject)) {
     // We need to re-calculate the correct style for the first letter element
     // and then apply that to the container and the text fragment inside.
     if (child->style()->styleType() == PseudoIdFirstLetter &&
         m_remainingTextLayoutObject) {
       if (ComputedStyle* pseudoStyle =
               styleForFirstLetter(m_remainingTextLayoutObject->parent()))
         child->setPseudoStyle(pseudoStyle);
       continue;
     }
 
     // We only manage the style for the generated content items.
     if (!child->isText() && !child->isQuote() && !child->isImage())
       continue;
 
     child->setPseudoStyle(layoutObject->mutableStyle());
   }
 }
 
 }  // namespace blink