Revert of [inspector] move console to builtins (patchset #9 id:180001 of https://codereview.chromium.org/2785293002/ )
Reason for revert:
Seems to block roll:
https://codereview.chromium.org/2801013002/
See also:
https://build.chromium.org/p/client.v8.fyi/builders/Linux%20Tests%20%28dbg%29%281%29/builds/2731
Original issue's description:
> [inspector] move console to builtins
>
> What will we get:
> - console would be included into snapshot and allow us to reduce time that we spent in contextCreated function (~5 times faster),
> - it allows us to make further small improvement of console methods, e.g. we can implement super quick return from console.assert if first argument is true,
> - console calls are ~ 15% faster.
>
> BUG=v8:6175
> R=dgozman@chromium.org
>
> Review-Url: https://codereview.chromium.org/2785293002
> Cr-Original-Original-Commit-Position: refs/heads/master@{#44353}
> Committed: https://chromium.googlesource.com/v8/v8/+/55905f85d63d75aaa9313e51eb7bede754a8e41c
> Review-Url: https://codereview.chromium.org/2785293002
> Cr-Original-Commit-Position: refs/heads/master@{#44355}
> Committed: https://chromium.googlesource.com/v8/v8/+/cc74ea0bc4fe4a71fa53d08b62cc18d15e01fbb3
> Review-Url: https://codereview.chromium.org/2785293002
> Cr-Commit-Position: refs/heads/master@{#44416}
> Committed: https://chromium.googlesource.com/v8/v8/+/f5dc738cda0336929dcb8eb73b87fdcd01b7c685
TBR=dgozman@chromium.org,kozyatinskiy@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=v8:6175
Review-Url: https://codereview.chromium.org/2801023003
Cr-Commit-Position: refs/heads/master@{#44429}
diff --git a/BUILD.gn b/BUILD.gn
index 61094d4..29df3cc 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -1109,7 +1109,6 @@
"src/builtins/builtins-boolean.cc",
"src/builtins/builtins-call.cc",
"src/builtins/builtins-callsite.cc",
- "src/builtins/builtins-console.cc",
"src/builtins/builtins-constructor.h",
"src/builtins/builtins-dataview.cc",
"src/builtins/builtins-date.cc",
diff --git a/include/v8.h b/include/v8.h
index 3f7a45b..7e96f4f 100644
--- a/include/v8.h
+++ b/include/v8.h
@@ -150,9 +150,6 @@
class GlobalHandles;
} // namespace internal
-namespace debug {
-class ConsoleCallArguments;
-} // namespace debug
// --- Handles ---
@@ -3571,7 +3568,6 @@
protected:
friend class internal::FunctionCallbackArguments;
friend class internal::CustomArguments<FunctionCallbackInfo>;
- friend class debug::ConsoleCallArguments;
static const int kHolderIndex = 0;
static const int kIsolateIndex = 1;
static const int kReturnValueDefaultValueIndex = 2;
diff --git a/src/api.cc b/src/api.cc
index 2ea7212..ae42da4 100644
--- a/src/api.cc
+++ b/src/api.cc
@@ -25,7 +25,6 @@
#include "src/base/safe_conversions.h"
#include "src/base/utils/random-number-generator.h"
#include "src/bootstrapper.h"
-#include "src/builtins/builtins-utils.h"
#include "src/char-predicates-inl.h"
#include "src/code-stubs.h"
#include "src/compiler-dispatcher/compiler-dispatcher.h"
@@ -9574,22 +9573,6 @@
return Utils::ToLocal(handle_scope.CloseAndEscape(fun));
}
-void debug::SetConsoleDelegate(Isolate* v8_isolate, ConsoleDelegate* delegate) {
- i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
- ENTER_V8(isolate);
- isolate->set_console_delegate(delegate);
-}
-
-debug::ConsoleCallArguments::ConsoleCallArguments(
- const v8::FunctionCallbackInfo<v8::Value>& info)
- : v8::FunctionCallbackInfo<v8::Value>(nullptr, info.values_, info.length_) {
-}
-
-debug::ConsoleCallArguments::ConsoleCallArguments(
- internal::BuiltinArguments& args)
- : v8::FunctionCallbackInfo<v8::Value>(nullptr, &args[0] - 1,
- args.length() - 1) {}
-
MaybeLocal<debug::Script> debug::GeneratorObject::Script() {
i::Handle<i::JSGeneratorObject> obj = Utils::OpenHandle(this);
i::Object* maybe_script = obj->function()->shared()->script();
diff --git a/src/bootstrapper.cc b/src/bootstrapper.cc
index 558eeb0..eb06ff1 100644
--- a/src/bootstrapper.cc
+++ b/src/bootstrapper.cc
@@ -2604,54 +2604,6 @@
static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
}
- { // -- C o n s o l e
- Handle<String> name = factory->InternalizeUtf8String("console");
- Handle<JSFunction> cons = factory->NewFunction(name);
- Handle<JSObject> empty = factory->NewJSObject(isolate->object_function());
- JSFunction::SetInstancePrototype(cons, empty);
- Handle<JSObject> console = factory->NewJSObject(cons, TENURED);
- DCHECK(console->IsJSObject());
- JSObject::AddProperty(global, name, console, DONT_ENUM);
- SimpleInstallFunction(console, "debug", Builtins::kConsoleDebug, 1, false);
- SimpleInstallFunction(console, "error", Builtins::kConsoleError, 1, false);
- SimpleInstallFunction(console, "info", Builtins::kConsoleInfo, 1, false);
- SimpleInstallFunction(console, "log", Builtins::kConsoleLog, 1, false);
- SimpleInstallFunction(console, "warn", Builtins::kConsoleWarn, 1, false);
- SimpleInstallFunction(console, "dir", Builtins::kConsoleDir, 1, false);
- SimpleInstallFunction(console, "dirxml", Builtins::kConsoleDirXml, 1,
- false);
- SimpleInstallFunction(console, "table", Builtins::kConsoleTable, 1, false);
- SimpleInstallFunction(console, "trace", Builtins::kConsoleTrace, 1, false);
- SimpleInstallFunction(console, "group", Builtins::kConsoleGroup, 1, false);
- SimpleInstallFunction(console, "groupCollapsed",
- Builtins::kConsoleGroupCollapsed, 1, false);
- SimpleInstallFunction(console, "groupEnd", Builtins::kConsoleGroupEnd, 1,
- false);
- SimpleInstallFunction(console, "clear", Builtins::kConsoleClear, 1, false);
- SimpleInstallFunction(console, "count", Builtins::kConsoleCount, 1, false);
- SimpleInstallFunction(console, "assert", Builtins::kConsoleAssert, 1,
- false);
- SimpleInstallFunction(console, "markTimeline",
- Builtins::kConsoleMarkTimeline, 1, false);
- SimpleInstallFunction(console, "profile", Builtins::kConsoleProfile, 1,
- false);
- SimpleInstallFunction(console, "profileEnd", Builtins::kConsoleProfileEnd,
- 1, false);
- SimpleInstallFunction(console, "timeline", Builtins::kConsoleTimeline, 1,
- false);
- SimpleInstallFunction(console, "timelineEnd", Builtins::kConsoleTimelineEnd,
- 1, false);
- SimpleInstallFunction(console, "time", Builtins::kConsoleTime, 1, false);
- SimpleInstallFunction(console, "timeEnd", Builtins::kConsoleTimeEnd, 1,
- false);
- SimpleInstallFunction(console, "timeStamp", Builtins::kConsoleTimeStamp, 1,
- false);
- JSObject::AddProperty(
- console, factory->to_string_tag_symbol(),
- factory->NewStringFromAsciiChecked("Object"),
- static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY));
- }
-
#ifdef V8_I18N_SUPPORT
{ // -- I n t l
Handle<String> name = factory->InternalizeUtf8String("Intl");
diff --git a/src/builtins/builtins-console.cc b/src/builtins/builtins-console.cc
deleted file mode 100644
index a021c8a..0000000
--- a/src/builtins/builtins-console.cc
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2017 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/builtins/builtins-utils.h"
-#include "src/builtins/builtins.h"
-
-#include "src/debug/interface-types.h"
-#include "src/objects-inl.h"
-
-namespace v8 {
-namespace internal {
-
-// -----------------------------------------------------------------------------
-// Console
-
-#define CONSOLE_METHOD_LIST(V) \
- V(Debug) \
- V(Error) \
- V(Info) \
- V(Log) \
- V(Warn) \
- V(Dir) \
- V(DirXml) \
- V(Table) \
- V(Trace) \
- V(Group) \
- V(GroupCollapsed) \
- V(GroupEnd) \
- V(Clear) \
- V(Count) \
- V(Assert) \
- V(MarkTimeline) \
- V(Profile) \
- V(ProfileEnd) \
- V(Timeline) \
- V(TimelineEnd) \
- V(Time) \
- V(TimeEnd) \
- V(TimeStamp)
-
-#define CONSOLE_BUILTIN_IMPLEMENTATION(name) \
- BUILTIN(Console##name) { \
- HandleScope scope(isolate); \
- if (isolate->console_delegate()) { \
- debug::ConsoleCallArguments wrapper(args); \
- isolate->console_delegate()->name(wrapper); \
- } \
- return isolate->heap()->undefined_value(); \
- }
-CONSOLE_METHOD_LIST(CONSOLE_BUILTIN_IMPLEMENTATION)
-#undef CONSOLE_BUILTIN_IMPLEMENTATION
-
-#undef CONSOLE_METHOD_LIST
-
-} // namespace internal
-} // namespace v8
diff --git a/src/builtins/builtins-definitions.h b/src/builtins/builtins-definitions.h
index b24bb28..78de114 100644
--- a/src/builtins/builtins-definitions.h
+++ b/src/builtins/builtins-definitions.h
@@ -335,31 +335,6 @@
CPP(CallSitePrototypeIsToplevel) \
CPP(CallSitePrototypeToString) \
\
- /* Console */ \
- CPP(ConsoleDebug) \
- CPP(ConsoleError) \
- CPP(ConsoleInfo) \
- CPP(ConsoleLog) \
- CPP(ConsoleWarn) \
- CPP(ConsoleDir) \
- CPP(ConsoleDirXml) \
- CPP(ConsoleTable) \
- CPP(ConsoleTrace) \
- CPP(ConsoleGroup) \
- CPP(ConsoleGroupCollapsed) \
- CPP(ConsoleGroupEnd) \
- CPP(ConsoleClear) \
- CPP(ConsoleCount) \
- CPP(ConsoleAssert) \
- CPP(ConsoleMarkTimeline) \
- CPP(ConsoleProfile) \
- CPP(ConsoleProfileEnd) \
- CPP(ConsoleTimeline) \
- CPP(ConsoleTimelineEnd) \
- CPP(ConsoleTime) \
- CPP(ConsoleTimeEnd) \
- CPP(ConsoleTimeStamp) \
- \
/* DataView */ \
CPP(DataViewConstructor) \
CPP(DataViewConstructor_ConstructStub) \
diff --git a/src/debug/debug-interface.h b/src/debug/debug-interface.h
index fec7663..443e074 100644
--- a/src/debug/debug-interface.h
+++ b/src/debug/debug-interface.h
@@ -207,8 +207,6 @@
Local<Function> GetBuiltin(Isolate* isolate, Builtin builtin);
-void SetConsoleDelegate(Isolate* isolate, ConsoleDelegate* delegate);
-
/**
* Native wrapper around v8::internal::JSGeneratorObject object.
*/
diff --git a/src/debug/interface-types.h b/src/debug/interface-types.h
index 3f82fe6..82eb2f2 100644
--- a/src/debug/interface-types.h
+++ b/src/debug/interface-types.h
@@ -9,15 +9,9 @@
#include <string>
#include <vector>
-#include "include/v8.h"
#include "src/globals.h"
namespace v8 {
-
-namespace internal {
-class BuiltinArguments;
-} // internal
-
namespace debug {
/**
@@ -96,47 +90,6 @@
BreakLocationType type_;
};
-class ConsoleCallArguments : private v8::FunctionCallbackInfo<v8::Value> {
- public:
- int Length() const { return v8::FunctionCallbackInfo<v8::Value>::Length(); }
- V8_INLINE Local<Value> operator[](int i) const {
- return v8::FunctionCallbackInfo<v8::Value>::operator[](i);
- }
-
- explicit ConsoleCallArguments(const v8::FunctionCallbackInfo<v8::Value>&);
- explicit ConsoleCallArguments(internal::BuiltinArguments&);
-};
-
-// v8::FunctionCallbackInfo could be used for getting arguments only. Calling
-// of any other getter will produce a crash.
-class ConsoleDelegate {
- public:
- virtual void Debug(const ConsoleCallArguments& args) {}
- virtual void Error(const ConsoleCallArguments& args) {}
- virtual void Info(const ConsoleCallArguments& args) {}
- virtual void Log(const ConsoleCallArguments& args) {}
- virtual void Warn(const ConsoleCallArguments& args) {}
- virtual void Dir(const ConsoleCallArguments& args) {}
- virtual void DirXml(const ConsoleCallArguments& args) {}
- virtual void Table(const ConsoleCallArguments& args) {}
- virtual void Trace(const ConsoleCallArguments& args) {}
- virtual void Group(const ConsoleCallArguments& args) {}
- virtual void GroupCollapsed(const ConsoleCallArguments& args) {}
- virtual void GroupEnd(const ConsoleCallArguments& args) {}
- virtual void Clear(const ConsoleCallArguments& args) {}
- virtual void Count(const ConsoleCallArguments& args) {}
- virtual void Assert(const ConsoleCallArguments& args) {}
- virtual void MarkTimeline(const ConsoleCallArguments& args) {}
- virtual void Profile(const ConsoleCallArguments& args) {}
- virtual void ProfileEnd(const ConsoleCallArguments& args) {}
- virtual void Timeline(const ConsoleCallArguments& args) {}
- virtual void TimelineEnd(const ConsoleCallArguments& args) {}
- virtual void Time(const ConsoleCallArguments& args) {}
- virtual void TimeEnd(const ConsoleCallArguments& args) {}
- virtual void TimeStamp(const ConsoleCallArguments& args) {}
- virtual ~ConsoleDelegate() = default;
-};
-
} // namespace debug
} // namespace v8
diff --git a/src/inspector/inspected-context.cc b/src/inspector/inspected-context.cc
index 08bb69f..05096837 100644
--- a/src/inspector/inspected-context.cc
+++ b/src/inspector/inspected-context.cc
@@ -27,15 +27,17 @@
v8::Isolate* isolate = m_inspector->isolate();
info.context->SetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex),
v8::Int32::New(isolate, contextId));
- if (!info.hasMemoryOnConsole) return;
- v8::Context::Scope contextScope(info.context);
v8::Local<v8::Object> global = info.context->Global();
- v8::Local<v8::Value> console;
- if (global->Get(info.context, toV8String(m_inspector->isolate(), "console"))
- .ToLocal(&console) &&
- console->IsObject()) {
- m_inspector->console()->installMemoryGetter(
- info.context, v8::Local<v8::Object>::Cast(console));
+ v8::Local<v8::Object> console =
+ m_inspector->console()->createConsole(info.context);
+ if (info.hasMemoryOnConsole) {
+ m_inspector->console()->installMemoryGetter(info.context, console);
+ }
+ if (!global
+ ->Set(info.context, toV8StringInternalized(isolate, "console"),
+ console)
+ .FromMaybe(false)) {
+ return;
}
}
diff --git a/src/inspector/v8-console.cc b/src/inspector/v8-console.cc
index 358b453..69e58df 100644
--- a/src/inspector/v8-console.cc
+++ b/src/inspector/v8-console.cc
@@ -25,11 +25,11 @@
class ConsoleHelper {
public:
- ConsoleHelper(const v8::debug::ConsoleCallArguments& info,
- V8InspectorImpl* inspector)
+ explicit ConsoleHelper(const v8::FunctionCallbackInfo<v8::Value>& info,
+ V8InspectorImpl* inspector)
: m_info(info),
- m_isolate(inspector->isolate()),
- m_context(m_isolate->GetCurrentContext()),
+ m_isolate(info.GetIsolate()),
+ m_context(info.GetIsolate()->GetCurrentContext()),
m_inspector(inspector),
m_contextId(InspectedContext::contextId(m_context)),
m_groupId(m_inspector->contextGroupId(m_contextId)) {}
@@ -145,7 +145,7 @@
}
private:
- const v8::debug::ConsoleCallArguments& m_info;
+ const v8::FunctionCallbackInfo<v8::Value>& m_info;
v8::Isolate* m_isolate;
v8::Local<v8::Context> m_context;
V8InspectorImpl* m_inspector = nullptr;
@@ -190,63 +190,66 @@
V8Console::V8Console(V8InspectorImpl* inspector) : m_inspector(inspector) {}
-void V8Console::Debug(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::debugCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector).reportCall(ConsoleAPIType::kDebug);
}
-void V8Console::Error(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::errorCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector).reportCall(ConsoleAPIType::kError);
}
-void V8Console::Info(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::infoCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector).reportCall(ConsoleAPIType::kInfo);
}
-void V8Console::Log(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::logCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector).reportCall(ConsoleAPIType::kLog);
}
-void V8Console::Warn(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::warnCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector).reportCall(ConsoleAPIType::kWarning);
}
-void V8Console::Dir(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::dirCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector).reportCall(ConsoleAPIType::kDir);
}
-void V8Console::DirXml(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::dirxmlCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector).reportCall(ConsoleAPIType::kDirXML);
}
-void V8Console::Table(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::tableCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector).reportCall(ConsoleAPIType::kTable);
}
-void V8Console::Trace(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::traceCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector)
.reportCallWithDefaultArgument(ConsoleAPIType::kTrace,
String16("console.trace"));
}
-void V8Console::Group(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::groupCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector)
.reportCallWithDefaultArgument(ConsoleAPIType::kStartGroup,
String16("console.group"));
}
-void V8Console::GroupCollapsed(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::groupCollapsedCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector)
.reportCallWithDefaultArgument(ConsoleAPIType::kStartGroupCollapsed,
String16("console.groupCollapsed"));
}
-void V8Console::GroupEnd(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::groupEndCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector)
.reportCallWithDefaultArgument(ConsoleAPIType::kEndGroup,
String16("console.groupEnd"));
}
-void V8Console::Clear(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::clearCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper helper(info, m_inspector);
if (!helper.groupId()) return;
m_inspector->client()->consoleClear(helper.groupId());
@@ -254,7 +257,7 @@
String16("console.clear"));
}
-void V8Console::Count(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::countCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper helper(info, m_inspector);
String16 title = helper.firstArgToString(String16());
String16 identifier;
@@ -277,7 +280,8 @@
title.isEmpty() ? countString : (title + ": " + countString));
}
-void V8Console::Assert(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::assertCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper helper(info, m_inspector);
if (helper.firstArgToBoolean(false)) return;
@@ -285,7 +289,7 @@
for (int i = 1; i < info.Length(); ++i) arguments.push_back(info[i]);
if (info.Length() < 2)
arguments.push_back(
- toV8String(m_inspector->isolate(), String16("console.assert")));
+ toV8String(info.GetIsolate(), String16("console.assert")));
helper.reportCall(ConsoleAPIType::kAssert, arguments);
if (V8DebuggerAgentImpl* debuggerAgent = helper.debuggerAgent())
@@ -293,28 +297,31 @@
protocol::Debugger::Paused::ReasonEnum::Assert, nullptr);
}
-void V8Console::MarkTimeline(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::markTimelineCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector)
.reportDeprecatedCall("V8Console#markTimelineDeprecated",
"'console.markTimeline' is "
"deprecated. Please use "
"'console.timeStamp' instead.");
- TimeStamp(info);
+ timeStampCallback(info);
}
-void V8Console::Profile(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::profileCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper helper(info, m_inspector);
if (V8ProfilerAgentImpl* profilerAgent = helper.profilerAgent())
profilerAgent->consoleProfile(helper.firstArgToString(String16()));
}
-void V8Console::ProfileEnd(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::profileEndCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper helper(info, m_inspector);
if (V8ProfilerAgentImpl* profilerAgent = helper.profilerAgent())
profilerAgent->consoleProfileEnd(helper.firstArgToString(String16()));
}
-static void timeFunction(const v8::debug::ConsoleCallArguments& info,
+static void timeFunction(const v8::FunctionCallbackInfo<v8::Value>& info,
bool timelinePrefix, V8InspectorImpl* inspector) {
ConsoleHelper helper(info, inspector);
String16 protocolTitle = helper.firstArgToString("default");
@@ -323,7 +330,7 @@
helper.consoleMessageStorage()->time(helper.contextId(), protocolTitle);
}
-static void timeEndFunction(const v8::debug::ConsoleCallArguments& info,
+static void timeEndFunction(const v8::FunctionCallbackInfo<v8::Value>& info,
bool timelinePrefix, V8InspectorImpl* inspector) {
ConsoleHelper helper(info, inspector);
String16 protocolTitle = helper.firstArgToString("default");
@@ -336,7 +343,8 @@
helper.reportCallWithArgument(ConsoleAPIType::kTimeEnd, message);
}
-void V8Console::Timeline(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::timelineCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector)
.reportDeprecatedCall("V8Console#timeline",
"'console.timeline' is deprecated. Please use "
@@ -344,7 +352,8 @@
timeFunction(info, true, m_inspector);
}
-void V8Console::TimelineEnd(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::timelineEndCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper(info, m_inspector)
.reportDeprecatedCall("V8Console#timelineEnd",
"'console.timelineEnd' is "
@@ -353,15 +362,17 @@
timeEndFunction(info, true, m_inspector);
}
-void V8Console::Time(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::timeCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
timeFunction(info, false, m_inspector);
}
-void V8Console::TimeEnd(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::timeEndCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& info) {
timeEndFunction(info, false, m_inspector);
}
-void V8Console::TimeStamp(const v8::debug::ConsoleCallArguments& info) {
+void V8Console::timeStampCallback(
+ const v8::FunctionCallbackInfo<v8::Value>& info) {
ConsoleHelper helper(info, m_inspector);
String16 title = helper.firstArgToString(String16());
m_inspector->client()->consoleTimeStamp(toStringView(title));
@@ -389,8 +400,7 @@
v8::Isolate* isolate = info.GetIsolate();
info.GetReturnValue().Set(v8::Array::New(isolate));
- v8::debug::ConsoleCallArguments args(info);
- ConsoleHelper helper(args, m_inspector);
+ ConsoleHelper helper(info, m_inspector);
v8::Local<v8::Object> obj;
if (!helper.firstArgAsObject().ToLocal(&obj)) return;
v8::Local<v8::Array> names;
@@ -404,8 +414,7 @@
v8::Isolate* isolate = info.GetIsolate();
info.GetReturnValue().Set(v8::Array::New(isolate));
- v8::debug::ConsoleCallArguments args(info);
- ConsoleHelper helper(args, m_inspector);
+ ConsoleHelper helper(info, m_inspector);
v8::Local<v8::Object> obj;
if (!helper.firstArgAsObject().ToLocal(&obj)) return;
v8::Local<v8::Array> names;
@@ -444,8 +453,7 @@
void V8Console::debugFunctionCallback(
const v8::FunctionCallbackInfo<v8::Value>& info) {
- v8::debug::ConsoleCallArguments args(info);
- ConsoleHelper helper(args, m_inspector);
+ ConsoleHelper helper(info, m_inspector);
v8::Local<v8::Function> function;
if (!helper.firstArgAsFunction().ToLocal(&function)) return;
setFunctionBreakpoint(helper, function,
@@ -455,8 +463,7 @@
void V8Console::undebugFunctionCallback(
const v8::FunctionCallbackInfo<v8::Value>& info) {
- v8::debug::ConsoleCallArguments args(info);
- ConsoleHelper helper(args, m_inspector);
+ ConsoleHelper helper(info, m_inspector);
v8::Local<v8::Function> function;
if (!helper.firstArgAsFunction().ToLocal(&function)) return;
setFunctionBreakpoint(helper, function,
@@ -466,8 +473,7 @@
void V8Console::monitorFunctionCallback(
const v8::FunctionCallbackInfo<v8::Value>& info) {
- v8::debug::ConsoleCallArguments args(info);
- ConsoleHelper helper(args, m_inspector);
+ ConsoleHelper helper(info, m_inspector);
v8::Local<v8::Function> function;
if (!helper.firstArgAsFunction().ToLocal(&function)) return;
v8::Local<v8::Value> name = function->GetName();
@@ -490,8 +496,7 @@
void V8Console::unmonitorFunctionCallback(
const v8::FunctionCallbackInfo<v8::Value>& info) {
- v8::debug::ConsoleCallArguments args(info);
- ConsoleHelper helper(args, m_inspector);
+ ConsoleHelper helper(info, m_inspector);
v8::Local<v8::Function> function;
if (!helper.firstArgAsFunction().ToLocal(&function)) return;
setFunctionBreakpoint(helper, function,
@@ -501,8 +506,7 @@
void V8Console::lastEvaluationResultCallback(
const v8::FunctionCallbackInfo<v8::Value>& info) {
- v8::debug::ConsoleCallArguments args(info);
- ConsoleHelper helper(args, m_inspector);
+ ConsoleHelper helper(info, m_inspector);
InjectedScript* injectedScript = helper.injectedScript();
if (!injectedScript) return;
info.GetReturnValue().Set(injectedScript->lastEvaluationResult());
@@ -513,8 +517,7 @@
if (info.Length() < 1) return;
if (!copyToClipboard) info.GetReturnValue().Set(info[0]);
- v8::debug::ConsoleCallArguments args(info);
- ConsoleHelper helper(args, inspector);
+ ConsoleHelper helper(info, inspector);
InjectedScript* injectedScript = helper.injectedScript();
if (!injectedScript) return;
std::unique_ptr<protocol::Runtime::RemoteObject> wrappedObject;
@@ -544,8 +547,7 @@
void V8Console::inspectedObject(const v8::FunctionCallbackInfo<v8::Value>& info,
unsigned num) {
DCHECK(num < V8InspectorSessionImpl::kInspectedObjectBufferSize);
- v8::debug::ConsoleCallArguments args(info);
- ConsoleHelper helper(args, m_inspector);
+ ConsoleHelper helper(info, m_inspector);
if (V8InspectorSessionImpl* session = helper.currentSession()) {
V8InspectorSession::Inspectable* object = session->inspectedObject(num);
v8::Isolate* isolate = info.GetIsolate();
@@ -556,6 +558,71 @@
}
}
+v8::Local<v8::Object> V8Console::createConsole(v8::Local<v8::Context> context) {
+ v8::Context::Scope contextScope(context);
+ v8::Isolate* isolate = context->GetIsolate();
+ v8::MicrotasksScope microtasksScope(isolate,
+ v8::MicrotasksScope::kDoNotRunMicrotasks);
+
+ v8::Local<v8::Object> console = v8::Object::New(isolate);
+ bool success =
+ console->SetPrototype(context, v8::Object::New(isolate)).FromMaybe(false);
+ DCHECK(success);
+ USE(success);
+
+ v8::Local<v8::External> data = v8::External::New(isolate, this);
+ createBoundFunctionProperty(context, console, data, "debug",
+ &V8Console::call<&V8Console::debugCallback>);
+ createBoundFunctionProperty(context, console, data, "error",
+ &V8Console::call<&V8Console::errorCallback>);
+ createBoundFunctionProperty(context, console, data, "info",
+ &V8Console::call<&V8Console::infoCallback>);
+ createBoundFunctionProperty(context, console, data, "log",
+ &V8Console::call<&V8Console::logCallback>);
+ createBoundFunctionProperty(context, console, data, "warn",
+ &V8Console::call<&V8Console::warnCallback>);
+ createBoundFunctionProperty(context, console, data, "dir",
+ &V8Console::call<&V8Console::dirCallback>);
+ createBoundFunctionProperty(context, console, data, "dirxml",
+ &V8Console::call<&V8Console::dirxmlCallback>);
+ createBoundFunctionProperty(context, console, data, "table",
+ &V8Console::call<&V8Console::tableCallback>);
+ createBoundFunctionProperty(context, console, data, "trace",
+ &V8Console::call<&V8Console::traceCallback>);
+ createBoundFunctionProperty(context, console, data, "group",
+ &V8Console::call<&V8Console::groupCallback>);
+ createBoundFunctionProperty(
+ context, console, data, "groupCollapsed",
+ &V8Console::call<&V8Console::groupCollapsedCallback>);
+ createBoundFunctionProperty(context, console, data, "groupEnd",
+ &V8Console::call<&V8Console::groupEndCallback>);
+ createBoundFunctionProperty(context, console, data, "clear",
+ &V8Console::call<&V8Console::clearCallback>);
+ createBoundFunctionProperty(context, console, data, "count",
+ &V8Console::call<&V8Console::countCallback>);
+ createBoundFunctionProperty(context, console, data, "assert",
+ &V8Console::call<&V8Console::assertCallback>);
+ createBoundFunctionProperty(
+ context, console, data, "markTimeline",
+ &V8Console::call<&V8Console::markTimelineCallback>);
+ createBoundFunctionProperty(context, console, data, "profile",
+ &V8Console::call<&V8Console::profileCallback>);
+ createBoundFunctionProperty(context, console, data, "profileEnd",
+ &V8Console::call<&V8Console::profileEndCallback>);
+ createBoundFunctionProperty(context, console, data, "timeline",
+ &V8Console::call<&V8Console::timelineCallback>);
+ createBoundFunctionProperty(
+ context, console, data, "timelineEnd",
+ &V8Console::call<&V8Console::timelineEndCallback>);
+ createBoundFunctionProperty(context, console, data, "time",
+ &V8Console::call<&V8Console::timeCallback>);
+ createBoundFunctionProperty(context, console, data, "timeEnd",
+ &V8Console::call<&V8Console::timeEndCallback>);
+ createBoundFunctionProperty(context, console, data, "timeStamp",
+ &V8Console::call<&V8Console::timeStampCallback>);
+ return console;
+}
+
void V8Console::installMemoryGetter(v8::Local<v8::Context> context,
v8::Local<v8::Object> console) {
v8::Isolate* isolate = context->GetIsolate();
@@ -587,24 +654,24 @@
v8::Local<v8::External> data = v8::External::New(isolate, this);
createBoundFunctionProperty(context, commandLineAPI, data, "dir",
- &V8Console::call<&V8Console::Dir>,
+ &V8Console::call<&V8Console::dirCallback>,
"function dir(value) { [Command Line API] }");
createBoundFunctionProperty(context, commandLineAPI, data, "dirxml",
- &V8Console::call<&V8Console::DirXml>,
+ &V8Console::call<&V8Console::dirxmlCallback>,
"function dirxml(value) { [Command Line API] }");
createBoundFunctionProperty(context, commandLineAPI, data, "profile",
- &V8Console::call<&V8Console::Profile>,
+ &V8Console::call<&V8Console::profileCallback>,
"function profile(title) { [Command Line API] }");
createBoundFunctionProperty(
context, commandLineAPI, data, "profileEnd",
- &V8Console::call<&V8Console::ProfileEnd>,
+ &V8Console::call<&V8Console::profileEndCallback>,
"function profileEnd(title) { [Command Line API] }");
createBoundFunctionProperty(context, commandLineAPI, data, "clear",
- &V8Console::call<&V8Console::Clear>,
+ &V8Console::call<&V8Console::clearCallback>,
"function clear() { [Command Line API] }");
createBoundFunctionProperty(
context, commandLineAPI, data, "table",
- &V8Console::call<&V8Console::Table>,
+ &V8Console::call<&V8Console::tableCallback>,
"function table(data, [columns]) { [Command Line API] }");
createBoundFunctionProperty(context, commandLineAPI, data, "keys",
diff --git a/src/inspector/v8-console.h b/src/inspector/v8-console.h
index e31133c..0b833b3 100644
--- a/src/inspector/v8-console.h
+++ b/src/inspector/v8-console.h
@@ -8,7 +8,6 @@
#include "src/base/macros.h"
#include "include/v8.h"
-#include "src/debug/interface-types.h"
namespace v8_inspector {
@@ -17,8 +16,9 @@
// Console API
// https://console.spec.whatwg.org/#console-interface
-class V8Console : public v8::debug::ConsoleDelegate {
+class V8Console {
public:
+ v8::Local<v8::Object> createConsole(v8::Local<v8::Context> context);
v8::Local<v8::Object> createCommandLineAPI(v8::Local<v8::Context> context);
void installMemoryGetter(v8::Local<v8::Context> context,
v8::Local<v8::Object> console);
@@ -49,29 +49,29 @@
explicit V8Console(V8InspectorImpl* inspector);
private:
- void Debug(const v8::debug::ConsoleCallArguments&) override;
- void Error(const v8::debug::ConsoleCallArguments&) override;
- void Info(const v8::debug::ConsoleCallArguments&) override;
- void Log(const v8::debug::ConsoleCallArguments&) override;
- void Warn(const v8::debug::ConsoleCallArguments&) override;
- void Dir(const v8::debug::ConsoleCallArguments&) override;
- void DirXml(const v8::debug::ConsoleCallArguments&) override;
- void Table(const v8::debug::ConsoleCallArguments&) override;
- void Trace(const v8::debug::ConsoleCallArguments&) override;
- void Group(const v8::debug::ConsoleCallArguments&) override;
- void GroupCollapsed(const v8::debug::ConsoleCallArguments&) override;
- void GroupEnd(const v8::debug::ConsoleCallArguments&) override;
- void Clear(const v8::debug::ConsoleCallArguments&) override;
- void Count(const v8::debug::ConsoleCallArguments&) override;
- void Assert(const v8::debug::ConsoleCallArguments&) override;
- void MarkTimeline(const v8::debug::ConsoleCallArguments&) override;
- void Profile(const v8::debug::ConsoleCallArguments&) override;
- void ProfileEnd(const v8::debug::ConsoleCallArguments&) override;
- void Timeline(const v8::debug::ConsoleCallArguments&) override;
- void TimelineEnd(const v8::debug::ConsoleCallArguments&) override;
- void Time(const v8::debug::ConsoleCallArguments&) override;
- void TimeEnd(const v8::debug::ConsoleCallArguments&) override;
- void TimeStamp(const v8::debug::ConsoleCallArguments&) override;
+ void debugCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void errorCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void infoCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void logCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void warnCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void dirCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void dirxmlCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void tableCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void traceCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void groupCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void groupCollapsedCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void groupEndCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void clearCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void countCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void assertCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void markTimelineCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void profileCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void profileEndCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void timelineCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void timelineEndCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void timeCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void timeEndCallback(const v8::FunctionCallbackInfo<v8::Value>&);
+ void timeStampCallback(const v8::FunctionCallbackInfo<v8::Value>&);
template <void (V8Console::*func)(const v8::FunctionCallbackInfo<v8::Value>&)>
static void call(const v8::FunctionCallbackInfo<v8::Value>& info) {
@@ -79,13 +79,6 @@
static_cast<V8Console*>(info.Data().As<v8::External>()->Value());
(console->*func)(info);
}
- template <void (V8Console::*func)(const v8::debug::ConsoleCallArguments&)>
- static void call(const v8::FunctionCallbackInfo<v8::Value>& info) {
- V8Console* console =
- static_cast<V8Console*>(info.Data().As<v8::External>()->Value());
- v8::debug::ConsoleCallArguments args(info);
- (console->*func)(args);
- }
// TODO(foolip): There is no spec for the Memory Info API, see blink-dev:
// https://groups.google.com/a/chromium.org/d/msg/blink-dev/g5YRCGpC9vs/b4OJz71NmPwJ
diff --git a/src/inspector/v8-inspector-impl.cc b/src/inspector/v8-inspector-impl.cc
index 3c55507..705fd79 100644
--- a/src/inspector/v8-inspector-impl.cc
+++ b/src/inspector/v8-inspector-impl.cc
@@ -56,13 +56,9 @@
m_debugger(new V8Debugger(isolate, this)),
m_capturingStackTracesCount(0),
m_lastExceptionId(0),
- m_lastContextId(0) {
- v8::debug::SetConsoleDelegate(m_isolate, console());
-}
+ m_lastContextId(0) {}
-V8InspectorImpl::~V8InspectorImpl() {
- v8::debug::SetConsoleDelegate(m_isolate, nullptr);
-}
+V8InspectorImpl::~V8InspectorImpl() {}
int V8InspectorImpl::contextGroupId(v8::Local<v8::Context> context) {
return contextGroupId(InspectedContext::contextId(context));
diff --git a/src/isolate.h b/src/isolate.h
index 29d63ce..ae8d71b 100644
--- a/src/isolate.h
+++ b/src/isolate.h
@@ -32,10 +32,6 @@
class RandomNumberGenerator;
}
-namespace debug {
-class ConsoleDelegate;
-}
-
namespace internal {
class AccessCompilerData;
@@ -741,11 +737,6 @@
return MaybeHandle<T>();
}
- void set_console_delegate(debug::ConsoleDelegate* delegate) {
- console_delegate_ = delegate;
- }
- debug::ConsoleDelegate* console_delegate() { return console_delegate_; }
-
// Re-throw an exception. This involves no error reporting since error
// reporting was handled when the exception was thrown originally.
Object* ReThrow(Object* exception);
@@ -1541,8 +1532,6 @@
CancelableTaskManager* cancelable_task_manager_;
- debug::ConsoleDelegate* console_delegate_ = nullptr;
-
v8::Isolate::AbortOnUncaughtExceptionCallback
abort_on_uncaught_exception_callback_;
diff --git a/src/v8.gyp b/src/v8.gyp
index 23c296f..8be85f7 100644
--- a/src/v8.gyp
+++ b/src/v8.gyp
@@ -493,7 +493,6 @@
'builtins/builtins-boolean-gen.cc',
'builtins/builtins-call.cc',
'builtins/builtins-callsite.cc',
- 'builtins/builtins-console.cc',
'builtins/builtins-constructor-gen.cc',
'builtins/builtins-constructor-gen.h',
'builtins/builtins-constructor.h',
diff --git a/test/inspector/inspector-impl.cc b/test/inspector/inspector-impl.cc
index d1ae71f..ddf1b13 100644
--- a/test/inspector/inspector-impl.cc
+++ b/test/inspector/inspector-impl.cc
@@ -207,7 +207,6 @@
states_[it.first] = it.second->stateJSON();
}
sessions_.clear();
- inspector_.reset();
}
void InspectorClientImpl::scheduleCreateContextGroup(
diff --git a/test/inspector/runtime/console-spec-expected.txt b/test/inspector/runtime/console-spec-expected.txt
deleted file mode 100644
index 74dcfa2..0000000
--- a/test/inspector/runtime/console-spec-expected.txt
+++ /dev/null
@@ -1,20 +0,0 @@
-
-Running test: consoleExistsOnGlobal
-true
-
-Running test: consoleHasRightPropertyDescriptor
-{
- configurable : true
- enumerable : false
- value : <value>
- writable : true
-}
-
-Running test: ConsoleNotExistsOnGlobal
-false
-
-Running test: prototypeChainMustBeCorrect
-true
-
-Running test: consoleToString
-[object Object]
diff --git a/test/inspector/runtime/console-spec.js b/test/inspector/runtime/console-spec.js
deleted file mode 100644
index 6644d29..0000000
--- a/test/inspector/runtime/console-spec.js
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2017 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.
-
-InspectorTest.addScript(`
-var self = this;
-function checkPrototype() {
- const prototype1 = Object.getPrototypeOf(console);
- const prototype2 = Object.getPrototypeOf(prototype1);
- if (Object.getOwnPropertyNames(prototype1).length !== 0)
- return "false: The [[Prototype]] must have no properties";
- if (prototype2 !== Object.prototype)
- return "false: The [[Prototype]]'s [[Prototype]] must be %ObjectPrototype%";
- return "true";
-}
-`);
-
-InspectorTest.runAsyncTestSuite([
- async function consoleExistsOnGlobal() {
- let message = await Protocol.Runtime.evaluate({
- expression: 'self.hasOwnProperty(\'console\')', returnByValue: true});
- InspectorTest.log(message.result.result.value);
- },
-
- async function consoleHasRightPropertyDescriptor() {
- let message = await Protocol.Runtime.evaluate({
- expression: 'Object.getOwnPropertyDescriptor(self, \'console\')',
- returnByValue: true});
- let result = message.result.result.value;
- result.value = '<value>';
- InspectorTest.logObject(result);
- },
-
- async function ConsoleNotExistsOnGlobal() {
- let message = await Protocol.Runtime.evaluate({
- expression: '\'Console\' in self', returnByValue: true})
- InspectorTest.log(message.result.result.value);
- },
-
- async function prototypeChainMustBeCorrect() {
- let message = await Protocol.Runtime.evaluate({
- expression: "checkPrototype()", returnByValue: true });
- InspectorTest.log(message.result.result.value);
- },
-
- async function consoleToString() {
- let message = await Protocol.Runtime.evaluate({
- expression: 'console.toString()', returnByValue: true})
- InspectorTest.log(message.result.result.value);
- }
-]);
