Implement ThreadedInputConnection.deleteSurroundingTextInCodePoints()

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 17 matching lines @@
 
 #include "core/InputModeNames.h"
 #include "core/InputTypeNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/Text.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/commands/TypingCommand.h"
 #include "core/editing/markers/DocumentMarkerController.h"
+#include "core/editing/state_machines/BackwardCodePointStateMachine.h"
+#include "core/editing/state_machines/ForwardCodePointStateMachine.h"
 #include "core/events/CompositionEvent.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLTextAreaElement.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/page/ChromeClient.h"
 
 namespace blink {
@@ skipping 130 matching lines @@
   }
 
   if (!queryAttribute)
     return AtomicString();
 
   // TODO(dtapuska): We may wish to restrict this to a yet to be proposed
   // <contenteditable> or <richtext> element Mozilla discussed at TPAC 2016.
   return element->fastGetAttribute(HTMLNames::inputmodeAttr).lower();
 }
 
+constexpr int invalidDeletionLength = -1;
+constexpr bool isInvalidDeletionLength(const int length) {
+  return length == invalidDeletionLength;
+}
+
+int calculateBeforeDeletionLengthsInCodePoints(
+    const UChar* uText,

[yosin_UTC9, 2017/02/20 05:53:59]

Do we know length of |uText|?
We should make sure we don't do out-of-bound access to |uText|.

[yabinh, 2017/02/20 07:46:45]

Done.

+    const int beforeLengthInCodePoints,

[yosin_UTC9, 2017/02/20 05:53:59]

Let's add DCHECK_GE(beforeLengthInCodePoints, 0)

[yabinh, 2017/02/20 07:46:45]

Done.

+    const int selectionStart) {

[yosin_UTC9, 2017/02/20 05:53:59]

Let's add DCHECK_GE(selectionStart, 0)

[yabinh, 2017/02/20 07:46:45]

Done.

+  BackwardCodePointStateMachine backwardMachine;
+  int counter = beforeLengthInCodePoints;
+  int deletionStart = selectionStart;
+  while (counter > 0 && deletionStart > 0) {
+    const TextSegmentationMachineState state =
+        backwardMachine.feedPrecedingCodeUnit(uText[deletionStart - 1]);
+    // According to Android's InputConnection spec, we should do nothing if
+    // |text| has invalid surrogate pair in the deletion range.
+    if (state == TextSegmentationMachineState::Invalid)
+      return invalidDeletionLength;
+
+    if (backwardMachine.atCodePointBoundary())
+      --counter;
+    --deletionStart;
+  }
+  if (!backwardMachine.atCodePointBoundary())
+    return invalidDeletionLength;
+
+  const int offset = backwardMachine.getBoundaryOffset();
+  DCHECK_EQ(-offset, selectionStart - deletionStart);
+  return -offset;
+}
+
+int calculateAfterDeletionLengthsInCodePoints(const UChar* uText,
+                                              const int afterLengthInCodePoints,

[yosin_UTC9, 2017/02/20 05:53:59]

Let's add DCHECK_GE( afterLengthInCodePoints, 0)

[yabinh, 2017/02/20 07:46:45]

Done.

+                                              const int selectionEnd,

[yosin_UTC9, 2017/02/20 05:53:59]

Let's add DCHECK_GE(selectionEnd, 0)

[yabinh, 2017/02/20 07:46:45]

Done.

+                                              const int length) {

[yosin_UTC9, 2017/02/20 05:53:59]

Let's add DCHECK_GE(length, 0) or DCHECK_GE(length, 1)

[yabinh, 2017/02/20 07:46:45]

Done.

+  ForwardCodePointStateMachine forwardMachine;
+  int counter = afterLengthInCodePoints;
+  int deletionEnd = selectionEnd;
+  while (counter > 0 && deletionEnd < length) {
+    const TextSegmentationMachineState state =
+        forwardMachine.feedFollowingCodeUnit(uText[deletionEnd]);

[yosin_UTC9, 2017/02/20 05:53:59]

Do we know length of |uText|?
We should make sure we don't do out-of-bound access to |uText|.

[yabinh, 2017/02/20 07:46:45]

Done.

+    // According to Android's InputConnection spec, we should do nothing if
+    // |text| has invalid surrogate pair in the deletion range.
+    if (state == TextSegmentationMachineState::Invalid)
+      return invalidDeletionLength;
+
+    if (forwardMachine.atCodePointBoundary())
+      --counter;
+    ++deletionEnd;
+  }
+  if (!forwardMachine.atCodePointBoundary())
+    return invalidDeletionLength;
+
+  const int offset = forwardMachine.getBoundaryOffset();
+  DCHECK_EQ(offset, deletionEnd - selectionEnd);
+  return offset;
+}
+
 }  // anonymous namespace
 
 InputMethodController* InputMethodController::create(LocalFrame& frame) {
   return new InputMethodController(frame);
 }
 
 InputMethodController::InputMethodController(LocalFrame& frame)
     : m_frame(&frame), m_hasComposition(false) {}
 
 InputMethodController::~InputMethodController() = default;
