Implement cold 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/UndoStack.h"
 #include "core/editing/commands/UndoStep.h"
+#include "core/editing/iterators/CharacterIterator.h"
 #include "core/editing/spellcheck/HotModeSpellCheckRequester.h"
 #include "core/editing/spellcheck/SpellCheckRequester.h"
 #include "core/editing/spellcheck/SpellChecker.h"
 #include "core/frame/LocalFrame.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 namespace {
 
+const int kColdModeChunkSize = 16384;
 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 shouldCheckNodeInColdMode(Node& node) {
+  if (!node.isElementNode())
+    return false;
+  const Position& position = Position::firstPositionInNode(&node);
+  if (!isEditablePosition(position))
+    return false;
+  return SpellChecker::isSpellCheckingEnabledAt(position);
+}
+
 }  // namespace
 
 IdleSpellCheckCallback::~IdleSpellCheckCallback() {}
 
 DEFINE_TRACE(IdleSpellCheckCallback) {
   visitor->trace(m_frame);
+  visitor->trace(m_nextNodeInColdMode);
   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_lastCheckedDOMTreeVersionInColdMode(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 80 matching lines @@
     if (step->sequenceNumber() <= watermark)
       break;
     m_lastProcessedUndoStepSequence =
         std::max(step->sequenceNumber(), m_lastProcessedUndoStepSequence);
     if (deadline->timeRemaining() == 0)
       break;
     requester.checkSpellingAt(step->endingSelection().extent());
   }
 }
 
+// TODO(xiaochengh): Deduplicate with SpellChecker::chunkAndMarkAllMisspellings.
+void IdleSpellCheckCallback::chunkAndRequestFullCheckingFor(
+    const Element& editable) {
+  const EphemeralRange& fullRange = EphemeralRange::rangeOfContents(editable);
+  const int fullLength = TextIterator::rangeLength(fullRange.startPosition(),
+                                                   fullRange.endPosition());
+
+  // Check the full content if it is short.
+  if (fullLength <= kColdModeChunkSize) {
+    SpellCheckRequest* fullRequest = SpellCheckRequest::create(fullRange);
+    spellCheckRequester().requestCheckingFor(fullRequest);
+    return;
+  }
+
+  // TODO(xiaochengh): Figure out if this is going to cause performance issues.
+  // In that case, we need finer-grained control over request generation.
+  Position chunkStart = fullRange.startPosition();
+  const int chunkLimit = fullLength / kColdModeChunkSize + 1;
+  for (int chunkIndex = 0; chunkIndex <= chunkLimit; ++chunkIndex) {
+    const Position& chunkEnd =
+        calculateCharacterSubrange(
+            EphemeralRange(chunkStart, fullRange.endPosition()), 0,
+            kColdModeChunkSize)
+            .endPosition();
+    if (chunkEnd <= chunkStart)
+      break;
+    const EphemeralRange chunkRange(chunkStart, chunkEnd);
+    const EphemeralRange& checkRange =
+        chunkIndex >= 1 ? expandEndToSentenceBoundary(chunkRange)
+                        : expandRangeToSentenceBoundary(chunkRange);
+
+    SpellCheckRequest* chunkRequest =
+        SpellCheckRequest::create(checkRange, chunkIndex);
+    spellCheckRequester().requestCheckingFor(chunkRequest);

[yosin_UTC9, 2017/03/07 04:28:50]

In following patch, we may want to make
SpellCheckerRequester::requestCheckingFor() to take EphmeralRange and
requestNumber instead of SpellCheckRequest.

All call sites, including this one, don't use |SpellCheckRequest*| after
requested.

[Xiaocheng, 2017/03/07 06:46:54]

Good catch. Will do.

+
+    chunkStart = checkRange.endPosition();
+  }
+}
+
 void IdleSpellCheckCallback::coldModeInvocation(IdleDeadline* deadline) {
-  // TODO(xiaochengh): Implementation.
+  TRACE_EVENT0("blink", "IdleSpellCheckCallback::coldModeInvocation");
+
+  Node* body = frame().document()->body();
+  if (!body) {
+    m_nextNodeInColdMode = nullptr;
+    m_lastCheckedDOMTreeVersionInColdMode =
+        frame().document()->domTreeVersion();
+    return;
+  }
+
+  // TODO(xiaochengh): Figure out if this has any performance impact.
+  frame().document()->updateStyleAndLayout();
+
+  if (m_lastCheckedDOMTreeVersionInColdMode !=
+      frame().document()->domTreeVersion())
+    m_nextNodeInColdMode = body;
+
+  while (m_nextNodeInColdMode && deadline->timeRemaining() > 0) {
+    if (!shouldCheckNodeInColdMode(*m_nextNodeInColdMode)) {
+      m_nextNodeInColdMode =
+          FlatTreeTraversal::next(*m_nextNodeInColdMode, body);
+      continue;
+    }
+
+    chunkAndRequestFullCheckingFor(toElement(*m_nextNodeInColdMode));
+    m_nextNodeInColdMode =
+        FlatTreeTraversal::nextSkippingChildren(*m_nextNodeInColdMode, body);
+  }
+
+  m_lastCheckedDOMTreeVersionInColdMode = frame().document()->domTreeVersion();
 }
 
 bool IdleSpellCheckCallback::coldModeFinishesFullDocument() const {
   if (m_needsMoreColdModeInvocationForTesting) {
     m_needsMoreColdModeInvocationForTesting = false;
     return false;
   }
 
-  // TODO(xiaochengh): Implementation.
-  return true;
+  return !m_nextNodeInColdMode;
 }
 
 void IdleSpellCheckCallback::handleEvent(IdleDeadline* deadline) {
   DCHECK(frame().document());
   DCHECK(frame().document()->isActive());
   DCHECK_NE(m_idleCallbackHandle, kInvalidHandle);
   m_idleCallbackHandle = kInvalidHandle;
 
   if (!isSpellCheckingEnabled()) {
     deactivate();
@@ skipping 52 matching lines @@
   }
 }
 
 void IdleSpellCheckCallback::skipColdModeTimerForTesting() {
   DCHECK(m_coldModeTimer.isActive());
   m_coldModeTimer.stop();
   coldModeTimerFired(&m_coldModeTimer);
 }
 
 }  // namespace blink