[inspector] added Debugger.moduleRequested notification

src/debug/debug.cc

 // Copyright 2012 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/debug/debug.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 1876 matching lines @@
 void Debug::OnCompileError(Handle<Script> script) {
   ProcessCompileEvent(v8::CompileError, script);
 }
 
 
 // Handle debugger actions when a new script is compiled.
 void Debug::OnAfterCompile(Handle<Script> script) {
   ProcessCompileEvent(v8::AfterCompile, script);
 }
 
+void Debug::OnModuleResolved(Handle<Module> referer, Handle<Module> requested,
+                             Handle<String> specifier) {
+  if (!debug_delegate_) return;
+  if (!referer->script()->IsScript() || !requested->script()->IsScript())
+    return;

[neis, 2017/02/01 13:38:55]

Should this ever happen? See comment in objects.h.

[kozy, 2017/02/01 16:39:25]

Done.

+  debug_delegate_->ModuleResolved(
+      ToApiHandle<debug::Script>(handle(Script::cast(referer->script()))),
+      ToApiHandle<debug::Script>(handle(Script::cast(requested->script()))),
+      Utils::ToLocal(specifier));
+}
+
+void Debug::ReportExistingModules() {
+  if (!debug_delegate_) return;
+  HandleScope handle_scope(isolate_);
+  HeapIterator iterator(isolate_->heap());
+  HeapObject* obj;
+  while ((obj = iterator.next())) {
+    if (!obj->IsModule()) continue;
+    Handle<Module> module(Module::cast(obj));
+    if (!module->evaluated()) continue;
+    Handle<FixedArray> requested_modules(module->requested_modules(), isolate_);
+    Handle<FixedArray> module_requests(module->info()->module_requests(),
+                                       isolate_);
+    for (int j = 0, length = requested_modules->length(); j < length; ++j) {
+      Handle<Module> import(i::Module::cast(requested_modules->get(j)),
+                            isolate_);
+      Handle<String> request(i::String::cast(module_requests->get(j)),
+                             isolate_);
+      OnModuleResolved(module, import, request);
+    }
+  }
+}
+
 namespace {
 struct CollectedCallbackData {
   Object** location;
   int id;
   Debug* debug;
   Isolate* isolate;
 
   CollectedCallbackData(Object** location, int id, Debug* debug,
                         Isolate* isolate)
       : location(location), id(id), debug(debug), isolate(isolate) {}
@@ skipping 521 matching lines @@
   return v8::Utils::ToLocal(callback_data_);
 }
 
 
 v8::Isolate* EventDetailsImpl::GetIsolate() const {
   return reinterpret_cast<v8::Isolate*>(exec_state_->GetIsolate());
 }
 
 }  // namespace internal
 }  // namespace v8