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;
 
 }  // 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);
+  int fullLength = TextIterator::rangeLength(fullRange.startPosition(),

[yosin_UTC9, 2017/03/07 01:47:03]

nit: s/int/const int/

[Xiaocheng, 2017/03/07 04:20:30]

Done.

+                                             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();
+  int chunkLimit = fullLength / kColdModeChunkSize + 1;

[yosin_UTC9, 2017/03/07 01:47:03]

nit: s/int/const int/

[Xiaocheng, 2017/03/07 04:20:30]

Done.

+  for (int requestNum = 0; requestNum <= chunkLimit; ++requestNum) {

[yosin_UTC9, 2017/03/07 01:47:03]

nit: s/requestNum/chunkNumber/
or
nit: s/requestNum/chunkIndex/

I feel comparing |requestNum| and |chunkLimit| strange since relation between
"request" and "chunk" isn't clear.

[Xiaocheng, 2017/03/07 04:20:30]

Done.

+    Position chunkEnd = calculateCharacterSubrange(

[yosin_UTC9, 2017/03/07 01:47:03]

nit: s/Position/const Position/

[Xiaocheng, 2017/03/07 04:20:29]

Done.

+                            EphemeralRange(chunkStart, fullRange.endPosition()),
+                            0, kColdModeChunkSize)
+                            .endPosition();
+    if (chunkEnd <= chunkStart)
+      break;
+    EphemeralRange chunkRange(chunkStart, chunkEnd);

[yosin_UTC9, 2017/03/07 01:47:03]

nit: s/EphemeralRange/const EphmeralRange/

[Xiaocheng, 2017/03/07 04:20:30]

Done.

+    EphemeralRange checkRange = requestNum

[yosin_UTC9, 2017/03/07 01:47:03]

nit: s/EphmeralRange/const EphemeralRange&/ to avoid copy
nit: s/requstnum/requestNum >= 1/ to say non-zero explicitly

[Xiaocheng, 2017/03/07 04:20:30]

Done.

+                                    ? expandEndToSentenceBoundary(chunkRange)
+                                    : expandRangeToSentenceBoundary(chunkRange);
+
+    SpellCheckRequest* chunkRequest =
+        SpellCheckRequest::create(checkRange, requestNum);
+    spellCheckRequester().requestCheckingFor(chunkRequest);
+
+    chunkStart = checkRange.endPosition();
+  }
+}
+
 void IdleSpellCheckCallback::coldModeInvocation(IdleDeadline* deadline) {
-  // TODO(xiaochengh): Implementation.
+  TRACE_EVENT0("blink", "IdleSpellCheckCallback::coldModeInvocation");
+
+  // TODO(xiaochengh): Figure out if this has any performance impact.
+  frame().document()->updateStyleAndLayout();
+
+  Node* body = frame().document()->body();

[yosin_UTC9, 2017/03/07 01:47:03]

|body| can be null, e.g. no BODY element.
We may want to check this at entry of this function before update layout.

[Xiaocheng, 2017/03/07 04:20:30]

Done.

+  if (m_lastCheckedDOMTreeVersionInColdMode !=
+      frame().document()->domTreeVersion())
+    m_nextNodeInColdMode = body;
+
+  while (m_nextNodeInColdMode && deadline->timeRemaining() > 0) {
+    const Position& refPosition =
+        Position::firstPositionInNode(m_nextNodeInColdMode);
+    if (m_nextNodeInColdMode->isElementNode() &&
+        isEditablePosition(refPosition) &&
+        SpellChecker::isSpellCheckingEnabledAt(refPosition)) {
+      chunkAndRequestFullCheckingFor(toElement(*m_nextNodeInColdMode));
+      m_nextNodeInColdMode =
+          FlatTreeTraversal::nextSkippingChildren(*m_nextNodeInColdMode, body);
+    } else {

[yosin_UTC9, 2017/03/07 01:47:03]

Prefer early-continue style to shallow indentation.

[Xiaocheng, 2017/03/07 04:20:29]

Done by introducing |shouldCheckNodeInColdMode()|

+      m_nextNodeInColdMode =
+          FlatTreeTraversal::next(*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