[inspector] support setTimeout in Debugger.scheduleStepIntoAsync method

src/inspector/v8-debugger-agent-impl.cc

 // Copyright 2015 the V8 project 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 "src/inspector/v8-debugger-agent-impl.h"
 
 #include <algorithm>
 
 #include "src/debug/debug-interface.h"
 #include "src/inspector/injected-script.h"
@@ skipping 728 matching lines @@
   m_debugger->stepOutOfFunction(m_session->contextGroupId());
   return Response::OK();
 }
 
 void V8DebuggerAgentImpl::scheduleStepIntoAsync(
     std::unique_ptr<ScheduleStepIntoAsyncCallback> callback) {
   if (!isPaused()) {
     callback->sendFailure(Response::Error(kDebuggerNotPaused));
     return;
   }
-  if (m_stepIntoAsyncCallback) {
-    m_stepIntoAsyncCallback->sendFailure(Response::Error(
-        "Current scheduled step into async was overriden with new one."));
-  }
-  m_stepIntoAsyncCallback = std::move(callback);
-}
-
-bool V8DebuggerAgentImpl::shouldBreakInScheduledAsyncTask() {
-  if (!m_stepIntoAsyncCallback) return false;
-  m_stepIntoAsyncCallback->sendSuccess();
-  m_stepIntoAsyncCallback.reset();
-  return true;
+  m_debugger->scheduleStepIntoAsync(std::move(callback),
+                                    m_session->contextGroupId());
 }
 
 Response V8DebuggerAgentImpl::setPauseOnExceptions(
     const String16& stringPauseState) {
   if (!enabled()) return Response::Error(kDebuggerNotEnabled);
   v8::debug::ExceptionBreakState pauseState;
   if (stringPauseState == "none") {
     pauseState = v8::debug::NoBreakOnException;
   } else if (stringPauseState == "all") {
     pauseState = v8::debug::BreakOnAnyException;
@@ skipping 452 matching lines @@
           protocol::DictionaryValue::create();
       reason->setString("reason", hitReasons[i].first);
       if (hitReasons[i].second)
         reason->setObject("auxData", std::move(hitReasons[i].second));
       reasons->pushValue(std::move(reason));
     }
     breakAuxData = protocol::DictionaryValue::create();
     breakAuxData->setArray("reasons", std::move(reasons));
   }
 
-  if (m_stepIntoAsyncCallback) {
-    m_stepIntoAsyncCallback->sendFailure(
-        Response::Error("No async tasks were scheduled before pause."));
-    m_stepIntoAsyncCallback.reset();
-  }
-
   std::unique_ptr<Array<CallFrame>> protocolCallFrames;
   Response response = currentCallFrames(&protocolCallFrames);
   if (!response.isSuccess()) protocolCallFrames = Array<CallFrame>::create();
   m_frontend.paused(std::move(protocolCallFrames), breakReason,
                     std::move(breakAuxData), std::move(hitBreakpointIds),
                     currentAsyncStackTrace());
 
   if (!m_continueToLocationBreakpointId.isEmpty()) {
     m_debugger->removeBreakpoint(m_continueToLocationBreakpointId);
     m_continueToLocationBreakpointId = "";
@@ skipping 50 matching lines @@
 
 void V8DebuggerAgentImpl::reset() {
   if (!enabled()) return;
   m_blackboxedPositions.clear();
   resetBlackboxedStateCache();
   m_scripts.clear();
   m_breakpointIdToDebuggerBreakpointIds.clear();
 }
 
 }  // namespace v8_inspector