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

third_party/WebKit/Source/core/editing/InputMethodController.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 47 matching lines @@
 void dispatchCompositionEndEvent(LocalFrame& frame, const String& text) {
   Element* target = frame.document()->focusedElement();
   if (!target)
     return;
 
   CompositionEvent* event = CompositionEvent::create(
       EventTypeNames::compositionend, frame.domWindow(), text);
   target->dispatchEvent(event);
 }
 
-// Used to insert/replace text during composition update and confirm composition.
+// Used to insert/replace text during composition update and confirm
+// composition.
 // Procedure:
-//   1. Fire 'beforeinput' event for (TODO(chongz): deleted composed text) and inserted text
+//   1. Fire 'beforeinput' event for (TODO(chongz): deleted composed text) and
+//      inserted text
 //   2. Fire 'compositionupdate' event
 //   3. Fire TextEvent and modify DOM
 //   TODO(chongz): 4. Fire 'input' event
 void insertTextDuringCompositionWithEvents(
     LocalFrame& frame,
     const String& text,
     TypingCommand::Options options,
     TypingCommand::TextCompositionType compositionType) {
   DCHECK(compositionType ==
              TypingCommand::TextCompositionType::TextCompositionUpdate ||
          compositionType ==
              TypingCommand::TextCompositionType::TextCompositionConfirm)
       << "compositionType should be TextCompositionUpdate or "
          "TextCompositionConfirm, but got "
       << static_cast<int>(compositionType);
   if (!frame.document())
     return;
 
   Element* target = frame.document()->focusedElement();
   if (!target)
     return;
 
-  // TODO(chongz): Fire 'beforeinput' for the composed text being replaced/deleted.
+  // TODO(chongz): Fire 'beforeinput' for the composed text being
+  // replaced/deleted.
 
   // Only the last confirmed text is cancelable.
   InputEvent::EventCancelable beforeInputCancelable =
       (compositionType ==
        TypingCommand::TextCompositionType::TextCompositionUpdate)
           ? InputEvent::EventCancelable::NotCancelable
           : InputEvent::EventCancelable::IsCancelable;
   DispatchEventResult result = dispatchBeforeInputFromComposition(
       target, InputEvent::InputType::InsertText, text, beforeInputCancelable);
 
   if (beforeInputCancelable == InputEvent::EventCancelable::IsCancelable &&
       result != DispatchEventResult::NotCanceled)
     return;
 
   // 'beforeinput' event handler may destroy document.
   if (!frame.document())
     return;
 
   dispatchCompositionUpdateEvent(frame, text);
   // 'compositionupdate' event handler may destroy document.
   if (!frame.document())
     return;
 
   switch (compositionType) {
     case TypingCommand::TextCompositionType::TextCompositionUpdate:
       TypingCommand::insertText(*frame.document(), text, options,
                                 compositionType);
       break;
     case TypingCommand::TextCompositionType::TextCompositionConfirm:
-      // TODO(chongz): Use TypingCommand::insertText after TextEvent was removed. (Removed from spec since 2012)
+      // TODO(chongz): Use TypingCommand::insertText after TextEvent was
+      // removed. (Removed from spec since 2012)
       // See TextEvent.idl.
       frame.eventHandler().handleTextInputEvent(text, 0,
                                                 TextEventInputComposition);
       break;
     default:
       NOTREACHED();
   }
   // TODO(chongz): Fire 'input' event.
 }
 
@@ skipping 27 matching lines @@
 void InputMethodController::documentDetached() {
   clear();
   m_compositionRange = nullptr;
 }
 
 void InputMethodController::selectComposition() const {
   const EphemeralRange range = compositionEphemeralRange();
   if (range.isNull())
     return;
 
-  // The composition can start inside a composed character sequence, so we have to override checks.
-  // See <http://bugs.webkit.org/show_bug.cgi?id=15781>
+  // The composition can start inside a composed character sequence, so we have
+  // to override checks. See <http://bugs.webkit.org/show_bug.cgi?id=15781>
   VisibleSelection selection;
   selection.setWithoutValidation(range.startPosition(), range.endPosition());
   frame().selection().setSelection(selection, 0);
 }
 
 bool InputMethodController::finishComposingText(
     ConfirmCompositionBehavior confirmBehavior) {
   if (!hasComposition())
     return false;
 
@@ skipping 195 matching lines @@
   // needs to be audited. see http://crbug.com/590369 for more details.
   frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   int selectionOffsetsStart = static_cast<int>(getSelectionOffsets().start());
   int start = selectionOffsetsStart + selectionStart;
   int end = selectionOffsetsStart + selectionEnd;
   PlainTextRange selectedRange =
       createRangeForSelection(start, end, text.length());
 
   // Dispatch an appropriate composition event to the focused node.
-  // We check the composition status and choose an appropriate composition event since this
-  // function is used for three purposes:
+  // We check the composition status and choose an appropriate composition event
+  // since this function is used for three purposes:
   // 1. Starting a new composition.
-  //    Send a compositionstart and a compositionupdate event when this function creates
-  //    a new composition node, i.e.
-  //    !hasComposition() && !text.isEmpty().
+  //    Send a compositionstart and a compositionupdate event when this function
+  //    creates a new composition node, i.e. !hasComposition() &&
+  //    !text.isEmpty().
   //    Sending a compositionupdate event at this time ensures that at least one
   //    compositionupdate event is dispatched.
   // 2. Updating the existing composition node.
-  //    Send a compositionupdate event when this function updates the existing composition
-  //    node, i.e. hasComposition() && !text.isEmpty().
+  //    Send a compositionupdate event when this function updates the existing
+  //    composition node, i.e. hasComposition() && !text.isEmpty().
   // 3. Canceling the ongoing composition.
-  //    Send a compositionend event when function deletes the existing composition node, i.e.
-  //    !hasComposition() && test.isEmpty().
+  //    Send a compositionend event when function deletes the existing
+  //    composition node, i.e. !hasComposition() && test.isEmpty().
   if (text.isEmpty()) {
     if (hasComposition()) {
       Editor::RevealSelectionScope revealSelectionScope(&editor());
       replaceComposition(emptyString());
     } else {
-      // It's weird to call |setComposition()| with empty text outside composition, however some IME
-      // (e.g. Japanese IBus-Anthy) did this, so we simply delete selection without sending extra events.
+      // It's weird to call |setComposition()| with empty text outside
+      // composition, however some IME (e.g. Japanese IBus-Anthy) did this, so
+      // we simply delete selection without sending extra events.
       TypingCommand::deleteSelection(*frame().document(),
                                      TypingCommand::PreventSpellChecking);
     }
 
     // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
     // needs to be audited. see http://crbug.com/590369 for more details.
     frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
     setEditableSelectionOffsets(selectedRange);
     return;
   }
 
-  // We should send a 'compositionstart' event only when the given text is not empty because this
-  // function doesn't create a composition node when the text is empty.
+  // We should send a 'compositionstart' event only when the given text is not
+  // empty because this function doesn't create a composition node when the text
+  // is empty.
   if (!hasComposition()) {
     target->dispatchEvent(
         CompositionEvent::create(EventTypeNames::compositionstart,
                                  frame().domWindow(), frame().selectedText()));
     if (!frame().document())
       return;
   }
 
   DCHECK(!text.isEmpty());
 
@@ skipping 245 matching lines @@
       new RangeVector(1, m_frame->selection().firstRange()));
   TypingCommand::deleteSelection(*frame().document());
 }
 
 DEFINE_TRACE(InputMethodController) {
   visitor->trace(m_frame);
   visitor->trace(m_compositionRange);
 }
 
 }  // namespace blink