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

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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
@@ skipping 146 matching lines @@
   }
 }
 
 // When an event handler has moved the selection outside of a text control
 // we should use the target control's selection for this editing operation.
 VisibleSelection Editor::selectionForCommand(Event* event) {
   frame().selection().updateIfNeeded();
   VisibleSelection selection = frame().selection().selection();
   if (!event)
     return selection;
-  // If the target is a text control, and the current selection is outside of its shadow tree,
-  // then use the saved selection for that text control.
+  // If the target is a text control, and the current selection is outside of
+  // its shadow tree, then use the saved selection for that text control.
   HTMLTextFormControlElement* textFormControlOfSelectionStart =
       enclosingTextFormControl(selection.start());
   HTMLTextFormControlElement* textFromControlOfTarget =
       isHTMLTextFormControlElement(*event->target()->toNode())
           ? toHTMLTextFormControlElement(event->target()->toNode())
           : 0;
   if (textFromControlOfTarget &&
       (selection.start().isNull() ||
        textFromControlOfTarget != textFormControlOfSelectionStart)) {
     if (Range* range = textFromControlOfTarget->selection()) {
       return createVisibleSelection(EphemeralRange(range),
                                     TextAffinity::Downstream,
                                     selection.isDirectional());
     }
   }
   return selection;
 }
 
-// Function considers Mac editing behavior a fallback when Page or Settings is not available.
+// Function considers Mac editing behavior a fallback when Page or Settings is
+// not available.
 EditingBehavior Editor::behavior() const {
   if (!frame().settings())
     return EditingBehavior(EditingMacBehavior);
 
   return EditingBehavior(frame().settings()->editingBehaviorType());
 }
 
 static EditorClient& emptyEditorClient() {
   DEFINE_STATIC_LOCAL(EmptyEditorClient, client, ());
   return client;
@@ skipping 37 matching lines @@
 }
 
 bool Editor::canEdit() const {
   return frame().selection().rootEditableElement();
 }
 
 bool Editor::canEditRichly() const {
   return frame().selection().isContentRichlyEditable();
 }
 
-// WinIE uses onbeforecut and onbeforepaste to enables the cut and paste menu items. They
-// also send onbeforecopy, apparently for symmetry, but it doesn't affect the menu items.
-// We need to use onbeforecopy as a real menu enabler because we allow elements that are not
-// normally selectable to implement copy/paste (like divs, or a document body).
+// WinIE uses onbeforecut and onbeforepaste to enables the cut and paste menu
+// items. They also send onbeforecopy, apparently for symmetry, but it doesn't
+// affect the menu items. We need to use onbeforecopy as a real menu enabler
+// because we allow elements that are not normally selectable to implement
+// copy/paste (like divs, or a document body).
 
 bool Editor::canDHTMLCut() {
   return !frame().selection().isInPasswordField() &&
          !dispatchCPPEvent(EventTypeNames::beforecut, DataTransferNumb);
 }
 
 bool Editor::canDHTMLCopy() {
   return !frame().selection().isInPasswordField() &&
          !dispatchCPPEvent(EventTypeNames::beforecopy, DataTransferNumb);
 }
@@ skipping 91 matching lines @@
       case DeleteDirection::Backward:
         DCHECK(frame().document());
         TypingCommand::deleteKeyPressed(*frame().document(), options,
                                         granularity);
         break;
     }
     revealSelectionAfterEditingOperation();
   }
 
   // FIXME: We should to move this down into deleteKeyPressed.
