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();
 }
 
+UndoStack& IdleSpellCheckCallback::undoStack() const {

[yosin_UTC9, 2017/03/02 03:38:41]

This should be |const UndoStack&|

[Xiaocheng, 2017/03/02 04:34:59]

This one can be changed to const. Interesting...

+  return frame().editor().undoStack();
+}
+
 bool IdleSpellCheckCallback::isSpellCheckingEnabled() const {
   return frame().spellChecker().isSpellCheckingEnabled();
 }
 
 void IdleSpellCheckCallback::requestInvocation() {
   DCHECK_EQ(m_idleCallbackHandle, kInvalidHandle);
 
   IdleRequestOptions options;
   options.setTimeout(kRequestTimeoutMS);
   m_idleCallbackHandle = frame().document()->requestIdleCallback(this, options);
@@ skipping 50 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);
+  int fullLength = TextIterator::rangeLength(fullRange.startPosition(),

[yosin_UTC9, 2017/03/02 03:38:41]

nit: s/int/const int/

[Xiaocheng, 2017/03/02 04:34:59]

Done.

+                                             fullRange.endPosition());
+  if (fullLength <= kHotModeChunkSize)
+    return fullRange;
+
+  TextIteratorBehavior behavior = TextIteratorBehavior::Builder()
+                                      .setEmitsObjectReplacementCharacter(true)
+                                      .build();
+

[yosin_UTC9, 2017/03/02 03:38:40]

nit: Get rid of an extra blank line.

+  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();
+

[yosin_UTC9, 2017/03/02 03:38:40]

nit: Get rid of an extra blank line.

[Xiaocheng, 2017/03/02 04:34:59]

Done.

+  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;
+
+  TypingCommand* typingCommand =
+      TypingCommand::lastTypingCommandIfStillOpenForTyping(&frame());
+  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(
+    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);
+
+  const UndoStepStack& undoSteps = undoStack().undoSteps();
+  if (undoSteps.isEmpty())
+    return;
+
+  for (auto iter = undoSteps.rbegin(); iter != undoSteps.rend(); ++iter) {

[yosin_UTC9, 2017/03/02 03:38:41]

Could you we import |base::Reversed()|[1] into Blink?

[1]
https://cs.chromium.org/chromium/src/base/containers/adapters.h?q=base::Rever...

[Xiaocheng, 2017/03/02 04:34:59]

Never done such thing before...

Can I follow the way how |WTF::Optional| is imported?

[yosin_UTC9, 2017/03/02 04:41:48]

Yes. It also helps others not only us.

BTW, we don't need to do this now f we expose reverse range from UndoStack
class, we don't need.
Since we don't want to expose HeapvEctor<UndoStep> from UndoStack.

Here is sketch:

class UndoStack {
  UndoStepRange undoSteps() { return UndoStepRange(this); }

  class UndoStatepRange {
    using Iterator = HeapVector<UndoStep>::reverse_iterator<...>;
    Iterator begin() const { return m_undostack.rbegin(); }
    Iterator end() const { return m_undoStack.rend(); }
  }
};

[Xiaocheng, 2017/03/02 04:57:52]

Thanks. I'll do this for now and add a TODO to use |Reversed|.

+    if (deadline->timeRemaining() < 0)
+      break;
+    const UndoStep& step = **iter;
+    if (step.sequenceNumber() <= m_lastProcessedUndoStepSequence)
+      break;
+    hotModeCheckRootEditable(step.endingRootEditableElement(),
+                             step.endingSelection().extent(),
+                             &processedRootEditables);
+  }
+
+  m_lastProcessedUndoStepSequence = std::max(
+      m_lastProcessedUndoStepSequence, undoSteps.back()->sequenceNumber());
 }
 
 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