reflow comments in platform/{testing,text}

third_party/WebKit/Source/platform/text/BidiResolver.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008 Apple Inc.  All right 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,
@@ skipping 41 matching lines @@
   void startIgnoringSpaces(const Iterator& midpoint) {
     ASSERT(!(m_numMidpoints % 2));
     addMidpoint(midpoint);
   }
 
   void stopIgnoringSpaces(const Iterator& midpoint) {
     ASSERT(m_numMidpoints % 2);
     addMidpoint(midpoint);
   }
 
-  // Adding a pair of midpoints before a character will split it out into a new line box.
+  // Adding a pair of midpoints before a character will split it out into a new
+  // line box.
   void ensureCharacterGetsLineBox(Iterator& textParagraphSeparator) {
     startIgnoringSpaces(Iterator(0, textParagraphSeparator.getLineLayoutItem(),
                                  textParagraphSeparator.offset() - 1));
     stopIgnoringSpaces(Iterator(0, textParagraphSeparator.getLineLayoutItem(),
                                 textParagraphSeparator.offset()));
   }
 
   void checkMidpoints(Iterator& lBreak) {
-    // Check to see if our last midpoint is a start point beyond the line break. If so,
-    // shave it off the list, and shave off a trailing space if the previous end point doesn't
-    // preserve whitespace.
+    // Check to see if our last midpoint is a start point beyond the line break.
+    // If so, shave it off the list, and shave off a trailing space if the
+    // previous end point doesn't preserve whitespace.
     if (lBreak.getLineLayoutItem() && m_numMidpoints && !(m_numMidpoints % 2)) {
       Iterator* midpointsIterator = m_midpoints.data();
       Iterator& endpoint = midpointsIterator[m_numMidpoints - 2];
       const Iterator& startpoint = midpointsIterator[m_numMidpoints - 1];
       Iterator currpoint = endpoint;
       while (!currpoint.atEnd() && currpoint != startpoint &&
              currpoint != lBreak)
         currpoint.increment();
       if (currpoint == lBreak) {
-        // We hit the line break before the start point. Shave off the start point.
+        // We hit the line break before the start point. Shave off the start
+        // point.
         m_numMidpoints--;
         if (endpoint.getLineLayoutItem().style()->collapseWhiteSpace() &&
             endpoint.getLineLayoutItem().isText())
           endpoint.setOffset(endpoint.offset() - 1);
       }
     }
   }
 
   Vector<Iterator>& midpoints() { return m_midpoints; }
   const unsigned& numMidpoints() const { return m_numMidpoints; }
   const unsigned& currentMidpoint() const { return m_currentMidpoint; }
   void incrementCurrentMidpoint() { m_currentMidpoint++; }
   const bool& betweenMidpoints() const { return m_betweenMidpoints; }
   void setBetweenMidpoints(bool betweenMidpoint) {
     m_betweenMidpoints = betweenMidpoint;
   }
 
  private:
   // The goal is to reuse the line state across multiple
