[DevTools] Support CommandLineAPI in workers and Node.js

third_party/WebKit/Source/platform/v8_inspector/V8Console.cpp

 // Copyright 2016 The Chromium 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 "platform/v8_inspector/V8Console.h"
 
 #include "platform/inspector_protocol/String16.h"
 #include "platform/v8_inspector/InjectedScript.h"
 #include "platform/v8_inspector/InspectedContext.h"
 #include "platform/v8_inspector/V8Compat.h"
@@ skipping 684 matching lines @@
     createBoundFunctionProperty(context, commandLineAPI, "$2", V8Console::inspectedObject2);
     createBoundFunctionProperty(context, commandLineAPI, "$3", V8Console::inspectedObject3);
     createBoundFunctionProperty(context, commandLineAPI, "$4", V8Console::inspectedObject4);
 
     inspectedContext->debugger()->client()->installAdditionalCommandLineAPI(context, commandLineAPI);
 
     commandLineAPI->SetPrivate(context, inspectedContextPrivateKey(isolate), v8::External::New(isolate, inspectedContext));
     return commandLineAPI;
 }
 
-void V8Console::clearInspectedContextIfNeeded(v8::Local<v8::Context> context, v8::Local<v8::Object> console)
+static void setterCallback(const v8::FunctionCallbackInfo<v8::Value>& info)

[dgozman, 2016/06/01 01:25:40]

Why do we need this indirection?

[kozy, 2016/06/01 18:49:22]

We'd like to make CommandLineAPI methods replaceable on window object.

 {
-    v8::Isolate* isolate = context->GetIsolate();
-    console->SetPrivate(context, inspectedContextPrivateKey(isolate), v8::External::New(isolate, nullptr));
+    if (!info.Holder()->CreateDataProperty(info.GetIsolate()->GetCurrentContext(), v8::Local<v8::Name>::Cast(info.Data()), info[0]).FromMaybe(false))
+        return;
 }
 
-bool V8Debugger::isCommandLineAPIMethod(const String16& name)
-{
-    DEFINE_STATIC_LOCAL(protocol::HashSet<String16>, methods, ());
-    if (methods.size() == 0) {
-        const char* members[] = { "dir", "dirxml", "keys", "values", "profile", "profileEnd", "inspect",
-            "copy", "clear", "debug", "undebug", "monitor", "unmonitor", "table" };
-        for (size_t i = 0; i < WTF_ARRAY_LENGTH(members); ++i)
-            methods.add(members[i]);
-    }
-    return methods.find(name) != methods.end();
-}
-
-bool V8Debugger::isCommandLineAPIGetter(const String16& name)
+static bool isCommandLineAPIGetter(const String16& name)
 {
     DEFINE_STATIC_LOCAL(protocol::HashSet<String16>, getters, ());
     if (getters.size() == 0) {
         const char* members[] = { "$0", "$1", "$2", "$3", "$4", "$_" };
         for (size_t i = 0; i < WTF_ARRAY_LENGTH(members); ++i)
             getters.add(members[i]);
     }
     return getters.find(name) != getters.end();
 }
 
+v8::Local<v8::Object> V8Console::installCommandLineAPI(v8::Local<v8::Context> context, v8::Local<v8::Object> object, v8::Local<v8::Object> commandLineAPI)
+{
+    v8::Local<v8::Object> installedMethods = v8::Object::New(context->GetIsolate());
+    v8::Local<v8::Array> commandLineAPIMethodNames;
+    if (!commandLineAPI->GetOwnPropertyNames(context).ToLocal(&commandLineAPIMethodNames))

[dgozman, 2016/06/01 01:25:40]

Perhaps, it makes sense to migrate command line api object to map as well.

[kozy, 2016/06/01 18:49:22]

I'll make it in follow up.

+        return installedMethods;
+    for (size_t i = 0; i < commandLineAPIMethodNames->Length(); ++i) {
+        v8::Local<v8::Value> methodName;
+        if (!commandLineAPIMethodNames->Get(context, i).ToLocal(&methodName) || !methodName->IsName())
+            continue;
+        if (object->Has(context, methodName).FromMaybe(true))
+            continue;
+        v8::Local<v8::Value> method;
+        if (!commandLineAPI->Get(context, methodName).ToLocal(&method) || !method->IsFunction())
+            continue;
+        if (!installedMethods->Set(context, methodName, method).FromMaybe(false))
+            continue;
+        if (isCommandLineAPIGetter(toProtocolStringWithTypeCheck(methodName))) {
+            v8::Local<v8::Function> setter;
+            if (!v8::Function::New(context, setterCallback, methodName).ToLocal(&setter))
+                continue;
+            object->SetAccessorProperty(v8::Local<v8::Name>::Cast(methodName), v8::Local<v8::Function>::Cast(method), setter, v8::DontEnum);
+        } else if (!object->DefineOwnProperty(context, v8::Local<v8::Name>::Cast(methodName), method, v8::DontEnum).FromMaybe(false)) {
+            continue;
+        }
+    }
+    return installedMethods;
+}
+
+void V8Console::clearCommandLineAPI(v8::Local<v8::Context> context, v8::Local<v8::Object> object, v8::Local<v8::Object> installedMethods)
+{
+    v8::Local<v8::Array> installedMethodNames;
+    if (!installedMethods->GetOwnPropertyNames(context).ToLocal(&installedMethodNames))
+        return;
+    for (size_t i = 0; i < installedMethodNames->Length(); ++i) {
+        v8::Local<v8::Value> methodName;
+        if (!installedMethodNames->Get(context, i).ToLocal(&methodName) || !methodName->IsName())
+            continue;
+        if (!object->Has(context, methodName).FromMaybe(false))
+            continue;
+        v8::Local<v8::Value> commandLineAPIValue;
+        if (!installedMethods->Get(context, methodName).ToLocal(&commandLineAPIValue))
+            continue;
+        v8::Local<v8::Value> objectMethodValue;
+        if (isCommandLineAPIGetter(toProtocolStringWithTypeCheck(methodName))) {
+            v8::Local<v8::Value> propertyDescriptor;
+            if (!object->GetOwnPropertyDescriptor(context, v8::Local<v8::String>::Cast(methodName)).ToLocal(&propertyDescriptor) || !propertyDescriptor->IsObject())
+                continue;
+            if (!propertyDescriptor.As<v8::Object>()->Get(context, toV8StringInternalized(context->GetIsolate(), "get")).ToLocal(&objectMethodValue))
+                continue;
+        } else {
+            if (!object->Get(context, methodName).ToLocal(&objectMethodValue))
+                continue;
+        }
+        if (!commandLineAPIValue->Equals(context, objectMethodValue).FromMaybe(false))

[dgozman, 2016/06/01 01:25:40]

This is kind of scary. What about having a setter for each property, which will
remove it from a list of installed and set user-passed value?

[kozy, 2016/06/01 18:49:22]

Done.

+            continue;
+        if (!object->Delete(context, methodName).FromMaybe(false))
+            continue;
+    }
+}
+
+void V8Console::clearInspectedContextIfNeeded(v8::Local<v8::Context> context, v8::Local<v8::Object> console)
+{
+    v8::Isolate* isolate = context->GetIsolate();
+    console->SetPrivate(context, inspectedContextPrivateKey(isolate), v8::External::New(isolate, nullptr));
+}
+
 } // namespace blink