[DevTools] Move part of CommandLineAPI to native

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/V8DebuggerAgentImpl.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
 #include "platform/v8_inspector/V8ProfilerAgentImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/ConsoleAPITypes.h"
 #include "platform/v8_inspector/public/ConsoleTypes.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
@@ skipping 94 matching lines @@
         if (m_info[0]->IsObject()) {
             if (!m_info[0].As<v8::Object>()->ObjectProtoToString(m_context).ToLocal(&titleValue))
                 return defaultValue;
         } else {
             if (!m_info[0]->ToString(m_context).ToLocal(&titleValue))
                 return defaultValue;
         }
         return toProtocolString(titleValue);
     }
 
+    v8::MaybeLocal<v8::Object> firstArgAsObject()
+    {
+        if (m_info.Length() < 1 || !m_info[0]->IsObject())
+            return v8::MaybeLocal<v8::Object>();
+        return m_info[0].As<v8::Object>();
+    }
+
+    v8::MaybeLocal<v8::Function> firstArgAsFunction()
+    {
+        if (m_info.Length() < 1 || !m_info[0]->IsFunction())
+            return v8::MaybeLocal<v8::Function>();
+        return m_info[0].As<v8::Function>();
+    }
+
     v8::MaybeLocal<v8::Map> privateMap(const char* name)
     {
         v8::Local<v8::Object> console = ensureConsole();
         v8::Local<v8::Private> privateKey = v8::Private::ForApi(m_isolate, toV8StringInternalized(m_isolate, name));
         v8::Local<v8::Value> mapValue;
         if (!console->GetPrivate(m_context, privateKey).ToLocal(&mapValue))
             return v8::MaybeLocal<v8::Map>();
         if (mapValue->IsUndefined()) {
             v8::Local<v8::Map> map = v8::Map::New(m_isolate);
             if (!console->SetPrivate(m_context, privateKey, map).FromMaybe(false))
@@ skipping 311 matching lines @@
             return;
         info.GetReturnValue().Set(memoryValue);
     }
 }
 
 void V8Console::memorySetterCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     // We can't make the attribute readonly as it breaks existing code that relies on being able to assign to console.memory in strict mode. Instead, the setter just ignores the passed value.  http://crbug.com/468611
 }
 
