[inspector] changed a way of preserving stepping between tasks

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

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 279 matching lines @@
   if (includeCommandLineAPI.fromMaybe(false)) scope.installCommandLineAPI();
 
   bool evalIsDisabled = !scope.context()->IsCodeGenerationFromStringsAllowed();
   // Temporarily enable allow evals for inspector.
   if (evalIsDisabled) scope.context()->AllowCodeGenerationFromStrings(true);
 
   v8::MaybeLocal<v8::Value> maybeResultValue;
   v8::Local<v8::Script> script;
   if (m_inspector->compileScript(scope.context(), expression, String16())
           .ToLocal(&script)) {
-    maybeResultValue = m_inspector->runCompiledScript(scope.context(), script);
+    v8::MicrotasksScope microtasksScope(m_inspector->isolate(),
+                                        v8::MicrotasksScope::kRunMicrotasks);
+    maybeResultValue = script->Run(scope.context());
   }
 
   if (evalIsDisabled) scope.context()->AllowCodeGenerationFromStrings(false);
 
   // Re-initialize after running client's code, as it could have destroyed
   // context or session.
   response = scope.initialize();
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
@@ skipping 67 matching lines @@
   }
 
   if (silent.fromMaybe(false)) scope.ignoreExceptionsAndMuteConsole();
   if (userGesture.fromMaybe(false)) scope.pretendUserGesture();
 
   v8::MaybeLocal<v8::Value> maybeFunctionValue;
   v8::Local<v8::Script> functionScript;
   if (m_inspector
           ->compileScript(scope.context(), "(" + expression + ")", String16())
           .ToLocal(&functionScript)) {
-    maybeFunctionValue =
-        m_inspector->runCompiledScript(scope.context(), functionScript);
+    v8::MicrotasksScope microtasksScope(m_inspector->isolate(),
+                                        v8::MicrotasksScope::kRunMicrotasks);
+    maybeFunctionValue = functionScript->Run(scope.context());
   }
   // Re-initialize after running client's code, as it could have destroyed
   // context or session.
   response = scope.initialize();
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
 
   if (scope.tryCatch().HasCaught()) {
     wrapEvaluateResultAsync(scope.injectedScript(), maybeFunctionValue,
                             scope.tryCatch(), scope.objectGroupName(), false,
                             false, callback.get());
     return;
   }
 
   v8::Local<v8::Value> functionValue;
   if (!maybeFunctionValue.ToLocal(&functionValue) ||
       !functionValue->IsFunction()) {
     callback->sendFailure(
         Response::Error("Given expression does not evaluate to a function"));
     return;
   }
 
-  v8::MaybeLocal<v8::Value> maybeResultValue = m_inspector->callFunction(
-      functionValue.As<v8::Function>(), scope.context(), scope.object(), argc,
-      argv.get());
+  v8::MaybeLocal<v8::Value> maybeResultValue;
+  {
+    v8::MicrotasksScope microtasksScope(m_inspector->isolate(),
+                                        v8::MicrotasksScope::kRunMicrotasks);
+    maybeResultValue = functionValue.As<v8::Function>()->Call(
+        scope.context(), scope.object(), argc, argv.get());
+  }
   // Re-initialize after running client's code, as it could have destroyed
   // context or session.
   response = scope.initialize();
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
 
   if (!awaitPromise.fromMaybe(false) || scope.tryCatch().HasCaught()) {
     wrapEvaluateResultAsync(scope.injectedScript(), maybeResultValue,
@@ skipping 186 matching lines @@
   std::unique_ptr<v8::Global<v8::Script>> scriptWrapper = std::move(it->second);
   m_compiledScripts.erase(it);
   v8::Local<v8::Script> script = scriptWrapper->Get(m_inspector->isolate());
   if (script.IsEmpty()) {
     callback->sendFailure(Response::Error("Script execution failed"));
     return;
   }
 
   if (includeCommandLineAPI.fromMaybe(false)) scope.installCommandLineAPI();
 
-  v8::MaybeLocal<v8::Value> maybeResultValue =
-      m_inspector->runCompiledScript(scope.context(), script);
+  v8::MaybeLocal<v8::Value> maybeResultValue;
+  {
+    v8::MicrotasksScope microtasksScope(m_inspector->isolate(),
+                                        v8::MicrotasksScope::kRunMicrotasks);
+    maybeResultValue = script->Run(scope.context());
+  }
 
   // Re-initialize after running client's code, as it could have destroyed
   // context or session.
   response = scope.initialize();
   if (!response.isSuccess()) {
     callback->sendFailure(response);
     return;
   }
 
   if (!awaitPromise.fromMaybe(false) || scope.tryCatch().HasCaught()) {
@@ skipping 98 matching lines @@
 }
 
 bool V8RuntimeAgentImpl::reportMessage(V8ConsoleMessage* message,
                                        bool generatePreview) {
   message->reportToFrontend(&m_frontend, m_session, generatePreview);
   m_frontend.flush();
   return m_inspector->hasConsoleMessageStorage(m_session->contextGroupId());
 }
 
 }  // namespace v8_inspector