[inspector] migrate scriptParsed and getCompiledScripts to native

src/inspector/v8-debugger.cc

 // Copyright 2016 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.h"
 
 #include "src/inspector/debugger-script.h"
 #include "src/inspector/protocol/Protocol.h"
 #include "src/inspector/script-breakpoint.h"
 #include "src/inspector/string-util.h"
 #include "src/inspector/v8-debugger-agent-impl.h"
 #include "src/inspector/v8-inspector-impl.h"
 #include "src/inspector/v8-internal-value-type.h"
 #include "src/inspector/v8-stack-trace-impl.h"
 #include "src/inspector/v8-value-copier.h"
 
+#include "include/v8-util.h"
+
 namespace v8_inspector {
 
 namespace {
 static const char v8AsyncTaskEventEnqueue[] = "enqueue";
 static const char v8AsyncTaskEventEnqueueRecurring[] = "enqueueRecurring";
 static const char v8AsyncTaskEventWillHandle[] = "willHandle";
 static const char v8AsyncTaskEventDidHandle[] = "didHandle";
 static const char v8AsyncTaskEventCancel[] = "cancel";
 
 inline v8::Local<v8::Boolean> v8Boolean(bool value, v8::Isolate* isolate) {
@@ skipping 82 matching lines @@
   if (dataString.isEmpty()) return 0;
   size_t commaPos = dataString.find(",");
   if (commaPos == String16::kNotFound) return 0;
   return dataString.substring(0, commaPos).toInteger();
 }
 
 void V8Debugger::getCompiledScripts(
     int contextGroupId,
     std::vector<std::unique_ptr<V8DebuggerScript>>& result) {
   v8::HandleScope scope(m_isolate);
-  v8::MicrotasksScope microtasks(m_isolate,
-                                 v8::MicrotasksScope::kDoNotRunMicrotasks);
   v8::Local<v8::Context> context = debuggerContext();
-  v8::Local<v8::Object> debuggerScript = m_debuggerScript.Get(m_isolate);
-  DCHECK(!debuggerScript->IsUndefined());
-  v8::Local<v8::Function> getScriptsFunction = v8::Local<v8::Function>::Cast(
-      debuggerScript
-          ->Get(context, toV8StringInternalized(m_isolate, "getScripts"))
-          .ToLocalChecked());
-  v8::Local<v8::Value> argv[] = {v8::Integer::New(m_isolate, contextGroupId)};
-  v8::Local<v8::Value> value;
-  if (!getScriptsFunction->Call(context, debuggerScript, arraysize(argv), argv)
-           .ToLocal(&value))
-    return;
-  DCHECK(value->IsArray());
-  v8::Local<v8::Array> scriptsArray = v8::Local<v8::Array>::Cast(value);
-  result.reserve(scriptsArray->Length());
-  for (unsigned i = 0; i < scriptsArray->Length(); ++i) {
-    v8::Local<v8::Object> scriptObject = v8::Local<v8::Object>::Cast(
-        scriptsArray->Get(context, v8::Integer::New(m_isolate, i))
-            .ToLocalChecked());
-    result.push_back(wrapUnique(
-        new V8DebuggerScript(context, scriptObject, inLiveEditScope)));
+  v8::Context::Scope contextScope(context);
+
+  v8::PersistentValueVector<v8::DebugInterface::Script> scripts(m_isolate);
+  v8::DebugInterface::GetLoadedScripts(m_isolate, scripts);
+  String16 contextPrefix = String16::fromInteger(contextGroupId) + ",";
+  for (size_t i = 0; i < scripts.Size(); ++i) {
+    v8::Local<v8::DebugInterface::Script> script = scripts.Get(i);
+    if (!script->WasCompiled()) continue;
+    v8::ScriptOriginOptions origin = script->OriginOptions();
+    if (origin.IsEmbedderDebugScript()) continue;
+    v8::Local<v8::String> v8ContextData;
+    if (!script->ContextData(context).ToLocal(&v8ContextData)) continue;
+    String16 contextData = toProtocolString(v8ContextData);
+    if (contextData.find(contextPrefix) != 0) continue;
+    result.push_back(wrapUnique(new V8DebuggerScript(context, script, false)));
   }
 }
 
 String16 V8Debugger::setBreakpoint(const String16& sourceID,
                                    const ScriptBreakpoint& scriptBreakpoint,
                                    int* actualLineNumber,
                                    int* actualColumnNumber) {
   v8::HandleScope scope(m_isolate);
   v8::Local<v8::Context> context = debuggerContext();
   v8::Context::Scope contextScope(context);
@@ skipping 427 matching lines @@
                            eventDetails.GetEventData());
     return;
   }
 
   V8DebuggerAgentImpl* agent =
       m_inspector->enabledDebuggerAgentForGroup(getGroupId(eventContext));
   if (agent) {
     v8::HandleScope scope(m_isolate);
     if (m_ignoreScriptParsedEventsCounter == 0 &&
         (event == v8::AfterCompile || event == v8::CompileError)) {
-      v8::Context::Scope contextScope(debuggerContext());
+      v8::Local<v8::Context> context = debuggerContext();
+      v8::Context::Scope contextScope(context);
       v8::Local<v8::Value> argv[] = {eventDetails.GetEventData()};
       v8::Local<v8::Value> value =
           callDebuggerMethod("getAfterCompileScript", 1, argv).ToLocalChecked();
       if (value->IsNull()) return;
       DCHECK(value->IsObject());
       v8::Local<v8::Object> scriptObject = v8::Local<v8::Object>::Cast(value);
+      v8::Local<v8::DebugInterface::Script> script;
+      if (!v8::DebugInterface::Script::Wrap(context, scriptObject)
+               .ToLocal(&script))
+        return;
       agent->didParseSource(
-          wrapUnique(new V8DebuggerScript(debuggerContext(), scriptObject,
-                                          inLiveEditScope)),
+          wrapUnique(new V8DebuggerScript(context, script, inLiveEditScope)),
           event == v8::AfterCompile);
     } else if (event == v8::Exception) {
       v8::Local<v8::Object> eventData = eventDetails.GetEventData();
       v8::Local<v8::Value> exception =
           callInternalGetterFunction(eventData, "exception");
       v8::Local<v8::Value> promise =
           callInternalGetterFunction(eventData, "promise");
       bool isPromiseRejection = !promise.IsEmpty() && promise->IsObject();
       handleProgramBreak(eventContext, eventDetails.GetExecutionState(),
                          exception, v8::Local<v8::Array>(), isPromiseRejection);
@@ skipping 367 matching lines @@
 
   size_t stackSize =
       fullStack ? V8StackTraceImpl::maxCallStackSizeToCapture : 1;
   if (m_inspector->enabledRuntimeAgentForGroup(contextGroupId))
     stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
 
   return V8StackTraceImpl::capture(this, contextGroupId, stackSize);
 }
 
 }  // namespace v8_inspector