Reflow comments in //third_party/WebKit/Source/core/editing

third_party/WebKit/Source/core/editing/SelectionModifier.cpp

 /*
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 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
  *    documentation and/or other materials provided with the distribution.
  *
@@ skipping 68 matching lines @@
                                        SelectionDirection direction) {
   if (alter != FrameSelection::AlterationExtend)
     return;
 
   Position start = m_selection.start();
   Position end = m_selection.end();
 
   bool baseIsStart = true;
 
   if (m_selection.isDirectional()) {
-    // Make base and extent match start and end so we extend the user-visible selection.
-    // This only matters for cases where base and extend point to different positions than
-    // start and end (e.g. after a double-click to select a word).
+    // Make base and extent match start and end so we extend the user-visible
+    // selection. This only matters for cases where base and extend point to
+    // different positions than start and end (e.g. after a double-click to
+    // select a word).
     if (m_selection.isBaseFirst())
       baseIsStart = true;
     else
       baseIsStart = false;
   } else {
     switch (direction) {
       case DirectionRight:
         if (directionOfSelection() == LTR)
           baseIsStart = true;
         else
@@ skipping 83 matching lines @@
                                         CanCrossEditingBoundary));
 }
 
 VisiblePosition SelectionModifier::modifyExtendingRight(
     TextGranularity granularity) {
   VisiblePosition pos =
       createVisiblePosition(m_selection.extent(), m_selection.affinity());
 
   // The difference between modifyExtendingRight and modifyExtendingForward is:
   // modifyExtendingForward always extends forward logically.
-  // modifyExtendingRight behaves the same as modifyExtendingForward except for extending character or word,
-  // it extends forward logically if the enclosing block is LTR direction,
-  // but it extends backward logically if the enclosing block is RTL direction.
+  // modifyExtendingRight behaves the same as modifyExtendingForward except for
+  // extending character or word, it extends forward logically if the enclosing
+  // block is LTR direction, but it extends backward logically if the enclosing
+  // block is RTL direction.
   switch (granularity) {
     case CharacterGranularity:
       if (directionOfEnclosingBlock() == LTR)
         pos = nextPositionOf(pos, CanSkipOverEditingBoundary);
       else
         pos = previousPositionOf(pos, CanSkipOverEditingBoundary);
       break;
     case WordGranularity:
       if (directionOfEnclosingBlock() == LTR)
         pos = nextWordPositionForPlatform(pos);
@@ skipping 121 matching lines @@
       break;
     case WordGranularity:
       pos = nextWordPositionForPlatform(
           createVisiblePosition(m_selection.extent(), m_selection.affinity()));
       break;
     case SentenceGranularity:
       pos = nextSentencePosition(
           createVisiblePosition(m_selection.extent(), m_selection.affinity()));
       break;
     case LineGranularity: {
-      // down-arrowing from a range selection that ends at the start of a line needs
-      // to leave the selection at that line start (no need to call nextLinePosition!)
+      // down-arrowing from a range selection that ends at the start of a line
+      // needs to leave the selection at that line start (no need to call
+      // nextLinePosition!)
       pos = endForPlatform();
       if (!m_selection.isRange() || !isStartOfLine(pos))
         pos = nextLinePosition(
             pos, lineDirectionPointForBlockDirectionNavigation(START));
       break;
     }
     case ParagraphGranularity:
       pos = nextParagraphPosition(
           endForPlatform(),
           lineDirectionPointForBlockDirectionNavigation(START));
@@ skipping 18 matching lines @@
   return pos;
 }
 
 VisiblePosition SelectionModifier::modifyExtendingLeft(
     TextGranularity granularity) {
   VisiblePosition pos =
       createVisiblePosition(m_selection.extent(), m_selection.affinity());
 
   // The difference between modifyExtendingLeft and modifyExtendingBackward is:
   // modifyExtendingBackward always extends backward logically.
-  // modifyExtendingLeft behaves the same as modifyExtendingBackward except for extending character or word,
-  // it extends backward logically if the enclosing block is LTR direction,
-  // but it extends forward logically if the enclosing block is RTL direction.
+  // modifyExtendingLeft behaves the same as modifyExtendingBackward except for
+  // extending character or word, it extends backward logically if the enclosing
+  // block is LTR direction, but it extends forward logically if the enclosing
+  // block is RTL direction.
   switch (granularity) {
     case CharacterGranularity:
       if (directionOfEnclosingBlock() == LTR)
         pos = previousPositionOf(pos, CanSkipOverEditingBoundary);
       else
         pos = nextPositionOf(pos, CanSkipOverEditingBoundary);
       break;
     case WordGranularity:
       if (directionOfEnclosingBlock() == LTR)
         pos = previousWordPosition(pos);
@@ skipping 17 matching lines @@
   }
   adjustPositionForUserSelectAll(pos, !(directionOfEnclosingBlock() == LTR));
   return pos;
 }
 
 VisiblePosition SelectionModifier::modifyExtendingBackward(
     TextGranularity granularity) {
   VisiblePosition pos =
       createVisiblePosition(m_selection.extent(), m_selection.affinity());
 
-  // Extending a selection backward by word or character from just after a table selects
-  // the table.  This "makes sense" from the user perspective, esp. when deleting.
-  // It was done here instead of in VisiblePosition because we want VPs to iterate
-  // over everything.
+  // Extending a selection backward by word or character from just after a table
+  // selects the table.  This "makes sense" from the user perspective, esp. when
+  // deleting. It was done here instead of in VisiblePosition because we want
+  // VPs to iterate over everything.
   switch (granularity) {
     case CharacterGranularity:
       pos = previousPositionOf(pos, CanSkipOverEditingBoundary);
       break;
     case WordGranularity:
       pos = previousWordPosition(pos);
       break;
     case SentenceGranularity:
       pos = previousSentencePosition(pos);
       break;
@@ skipping 188 matching lines @@
     return false;
 
   if (isSpatialNavigationEnabled(frame())) {
     if (!wasRange && alter == FrameSelection::AlterationMove &&
         position.deepEquivalent() == originalStartPosition.deepEquivalent())
       return false;
   }
 
   // Some of the above operations set an xPosForVerticalArrowNavigation.
   // Setting a selection will clear it, so save it to possibly restore later.
-  // Note: the START position type is arbitrary because it is unused, it would be
-  // the requested position type if there were no xPosForVerticalArrowNavigation set.
+  // Note: the START position type is arbitrary because it is unused, it would
+  // be the requested position type if there were no
+  // xPosForVerticalArrowNavigation set.
   LayoutUnit x = lineDirectionPointForBlockDirectionNavigation(START);
   m_selection.setIsDirectional(shouldAlwaysUseDirectionalSelection(frame()) ||
                                alter == FrameSelection::AlterationExtend);
 
   switch (alter) {
     case FrameSelection::AlterationMove:
       m_selection =
           createVisibleSelection(position, m_selection.isDirectional());
       break;
     case FrameSelection::AlterationExtend:
 
       if (!m_selection.isCaret() && (granularity == WordGranularity ||
                                      granularity == ParagraphGranularity ||
                                      granularity == LineGranularity) &&
           frame() &&
           !frame()
                ->editor()
                .behavior()
                .shouldExtendSelectionByWordOrLineAcrossCaret()) {
-        // Don't let the selection go across the base position directly. Needed to match mac
-        // behavior when, for instance, word-selecting backwards starting with the caret in
-        // the middle of a word and then word-selecting forward, leaving the caret in the
-        // same place where it was, instead of directly selecting to the end of the word.
+        // Don't let the selection go across the base position directly. Needed
+        // to match mac behavior when, for instance, word-selecting backwards
+        // starting with the caret in the middle of a word and then
+        // word-selecting forward, leaving the caret in the same place where it
+        // was, instead of directly selecting to the end of the word.
         VisibleSelection newSelection = m_selection;
         newSelection.setExtent(position);
         if (m_selection.isBaseFirst() != newSelection.isBaseFirst())
           position = m_selection.visibleBase();
       }
 
       // Standard Mac behavior when extending to a boundary is grow the
       // selection rather than leaving the base in place and moving the
       // extent. Matches NSTextView.
       if (!frame() ||
@@ skipping 125 matching lines @@
       visiblePosition.toPositionWithAffinity(), layoutObject);
   if (localRect.isEmpty() || !layoutObject)
     return LayoutUnit();
 
   // This ignores transforms on purpose, for now. Vertical navigation is done
   // without consulting transforms, so that 'up' in transformed text is 'up'
   // relative to the text, not absolute 'up'.
   FloatPoint caretPoint =
       layoutObject->localToAbsolute(FloatPoint(localRect.location()));
   LayoutObject* containingBlock = layoutObject->containingBlock();
-  if (!containingBlock)
-    containingBlock =
-        layoutObject;  // Just use ourselves to determine the writing mode if we have no containing block.
+  if (!containingBlock) {
+    // Just use ourselves to determine the writing mode if we have no containing
+    // block.
+    containingBlock = layoutObject;
+  }
   return LayoutUnit(containingBlock->isHorizontalWritingMode()
                         ? caretPoint.x()
                         : caretPoint.y());
 }
 
 LayoutUnit SelectionModifier::lineDirectionPointForBlockDirectionNavigation(
     EPositionType type) {
   LayoutUnit x;
 
   if (m_selection.isNone())
@@ skipping 15 matching lines @@
       break;
   }
 
   LocalFrame* frame = pos.document()->frame();
   if (!frame)
     return x;
 
   if (m_xPosForVerticalArrowNavigation == NoXPosForVerticalArrowNavigation()) {
     VisiblePosition visiblePosition =
         createVisiblePosition(pos, m_selection.affinity());
-    // VisiblePosition creation can fail here if a node containing the selection becomes visibility:hidden
-    // after the selection is created and before this function is called.
+    // VisiblePosition creation can fail here if a node containing the selection
+    // becomes visibility:hidden after the selection is created and before this
+    // function is called.
     x = lineDirectionPointForBlockDirectionNavigationOf(visiblePosition);
     m_xPosForVerticalArrowNavigation = x;
   } else {
     x = m_xPosForVerticalArrowNavigation;
   }
 
   return x;
 }
 
 DEFINE_TRACE(SelectionModifier) {
   visitor->trace(m_frame);
   visitor->trace(m_selection);
 }
 
 }  // namespace blink