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

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

 /*
  * Copyright (C) 2004, 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
@@ skipping 311 matching lines @@
     // "FocusIn", |m_frame| may associate to another document.
     if (!isAvailable() || document() != currentDocument) {
       // Once we get test case to reach here, we should change this
       // if-statement to |DCHECK()|.
       NOTREACHED();
       return;
     }
   }
 
   if (!(options & DoNotUpdateAppearance)) {
-    // Hits in compositing/overflow/do-not-paint-outline-into-composited-scrolling-contents.html
+    // Hits in
+    // compositing/overflow/do-not-paint-outline-into-composited-scrolling-contents.html
     DisableCompositingQueryAsserts disabler;
     m_frameCaret->stopCaretBlinkTimer();
     updateAppearance();
   }
 
   // Always clear the x position used for vertical arrow navigation.
   // It will be restored by the vertical arrow navigation code if necessary.
   m_xPosForVerticalArrowNavigation = NoXPosForVerticalArrowNavigation();
   // This may dispatch a synchronous focus-related events.
   selectFrameElementInParentIfFullySelected();
@@ skipping 100 matching lines @@
     m_selectionEditor->setWithoutValidation(newStart, newEnd);
   else
     m_selectionEditor->setWithoutValidation(newEnd, newStart);
   m_frameCaret->setCaretRectNeedsUpdate();
   if (document().isRunningExecCommand())
     return;
   TypingCommand::closeTyping(m_frame);
 }
 
 void FrameSelection::nodeWillBeRemoved(Node& node) {
-  // There can't be a selection inside a fragment, so if a fragment's node is being removed,
-  // the selection in the document that created the fragment needs no adjustment.
+  // There can't be a selection inside a fragment, so if a fragment's node is
+  // being removed, the selection in the document that created the fragment
+  // needs no adjustment.
   if (isNone() || !node.inActiveDocument())
     return;
 
   respondToNodeModification(
       node, removingNodeRemovesPosition(node, selection().base()),
       removingNodeRemovesPosition(node, selection().extent()),
       removingNodeRemovesPosition(node, selection().start()),
       removingNodeRemovesPosition(node, selection().end()));
 
   m_frameCaret->nodeWillBeRemoved(node);
@@ skipping 29 matching lines @@
       if (selection().isBaseFirst())
         m_selectionEditor->setWithoutValidation(start, end);
       else
         m_selectionEditor->setWithoutValidation(end, start);
     } else {
       clearDOMTreeSelection = true;
     }
 
     clearLayoutTreeSelection = true;
   } else if (baseRemoved || extentRemoved) {
-    // The base and/or extent are about to be removed, but the start and end aren't.
-    // Change the base and extent to the start and end, but don't re-validate the
-    // selection, since doing so could move the start and end into the node
-    // that is about to be removed.
+    // The base and/or extent are about to be removed, but the start and end
+    // aren't. Change the base and extent to the start and end, but don't
+    // re-validate the selection, since doing so could move the start and end
+    // into the node that is about to be removed.
     if (selection().isBaseFirst())
       m_selectionEditor->setWithoutValidation(selection().start(),
                                               selection().end());
     else
       m_selectionEditor->setWithoutValidation(selection().end(),
                                               selection().start());
   } else if (selectionStateOf(node) != SelectionNone) {
     // When node to be removed is part of selection, we invalidate
     // selection to paint again.
     // TODO(yosin): We should paint changed area only rather than whole
@@ skipping 17 matching lines @@
 static Position updatePositionAfterAdoptingTextReplacement(
     const Position& position,
     CharacterData* node,
     unsigned offset,
     unsigned oldLength,
     unsigned newLength) {
   if (!position.anchorNode() || position.anchorNode() != node ||
       !position.isOffsetInAnchor())
     return position;
 
-  // See: http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Mutation
+  // See:
+  // http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Mutation
   DCHECK_GE(position.offsetInContainerNode(), 0);
   unsigned positionOffset =
       static_cast<unsigned>(position.offsetInContainerNode());
   // Replacing text can be viewed as a deletion followed by insertion.
   if (positionOffset >= offset && positionOffset <= offset + oldLength)
     positionOffset = offset;
 
   // Adjust the offset if the position is after the end of the deleted contents
   // (positionOffset > offset + oldLength) to avoid having a stale offset.
   if (positionOffset > offset + oldLength)
     positionOffset = positionOffset - oldLength + newLength;
 
-  // Due to case folding (http://unicode.org/Public/UCD/latest/ucd/CaseFolding.txt),
-  // LayoutText length may be different from Text length.  A correct implementation
-  // would translate the LayoutText offset to a Text offset; this is just a safety
+  // Due to case folding
+  // (http://unicode.org/Public/UCD/latest/ucd/CaseFolding.txt), LayoutText
+  // length may be different from Text length.  A correct implementation would
+  // translate the LayoutText offset to a Text offset; this is just a safety
   // precaution to avoid offset values that run off the end of the Text.
   if (positionOffset > node->length())
     positionOffset = node->length();
 
   // CharacterNode in VisibleSelection must be Text node, because Comment
   // and ProcessingInstruction node aren't visible.
   return Position(toText(node), positionOffset);
 }
 
 void FrameSelection::didUpdateCharacterData(CharacterData* node,
                                             unsigned offset,
                                             unsigned oldLength,
                                             unsigned newLength) {
-  // The fragment check is a performance optimization. See http://trac.webkit.org/changeset/30062.
+  // The fragment check is a performance optimization. See
+  // http://trac.webkit.org/changeset/30062.
   if (isNone() || !node || !node->isConnected())
     return;
 
   Position base = updatePositionAfterAdoptingTextReplacement(
       selection().base(), node, offset, oldLength, newLength);
   Position extent = updatePositionAfterAdoptingTextReplacement(
       selection().extent(), node, offset, oldLength, newLength);
   Position start = updatePositionAfterAdoptingTextReplacement(
       selection().start(), node, offset, oldLength, newLength);
   Position end = updatePositionAfterAdoptingTextReplacement(
@@ skipping 34 matching lines @@
                                                            oldNode, offset);
   updateSelectionIfNeeded(base, extent, start, end);
 }
 
 static Position updatePostionAfterAdoptingTextNodeSplit(
     const Position& position,
     const Text& oldNode) {
   if (!position.anchorNode() || position.anchorNode() != &oldNode ||
       !position.isOffsetInAnchor())
     return position;
-  // See: http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Mutation
+  // See:
+  // http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html#Level-2-Range-Mutation
   DCHECK_GE(position.offsetInContainerNode(), 0);
   unsigned positionOffset =
       static_cast<unsigned>(position.offsetInContainerNode());
   unsigned oldLength = oldNode.length();
   if (positionOffset <= oldLength)
     return position;
   return Position(toText(oldNode.nextSibling()), positionOffset - oldLength);
 }
 
 void FrameSelection::didSplitTextNode(const Text& oldNode) {
@@ skipping 23 matching lines @@
     TypingCommand::closeTyping(m_frame);
   VisibleSelection newSelection;
   if (selection().isBaseFirst())
     newSelection.setWithoutValidation(start, end);
   else
     newSelection.setWithoutValidation(end, start);
   setSelection(newSelection, DoNotSetFocus);
 }
 
 void FrameSelection::didChangeFocus() {
-  // Hits in virtual/gpu/compositedscrolling/scrollbars/scrollbar-miss-mousemove-disabled.html
+  // Hits in
+  // virtual/gpu/compositedscrolling/scrollbars/scrollbar-miss-mousemove-disabled.html
   DisableCompositingQueryAsserts disabler;
   updateAppearance();
 }
 
 static DispatchEventResult dispatchSelectStart(
     const VisibleSelection& selection) {
   Node* selectStartTarget = selection.extent().computeContainerNode();
   if (!selectStartTarget)
     return DispatchEventResult::NotCanceled;
 
@@ skipping 153 matching lines @@
   if (visibleStart.isNull() || visibleEnd.isNull())
     return false;
 
   const PositionInFlatTree& start = visibleStart.deepEquivalent();
   const PositionInFlatTree& end = visibleEnd.deepEquivalent();
   const PositionInFlatTree& pos = visiblePos.deepEquivalent();
   return start.compareTo(pos) <= 0 && pos.compareTo(end) <= 0;
 }
 
 // Workaround for the fact that it's hard to delete a frame.
-// Call this after doing user-triggered selections to make it easy to delete the frame you entirely selected.
-// Can't do this implicitly as part of every setSelection call because in some contexts it might not be good
-// for the focus to move to another frame. So instead we call it from places where we are selecting with the
-// mouse or the keyboard after setting the selection.
+// Call this after doing user-triggered selections to make it easy to delete the
+// frame you entirely selected. Can't do this implicitly as part of every
+// setSelection call because in some contexts it might not be good for the focus
+// to move to another frame. So instead we call it from places where we are
+// selecting with the mouse or the keyboard after setting the selection.
 void FrameSelection::selectFrameElementInParentIfFullySelected() {
   // Find the parent frame; if there is none, then we have nothing to do.
   Frame* parent = m_frame->tree().parent();
   if (!parent)
     return;
   Page* page = m_frame->page();
   if (!page)
     return;
 
-  // Check if the selection contains the entire frame contents; if not, then there is nothing to do.
+  // Check if the selection contains the entire frame contents; if not, then
+  // there is nothing to do.
   if (!isRange())
     return;
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   if (!isStartOfDocument(selection().visibleStart()))
     return;
   if (!isEndOfDocument(selection().visibleEnd()))
     return;
 
   // FIXME: This is not yet implemented for cross-process frame relationships.
   if (!parent->isLocalFrame())
     return;
 
-  // Get to the <iframe> or <frame> (or even <object>) element in the parent frame.
+  // Get to the <iframe> or <frame> (or even <object>) element in the parent
+  // frame.
   // FIXME: Doesn't work for OOPI.
   HTMLFrameOwnerElement* ownerElement = m_frame->deprecatedLocalOwner();
   if (!ownerElement)
     return;
   ContainerNode* ownerElementParent = ownerElement->parentNode();
   if (!ownerElementParent)
     return;
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   ownerElementParent->document().updateStyleAndLayoutIgnorePendingStylesheets();
 
-  // This method's purpose is it to make it easier to select iframes (in order to delete them).  Don't do anything if the iframe isn't deletable.
+  // This method's purpose is it to make it easier to select iframes (in order
+  // to delete them).  Don't do anything if the iframe isn't deletable.
   if (!blink::hasEditableStyle(*ownerElementParent))
     return;
 
   // Create compute positions before and after the element.
   unsigned ownerElementNodeIndex = ownerElement->nodeIndex();
   VisiblePosition beforeOwnerElement = createVisiblePosition(
       Position(ownerElementParent, ownerElementNodeIndex));
   VisiblePosition afterOwnerElement = createVisiblePosition(
       Position(ownerElementParent, ownerElementNodeIndex + 1),
       VP_UPSTREAM_IF_POSSIBLE);
 
-  // Focus on the parent frame, and then select from before this element to after.
+  // Focus on the parent frame, and then select from before this element to
+  // after.
   VisibleSelection newSelection =
       createVisibleSelection(beforeOwnerElement, afterOwnerElement);
   page->focusController().setFocusedFrame(parent);
   // setFocusedFrame can dispatch synchronous focus/blur events.  The document
   // tree might be modified.
   if (newSelection.isNonOrphanedCaretOrRange())
     toLocalFrame(parent)->selection().setSelection(newSelection);
 }
 
 // Returns a shadow tree node for legacy shadow trees, a child of the
@@ skipping 189 matching lines @@
   m_pendingSelection->setHasPendingSelection();
 }
 
 void FrameSelection::notifyLayoutObjectOfSelectionChange(
     EUserTriggered userTriggered) {
   if (HTMLTextFormControlElement* textControl =
           enclosingTextFormControl(start()))
     textControl->selectionChanged(userTriggered == UserTriggered);
 }
 
-// Helper function that tells whether a particular node is an element that has an entire
-// LocalFrame and FrameView, a <frame>, <iframe>, or <object>.
+// Helper function that tells whether a particular node is an element that has
+// an entire LocalFrame and FrameView, a <frame>, <iframe>, or <object>.
 static bool isFrameElement(const Node* n) {
   if (!n)
     return false;
   LayoutObject* layoutObject = n->layoutObject();
   if (!layoutObject || !layoutObject->isLayoutPart())
     return false;
   Widget* widget = toLayoutPart(layoutObject)->widget();
   return widget && widget->isFrameView();
 }
 
 void FrameSelection::setFocusedNodeIfNeeded() {
   if (isNone() || !isFocused())
     return;
 
   bool caretBrowsing =
       m_frame->settings() && m_frame->settings()->caretBrowsingEnabled();
   if (caretBrowsing) {
     if (Element* anchor = enclosingAnchorElement(base())) {
       m_frame->page()->focusController().setFocusedElement(anchor, m_frame);
       return;
     }
   }
 
   if (Element* target = rootEditableElement()) {
     // Walk up the DOM tree to search for a node to focus.
     document().updateStyleAndLayoutTreeIgnorePendingStylesheets();
     while (target) {
-      // We don't want to set focus on a subframe when selecting in a parent frame,
-      // so add the !isFrameElement check here. There's probably a better way to make this
-      // work in the long term, but this is the safest fix at this time.
+      // We don't want to set focus on a subframe when selecting in a parent
+      // frame, so add the !isFrameElement check here. There's probably a better
+      // way to make this work in the long term, but this is the safest fix at
+      // this time.
       if (target->isMouseFocusable() && !isFrameElement(target)) {
         m_frame->page()->focusController().setFocusedElement(target, m_frame);
         return;
       }
       target = target->parentOrShadowHostElement();
     }
     document().clearFocusedElement();
   }
 
   if (caretBrowsing)
     m_frame->page()->focusController().setFocusedElement(0, m_frame);
 }
 
 static String extractSelectedText(const FrameSelection& selection,
                                   TextIteratorBehavior behavior) {
   const VisibleSelectionInFlatTree& visibleSelection =
       selection.visibleSelection<EditingInFlatTreeStrategy>();
   const EphemeralRangeInFlatTree& range =
       visibleSelection.toNormalizedEphemeralRange();
-  // We remove '\0' characters because they are not visibly rendered to the user.
+  // We remove '\0' characters because they are not visibly rendered to the
+  // user.
   return plainText(range, behavior).replace(0, "");
 }
 
 String FrameSelection::selectedHTMLForClipboard() const {
   const VisibleSelectionInFlatTree& visibleSelection =
       this->visibleSelection<EditingInFlatTreeStrategy>();
   const EphemeralRangeInFlatTree& range =
       visibleSelection.toNormalizedEphemeralRange();
   return createMarkup(range.startPosition(), range.endPosition(),
                       AnnotateForInterchange,
@@ skipping 50 matching lines @@
 
     if (isHTMLFrameElementBase(element)) {
       Node* childDocument = toHTMLFrameElementBase(element).contentDocument();
       if (HTMLFormElement* frameResult = scanForForm(childDocument))
         return frameResult;
     }
   }
   return 0;
 }
 
-// We look for either the form containing the current focus, or for one immediately after it
+// We look for either the form containing the current focus, or for one
+// immediately after it
 HTMLFormElement* FrameSelection::currentForm() const {
-  // Start looking either at the active (first responder) node, or where the selection is.
+  // Start looking either at the active (first responder) node, or where the
+  // selection is.
   Node* start = document().focusedElement();
   if (!start)
     start = this->start().anchorNode();
   if (!start)
     return 0;
 
   // Try walking up the node tree to find a form element.
   for (HTMLElement* element =
            Traversal<HTMLElement>::firstAncestorOrSelf(*start);
        element; element = Traversal<HTMLElement>::firstAncestor(*element)) {
@@ skipping 230 matching lines @@
 }
 
 void showTree(const blink::FrameSelection* sel) {
   if (sel)
     sel->showTreeForThis();
   else
     LOG(INFO) << "Cannot showTree for <null> FrameSelection.";
 }
 
 #endif