2017-11-05 07:33:05 +00:00
|
|
|
Checks Debugger.scheduleStepIntoAsync.
|
|
|
|
|
|
|
|
Running test: testScheduleErrors
|
|
|
|
paused at:
|
|
|
|
function testNoScheduledTask() {
|
|
|
|
#debugger;
|
|
|
|
return 42;
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
#return 42;
|
|
|
|
}
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
return 42;#
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Running test: testSimple
|
|
|
|
paused at:
|
|
|
|
function testSimple() {
|
|
|
|
#debugger;
|
|
|
|
Promise.resolve().then(v => v * 2);
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
#Promise.resolve().then(v => v * 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
Promise.resolve().#then(v => v * 2);
|
|
|
|
}
|
|
|
|
|
2017-11-21 19:34:34 +00:00
|
|
|
asyncCallStackTraceId is set
|
2017-11-05 07:33:05 +00:00
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
[inspector] use interrupt for pause only as last resort
With this CL we use interrupt for pause in two cases:
- when we process Debugger.pause on interruption,
- when we would like to break as soon as possible after OOM.
In all other cases, e.g. for async step into we use break
on function call by calling StepIn debugger action.
In mentioned cases we should not actually use interrupt as well:
- Debugger.pause in this case scheduled using interrupt and we
may just break right now without requesting another interrupt,
unfortunately blink side is not ready,
- we should use more reliable way to break right after near OOM
callback, otherwise we can get this callback, increase limit,
request break on next interrupt, before interrupt get another
huge memory allocation and crash.
There are couple advantages:
- we get much better break locations for async stepping
(see inspector tests expectations),
- we can remove DEBUG_BREAK interruption
(it should speedup blackboxing with async tasks, see
removed todo in debug.cc for details)
- it is required preparation step for async step out,
(see https://chromium-review.googlesource.com/c/v8/v8/+/1054618)
Bug: v8:7753
Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Iabd7627dbffa9a0eab1736064caf589d02591926
Reviewed-on: https://chromium-review.googlesource.com/1054155
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53439}
2018-05-29 14:54:08 +00:00
|
|
|
Promise.resolve().then(v => v #* 2);
|
2017-11-05 07:33:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Running test: testNotResolvedPromise
|
|
|
|
paused at:
|
|
|
|
var p = new Promise(resolve => resolveCallback = resolve);
|
|
|
|
#debugger;
|
|
|
|
p.then(v => v * 2);
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
p.#then(v => v * 2);
|
|
|
|
resolveCallback();
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
p.#then(v => v * 2);
|
|
|
|
resolveCallback();
|
|
|
|
|
2017-11-21 19:34:34 +00:00
|
|
|
asyncCallStackTraceId is set
|
2017-11-05 07:33:05 +00:00
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
[inspector] use interrupt for pause only as last resort
With this CL we use interrupt for pause in two cases:
- when we process Debugger.pause on interruption,
- when we would like to break as soon as possible after OOM.
In all other cases, e.g. for async step into we use break
on function call by calling StepIn debugger action.
In mentioned cases we should not actually use interrupt as well:
- Debugger.pause in this case scheduled using interrupt and we
may just break right now without requesting another interrupt,
unfortunately blink side is not ready,
- we should use more reliable way to break right after near OOM
callback, otherwise we can get this callback, increase limit,
request break on next interrupt, before interrupt get another
huge memory allocation and crash.
There are couple advantages:
- we get much better break locations for async stepping
(see inspector tests expectations),
- we can remove DEBUG_BREAK interruption
(it should speedup blackboxing with async tasks, see
removed todo in debug.cc for details)
- it is required preparation step for async step out,
(see https://chromium-review.googlesource.com/c/v8/v8/+/1054618)
Bug: v8:7753
Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Iabd7627dbffa9a0eab1736064caf589d02591926
Reviewed-on: https://chromium-review.googlesource.com/1054155
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53439}
2018-05-29 14:54:08 +00:00
|
|
|
p.then(v => v #* 2);
|
2017-11-05 07:33:05 +00:00
|
|
|
resolveCallback();
|
|
|
|
|
|
|
|
|
|
|
|
Running test: testTwoAsyncTasks
|
|
|
|
paused at:
|
|
|
|
function testTwoAsyncTasks() {
|
|
|
|
#debugger;
|
|
|
|
Promise.resolve().then(v => v * 2);
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
#Promise.resolve().then(v => v * 2);
|
|
|
|
Promise.resolve().then(v => v * 4);
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
Promise.resolve().#then(v => v * 2);
|
|
|
|
Promise.resolve().then(v => v * 4);
|
|
|
|
|
2017-11-21 19:34:34 +00:00
|
|
|
asyncCallStackTraceId is set
|
2017-11-05 07:33:05 +00:00
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
[inspector] use interrupt for pause only as last resort
With this CL we use interrupt for pause in two cases:
- when we process Debugger.pause on interruption,
- when we would like to break as soon as possible after OOM.
In all other cases, e.g. for async step into we use break
on function call by calling StepIn debugger action.
In mentioned cases we should not actually use interrupt as well:
- Debugger.pause in this case scheduled using interrupt and we
may just break right now without requesting another interrupt,
unfortunately blink side is not ready,
- we should use more reliable way to break right after near OOM
callback, otherwise we can get this callback, increase limit,
request break on next interrupt, before interrupt get another
huge memory allocation and crash.
There are couple advantages:
- we get much better break locations for async stepping
(see inspector tests expectations),
- we can remove DEBUG_BREAK interruption
(it should speedup blackboxing with async tasks, see
removed todo in debug.cc for details)
- it is required preparation step for async step out,
(see https://chromium-review.googlesource.com/c/v8/v8/+/1054618)
Bug: v8:7753
Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Iabd7627dbffa9a0eab1736064caf589d02591926
Reviewed-on: https://chromium-review.googlesource.com/1054155
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53439}
2018-05-29 14:54:08 +00:00
|
|
|
Promise.resolve().then(v => v #* 2);
|
2017-11-05 07:33:05 +00:00
|
|
|
Promise.resolve().then(v => v * 4);
|
|
|
|
|
|
|
|
|
|
|
|
Running test: testTwoTasksAndGoToSecond
|
|
|
|
paused at:
|
|
|
|
function testTwoAsyncTasks() {
|
|
|
|
#debugger;
|
|
|
|
Promise.resolve().then(v => v * 2);
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
#Promise.resolve().then(v => v * 2);
|
|
|
|
Promise.resolve().then(v => v * 4);
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
Promise.resolve().then(v => v * 2);
|
|
|
|
#Promise.resolve().then(v => v * 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
Promise.resolve().then(v => v * 2);
|
|
|
|
Promise.resolve().#then(v => v * 4);
|
|
|
|
}
|
|
|
|
|
2017-11-21 19:34:34 +00:00
|
|
|
asyncCallStackTraceId is set
|
2017-11-05 07:33:05 +00:00
|
|
|
|
|
|
|
paused at:
|
|
|
|
Promise.resolve().then(v => v * 2);
|
[inspector] use interrupt for pause only as last resort
With this CL we use interrupt for pause in two cases:
- when we process Debugger.pause on interruption,
- when we would like to break as soon as possible after OOM.
In all other cases, e.g. for async step into we use break
on function call by calling StepIn debugger action.
In mentioned cases we should not actually use interrupt as well:
- Debugger.pause in this case scheduled using interrupt and we
may just break right now without requesting another interrupt,
unfortunately blink side is not ready,
- we should use more reliable way to break right after near OOM
callback, otherwise we can get this callback, increase limit,
request break on next interrupt, before interrupt get another
huge memory allocation and crash.
There are couple advantages:
- we get much better break locations for async stepping
(see inspector tests expectations),
- we can remove DEBUG_BREAK interruption
(it should speedup blackboxing with async tasks, see
removed todo in debug.cc for details)
- it is required preparation step for async step out,
(see https://chromium-review.googlesource.com/c/v8/v8/+/1054618)
Bug: v8:7753
Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Iabd7627dbffa9a0eab1736064caf589d02591926
Reviewed-on: https://chromium-review.googlesource.com/1054155
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53439}
2018-05-29 14:54:08 +00:00
|
|
|
Promise.resolve().then(v => v #* 4);
|
2017-11-05 07:33:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Running test: testTwoAsyncTasksWithBreak
|
|
|
|
paused at:
|
|
|
|
function testTwoAsyncTasksWithBreak() {
|
|
|
|
#debugger;
|
|
|
|
Promise.resolve().then(v => v * 2);
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
#Promise.resolve().then(v => v * 2);
|
|
|
|
debugger;
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
Promise.resolve().#then(v => v * 2);
|
|
|
|
debugger;
|
|
|
|
|
2017-11-21 19:34:34 +00:00
|
|
|
asyncCallStackTraceId is set
|
2017-11-05 07:33:05 +00:00
|
|
|
|
|
|
|
paused at:
|
|
|
|
Promise.resolve().then(v => v * 2);
|
|
|
|
#debugger;
|
|
|
|
Promise.resolve().then(v => v * 4);
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
#Promise.resolve().then(v => v * 4);
|
|
|
|
}
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
Promise.resolve().#then(v => v * 4);
|
|
|
|
}
|
|
|
|
|
2017-11-21 19:34:34 +00:00
|
|
|
asyncCallStackTraceId is set
|
2017-11-05 07:33:05 +00:00
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
[inspector] use interrupt for pause only as last resort
With this CL we use interrupt for pause in two cases:
- when we process Debugger.pause on interruption,
- when we would like to break as soon as possible after OOM.
In all other cases, e.g. for async step into we use break
on function call by calling StepIn debugger action.
In mentioned cases we should not actually use interrupt as well:
- Debugger.pause in this case scheduled using interrupt and we
may just break right now without requesting another interrupt,
unfortunately blink side is not ready,
- we should use more reliable way to break right after near OOM
callback, otherwise we can get this callback, increase limit,
request break on next interrupt, before interrupt get another
huge memory allocation and crash.
There are couple advantages:
- we get much better break locations for async stepping
(see inspector tests expectations),
- we can remove DEBUG_BREAK interruption
(it should speedup blackboxing with async tasks, see
removed todo in debug.cc for details)
- it is required preparation step for async step out,
(see https://chromium-review.googlesource.com/c/v8/v8/+/1054618)
Bug: v8:7753
Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Iabd7627dbffa9a0eab1736064caf589d02591926
Reviewed-on: https://chromium-review.googlesource.com/1054155
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53439}
2018-05-29 14:54:08 +00:00
|
|
|
Promise.resolve().then(v => v #* 4);
|
2017-11-05 07:33:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Running test: testPromiseAll
|
|
|
|
paused at:
|
|
|
|
function testPromiseAll() {
|
|
|
|
#debugger;
|
|
|
|
Promise.all([ Promise.resolve(), Promise.resolve() ]).then(v => v * 2);
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
#Promise.all([ Promise.resolve(), Promise.resolve() ]).then(v => v * 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
Promise.all([ Promise.resolve(), Promise.resolve() ]).#then(v => v * 2);
|
|
|
|
}
|
|
|
|
|
2017-11-21 19:34:34 +00:00
|
|
|
asyncCallStackTraceId is set
|
2017-11-05 07:33:05 +00:00
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
[inspector] use interrupt for pause only as last resort
With this CL we use interrupt for pause in two cases:
- when we process Debugger.pause on interruption,
- when we would like to break as soon as possible after OOM.
In all other cases, e.g. for async step into we use break
on function call by calling StepIn debugger action.
In mentioned cases we should not actually use interrupt as well:
- Debugger.pause in this case scheduled using interrupt and we
may just break right now without requesting another interrupt,
unfortunately blink side is not ready,
- we should use more reliable way to break right after near OOM
callback, otherwise we can get this callback, increase limit,
request break on next interrupt, before interrupt get another
huge memory allocation and crash.
There are couple advantages:
- we get much better break locations for async stepping
(see inspector tests expectations),
- we can remove DEBUG_BREAK interruption
(it should speedup blackboxing with async tasks, see
removed todo in debug.cc for details)
- it is required preparation step for async step out,
(see https://chromium-review.googlesource.com/c/v8/v8/+/1054618)
Bug: v8:7753
Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Iabd7627dbffa9a0eab1736064caf589d02591926
Reviewed-on: https://chromium-review.googlesource.com/1054155
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53439}
2018-05-29 14:54:08 +00:00
|
|
|
Promise.all([ Promise.resolve(), Promise.resolve() ]).then(v => v #* 2);
|
2017-11-05 07:33:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Running test: testWithBlackboxedCode
|
|
|
|
paused at:
|
|
|
|
function testBlackboxedCreatePromise() {
|
|
|
|
#debugger;
|
|
|
|
createPromise().then(v => v * 2);
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
#createPromise().then(v => v * 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
createPromise().#then(v => v * 2);
|
|
|
|
}
|
|
|
|
|
2017-11-21 19:34:34 +00:00
|
|
|
asyncCallStackTraceId is set
|
2017-11-05 07:33:05 +00:00
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
[inspector] use interrupt for pause only as last resort
With this CL we use interrupt for pause in two cases:
- when we process Debugger.pause on interruption,
- when we would like to break as soon as possible after OOM.
In all other cases, e.g. for async step into we use break
on function call by calling StepIn debugger action.
In mentioned cases we should not actually use interrupt as well:
- Debugger.pause in this case scheduled using interrupt and we
may just break right now without requesting another interrupt,
unfortunately blink side is not ready,
- we should use more reliable way to break right after near OOM
callback, otherwise we can get this callback, increase limit,
request break on next interrupt, before interrupt get another
huge memory allocation and crash.
There are couple advantages:
- we get much better break locations for async stepping
(see inspector tests expectations),
- we can remove DEBUG_BREAK interruption
(it should speedup blackboxing with async tasks, see
removed todo in debug.cc for details)
- it is required preparation step for async step out,
(see https://chromium-review.googlesource.com/c/v8/v8/+/1054618)
Bug: v8:7753
Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Iabd7627dbffa9a0eab1736064caf589d02591926
Reviewed-on: https://chromium-review.googlesource.com/1054155
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53439}
2018-05-29 14:54:08 +00:00
|
|
|
createPromise().then(v => v #* 2);
|
2017-11-05 07:33:05 +00:00
|
|
|
}
|
|
|
|
|
2017-12-14 22:24:15 +00:00
|
|
|
|
|
|
|
Running test: testWithBlackboxedCode
|
|
|
|
paused at:
|
|
|
|
function testBlackboxedCreatePromise() {
|
|
|
|
#debugger;
|
|
|
|
createPromise().then(v => v * 2);
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
#createPromise().then(v => v * 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
createPromise().#then(v => v * 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
asyncCallStackTraceId is set
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
[inspector] use interrupt for pause only as last resort
With this CL we use interrupt for pause in two cases:
- when we process Debugger.pause on interruption,
- when we would like to break as soon as possible after OOM.
In all other cases, e.g. for async step into we use break
on function call by calling StepIn debugger action.
In mentioned cases we should not actually use interrupt as well:
- Debugger.pause in this case scheduled using interrupt and we
may just break right now without requesting another interrupt,
unfortunately blink side is not ready,
- we should use more reliable way to break right after near OOM
callback, otherwise we can get this callback, increase limit,
request break on next interrupt, before interrupt get another
huge memory allocation and crash.
There are couple advantages:
- we get much better break locations for async stepping
(see inspector tests expectations),
- we can remove DEBUG_BREAK interruption
(it should speedup blackboxing with async tasks, see
removed todo in debug.cc for details)
- it is required preparation step for async step out,
(see https://chromium-review.googlesource.com/c/v8/v8/+/1054618)
Bug: v8:7753
Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Iabd7627dbffa9a0eab1736064caf589d02591926
Reviewed-on: https://chromium-review.googlesource.com/1054155
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53439}
2018-05-29 14:54:08 +00:00
|
|
|
createPromise().then(v => v #* 2);
|
2017-12-14 22:24:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Running test: testAsyncFunction
|
|
|
|
paused at:
|
|
|
|
async function testAsyncFunction() {
|
|
|
|
#debugger;
|
|
|
|
foo();
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
debugger;
|
|
|
|
#foo();
|
|
|
|
await foo();
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
async function foo() {
|
|
|
|
#return 42;
|
|
|
|
}
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
foo();
|
|
|
|
await #foo();
|
|
|
|
foo().then(boo);
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
async function foo() {
|
|
|
|
#return 42;
|
|
|
|
}
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
await foo();
|
|
|
|
#foo().then(boo);
|
|
|
|
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
async function foo() {
|
|
|
|
#return 42;
|
|
|
|
}
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
await foo();
|
|
|
|
foo().#then(boo);
|
|
|
|
|
|
|
|
|
|
|
|
paused at:
|
|
|
|
await foo();
|
|
|
|
foo().#then(boo);
|
|
|
|
|
|
|
|
|
|
|
|
asyncCallStackTraceId is set
|
|
|
|
|
|
|
|
paused at:
|
[inspector] use interrupt for pause only as last resort
With this CL we use interrupt for pause in two cases:
- when we process Debugger.pause on interruption,
- when we would like to break as soon as possible after OOM.
In all other cases, e.g. for async step into we use break
on function call by calling StepIn debugger action.
In mentioned cases we should not actually use interrupt as well:
- Debugger.pause in this case scheduled using interrupt and we
may just break right now without requesting another interrupt,
unfortunately blink side is not ready,
- we should use more reliable way to break right after near OOM
callback, otherwise we can get this callback, increase limit,
request break on next interrupt, before interrupt get another
huge memory allocation and crash.
There are couple advantages:
- we get much better break locations for async stepping
(see inspector tests expectations),
- we can remove DEBUG_BREAK interruption
(it should speedup blackboxing with async tasks, see
removed todo in debug.cc for details)
- it is required preparation step for async step out,
(see https://chromium-review.googlesource.com/c/v8/v8/+/1054618)
Bug: v8:7753
Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: Iabd7627dbffa9a0eab1736064caf589d02591926
Reviewed-on: https://chromium-review.googlesource.com/1054155
Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Dmitry Gozman <dgozman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#53439}
2018-05-29 14:54:08 +00:00
|
|
|
function boo() {
|
|
|
|
#}
|
|
|
|
}
|
2017-12-14 22:24:15 +00:00
|
|
|
|