[inspector] better isArrayLike for injected-script-source.js

src/inspector/v8-injected-script-host.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-injected-script-host.h"
 
 #include "src/base/macros.h"
 #include "src/inspector/injected-script-native.h"
 #include "src/inspector/string-util.h"
 #include "src/inspector/v8-debugger.h"
@@ skipping 40 matching lines @@
   v8::Local<v8::Object> injectedScriptHost = v8::Object::New(isolate);
   bool success = injectedScriptHost->SetPrototype(context, v8::Null(isolate))
                      .FromMaybe(false);
   DCHECK(success);
   USE(success);
   v8::Local<v8::External> debuggerExternal =
       v8::External::New(isolate, inspector);
   setFunctionProperty(context, injectedScriptHost, "nullifyPrototype",
                       V8InjectedScriptHost::nullifyPrototypeCallback,
                       debuggerExternal);
+  setFunctionProperty(context, injectedScriptHost, "get",
+                      V8InjectedScriptHost::getCallback, debuggerExternal);
   setFunctionProperty(context, injectedScriptHost, "internalConstructorName",
                       V8InjectedScriptHost::internalConstructorNameCallback,
                       debuggerExternal);
   setFunctionProperty(
       context, injectedScriptHost, "formatAccessorsAsProperties",
       V8InjectedScriptHost::formatAccessorsAsProperties, debuggerExternal);
   setFunctionProperty(context, injectedScriptHost, "subtype",
                       V8InjectedScriptHost::subtypeCallback, debuggerExternal);
   setFunctionProperty(context, injectedScriptHost, "getInternalProperties",
                       V8InjectedScriptHost::getInternalPropertiesCallback,
@@ skipping 12 matching lines @@
 void V8InjectedScriptHost::nullifyPrototypeCallback(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   CHECK(info.Length() == 1 && info[0]->IsObject());
   v8::Isolate* isolate = info.GetIsolate();
   info[0]
       .As<v8::Object>()
       ->SetPrototype(isolate->GetCurrentContext(), v8::Null(isolate))
       .ToChecked();
 }
 
+void V8InjectedScriptHost::getCallback(
+    const v8::FunctionCallbackInfo<v8::Value>& info) {
+  CHECK(info.Length() == 2 && info[1]->IsString());
+  if (!info[0]->IsObject()) return;
+  v8::Isolate* isolate = info.GetIsolate();
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::TryCatch tryCatch(isolate);
+  v8::Isolate::DisallowJavascriptExecutionScope throwJs(
+      isolate, v8::Isolate::DisallowJavascriptExecutionScope::THROW_ON_FAILURE);
+  v8::Local<v8::Value> property;
+  if (info[0]
+          .As<v8::Object>()
+          ->Get(context, v8::Local<v8::String>::Cast(info[1]))
+          .ToLocal(&property)) {
+    info.GetReturnValue().Set(property);

[dgozman, 2017/03/23 21:10:20]

So, do we return undefined in case of JS execution or exception?

[kozy, 2017/03/24 00:40:37]

yes, we do, in current use cases it looks like expected behavior.

+  }
+}
+
 void V8InjectedScriptHost::internalConstructorNameCallback(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   if (info.Length() < 1 || !info[0]->IsObject()) return;
 
   v8::Local<v8::Object> object = info[0].As<v8::Object>();
   info.GetReturnValue().Set(object->GetConstructorName());
 }
 
 void V8InjectedScriptHost::formatAccessorsAsProperties(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
@@ skipping 182 matching lines @@
     UNREACHABLE();
     return;
   }
   v8::Local<v8::Object> target = info[0].As<v8::Proxy>();
   while (target->IsProxy())
     target = v8::Local<v8::Proxy>::Cast(target)->GetTarget();
   info.GetReturnValue().Set(target);
 }
 
 }  // namespace v8_inspector