-v8::MaybeLocal<v8::Object> V8Console::create(v8::Local<v8::Context> context, InspectedContext* inspectedContext, bool hasMemoryAttribute)
+void V8Console::keysCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
+    v8::Isolate* isolate = info.GetIsolate();
+    info.GetReturnValue().Set(v8::Array::New(isolate));
+
+    ConsoleHelper helper(info);
+    v8::Local<v8::Object> obj;
+    if (!helper.firstArgAsObject().ToLocal(&obj))
+        return;
+    v8::Local<v8::Array> names;
+    if (!obj->GetOwnPropertyNames(isolate->GetCurrentContext()).ToLocal(&names))
+        return;
+    info.GetReturnValue().Set(names);
+}
+
+void V8Console::valuesCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    v8::Isolate* isolate = info.GetIsolate();
+    info.GetReturnValue().Set(v8::Array::New(isolate));
+
+    ConsoleHelper helper(info);
+    v8::Local<v8::Object> obj;
+    if (!helper.firstArgAsObject().ToLocal(&obj))
+        return;
+    v8::Local<v8::Array> names;
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    if (!obj->GetOwnPropertyNames(context).ToLocal(&names))
+        return;
+    v8::Local<v8::Array> values = v8::Array::New(isolate, names->Length());
+    for (size_t i = 0; i < names->Length(); ++i) {
+        v8::Local<v8::Value> key;
+        if (!names->Get(context, i).ToLocal(&key))
+            continue;
+        v8::Local<v8::Value> value;
+        if (!obj->Get(context, key).ToLocal(&value))
+            continue;
+        if (!values->Set(context, i, value).FromMaybe(false))
+            continue;
+    }
+    info.GetReturnValue().Set(values);
+}
+
+static void setFunctionBreakpoint(ConsoleHelper& helper, v8::Local<v8::Function> function, V8DebuggerAgentImpl::BreakpointSource source, const String16& condition, bool enable)
+{
+    V8DebuggerAgentImpl* debuggerAgent = helper.debuggerAgent();
+    if (!debuggerAgent)
+        return;
+    String16 scriptId = String16::number(function->ScriptId());
+    int lineNumber = function->GetScriptLineNumber();
+    int columnNumber = function->GetScriptColumnNumber();
+    if (lineNumber == v8::Function::kLineOffsetNotFound || columnNumber == v8::Function::kLineOffsetNotFound)
+        return;
+    if (enable)
+        debuggerAgent->setBreakpointAt(scriptId, lineNumber, columnNumber, source, condition);
+    else
+        debuggerAgent->removeBreakpointAt(scriptId, lineNumber, columnNumber, source);
+}
+
+void V8Console::debugFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ConsoleHelper helper(info);
+    v8::Local<v8::Function> function;
+    if (!helper.firstArgAsFunction().ToLocal(&function))
+        return;
+    setFunctionBreakpoint(helper, function, V8DebuggerAgentImpl::DebugCommandBreakpointSource, String16(), true);
+}
+
+void V8Console::undebugFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ConsoleHelper helper(info);
+    v8::Local<v8::Function> function;
+    if (!helper.firstArgAsFunction().ToLocal(&function))
+        return;
+    setFunctionBreakpoint(helper, function, V8DebuggerAgentImpl::DebugCommandBreakpointSource, String16(), false);
+}
+
+void V8Console::monitorFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ConsoleHelper helper(info);
+    v8::Local<v8::Function> function;
+    if (!helper.firstArgAsFunction().ToLocal(&function))
+        return;
+    v8::Local<v8::Value> name = function->GetName();
+    if (!name->IsString() || !v8::Local<v8::String>::Cast(name)->Length())
+        name = function->GetInferredName();
+    String16 functionName = toProtocolStringWithTypeCheck(name);
+    String16Builder builder;
+    builder.append("console.log(\"function ");
+    if (functionName.isEmpty())
+        builder.append("(anonymous function)");
+    else
+        builder.append(functionName);
+    builder.append(" called\" + (arguments.length > 0 ? \" with arguments: \" + Array.prototype.join.call(arguments, \", \") : \"\")) && false");
+    setFunctionBreakpoint(helper, function, V8DebuggerAgentImpl::MonitorCommandBreakpointSource, builder.toString(), true);
+}
+
+void V8Console::unmonitorFunctionCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ConsoleHelper helper(info);
+    v8::Local<v8::Function> function;
+    if (!helper.firstArgAsFunction().ToLocal(&function))
+        return;
+    setFunctionBreakpoint(helper, function, V8DebuggerAgentImpl::MonitorCommandBreakpointSource, String16(), false);
+}
+
+void V8Console::lastEvaluationResultCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    ConsoleHelper helper(info);
+    InspectedContext* context = helper.ensureInspectedContext();
+    if (!context)
+        return;
+    if (InjectedScript* injectedScript = context->getInjectedScript())
+        info.GetReturnValue().Set(injectedScript->lastEvaluationResult());
+}
+
+v8::MaybeLocal<v8::Object> V8Console::createConsole(InspectedContext* inspectedContext, bool hasMemoryAttribute)
+{
+    v8::Local<v8::Context> context = inspectedContext->context();
     v8::Isolate* isolate = context->GetIsolate();
     v8::MicrotasksScope microtasksScope(isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
 
     v8::Local<v8::Object> console;
     if (!createObjectWithClassName(inspectedContext->debugger(), context, "Console").ToLocal(&console))
         return v8::MaybeLocal<v8::Object>();
 
     v8::Local<v8::Object> prototype;
     if (!createObjectWithClassName(inspectedContext->debugger(), context, "ConsolePrototype").ToLocal(&prototype))
         return v8::MaybeLocal<v8::Object>();
@@ skipping 25 matching lines @@
     if (!console->SetPrototype(context, prototype).FromMaybe(false))
         return v8::MaybeLocal<v8::Object>();
 
     if (hasMemoryAttribute)
         console->SetAccessorProperty(toV8StringInternalized(isolate, "memory"), v8::Function::New(isolate, V8Console::memoryGetterCallback, console), v8::Function::New(isolate, V8Console::memorySetterCallback), static_cast<v8::PropertyAttribute>(v8::None), v8::DEFAULT);
 
     console->SetPrivate(context, inspectedContextPrivateKey(isolate), v8::External::New(isolate, inspectedContext));
     return console;
 }
 
+v8::Local<v8::Object> V8Console::createCommandLineAPI(InspectedContext* inspectedContext)
+{
+    v8::Local<v8::Context> context = inspectedContext->context();
+    v8::Isolate* isolate = context->GetIsolate();
+    v8::MicrotasksScope microtasksScope(isolate, v8::MicrotasksScope::kDoNotRunMicrotasks);
+
+    v8::Local<v8::Object> commandLineAPI = v8::Object::New(isolate);
+
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "dir", V8Console::dirCallback);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "dirxml", V8Console::dirxmlCallback);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "profile", V8Console::profileCallback);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "profileEnd", V8Console::profileEndCallback);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "clear", V8Console::clearCallback);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "table", V8Console::tableCallback);
+
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "keys", V8Console::keysCallback);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "values", V8Console::valuesCallback);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "debug", V8Console::debugFunctionCallback);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "undebug", V8Console::undebugFunctionCallback);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "monitor", V8Console::monitorFunctionCallback);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "unmonitor", V8Console::unmonitorFunctionCallback);
+    createBoundFunctionProperty(context, commandLineAPI, commandLineAPI, "$_", V8Console::lastEvaluationResultCallback);
+
+    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)
 {
     v8::Isolate* isolate = context->GetIsolate();
     console->SetPrivate(context, inspectedContextPrivateKey(isolate), v8::External::New(isolate, nullptr));
 }
 
+bool V8Debugger::isCommandLineAPIMethod(const String16& name)
+{
+    DEFINE_STATIC_LOCAL(protocol::HashSet<String16>, methods, ());
+    if (methods.size() == 0) {
+        const char* members[] = { "$", "$$", "$x", "dir", "dirxml", "keys", "values", "profile", "profileEnd",
+            "monitorEvents", "unmonitorEvents", "inspect", "copy", "clear", "getEventListeners",
+            "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)
+{
+    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();
+}
+
 } // namespace blink