Implement hot mode invocation for idle time spell checker

third_party/WebKit/Source/core/editing/spellcheck/IdleSpellCheckCallback.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/editing/spellcheck/IdleSpellCheckCallback.h"
 
 #include "core/dom/IdleRequestOptions.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/editing/EditingUtilities.h"
+#include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/VisibleSelection.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/commands/CompositeEditCommand.h"
+#include "core/editing/commands/TypingCommand.h"
+#include "core/editing/commands/UndoStack.h"
 #include "core/editing/commands/UndoStep.h"
 #include "core/editing/iterators/BackwardsCharacterIterator.h"
 #include "core/editing/iterators/CharacterIterator.h"
 #include "core/editing/spellcheck/SpellCheckRequester.h"
 #include "core/editing/spellcheck/SpellChecker.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/TextControlElement.h"
 #include "core/layout/LayoutObject.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 namespace {
 
+const int kHotModeChunkSize = 1024;
 const int kColdModeTimerIntervalMS = 1000;
 const int kConsecutiveColdModeTimerIntervalMS = 200;
 const int kRequestTimeoutMS = 200;
 const int kInvalidHandle = -1;
 const int kDummyHandleForForcedInvocation = -2;
 const double kForcedInvocationDeadlineSeconds = 10;
 
+bool isInOrAdjacentToWord(const Position& pos) {
+  const VisiblePosition& visiblePos = createVisiblePosition(pos);
+  const VisiblePosition& wordStart = previousWordPosition(visiblePos);
+  if (wordStart.isNull())
+    return false;
+  const VisiblePosition& wordEnd = endOfWord(wordStart);
+  if (wordEnd.isNull())
+    return false;
+  return comparePositions(visiblePos, wordEnd) <= 0;
+}
+
 }  // namespace
 
 IdleSpellCheckCallback::~IdleSpellCheckCallback() {}
 
 DEFINE_TRACE(IdleSpellCheckCallback) {
   visitor->trace(m_frame);
   IdleRequestCallback::trace(visitor);
   SynchronousMutationObserver::trace(visitor);
 }
 
 IdleSpellCheckCallback* IdleSpellCheckCallback::create(LocalFrame& frame) {
   return new IdleSpellCheckCallback(frame);
 }
 
 IdleSpellCheckCallback::IdleSpellCheckCallback(LocalFrame& frame)
     : m_state(State::kInactive),
       m_idleCallbackHandle(kInvalidHandle),
       m_needsMoreColdModeInvocationForTesting(false),
       m_frame(frame),
+      m_lastProcessedUndoStepSequence(0),
       m_coldModeTimer(TaskRunnerHelper::get(TaskType::UnspecedTimer, &frame),
                       this,
                       &IdleSpellCheckCallback::coldModeTimerFired) {}
 
 SpellCheckRequester& IdleSpellCheckCallback::spellCheckRequester() const {
   return frame().spellChecker().spellCheckRequester();
 }
 
 bool IdleSpellCheckCallback::isSpellCheckingEnabled() const {
   return frame().spellChecker().isSpellCheckingEnabled();
@@ skipping 58 matching lines @@
 
   if (!isSpellCheckingEnabled()) {
     deactivate();
     return;
   }
 
   requestInvocation();
   m_state = State::kColdModeRequested;
 }
 
