Remove timeout from idle time spell checker's cold mode request

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/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 kColdModeTimerIntervalMS = 1000;
 const int kConsecutiveColdModeTimerIntervalMS = 200;
-const int kRequestTimeoutMS = 200;
+const int kHotModeRequestTimeoutMS = 200;
 const int kInvalidHandle = -1;
 const int kDummyHandleForForcedInvocation = -2;
 const double kForcedInvocationDeadlineSeconds = 10;
 
 }  // namespace
 
 IdleSpellCheckCallback::~IdleSpellCheckCallback() {}
 
 DEFINE_TRACE(IdleSpellCheckCallback) {
   visitor->trace(m_frame);
@@ skipping 16 matching lines @@
                       &IdleSpellCheckCallback::coldModeTimerFired) {}
 
 SpellCheckRequester& IdleSpellCheckCallback::spellCheckRequester() const {
   return frame().spellChecker().spellCheckRequester();
 }
 
 bool IdleSpellCheckCallback::isSpellCheckingEnabled() const {
   return frame().spellChecker().isSpellCheckingEnabled();
 }
 
-void IdleSpellCheckCallback::requestInvocation() {
+void IdleSpellCheckCallback::requestInvocation(int timeoutMS) {

[yosin_UTC9, 2017/03/07 08:15:30]

Should we use base::TimeDeltta, available in WTF/Time.h? 

[Xiaocheng, 2017/03/07 21:27:44]

I still prefer just an |int|, as IdleRequestOptions take |int| as parameter.

   DCHECK_EQ(m_idleCallbackHandle, kInvalidHandle);
 
   IdleRequestOptions options;
-  options.setTimeout(kRequestTimeoutMS);
+  if (timeoutMS > 0)
+    options.setTimeout(timeoutMS);
   m_idleCallbackHandle = frame().document()->requestIdleCallback(this, options);
 }
 
 void IdleSpellCheckCallback::deactivate() {
   m_state = State::kInactive;
   if (m_coldModeTimer.isActive())
     m_coldModeTimer.stop();
   if (m_idleCallbackHandle != kInvalidHandle)
     frame().document()->cancelIdleCallback(m_idleCallbackHandle);
   m_idleCallbackHandle = kInvalidHandle;
 }
 
 void IdleSpellCheckCallback::setNeedsInvocation() {
   if (!isSpellCheckingEnabled()) {
     deactivate();
     return;
   }
 
   if (m_state == State::kHotModeRequested)
     return;
 
   if (m_state == State::kColdModeTimerStarted) {
     DCHECK(m_coldModeTimer.isActive());
     m_coldModeTimer.stop();
   }
 
-  if (m_state != State::kColdModeRequested)
-    requestInvocation();
+  if (m_state == State::kColdModeRequested) {
+    frame().document()->cancelIdleCallback(m_idleCallbackHandle);
+    m_idleCallbackHandle = kInvalidHandle;
+  }
+
+  requestInvocation(kHotModeRequestTimeoutMS);
   m_state = State::kHotModeRequested;
 }
 
 void IdleSpellCheckCallback::setNeedsColdModeInvocation() {
   if (!isSpellCheckingEnabled()) {
     deactivate();
     return;
   }
 
   if (m_state != State::kInactive && m_state != State::kInHotModeInvocation &&
       m_state != State::kInColdModeInvocation)
     return;
 
   DCHECK(!m_coldModeTimer.isActive());
   int intervalMS = m_state == State::kInColdModeInvocation
                        ? kConsecutiveColdModeTimerIntervalMS
                        : kColdModeTimerIntervalMS;
   m_coldModeTimer.startOneShot(intervalMS / 1000.0, BLINK_FROM_HERE);
   m_state = State::kColdModeTimerStarted;
 }
 
 void IdleSpellCheckCallback::coldModeTimerFired(TimerBase*) {
   DCHECK_EQ(State::kColdModeTimerStarted, m_state);
 
   if (!isSpellCheckingEnabled()) {
     deactivate();
     return;
   }
 
-  requestInvocation();
+  requestInvocation(0);
   m_state = State::kColdModeRequested;
 }
 
 void IdleSpellCheckCallback::hotModeInvocation(IdleDeadline* deadline) {
   TRACE_EVENT0("blink", "IdleSpellCheckCallback::hotModeInvocation");
 
   // TODO(xiaochengh): Figure out if this has any performance impact.
   frame().document()->updateStyleAndLayout();
 
   HotModeSpellCheckRequester requester(spellCheckRequester());
@@ skipping 89 matching lines @@
   }
 }
 
 void IdleSpellCheckCallback::skipColdModeTimerForTesting() {
   DCHECK(m_coldModeTimer.isActive());
   m_coldModeTimer.stop();
   coldModeTimerFired(&m_coldModeTimer);
 }
 
 }  // namespace blink