[inspector] migrate scriptParsed and getCompiledScripts to native

src/api.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/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 8793 matching lines @@
   isolate->debug()->PrepareStep(static_cast<i::StepAction>(action));
 }
 
 void DebugInterface::ClearStepping(Isolate* v8_isolate) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   ENTER_V8(isolate);
   // Clear all current stepping setup.
   isolate->debug()->ClearStepping();
 }
 
+ScriptOriginOptions DebugInterface::Script::OriginOptions() const {
+  i::Handle<i::Script> script = Utils::OpenHandle(this);
+  return script->origin_options();
+}
+
+bool DebugInterface::Script::WasCompiled() const {
+  i::Handle<i::Script> script = Utils::OpenHandle(this);
+  return script->compilation_state() == i::Script::COMPILATION_STATE_COMPILED;
+}
+
+int DebugInterface::Script::Id() const {
+  i::Handle<i::Script> script = Utils::OpenHandle(this);
+  return script->id();
+}
+
+int DebugInterface::Script::LineOffset() const {
+  i::Handle<i::Script> script = Utils::OpenHandle(this);
+  return script->line_offset();
+}
+
+int DebugInterface::Script::ColumnOffset() const {
+  i::Handle<i::Script> script = Utils::OpenHandle(this);
+  return script->column_offset();
+}
+
+MaybeLocal<Array> DebugInterface::Script::LineEnds(
+    v8::Local<v8::Context> context) const {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(context->GetIsolate());
+  i::HandleScope handle_scope(isolate);
+  i::Handle<i::Script> script = Utils::OpenHandle(this);
+  i::Script::InitLineEnds(script);
+  i::Handle<i::Object> line_ends_obj(script->line_ends(), isolate);
+  if (!line_ends_obj->IsFixedArray()) return MaybeLocal<Array>();
+  i::Handle<i::FixedArray> line_ends =
+      i::Handle<i::FixedArray>::cast(line_ends_obj);
+  auto result = isolate->factory()->NewJSArrayWithElements(line_ends);
+  CHECK(!result.is_null());
+  return Utils::ToLocal(handle_scope.CloseAndEscape(result));
+}
+
+MaybeLocal<String> DebugInterface::Script::Name(
+    v8::Local<v8::Context> context) const {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(context->GetIsolate());
+  i::HandleScope handle_scope(isolate);
+  i::Handle<i::Script> script = Utils::OpenHandle(this);
+  i::Handle<i::Object> value(script->name(), isolate);
+  if (!value->IsString()) return MaybeLocal<String>();
+  return Utils::ToLocal(
+      handle_scope.CloseAndEscape(i::Handle<i::String>::cast(value)));
+}
+
+MaybeLocal<String> DebugInterface::Script::SourceURL(
+    v8::Local<v8::Context> context) const {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(context->GetIsolate());
+  i::HandleScope handle_scope(isolate);
+  i::Handle<i::Script> script = Utils::OpenHandle(this);
+  i::Handle<i::Object> value(script->source_url(), isolate);
+  if (!value->IsString()) return MaybeLocal<String>();
+  return Utils::ToLocal(
+      handle_scope.CloseAndEscape(i::Handle<i::String>::cast(value)));
+}
+
+MaybeLocal<String> DebugInterface::Script::SourceMappingURL(
+    v8::Local<v8::Context> context) const {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(context->GetIsolate());
+  i::HandleScope handle_scope(isolate);
+  i::Handle<i::Script> script = Utils::OpenHandle(this);
+  i::Handle<i::Object> value(script->source_mapping_url(), isolate);
+  if (!value->IsString()) return MaybeLocal<String>();
+  return Utils::ToLocal(
+      handle_scope.CloseAndEscape(i::Handle<i::String>::cast(value)));
+}
+
+MaybeLocal<String> DebugInterface::Script::ContextData(
+    v8::Local<v8::Context> context) const {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(context->GetIsolate());
+  i::HandleScope handle_scope(isolate);
+  i::Handle<i::Script> script = Utils::OpenHandle(this);
+  i::Handle<i::Object> value(script->context_data(), isolate);
+  if (!value->IsString()) return MaybeLocal<String>();
+  return Utils::ToLocal(
+      handle_scope.CloseAndEscape(i::Handle<i::String>::cast(value)));
+}
+
+MaybeLocal<String> DebugInterface::Script::Source(
+    v8::Local<v8::Context> context) const {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(context->GetIsolate());
+  i::HandleScope handle_scope(isolate);
+  i::Handle<i::Script> script = Utils::OpenHandle(this);
+  i::Handle<i::Object> value(script->source(), isolate);
+  if (!value->IsString()) return MaybeLocal<String>();
+  return Utils::ToLocal(
+      handle_scope.CloseAndEscape(i::Handle<i::String>::cast(value)));
+}
+
+MaybeLocal<DebugInterface::Script> DebugInterface::Script::Wrap(
+    v8::Local<v8::Context> context, v8::Local<v8::Object> script) {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(context->GetIsolate());
+  ENTER_V8(isolate);
+  i::HandleScope handle_scope(isolate);
+  i::Handle<i::JSReceiver> script_receiver(Utils::OpenHandle(*script));
+  if (!script_receiver->IsJSValue()) return MaybeLocal<Script>();
+  i::Handle<i::Object> script_value(
+      i::Handle<i::JSValue>::cast(script_receiver)->value(), isolate);
+  if (!script_value->IsScript()) {
+    return MaybeLocal<Script>();
+  }
+  i::Handle<i::Script> script_obj = i::Handle<i::Script>::cast(script_value);
+  if (script_obj->type() != i::Script::TYPE_NORMAL) return MaybeLocal<Script>();
+  return ToApiHandle<DebugInterface::Script>(
+      handle_scope.CloseAndEscape(script_obj));
+}
+
+MaybeLocal<Array> DebugInterface::GetLoadedScripts(v8::Isolate* v8_isolate) {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
+  ENTER_V8(isolate);
+  i::HandleScope handle_scope(isolate);
+
+  i::Handle<i::FixedArray> instances = isolate->debug()->GetLoadedScripts();
+  // Convert the script objects to proper JS objects.
+  for (int i = 0; i < instances->length(); i++) {
+    i::Handle<i::Script> script =
+        i::Handle<i::Script>(i::Script::cast(instances->get(i)));
+    i::Handle<i::JSObject> wrapper = i::Script::GetWrapper(script);

[Yang, 2016/10/28 05:39:24]

If would be awesome if we could get rid of script wrapper objects. We only need
them to add JS functionality to it that the debugger uses. Since we are moving
away from that, it would be best not to use script wrappers at all anymore.

How about the caller passes in a PersistentValueVector that gets appended here
with Local<DebugInterface::Script> objects to return?

[kozy, 2016/10/28 05:50:44]

We still pass wrapped script as argument of event listener for after compile
events. I can change argument for these events in this patch and pass just
handle to Script object but it potentially can break another clients. WDYT?
And I'll change function to use persistent vector tomorrow.

+    instances->set(i, *wrapper);
+  }
+  auto result = isolate->factory()->NewJSArrayWithElements(instances);
+  return Utils::ToLocal(handle_scope.CloseAndEscape(result));
+}
+
 Local<String> CpuProfileNode::GetFunctionName() const {
   const i::ProfileNode* node = reinterpret_cast<const i::ProfileNode*>(this);
   i::Isolate* isolate = node->isolate();
   const i::CodeEntry* entry = node->entry();
   i::Handle<i::String> name =
       isolate->factory()->InternalizeUtf8String(entry->name());
   if (!entry->has_name_prefix()) {
     return ToApiHandle<String>(name);
   } else {
     // We do not expect this to fail. Change this if it does.
@@ skipping 668 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8