Reformat comments in core/layout/line

third_party/WebKit/Source/core/layout/line/InlineIterator.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
- * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010 Apple Inc. All right reserved.
+ * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010 Apple Inc.
+ *               All right reserved.
  * Copyright (C) 2010 Google Inc. 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 33 matching lines @@
 
   LineLayoutItem object;
   LineLayoutItem root;
   BidiRun& runToReplace;
   unsigned position;
   unsigned char level;
 };
 
 // This class is used to LayoutInline subtrees, stepping by character within the
 // text children. InlineIterator will use bidiNext to find the next LayoutText
-// optionally notifying a BidiResolver every time it steps into/out of a LayoutInline.
+// optionally notifying a BidiResolver every time it steps into/out of a
+// LayoutInline.
 class InlineIterator {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 
  public:
   enum IncrementRule { FastIncrementInIsolatedLayout, FastIncrementInTextNode };
 
   InlineIterator()
       : m_root(nullptr),
         m_lineLayoutItem(nullptr),
         m_nextBreakablePosition(-1),
@@ skipping 86 matching lines @@
 template <class Observer>
 static inline void notifyObserverEnteredObject(Observer* observer,
                                                LineLayoutItem object) {
   if (!observer || !object || !object.isLayoutInline())
     return;
 
   const ComputedStyle& style = object.styleRef();
   EUnicodeBidi unicodeBidi = style.unicodeBidi();
   if (unicodeBidi == UBNormal) {
     // http://dev.w3.org/csswg/css3-writing-modes/#unicode-bidi
-    // "The element does not open an additional level of embedding with respect to the bidirectional algorithm."
+    // "The element does not open an additional level of embedding with respect
+    // to the bidirectional algorithm."
     // Thus we ignore any possible dir= attribute on the span.
     return;
   }
   if (treatAsIsolated(style)) {
-    // Make sure that explicit embeddings are committed before we enter the isolated content.
+    // Make sure that explicit embeddings are committed before we enter the
+    // isolated content.
     observer->commitExplicitEmbedding(observer->runs());
     observer->enterIsolate();
     // Embedding/Override characters implied by dir= will be handled when
     // we process the isolated span, not when laying out the "parent" run.
     return;
   }
 
   if (!observer->inIsolate())
     observer->embed(embedCharFromDirection(style.direction(), unicodeBidi),
                     FromStyleOrDOM);
 }
 
 template <class Observer>
 static inline void notifyObserverWillExitObject(Observer* observer,
                                                 LineLayoutItem object) {
   if (!observer || !object || !object.isLayoutInline())
     return;
 
   EUnicodeBidi unicodeBidi = object.style()->unicodeBidi();
   if (unicodeBidi == UBNormal)
     return;  // Nothing to do for unicode-bidi: normal
   if (treatAsIsolated(object.styleRef())) {
     observer->exitIsolate();
     return;
   }
 
-  // Otherwise we pop any embed/override character we added when we opened this tag.
+  // Otherwise we pop any embed/override character we added when we opened this
+  // tag.
   if (!observer->inIsolate())
     observer->embed(WTF::Unicode::PopDirectionalFormat, FromStyleOrDOM);
 }
 
 static inline bool isIteratorTarget(LineLayoutItem object) {
-  ASSERT(
-      object);  // The iterator will of course return 0, but its not an expected argument to this function.
+  // The iterator will of course return 0, but its not an expected argument to
+  // this function.
+  DCHECK(object);
   return object.isText() || object.isFloating() ||
          object.isOutOfFlowPositioned() || object.isAtomicInlineLevel();
 }
 
 // This enum is only used for bidiNextShared()
 enum EmptyInlineBehavior {
   SkipEmptyInlines,
   IncludeEmptyInlines,
 };
 
 static bool isEmptyInline(LineLayoutItem object) {
   if (!object.isLayoutInline())
     return false;
 
   for (LineLayoutItem curr = LineLayoutInline(object).firstChild(); curr;
        curr = curr.nextSibling()) {
     if (curr.isFloatingOrOutOfFlowPositioned())
       continue;
     if (curr.isText() && LineLayoutText(curr).isAllCollapsibleWhitespace())
       continue;
 
     if (!isEmptyInline(curr))
       return false;
   }
   return true;
 }
 
 // FIXME: This function is misleadingly named. It has little to do with bidi.
 // This function will iterate over inlines within a block, optionally notifying
-// a bidi resolver as it enters/exits inlines (so it can push/pop embedding levels).
+// a bidi resolver as it enters/exits inlines (so it can push/pop embedding
+// levels).
 template <class Observer>
 static inline LineLayoutItem bidiNextShared(
     LineLayoutItem root,
     LineLayoutItem current,
     Observer* observer = 0,
     EmptyInlineBehavior emptyInlineBehavior = SkipEmptyInlines,
     bool* endOfInlinePtr = nullptr) {
   LineLayoutItem next = nullptr;
-  // oldEndOfInline denotes if when we last stopped iterating if we were at the end of an inline.
+  // oldEndOfInline denotes if when we last stopped iterating if we were at the
+  // end of an inline.
   bool oldEndOfInline = endOfInlinePtr ? *endOfInlinePtr : false;
   bool endOfInline = false;
 
   while (current) {
     next = 0;
     if (!oldEndOfInline && !isIteratorTarget(current)) {
       next = current.slowFirstChild();
       notifyObserverEnteredObject(observer, next);
     }
 
-    // We hit this when either current has no children, or when current is not a layoutObject we care about.
+    // We hit this when either current has no children, or when current is not a
+    // layoutObject we care about.
     if (!next) {
-      // If it is a layoutObject we care about, and we're doing our inline-walk, return it.
+      // If it is a layoutObject we care about, and we're doing our inline-walk,
+      // return it.
       if (emptyInlineBehavior == IncludeEmptyInlines && !oldEndOfInline &&
           current.isLayoutInline()) {
         next = current;
         endOfInline = true;
         break;
       }
 
       while (current && current != root) {
         notifyObserverWillExitObject(observer, current);
 
@@ skipping 28 matching lines @@
     *endOfInlinePtr = endOfInline;
 
   return next;
 }
 
 template <class Observer>
 static inline LineLayoutItem bidiNextSkippingEmptyInlines(
     LineLayoutItem root,
     LineLayoutItem current,
     Observer* observer) {
-  // TODO(rhogan): Rename this caller. It's used for a detailed walk of every object in an inline flow, for example during line layout.
-  // We always return empty inlines in bidiNextShared, which gives lie to the bidiNext[Skipping|Including]EmptyInlines
-  // naming scheme we use to call it. bidiNextSkippingEmptyInlines is the less fussy of the two callers,
-  // it will always try to advance and will return what it finds if it's a line layout object in isIteratorTarget or if
-  // it's an empty LayoutInline. If the LayoutInline has content, it will advance past the start of the LayoutLine and try to return
-  // one of its children.
-  // The SkipEmptyInlines callers never care about endOfInlinePtr.
+  // TODO(rhogan): Rename this caller. It's used for a detailed walk of every
+  // object in an inline flow, for example during line layout.
+  // We always return empty inlines in bidiNextShared, which gives lie to the
+  // bidiNext[Skipping|Including]EmptyInlines naming scheme we use to call it.
+  // bidiNextSkippingEmptyInlines is the less fussy of the two callers, it will
+  // always try to advance and will return what it finds if it's a line layout
+  // object in isIteratorTarget or if it's an empty LayoutInline. If the
+  // LayoutInline has content, it will advance past the start of the LayoutLine
+  // and try to return one of its children. The SkipEmptyInlines callers never
+  // care about endOfInlinePtr.
   return bidiNextShared(root, current, observer, SkipEmptyInlines);
 }
 
-// This makes callers cleaner as they don't have to specify a type for the observer when not providing one.
+// This makes callers cleaner as they don't have to specify a type for the
+// observer when not providing one.
 static inline LineLayoutItem bidiNextSkippingEmptyInlines(
     LineLayoutItem root,
     LineLayoutItem current) {
   InlineBidiResolver* observer = nullptr;
   return bidiNextSkippingEmptyInlines(root, current, observer);
 }
 
 static inline LineLayoutItem bidiNextIncludingEmptyInlines(
     LineLayoutItem root,
     LineLayoutItem current,
     bool* endOfInlinePtr = nullptr) {
-  // TODO(rhogan): Rename this caller. It's used for quick and dirty walks of inline children by InlineWalker, which isn't
-  // interested in the contents of inlines. Use cases include dirtying objects or simplified layout that leaves lineboxes intact.
-  // bidiNextIncludingEmptyInlines will return if the iterator is at the start of a LayoutInline (even if it hasn't
-  // advanced yet) unless it previously stopped at the start of the same LayoutInline the last time it tried to iterate.
-  // If it finds itself inside a LayoutInline that doesn't have anything in isIteratorTarget it will return the enclosing
-  // LayoutInline.
+  // TODO(rhogan): Rename this caller. It's used for quick and dirty walks of
+  // inline children by InlineWalker, which isn't interested in the contents of
+  // inlines. Use cases include dirtying objects or simplified layout that
+  // leaves lineboxes intact. bidiNextIncludingEmptyInlines will return if the
+  // iterator is at the start of a LayoutInline (even if it hasn't advanced yet)
+  // unless it previously stopped at the start of the same LayoutInline the last
+  // time it tried to iterate.
+  // If it finds itself inside a LayoutInline that doesn't have anything in
+  // isIteratorTarget it will return the enclosing LayoutInline.
   InlineBidiResolver* observer =
       nullptr;  // Callers who include empty inlines, never use an observer.
   return bidiNextShared(root, current, observer, IncludeEmptyInlines,
                         endOfInlinePtr);
 }
 
 static inline LineLayoutItem bidiFirstSkippingEmptyInlines(
     LineLayoutBlockFlow root,
     BidiRunList<BidiRun>& runs,
     InlineBidiResolver* resolver = nullptr) {
@@ skipping 35 matching lines @@
 }
 
 inline void InlineIterator::fastIncrementInTextNode() {
   ASSERT(m_lineLayoutItem);
   ASSERT(m_lineLayoutItem.isText());
   ASSERT(m_pos <= LineLayoutText(m_lineLayoutItem).textLength());
   if (m_pos < INT_MAX)
     m_pos++;
 }
 
-// FIXME: This is used by LayoutBlockFlow for simplified layout, and has nothing to do with bidi
-// it shouldn't use functions called bidiFirst and bidiNext.
+// FIXME: This is used by LayoutBlockFlow for simplified layout, and has nothing
+// to do with bidi it shouldn't use functions called bidiFirst and bidiNext.
 class InlineWalker {
   STACK_ALLOCATED();
 
  public:
   InlineWalker(LineLayoutBlockFlow root)
       : m_root(root), m_current(nullptr), m_atEndOfInline(false) {
-    // FIXME: This class should be taught how to do the SkipEmptyInlines codepath as well.
+    // FIXME: This class should be taught how to do the SkipEmptyInlines
+    // codepath as well.
     m_current = bidiFirstIncludingEmptyInlines(m_root);
   }
 
   LineLayoutBlockFlow root() { return m_root; }
   LineLayoutItem current() { return m_current; }
 
   bool atEndOfInline() { return m_atEndOfInline; }
   bool atEnd() const { return !m_current; }
 
   LineLayoutItem advance() {
@@ skipping 198 matching lines @@
     return 0;
   unsigned count = 0;
   while (object && object != iter.root()) {
     if (isIsolatedInline(object))
       count++;
     object = object.parent();
   }
   return count;
 }
 
-// FIXME: This belongs on InlineBidiResolver, except it's a template specialization
-// of BidiResolver which knows nothing about LayoutObjects.
+// FIXME: This belongs on InlineBidiResolver, except it's a template
+// specialization of BidiResolver which knows nothing about LayoutObjects.
 static inline BidiRun* addPlaceholderRunForIsolatedInline(
     InlineBidiResolver& resolver,
     LineLayoutItem obj,
     unsigned pos,
     LineLayoutItem root) {
   ASSERT(obj);
   BidiRun* isolatedRun =
       new BidiRun(pos, pos, obj, resolver.context(), resolver.dir());
   resolver.runs().addRun(isolatedRun);
-  // FIXME: isolatedRuns() could be a hash of object->run and then we could cheaply
-  // ASSERT here that we didn't create multiple objects for the same inline.
+  // FIXME: isolatedRuns() could be a hash of object->run and then we could
+  // cheaply ASSERT here that we didn't create multiple objects for the same
+  // inline.
   resolver.isolatedRuns().append(BidiIsolatedRun(obj, pos, root, *isolatedRun,
                                                  resolver.context()->level()));
   return isolatedRun;
 }
 
 static inline BidiRun* createRun(int start,
                                  int end,
                                  LineLayoutItem obj,
                                  InlineBidiResolver& resolver) {
   return new BidiRun(start, end, obj, resolver.context(), resolver.dir());
@@ skipping 27 matching lines @@
   // We don't care if we encounter bidi directional overrides.
   void embed(WTF::Unicode::CharDirection, BidiEmbeddingSource) {}
   void commitExplicitEmbedding(BidiRunList<BidiRun>&) {}
   BidiRunList<BidiRun>& runs() { return m_runs; }
 
   void addFakeRunIfNecessary(LineLayoutItem obj,
                              unsigned pos,
                              unsigned end,
                              LineLayoutItem root,
                              InlineBidiResolver& resolver) {
-    // We only need to add a fake run for a given isolated span once during each call to createBidiRunsForLine.
-    // We'll be called for every span inside the isolated span so we just ignore subsequent calls.
-    // We also avoid creating a fake run until we hit a child that warrants one, e.g. we skip floats.
+    // We only need to add a fake run for a given isolated span once during each
+    // call to createBidiRunsForLine. We'll be called for every span inside the
+    // isolated span so we just ignore subsequent calls.
+    // We also avoid creating a fake run until we hit a child that warrants one,
+    // e.g. we skip floats.
     if (LayoutBlockFlow::shouldSkipCreatingRunsForObject(obj))
       return;
     if (!m_haveAddedFakeRunForRootIsolate) {
       BidiRun* run =
           addPlaceholderRunForIsolatedInline(resolver, obj, pos, root);
       resolver.setMidpointStateForIsolatedRun(*run,
                                               m_midpointStateForRootIsolate);
       m_haveAddedFakeRunForRootIsolate = true;
     }
-    // obj and pos together denote a single position in the inline, from which the parsing of the isolate will start.
-    // We don't need to mark the end of the run because this is implicit: it is either endOfLine or the end of the
-    // isolate, when we call createBidiRunsForLine it will stop at whichever comes first.
+    // obj and pos together denote a single position in the inline, from which
+    // the parsing of the isolate will start.
+    // We don't need to mark the end of the run because this is implicit: it is
+    // either endOfLine or the end of the isolate, when we call
+    // createBidiRunsForLine it will stop at whichever comes first.
   }
 
  private:
   unsigned m_nestedIsolateCount;
   bool m_haveAddedFakeRunForRootIsolate;
   LineMidpointState m_midpointStateForRootIsolate;
   BidiRunList<BidiRun>& m_runs;
 };
 
 static void inline appendRunObjectIfNecessary(LineLayoutItem obj,
@@ skipping 58 matching lines @@
         appendRunObjectIfNecessary(obj, start, end, root, resolver, behavior,
                                    tracker);
         return;
       }
 
       // An end midpoint has been encountered within our object. We
       // need to go ahead and append a run with our endpoint.
       if (nextMidpoint.offset() + 1 <= end) {
         lineMidpointState.setBetweenMidpoints(true);
         lineMidpointState.incrementCurrentMidpoint();
-        if (nextMidpoint.offset() !=
-            UINT_MAX) {  // UINT_MAX means stop at the object and don't nclude any of it.
+        // UINT_MAX means stop at the object and don't include any of it.
+        if (nextMidpoint.offset() != UINT_MAX) {
           if (nextMidpoint.offset() + 1 > start)
             appendRunObjectIfNecessary(obj, start, nextMidpoint.offset() + 1,
                                        root, resolver, behavior, tracker);
           start = nextMidpoint.offset() + 1;
           continue;
         }
       } else {
         appendRunObjectIfNecessary(obj, start, end, root, resolver, behavior,
                                    tracker);
       }
@@ skipping 10 matching lines @@
                                          IsolateTracker& tracker) {
   tracker.setMidpointStateForRootIsolate(resolver.midpointState());
   adjustMidpointsAndAppendRunsForObjectIfNeeded(
       obj, start, obj.length(), root, resolver, AppendingFakeRun, tracker);
 }
 
 template <>
 inline void InlineBidiResolver::appendRun(BidiRunList<BidiRun>& runs) {
   if (!m_emptyRun && !m_eor.atEnd() && !m_reachedEndOfLine) {
     // Keep track of when we enter/leave "unicode-bidi: isolate" inlines.
-    // Initialize our state depending on if we're starting in the middle of such an inline.
-    // FIXME: Could this initialize from this->inIsolate() instead of walking up the layout tree?
+    // Initialize our state depending on if we're starting in the middle of such
+    // an inline.
+    // FIXME: Could this initialize from this->inIsolate() instead of walking up
+    // the layout tree?
     IsolateTracker isolateTracker(runs, numberOfIsolateAncestors(m_sor));
     int start = m_sor.offset();
     LineLayoutItem obj = m_sor.getLineLayoutItem();
     while (obj && obj != m_eor.getLineLayoutItem() &&
            obj != m_endOfRunAtEndOfLine.getLineLayoutItem()) {
       if (isolateTracker.inIsolate())
         addFakeRunIfNecessary(obj, start, obj.length(), m_sor.root(), *this,
                               isolateTracker);
       else
         adjustMidpointsAndAppendRunsForObjectIfNeeded(
             obj, start, obj.length(), m_sor.root(), *this,
             AppendingRunsForObject, isolateTracker);
-      // FIXME: start/obj should be an InlineIterator instead of two separate variables.
+      // FIXME: start/obj should be an InlineIterator instead of two separate
+      // variables.
       start = 0;
       obj = bidiNextSkippingEmptyInlines(m_sor.root(), obj, &isolateTracker);
     }
     bool isEndOfLine =
         obj == m_endOfLine.getLineLayoutItem() && !m_endOfLine.offset();
     if (obj && !isEndOfLine) {
       unsigned pos =
           obj == m_eor.getLineLayoutItem() ? m_eor.offset() : INT_MAX;
       if (obj == m_endOfRunAtEndOfLine.getLineLayoutItem() &&
           m_endOfRunAtEndOfLine.offset() <= pos) {
         m_reachedEndOfLine = true;
         pos = m_endOfRunAtEndOfLine.offset();
       }
-      // It's OK to add runs for zero-length LayoutObjects, just don't make the run larger than it should be
+      // It's OK to add runs for zero-length LayoutObjects, just don't make the
+      // run larger than it should be
       int end = obj.length() ? pos + 1 : 0;
       if (isolateTracker.inIsolate())
         addFakeRunIfNecessary(obj, start, end, m_sor.root(), *this,
                               isolateTracker);
       else
         adjustMidpointsAndAppendRunsForObjectIfNeeded(
             obj, start, end, m_sor.root(), *this, AppendingRunsForObject,
             isolateTracker);
     }
 
     if (isEndOfLine)
       m_reachedEndOfLine = true;
-    // If isolateTrack is inIsolate, the next |start of run| can not be the current isolated layoutObject.
+    // If isolateTrack is inIsolate, the next |start of run| can not be the
+    // current isolated layoutObject.
     if (isolateTracker.inIsolate())
       m_eor.moveTo(
           bidiNextSkippingEmptyInlines(m_eor.root(), m_eor.getLineLayoutItem()),
           0);
     else
       m_eor.increment();
     m_sor = m_eor;
   }
 
   m_direction = WTF::Unicode::OtherNeutral;
   m_status.eor = WTF::Unicode::OtherNeutral;
 }
 
 }  // namespace blink
 
 #endif  // InlineIterator_h