+EphemeralRange IdleSpellCheckCallback::calcHotModeCheckingRange(
+    const Element& editable,
+    const Position& refPosition) const {
+  const EphemeralRange& fullRange = EphemeralRange::rangeOfContents(editable);
+  const int fullLength = TextIterator::rangeLength(fullRange.startPosition(),

[yosin_UTC9, 2017/03/03 05:34:23]

I'm not sure why we don't have TextIterator::rangeLength(const
EphemeralRange&)...

[Xiaocheng, 2017/03/03 06:28:28]

Maybe we don't need it that much, either...

+                                                   fullRange.endPosition());
+  if (fullLength <= kHotModeChunkSize)
+    return fullRange;
+
+  TextIteratorBehavior behavior = TextIteratorBehavior::Builder()
+                                      .setEmitsObjectReplacementCharacter(true)
+                                      .build();
+  BackwardsCharacterIterator backwardIterator(fullRange.startPosition(),
+                                              refPosition, behavior);
+  backwardIterator.advance(kHotModeChunkSize / 2);
+  const Position& chunkStart = backwardIterator.endPosition();
+  CharacterIterator forwardIterator(refPosition, fullRange.endPosition(),
+                                    behavior);
+  forwardIterator.advance(kHotModeChunkSize / 2);
+  const Position& chunkEnd = forwardIterator.endPosition();
+  return expandRangeToSentenceBoundary(EphemeralRange(chunkStart, chunkEnd));
+}
+
+bool IdleSpellCheckCallback::isTypingInPartialWord(
+    const Element& editable) const {
+  const SelectionInDOMTree& selection =
+      frame().selection().selectionInDOMTree();
+  if (!selection.isCaret())
+    return false;
+  if (rootEditableElementOf(selection.base()) != &editable)
+    return false;
+
+  CompositeEditCommand* typingCommand =
+      frame().editor().lastTypingCommandIfStillOpenForTyping();
+  if (!typingCommand)
+    return false;
+  if (typingCommand->endingSelection().asSelection() != selection)
+    return false;
+  return isInOrAdjacentToWord(selection.base());
+}
+
+bool IdleSpellCheckCallback::shouldCheckRootEditableInHotMode(
+    const Element& editable,
+    const Position& refPosition) const {
+  if (!editable.isSpellCheckingEnabled() &&
+      !SpellChecker::isSpellCheckingEnabledAt(refPosition))
+    return false;
+  if (editable.visibleBoundsInVisualViewport().isEmpty())
+    return false;
+  // TODO(xiaochengh): Design more aggressive strategies to reduce checking when
+  // we are just moving selection around without modifying anything.
+  return !isTypingInPartialWord(editable);
+}
+
+void IdleSpellCheckCallback::hotModeCheckRootEditable(

[yosin_UTC9, 2017/03/03 05:34:23]

Could you rename this function to start with verb?

requestSpellCheckForHotModeRootEditable() or better one.

[Xiaocheng, 2017/03/03 06:28:27]

Changed to checkRootEditableInHotMode.

+    Element* rootEditable,
+    const Position& refPosition,
+    HeapVector<Member<Element>>* processedRootEditables) {
+  if (!rootEditable || !rootEditable->isConnected())
+    return;
+
+  if (processedRootEditables->contains(rootEditable))
+    return;
+  processedRootEditables->push_back(rootEditable);
+
+  if (!shouldCheckRootEditableInHotMode(*rootEditable, refPosition))
+    return;
+
+  SpellCheckRequest* request = SpellCheckRequest::create(
+      calcHotModeCheckingRange(*rootEditable, refPosition));
+  spellCheckRequester().requestCheckingFor(request);
+}
+
 void IdleSpellCheckCallback::hotModeInvocation(IdleDeadline* deadline) {
-  // TODO(xiaochengh): Implementation.
+  TRACE_EVENT0("blink", "IdleSpellCheckCallback::hotModeInvocation");
+
+  // TODO(xiaochengh): Figure out if this has any performance impact.
+  frame().document()->updateStyleAndLayout();
+
+  HeapVector<Member<Element>> processedRootEditables;
+
+  const Position& extent = frame().selection().selectionInDOMTree().extent();
+  hotModeCheckRootEditable(rootEditableElementOf(extent), extent,
+                           &processedRootEditables);
+
+  uint64_t maxSequenceNumber = m_lastProcessedUndoStepSequence;
+  for (const UndoStep* step : frame().editor().undoStack().undoSteps()) {
+    if (step->sequenceNumber() <= m_lastProcessedUndoStepSequence)
+      break;
+    maxSequenceNumber = std::max(maxSequenceNumber, step->sequenceNumber());

[yosin_UTC9, 2017/03/03 05:34:23]

It is better to update |m_lastProcessUndoStepSequence| to use |const uint64_t|

const uint64_t watermark = m_lastProcessedUndoStepSequence;
for (const UndoStep* step : ...) {
  if (step->sequenceNumber() <= watermark)
    break;
  m_lastProcessUndoStepSequence = std::max(...)
  ...
}

This tells me what m_lastProcessUndoStepSequence holding.

[Xiaocheng, 2017/03/03 06:28:27]

Done.

+    if (deadline->timeRemaining() < 0)
+      break;
+    hotModeCheckRootEditable(step->endingRootEditableElement(),
+                             step->endingSelection().extent(),
+                             &processedRootEditables);
+  }
+
+  m_lastProcessedUndoStepSequence = maxSequenceNumber;
 }
 
 void IdleSpellCheckCallback::coldModeInvocation(IdleDeadline* deadline) {
   // TODO(xiaochengh): Implementation.
 }
 
 bool IdleSpellCheckCallback::coldModeFinishesFullDocument() const {
   if (m_needsMoreColdModeInvocationForTesting) {
     m_needsMoreColdModeInvocationForTesting = false;
     return false;
@@ skipping 66 matching lines @@
   }
 }
 
 void IdleSpellCheckCallback::skipColdModeTimerForTesting() {
   DCHECK(m_coldModeTimer.isActive());
   m_coldModeTimer.stop();
   coldModeTimerFired(&m_coldModeTimer);
 }
 
 }  // namespace blink