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 182 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();
 }
 
+bool hasInvalidSurrogatePair(const UChar* text,
+                             const int start,
+                             const int end) {
+  DCHECK_GE(start, 0);
+  DCHECK_LE(start, end);
+  for (int i = start; i < end; ++i) {
+    if (U_IS_SURROGATE(text[i])) {
+      const bool isValidSurrogatePair =
+          U16_IS_LEAD(text[i]) && i + 1 < end && U16_IS_TRAIL(text[i + 1]);
+      if (!isValidSurrogatePair)
+        return true;
+      ++i;
+    }
+  }
+  return false;
+}
+
+std::pair<int, int> invalidDeletionLength() {
+  return std::make_pair(-1, -1);
+}
+
+bool isInvalidDeletionLength(const std::pair<int, int>& lengthPair) {
+  return lengthPair.first == -1 && lengthPair.second == -1;

[yosin_UTC9, 2017/02/10 04:54:11]

You could write:

return lengthPair == invalidDeletionLength();

+}
+
+std::pair<int, int> calculateDeletionLengthsInCodePoints(
+    const String& text,
+    const int beforeLengthInCodePoints,
+    const int afterLengthInCodePoints,
+    const int selectionStart,
+    const int selectionEnd) {
+  int deletionStart = selectionStart;
+  int deletionEnd = selectionEnd;
+  const int length = static_cast<int>(text.length());
+
+  if (text.is8Bit()) {
+    const LChar* character8s = text.characters8();
+    U8_BACK_N(character8s, 0, deletionStart, beforeLengthInCodePoints);
+    U8_FWD_N(character8s, deletionEnd, length, afterLengthInCodePoints);
+  } else {
+    const UChar* character16s = text.characters16();
+    U16_BACK_N(character16s, 0, deletionStart, beforeLengthInCodePoints);

[yosin_UTC9, 2017/02/10 04:54:11]

Let's avoid U16_BACK_N() and U16_FWD_N() since they hide control structure.
It seems we can do Unicode Code Point walk and length calculation once by
introducing BackwardCodePointStateMachine and ForwardStateMachine into
editing/state_machines/.
(We'll also integrate them into {Backward,Forward}GraphemeBoundaryStateMachine)

It can be:

class BackwardCodePointStateMachine {
 public:
  BackwardCodePointStateMachine() = default;
  ~BackwardCodePointStateMachine() = default;

  // Returns true if position before |codeUnit| is code point boundary.
  bool feed(int codeUnit) {
    switch (m_state) {
      case State::Invalid:
        return false;
      case State::NotSurrogate:
        if (U16_IS_LEAD(codeUnit)) {
          m_state = State::Invalid;
          return false;
        }
        if (U16_IS_TAIL(codeUnit)) {
          m_state = State::TailSurrogate;
          return false;
        }
        return true;
      case State::TailSurrogate:
        if (U16_IS_LEAD(codeUnit)) {
          m_state = State::NotSurrogate;
          return true;
        }
        m_state = State::Invalid;
        return false;
    }
    NOTREACHED();
    return false;
  }

  // Returns true if we are at code point boundary.
  bool atCodePointBoundary() {
    return m_state == NotSurrogate;
  }

 private:
  enum class State {
    Invalid,
    NotSurogate,
    TailSurrogate,
  } m_state = NotSurrogate;
};

Then we could write:

BackwardCodePointStateMachine backwardMachine;
int counter = beforeLengthInCodePoints;
int deletionStart = selectionStart;
while (counter > 0 && deletionStart > 0) {
  if (backwardMachine.feed(text[deletionStart]))
    --counter;
  --deletionStart;
}
if (!backwardMachine.atCodePointBoundary()))
  return invaldiDeletionLegnth();

[yosin_UTC9, 2017/02/10 05:20:19]

Refined. Make BackwardCodePointMachine::feed() to return false for invalid
UTF-16 sequence.


class BackwardCodePointStateMachine {
 public:
  BackwardCodePointStateMachine() = default;
  ~BackwardCodePointStateMachine() = default;

  // Returns true if |codeUnit| is part of valid UTF-16 code unit sequence.
  bool feed(int codeUnit) {
    switch (m_state) {
      case State::Invalid:
        return false;
      case State::NotSurrogate:
        if (U16_IS_LEAD(codeUnit)) {
          m_state = State::Invalid;
          return false;
        }
        if (U16_IS_TAIL(codeUnit)) {
          m_state = State::TailSurrogate;
          return true;
        }
        return true;
      case State::TailSurrogate:
        if (U16_IS_LEAD(codeUnit)) {
          m_state = State::NotSurrogate;
          return true;
        }
        m_state = State::Invalid;
        return false;
    }
    NOTREACHED();
    return false;
  }

  // Returns true if we are at code point boundary.
  bool atCodePointBoundary() {
    return m_state == NotSurrogate;
  }

 private:
  enum class State {
    Invalid,
    NotSurogate,
    TailSurrogate,
  } m_state = NotSurrogate;
};

BackwardCodePointStateMachine backwardMachine;
int counter = beforeLengthInCodePoints;
int deletionStart = selectionStart;
while (counter > 0 && deletionStart > 0) {
  if (!backwardMachine.feed(text[deletionStart])) {
    // |text| is invalid UTF-16 code unit sequence.
    return;
  }
  if (backwardMachine.atCodePointBoundary())
    --counter;
  --deletionStart;
}
if (!backwardMachine.atCodePointBoundary()))
  return invaldiDeletionLegnth();

[yabinh, 2017/02/10 10:49:22]

Thanks!
Do we need to add a separate file and add a test file for that? Like
BackwardCodePointMachine.h, BackwardCodePointMachine.cpp,
BackwardCodePointMachineTest.cpp?

+    // Required by Android's InputConnection spec.
+    if (hasInvalidSurrogatePair(character16s, deletionStart, selectionStart))
+      return invalidDeletionLength();
+
+    U16_FWD_N(character16s, deletionEnd, length, afterLengthInCodePoints);
+    // Required by Android's InputConnection spec.
+    if (hasInvalidSurrogatePair(character16s, selectionEnd, deletionEnd))
+      return invalidDeletionLength();
+  }
+
+  const int beforeLength = selectionStart - deletionStart;
+  const int afterLength = deletionEnd - selectionEnd;
+  DCHECK_GE(beforeLength, 0);
+  DCHECK_GE(afterLength, 0);
+  return std::make_pair(beforeLength, afterLength);
+}
+
 }  // 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 671 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 int selectionStart = static_cast<int>(selectionOffsets.start());
+  const int selectionEnd = static_cast<int>(selectionOffsets.end());
+  const TextIteratorBehavior& behavior =
+      TextIteratorBehavior::Builder()
+          .setEmitsObjectReplacementCharacter(true)
+          .build();
+  const String& text = plainText(
+      EphemeralRange::rangeOfContents(*rootEditableElement), behavior);
+  std::pair<int, int> deletionLengthPair = calculateDeletionLengthsInCodePoints(
+      text, before, after, selectionStart, selectionEnd);
+  if (isInvalidDeletionLength(deletionLengthPair))
+    return;
+
+  return deleteSurroundingText(deletionLengthPair.first,
+                               deletionLengthPair.second);
+}
+
 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 204 matching lines @@
   frame().chromeClient().resetInputMethod();
 }
 
 DEFINE_TRACE(InputMethodController) {
   visitor->trace(m_frame);
   visitor->trace(m_compositionRange);
   SynchronousMutationObserver::trace(visitor);
 }
 
 }  // namespace blink