-  // clear the "start new kill ring sequence" setting, because it was set to true
-  // when the selection was updated by deleting the range
+  // clear the "start new kill ring sequence" setting, because it was set to
+  // true when the selection was updated by deleting the range
   if (killRing)
     setStartNewKillRingSequence(false);
 
   return true;
 }
 
 void Editor::deleteSelectionWithSmartDelete(
     DeleteMode deleteMode,
     InputEvent::InputType inputType,
     const Position& referenceMovePosition) {
@@ skipping 121 matching lines @@
 static void writeImageNodeToPasteboard(Pasteboard* pasteboard,
                                        Node* node,
                                        const String& title) {
   DCHECK(pasteboard);
   DCHECK(node);
 
   RefPtr<Image> image = imageFromNode(*node);
   if (!image.get())
     return;
 
-  // FIXME: This should probably be reconciled with HitTestResult::absoluteImageURL.
+  // FIXME: This should probably be reconciled with
+  // HitTestResult::absoluteImageURL.
   AtomicString urlString;
   if (isHTMLImageElement(*node) || isHTMLInputElement(*node))
     urlString = toHTMLElement(node)->getAttribute(srcAttr);
   else if (isSVGImageElement(*node))
     urlString = toSVGElement(node)->imageSourceURL();
   else if (isHTMLEmbedElement(*node) || isHTMLObjectElement(*node) ||
            isHTMLCanvasElement(*node))
     urlString = toHTMLElement(node)->imageSourceURL();
   KURL url = urlString.isEmpty()
                  ? KURL()
                  : node->document().completeURL(
                        stripLeadingAndTrailingHTMLSpaces(urlString));
 
   pasteboard->writeImage(image.get(), url, title);
 }
 
-// Returns whether caller should continue with "the default processing", which is the same as
-// the event handler NOT setting the return value to false
+// Returns whether caller should continue with "the default processing", which
+// is the same as the event handler NOT setting the return value to false
 bool Editor::dispatchCPPEvent(const AtomicString& eventType,
                               DataTransferAccessPolicy policy,
                               PasteMode pasteMode) {
   Element* target = findEventTargetFromSelection();
   if (!target)
     return true;
 
   DataTransfer* dataTransfer =
       DataTransfer::create(DataTransfer::CopyAndPaste, policy,
                            policy == DataTransferWritable
@@ skipping 71 matching lines @@
     DeleteMode deleteMode,
     const Position& referenceMovePosition) {
   if (!dragSource || !dragSource->isConnected())
     return true;
 
   // Dispatch 'beforeinput'.
   const bool shouldDelete = dispatchBeforeInputEditorCommand(
                                 dragSource, InputEvent::InputType::DeleteByDrag,
                                 nullptr) == DispatchEventResult::NotCanceled;
 
-  // 'beforeinput' event handler may destroy frame, return false to cancel remaining actions;
+  // 'beforeinput' event handler may destroy frame, return false to cancel
+  // remaining actions;
   if (m_frame->document()->frame() != m_frame)
     return false;
 
   if (shouldDelete && dragSource->isConnected()) {
     deleteSelectionWithSmartDelete(
         deleteMode, InputEvent::InputType::DeleteByDrag, referenceMovePosition);
   }
 
   return true;
 }
@@ skipping 11 matching lines @@
   // Dispatch 'beforeinput'.
   DataTransfer* dataTransfer =
       DataTransfer::create(DataTransfer::DragAndDrop, DataTransferReadable,
                            dragData->platformData());
   dataTransfer->setSourceOperation(dragData->draggingSourceOperationMask());
   const bool shouldInsert =
       dispatchBeforeInputDataTransfer(
           dropTarget, InputEvent::InputType::InsertFromDrop, dataTransfer,
           nullptr) == DispatchEventResult::NotCanceled;
 
-  // 'beforeinput' event handler may destroy frame, return false to cancel remaining actions;
+  // 'beforeinput' event handler may destroy frame, return false to cancel
+  // remaining actions;
   if (m_frame->document()->frame() != m_frame)
     return false;
 
   if (shouldInsert && dropTarget->isConnected())
     replaceSelectionAfterDragging(fragment, insertMode, dragSourceType);
 
   return true;
 }
 
 EphemeralRange Editor::selectedRange() {
@@ skipping 151 matching lines @@
   dispatchEditableContentChangedEvents(
       composition->startingRootEditableElement(),
       composition->endingRootEditableElement());
   // TODO(chongz): Filter empty InputType after spec is finalized.
   dispatchInputEventEditableContentChanged(
       composition->startingRootEditableElement(),
       composition->endingRootEditableElement(), cmd->inputType(),
       cmd->textDataForInputEvent(), isComposingFromCommand(cmd));
   VisibleSelection newSelection(cmd->endingSelection());
 
-  // Don't clear the typing style with this selection change. We do those things elsewhere if necessary.
+  // Don't clear the typing style with this selection change. We do those things
+  // elsewhere if necessary.
   changeSelectionAfterCommand(newSelection, 0);
 
   if (!cmd->preservesTypingStyle())
     frame().selection().clearTypingStyle();
 
   // Command will be equal to last edit command only in the case of typing
   if (m_lastEditCommand.get() == cmd) {
     DCHECK(cmd->isTypingCommand());
   } else if (m_lastEditCommand && m_lastEditCommand->isDragAndDropCommand() &&
              (cmd->inputType() == InputEvent::InputType::DeleteByDrag ||
@@ skipping 65 matching lines @@
 
 Editor* Editor::create(LocalFrame& frame) {
   return new Editor(frame);
 }
 
 Editor::Editor(LocalFrame& frame)
     : m_frame(&frame),
       m_undoStack(UndoStack::create()),
       m_preventRevealSelection(0),
       m_shouldStartNewKillRingSequence(false),
-      // This is off by default, since most editors want this behavior (this matches IE but not FF).
+      // This is off by default, since most editors want this behavior (this
+      // matches IE but not FF).
       m_shouldStyleWithCSS(false),
       m_killRing(wrapUnique(new KillRing)),
       m_areMarkedTextMatchesHighlighted(false),
       m_defaultParagraphSeparator(EditorParagraphSeparatorIsDiv),
       m_overwriteModeEnabled(false) {}
 
 Editor::~Editor() {}
 
 void Editor::clear() {
   frame().inputMethodController().clear();
@@ skipping 26 matching lines @@
       triggeringEvent && triggeringEvent->isComposition()
           ? TypingCommand::TextCompositionConfirm
           : TypingCommand::TextCompositionNone);
 
   // Reveal the current selection
   if (LocalFrame* editedFrame = selection.start().document()->frame()) {
     if (Page* page = editedFrame->page()) {
       LocalFrame* focusedOrMainFrame =
           toLocalFrame(page->focusController().focusedOrMainFrame());
 
-      // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+      // TODO(xiaochengh): The use of
+      // updateStyleAndLayoutIgnorePendingStylesheets
       // needs to be audited.  See http://crbug.com/590369 for more details.
       focusedOrMainFrame->document()
           ->updateStyleAndLayoutIgnorePendingStylesheets();
 
       focusedOrMainFrame->selection().revealSelection(
           ScrollAlignment::alignCenterIfNeeded);
     }
   }
 
   return true;
@@ skipping 136 matching lines @@
 void Editor::performDelete() {
   if (!canDelete())
     return;
   addToKillRing(selectedRange());
   // TODO(chongz): |Editor::performDelete()| has no direction.
   // https://github.com/w3c/editing/issues/130
   deleteSelectionWithSmartDelete(
       canSmartCopyOrDelete() ? DeleteMode::Smart : DeleteMode::Simple,
       InputEvent::InputType::DeleteContentBackward);
 
-  // clear the "start new kill ring sequence" setting, because it was set to true
-  // when the selection was updated by deleting the range
+  // clear the "start new kill ring sequence" setting, because it was set to
+  // true when the selection was updated by deleting the range
   setStartNewKillRingSequence(false);
 }
 
 static void countEditingEvent(ExecutionContext* executionContext,
                               const Event* event,
                               UseCounter::Feature featureOnInput,
                               UseCounter::Feature featureOnTextArea,
                               UseCounter::Feature featureOnContentEditable,
                               UseCounter::Feature featureOnNonNode) {
   EventTarget* eventTarget = event->target();
@@ skipping 165 matching lines @@
   m_shouldStartNewKillRingSequence = false;
 }
 
 void Editor::changeSelectionAfterCommand(
     const VisibleSelection& newSelection,
     FrameSelection::SetSelectionOptions options) {
   // If the new selection is orphaned, then don't update the selection.
   if (newSelection.start().isOrphan() || newSelection.end().isOrphan())
     return;
 
-  // See <rdar://problem/5729315> Some shouldChangeSelectedDOMRange contain Ranges for selections that are no longer valid
+  // See <rdar://problem/5729315> Some shouldChangeSelectedDOMRange contain
+  // Ranges for selections that are no longer valid
   bool selectionDidNotChangeDOMPosition =
       newSelection == frame().selection().selection();
   frame().selection().setSelection(newSelection, options);
 
-  // Some editing operations change the selection visually without affecting its position within the DOM.
-  // For example when you press return in the following (the caret is marked by ^):
+  // Some editing operations change the selection visually without affecting its
+  // position within the DOM. For example when you press return in the following
+  // (the caret is marked by ^):
   // <div contentEditable="true"><div>^Hello</div></div>
-  // WebCore inserts <div><br></div> *before* the current block, which correctly moves the paragraph down but which doesn't
-  // change the caret's DOM position (["hello", 0]). In these situations the above FrameSelection::setSelection call
-  // does not call EditorClient::respondToChangedSelection(), which, on the Mac, sends selection change notifications and
-  // starts a new kill ring sequence, but we want to do these things (matches AppKit).
+  // WebCore inserts <div><br></div> *before* the current block, which correctly
+  // moves the paragraph down but which doesn't change the caret's DOM position
+  // (["hello", 0]). In these situations the above FrameSelection::setSelection
+  // call does not call EditorClient::respondToChangedSelection(), which, on the
+  // Mac, sends selection change notifications and starts a new kill ring
+  // sequence, but we want to do these things (matches AppKit).
   if (selectionDidNotChangeDOMPosition)
     client().respondToChangedSelection(m_frame,
                                        frame().selection().getSelectionType());
 }
 
 IntRect Editor::firstRectForRange(const EphemeralRange& range) const {
   DCHECK(!frame().document()->needsLayoutTreeUpdate());
   DocumentLifecycle::DisallowTransitionScope disallowTransition(
       frame().document()->lifecycle());
 
@@ skipping 17 matching lines @@
     return IntRect();
 
   if (startCaretRect.y() == endCaretRect.y()) {
     // start and end are on the same line
     return IntRect(std::min(startCaretRect.x(), endCaretRect.x()),
                    startCaretRect.y(),
                    abs(endCaretRect.x() - startCaretRect.x()),
                    std::max(startCaretRect.height(), endCaretRect.height()));
   }
 
-  // start and end aren't on the same line, so go from start to the end of its line
+  // start and end aren't on the same line, so go from start to the end of its
+  // line
   return IntRect(startCaretRect.x(), startCaretRect.y(),
                  (startCaretRect.width() + extraWidthToEndOfLine).toInt(),
                  startCaretRect.height());
 }
 
 void Editor::computeAndSetTypingStyle(StylePropertySet* style,
                                       InputEvent::InputType inputType) {
   if (!style || style->isEmpty()) {
     frame().selection().clearTypingStyle();
     return;
@@ skipping 257 matching lines @@
 }
 
 DEFINE_TRACE(Editor) {
   visitor->trace(m_frame);
   visitor->trace(m_lastEditCommand);
   visitor->trace(m_undoStack);
   visitor->trace(m_mark);
 }
 
 }  // namespace blink