@@ skipping 662 matching lines @@
     const size_t diff = computeDistanceToRightGraphemeBoundary(position);
     const int adjustedEnd = end + static_cast<int>(diff);
     if (!setSelectionOffsets(PlainTextRange(selectionEnd, adjustedEnd)))
       return;
     TypingCommand::deleteSelection(document());
   }
 
   setSelectionOffsets(PlainTextRange(selectionStart, selectionEnd));
 }
 
+void InputMethodController::deleteSurroundingTextInCodePoints(int before,
+                                                              int after) {
+  DCHECK_GE(before, 0);
+  DCHECK_GE(after, 0);
+  if (!editor().canEdit())
+    return;
+  const PlainTextRange selectionOffsets(getSelectionOffsets());
+  if (selectionOffsets.isNull())
+    return;
+  Element* const rootEditableElement =
+      frame().selection().rootEditableElement();
+  if (!rootEditableElement)
+    return;
+
+  const TextIteratorBehavior& behavior =
+      TextIteratorBehavior::Builder()
+          .setEmitsObjectReplacementCharacter(true)
+          .build();
+  const String& text = plainText(
+      EphemeralRange::rangeOfContents(*rootEditableElement), behavior);
+
+  // UTF-8 is only used to encode Latin-1 characters, so the deletion lengths
+  // are trivial.
+  if (text.is8Bit())
+    return deleteSurroundingText(before, after);
+
+  const int selectionStart = static_cast<int>(selectionOffsets.start());
+  const int selectionEnd = static_cast<int>(selectionOffsets.end());
+
+  const UChar* uText = text.characters16();
+  const int beforeLength =
+      calculateBeforeDeletionLengthsInCodePoints(uText, before, selectionStart);

[yosin_UTC9, 2017/02/20 05:53:59]

It seems it is better to pass |text| for bounds checking in
|calculate{After,Before}DeletionLengthsInCodePoint()|.
Raw |UChar*| pointer seems to be dangerous.

[yabinh, 2017/02/20 06:28:23]

The length of |uText| == the length of |text|.
For the |Before| case, we don't need to know its length. We only need to ensure
"deletionStart > 0".
For the |After| case, I think "deletionEnd < length (of |text|)" is enough.
So I think raw |UChar*| pointer should be OK here.

+  if (isInvalidDeletionLength(beforeLength))
+    return;
+  const int afterLength = calculateAfterDeletionLengthsInCodePoints(
+      uText, after, selectionEnd, text.length());
+  if (isInvalidDeletionLength(afterLength))
+    return;
+
+  return deleteSurroundingText(beforeLength, afterLength);
+}
+
 WebTextInputInfo InputMethodController::textInputInfo() const {
   WebTextInputInfo info;
   if (!isAvailable())
     return info;
 
   if (!frame().selection().isAvailable()) {
     // plugins/mouse-capture-inside-shadow.html reaches here.
     return info;
   }
   Element* element = frame().selection().rootEditableElement();
@@ skipping 202 matching lines @@
   finishComposingText(DoNotKeepSelection);
 }
 
 DEFINE_TRACE(InputMethodController) {
   visitor->trace(m_frame);
   visitor->trace(m_compositionRange);
   SynchronousMutationObserver::trace(visitor);
 }
 
 }  // namespace blink