-  // lines so we just keep an array around for midpoints and never clear it across multiple
-  // lines. We track the number of items and position using the two other variables.
+  // lines so we just keep an array around for midpoints and never clear it
+  // across multiple lines. We track the number of items and position using the
+  // two other variables.
   Vector<Iterator> m_midpoints;
   unsigned m_numMidpoints;
   unsigned m_currentMidpoint;
   bool m_betweenMidpoints;
 
   void addMidpoint(const Iterator& midpoint) {
     if (m_midpoints.size() <= m_numMidpoints)
       m_midpoints.grow(m_numMidpoints + 10);
 
     Iterator* midpointsIterator = m_midpoints.data();
     midpointsIterator[m_numMidpoints++] = midpoint;
   }
 };
 
 // The BidiStatus at a given position (typically the end of a line) can
 // be cached and then used to restart bidi resolution at that position.
 struct BidiStatus final {
   DISALLOW_NEW();
   BidiStatus()
       : eor(WTF::Unicode::OtherNeutral),
         lastStrong(WTF::Unicode::OtherNeutral),
         last(WTF::Unicode::OtherNeutral) {}
 
-  // Creates a BidiStatus representing a new paragraph root with a default direction.
-  // Uses TextDirection as it only has two possibilities instead of WTF::Unicode::Direction which has 19.
+  // Creates a BidiStatus representing a new paragraph root with a default
+  // direction.  Uses TextDirection as it only has two possibilities instead of
+  // WTF::Unicode::Direction which has 19.
   BidiStatus(TextDirection textDirection, bool isOverride) {
     WTF::Unicode::CharDirection direction = textDirection == LTR
                                                 ? WTF::Unicode::LeftToRight
                                                 : WTF::Unicode::RightToLeft;
     eor = lastStrong = last = direction;
     context = BidiContext::create(textDirection == LTR ? 0 : 1, direction,
                                   isOverride);
   }
 
   BidiStatus(WTF::Unicode::CharDirection eorDir,
@@ skipping 112 matching lines @@
   const BidiStatus& status() const { return m_status; }
   void setStatus(const BidiStatus s) {
     ASSERT(s.context);
     m_status = s;
     m_paragraphDirectionality =
         s.context->dir() == WTF::Unicode::LeftToRight ? LTR : RTL;
   }
 
   MidpointState<Iterator>& midpointState() { return m_midpointState; }
 
-  // The current algorithm handles nested isolates one layer of nesting at a time.
-  // But when we layout each isolated span, we will walk into (and ignore) all
-  // child isolated spans.
+  // The current algorithm handles nested isolates one layer of nesting at a
+  // time.  But when we layout each isolated span, we will walk into (and
+  // ignore) all child isolated spans.
   void enterIsolate() { m_nestedIsolateCount++; }
   void exitIsolate() {
     ASSERT(m_nestedIsolateCount >= 1);
     m_nestedIsolateCount--;
   }
   bool inIsolate() const { return m_nestedIsolateCount; }
 
   void embed(WTF::Unicode::CharDirection, BidiEmbeddingSource);
   bool commitExplicitEmbedding(BidiRunList<Run>&);
 
@@ skipping 29 matching lines @@
   void setMidpointStateForIsolatedRun(Run&, const MidpointState<Iterator>&);
   MidpointState<Iterator> midpointStateForIsolatedRun(Run&);
 
   Iterator endOfLine() const { return m_endOfLine; }
 
   Run* trailingSpaceRun() const { return m_trailingSpaceRun; }
 
  protected:
   void increment() { m_current.increment(); }
   // FIXME: Instead of InlineBidiResolvers subclassing this method, we should
-  // pass in some sort of Traits object which knows how to create runs for appending.
+  // pass in some sort of Traits object which knows how to create runs for
+  // appending.
   void appendRun(BidiRunList<Run>&);
 
   Run* addTrailingRun(BidiRunList<Run>&,
                       int,
                       int,
                       Run*,
                       BidiContext*,
                       TextDirection) const {
     return 0;
   }
@@ skipping 125 matching lines @@
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::lowerExplicitEmbeddingLevel(
     BidiRunList<Run>& runs,
     WTF::Unicode::CharDirection from) {
   using namespace WTF::Unicode;
 
   if (!m_emptyRun && m_eor != m_last) {
     checkDirectionInLowerRaiseEmbeddingLevel();
-    // bidi.sor ... bidi.eor ... bidi.last eor; need to append the bidi.sor-bidi.eor run or extend it through bidi.last
+    // bidi.sor ... bidi.eor ... bidi.last eor; need to append the
+    // bidi.sor-bidi.eor run or extend it through bidi.last
     if (from == LeftToRight) {
       // bidi.sor ... bidi.eor ... bidi.last L
       if (m_status.eor == EuropeanNumber) {
         if (m_status.lastStrong != LeftToRight) {
           m_direction = EuropeanNumber;
           appendRun(runs);
         }
       } else if (m_status.eor == ArabicNumber) {
         m_direction = ArabicNumber;
         appendRun(runs);
@@ skipping 20 matching lines @@
 
 template <class Iterator, class Run, class IsolatedRun>
 void BidiResolver<Iterator, Run, IsolatedRun>::raiseExplicitEmbeddingLevel(
     BidiRunList<Run>& runs,
     WTF::Unicode::CharDirection from,
     WTF::Unicode::CharDirection to) {
   using namespace WTF::Unicode;
 
   if (!m_emptyRun && m_eor != m_last) {
     checkDirectionInLowerRaiseEmbeddingLevel();
-    // bidi.sor ... bidi.eor ... bidi.last eor; need to append the bidi.sor-bidi.eor run or extend it through bidi.last
+    // bidi.sor ... bidi.eor ... bidi.last eor; need to append the
+    // bidi.sor-bidi.eor run or extend it through bidi.last
     if (to == LeftToRight) {
       // bidi.sor ... bidi.eor ... bidi.last L
       if (m_status.eor == EuropeanNumber) {
         if (m_status.lastStrong != LeftToRight) {
           m_direction = EuropeanNumber;
           appendRun(runs);
         }
       } else if (m_status.eor == ArabicNumber) {
         m_direction = ArabicNumber;
         appendRun(runs);
@@ skipping 61 matching lines @@
     trailingSpaceRun->m_level = 1;
   }
   m_trailingSpaceRun = trailingSpaceRun;
 }
 
 template <class Iterator, class Run, class IsolatedRun>
 bool BidiResolver<Iterator, Run, IsolatedRun>::commitExplicitEmbedding(
     BidiRunList<Run>& runs) {
   // When we're "inIsolate()" we're resolving the parent context which
   // ignores (skips over) the isolated content, including embedding levels.
-  // We should never accrue embedding levels while skipping over isolated content.
+  // We should never accrue embedding levels while skipping over isolated
+  // content.
   ASSERT(!inIsolate() || m_currentExplicitEmbeddingSequence.isEmpty());
 
   using namespace WTF::Unicode;
 
   unsigned char fromLevel = context()->level();
   RefPtr<BidiContext> toContext = context();
 
   for (size_t i = 0; i < m_currentExplicitEmbeddingSequence.size(); ++i) {
     BidiEmbedding embedding = m_currentExplicitEmbeddingSequence[i];
     if (embedding.direction() == PopDirectionalFormat) {
@@ skipping 82 matching lines @@
     BidiRunList<Run>& runs) const {
   unsigned char levelLow = BidiContext::kMaxLevel;
   unsigned char levelHigh = 0;
   for (Run* run = runs.firstRun(); run; run = run->next()) {
     levelHigh = std::max(run->level(), levelHigh);
     levelLow = std::min(run->level(), levelLow);
   }
 
   // This implements reordering of the line (L2 according to Bidi spec):
   // http://unicode.org/reports/tr9/#L2
-  // L2. From the highest level found in the text to the lowest odd level on each line,
-  // reverse any contiguous sequence of characters that are at that level or higher.
+  // L2. From the highest level found in the text to the lowest odd level on
+  // each line, reverse any contiguous sequence of characters that are at that
+  // level or higher.
 
   // Reversing is only done up to the lowest odd level.
   if (!(levelLow % 2))
     levelLow++;
 
   unsigned count = runs.runCount() - 1;
 
   while (levelHigh >= levelLow) {
     unsigned i = 0;
     Run* run = runs.firstRun();
@@ skipping 18 matching lines @@
   while (!m_current.atEnd()) {
     if (inIsolate()) {
       increment();
       continue;
     }
     if (breakOnParagraph && m_current.atParagraphSeparator())
       break;
     UChar32 current = m_current.current();
     if (UNLIKELY(U16_IS_SURROGATE(current))) {
       increment();
-      // If this not the high part of the surrogate pair, then drop it and move to the next.
+      // If this not the high part of the surrogate pair, then drop it and move
+      // to the next.
       if (!U16_IS_SURROGATE_LEAD(current))
         continue;
       UChar high = static_cast<UChar>(current);
       if (m_current.atEnd())
         continue;
       UChar low = m_current.current();
-      // Verify the low part. If invalid, then assume an invalid surrogate pair and retry.
+      // Verify the low part. If invalid, then assume an invalid surrogate pair
+      // and retry.
       if (!U16_IS_TRAIL(low))
         continue;
       current = U16_GET_SUPPLEMENTARY(high, low);
     }
     WTF::Unicode::CharDirection charDirection =
         WTF::Unicode::direction(current);
     if (charDirection == WTF::Unicode::LeftToRight) {
       if (hasStrongDirectionality)
         *hasStrongDirectionality = true;
       return LTR;
@@ skipping 102 matching lines @@
       if (context()->override() && dirCurrent != RightToLeftEmbedding &&
           dirCurrent != LeftToRightEmbedding &&
           dirCurrent != RightToLeftOverride &&
           dirCurrent != LeftToRightOverride &&
           dirCurrent != PopDirectionalFormat)
         dirCurrent = context()->dir();
       else if (dirCurrent == NonSpacingMark)
         dirCurrent = m_status.last;
     }
 
-    // We ignore all character directionality while in unicode-bidi: isolate spans.
-    // We'll handle ordering the isolated characters in a second pass.
+    // We ignore all character directionality while in unicode-bidi: isolate
+    // spans.  We'll handle ordering the isolated characters in a second pass.
     if (inIsolate())
       dirCurrent = OtherNeutral;
 
     ASSERT(m_status.eor != OtherNeutral || m_eor.atEnd());
     switch (dirCurrent) {
       // embedding and overrides (X1-X9 in the Bidi specs)
       case RightToLeftEmbedding:
       case LeftToRightEmbedding:
       case RightToLeftOverride:
       case LeftToRightOverride:
@@ skipping 18 matching lines @@
           case EuropeanNumberSeparator:
           case EuropeanNumberTerminator:
           case CommonNumberSeparator:
           case BoundaryNeutral:
           case BlockSeparator:
           case SegmentSeparator:
           case WhiteSpaceNeutral:
           case OtherNeutral:
             if (m_status.eor == EuropeanNumber) {
               if (m_status.lastStrong != LeftToRight) {
-                // the numbers need to be on a higher embedding level, so let's close that run
+                // the numbers need to be on a higher embedding level, so let's
+                // close that run
                 m_direction = EuropeanNumber;
                 appendRun(m_runs);
                 if (context()->dir() != LeftToRight) {
                   // the neutrals take the embedding direction, which is R
                   m_eor = m_last;
                   m_direction = RightToLeft;
                   appendRun(m_runs);
                 }
               }
             } else if (m_status.eor == ArabicNumber) {
-              // Arabic numbers are always on a higher embedding level, so let's close that run
+              // Arabic numbers are always on a higher embedding level, so let's
+              // close that run
               m_direction = ArabicNumber;
               appendRun(m_runs);
               if (context()->dir() != LeftToRight) {
                 // the neutrals take the embedding direction, which is R
                 m_eor = m_last;
                 m_direction = RightToLeft;
                 appendRun(m_runs);
               }
             } else if (m_status.lastStrong != LeftToRight) {
               // last stuff takes embedding dir
@@ skipping 71 matching lines @@
               if (m_status.eor == EuropeanNumber)
                 break;
             case EuropeanNumberTerminator:
             case BoundaryNeutral:
             case BlockSeparator:
             case SegmentSeparator:
             case WhiteSpaceNeutral:
             case OtherNeutral:
               if (m_status.eor == EuropeanNumber) {
                 if (m_status.lastStrong == RightToLeft) {
-                  // ENs on both sides behave like Rs, so the neutrals should be R.
-                  // Terminate the EN run.
+                  // ENs on both sides behave like Rs, so the neutrals should be
+                  // R.  Terminate the EN run.
                   appendRun(m_runs);
                   // Make an R run.
                   m_eor = m_status.last == EuropeanNumberTerminator
                               ? m_lastBeforeET
                               : m_last;
                   m_direction = RightToLeft;
                   appendRun(m_runs);
                   // Begin a new EN run.
                   m_direction = EuropeanNumber;
                 }
@@ skipping 93 matching lines @@
         }
         break;
 
       // boundary neutrals should be ignored
       case BoundaryNeutral:
         if (m_eor == m_last)
           m_eor = m_current;
         break;
       // neutrals
       case BlockSeparator:
-        // ### what do we do with newline and paragraph seperators that come to here?
+        // ### what do we do with newline and paragraph seperators that come to
+        // here?
         break;
       case SegmentSeparator:
         // ### implement rule L1
         break;
       case WhiteSpaceNeutral:
         break;
       case OtherNeutral:
         break;
       default:
         break;
@@ skipping 76 matching lines @@
 template <class Iterator, class Run, class IsolatedRun>
 MidpointState<Iterator>
 BidiResolver<Iterator, Run, IsolatedRun>::midpointStateForIsolatedRun(
     Run& run) {
   return m_midpointStateForIsolatedRun.take(&run);
 }
 
 }  // namespace blink
 
 #endif  // BidiResolver_h