AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
84bad8ec6f
v8/test/inspector/debugger/async-stack-for-promise-expected.txt

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

134 lines
3.0 KiB
Plaintext
Raw Normal View History

[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
Checks that async chains for promises are correct.
Running test: testPromise
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
promise (test.js:19:14)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testPromise.js:0:0)
Running test: testPromiseResolvedBySetTimeout
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
promiseResolvedBySetTimeout (test.js:27:14)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testPromiseResolvedBySetTimeout.js:0:0)
Running test: testPromiseAll
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
promiseAll (test.js:37:35)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testPromiseAll.js:0:0)
Running test: testPromiseAllReverseOrder
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
promiseAllReverseOrder (test.js:48:35)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testPromiseAllReverseOrder.js:0:0)
Running test: testPromiseRace
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
promiseRace (test.js:59:36)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testPromiseRace.js:0:0)
Running test: testTwoChainedCallbacks
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
twoChainedCallbacks (test.js:68:14)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testTwoChainedCallbacks.js:0:0)
foo2 (test.js:13:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
twoChainedCallbacks (test.js:68:25)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testTwoChainedCallbacks.js:0:0)
Running test: testPromiseResolve
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
promiseResolve (test.js:74:27)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testPromiseResolve.js:0:0)
foo2 (test.js:13:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
promiseResolve (test.js:74:38)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testPromiseResolve.js:0:0)
Running test: testThenableJobResolvedInSetTimeout
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
thenableJobResolvedInSetTimeout (test.js:86:40)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testThenableJobResolvedInSetTimeout.js:0:0)
Running test: testThenableJobResolvedInSetTimeoutWithStack
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
thenableJobResolvedInSetTimeoutWithStack (test.js:104:40)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testThenableJobResolvedInSetTimeoutWithStack.js:0:0)
Running test: testThenableJobResolvedByPromise
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
thenableJobResolvedByPromise (test.js:118:40)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testThenableJobResolvedByPromise.js:0:0)
Running test: testThenableJobResolvedByPromiseWithStack
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
thenableJobResolvedByPromiseWithStack (test.js:136:40)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testThenableJobResolvedByPromiseWithStack.js:0:0)
Running test: testLateThenCallback
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
lateThenCallback (test.js:145:12)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testLateThenCallback.js:0:0)
Running test: testComplex
inner1 (test.js:154:6)
foo1 (test.js:156:4)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
complex (test.js:202:5)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testComplex.js:0:0)
[parser] Create arrow function scopes while parsing the head This simplifies NextArrowFunctionInfo, allows us to Scope::Snapshot::Reparent directly rather than moving it, and allows us to skip reparenting in the simple parameter arrow function cases. This CL additionally fixes arrow function name inferring. Change-Id: Ie3e5ea778f3d7b84b2a10d4f4ff73931cfc9384a Reviewed-on: https://chromium-review.googlesource.com/c/1386147 Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Toon Verwaest <verwaest@chromium.org> Cr-Commit-Position: refs/heads/master@{#58405}
2018-12-20 13:17:44 +00:00
(anonymous) (test.js:207:8)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[parser] Create arrow function scopes while parsing the head This simplifies NextArrowFunctionInfo, allows us to Scope::Snapshot::Reparent directly rather than moving it, and allows us to skip reparenting in the simple parameter arrow function cases. This CL additionally fixes arrow function name inferring. Change-Id: Ie3e5ea778f3d7b84b2a10d4f4ff73931cfc9384a Reviewed-on: https://chromium-review.googlesource.com/c/1386147 Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Toon Verwaest <verwaest@chromium.org> Cr-Commit-Position: refs/heads/master@{#58405}
2018-12-20 13:17:44 +00:00
(anonymous) (test.js:206:8)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.then --
[parser] Create arrow function scopes while parsing the head This simplifies NextArrowFunctionInfo, allows us to Scope::Snapshot::Reparent directly rather than moving it, and allows us to skip reparenting in the simple parameter arrow function cases. This CL additionally fixes arrow function name inferring. Change-Id: Ie3e5ea778f3d7b84b2a10d4f4ff73931cfc9384a Reviewed-on: https://chromium-review.googlesource.com/c/1386147 Reviewed-by: Igor Sheludko <ishell@chromium.org> Commit-Queue: Toon Verwaest <verwaest@chromium.org> Cr-Commit-Position: refs/heads/master@{#58405}
2018-12-20 13:17:44 +00:00
(anonymous) (test.js:205:6)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
-- setTimeout --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
complex (test.js:204:2)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testComplex.js:0:0)
Running test: testReject
foo1 (test.js:9:2)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
-- Promise.catch --
[inspector] use creation stack trace as parent for async call chains Creation stack trace points to the place where callback was actually chained, scheduled points where parent promise was resolved. For async tasks without creation stack (e.g. setTimeout) we continue to use scheduled as creation since usually they are the same. BUG=v8:6189 R=dgozman@chromium.org Review-Url: https://codereview.chromium.org/2868493002 Cr-Original-Commit-Position: refs/heads/master@{#45198} Committed: https://chromium.googlesource.com/v8/v8/+/e118462f18a862df81a04486e13dd62997cbfc5a Review-Url: https://codereview.chromium.org/2868493002 Cr-Commit-Position: refs/heads/master@{#45266}
2017-05-11 19:21:24 +00:00
reject (test.js:217:31)
[inspector] async stacks for Promise.then calls... ... which were done after the promise has been resolved. Goal of this CL - change promise instrumentation to support better callbacks, chained after promise resolution and prepare instrumentation for adding new asyncTaskCreated instrumentation. Instrumentation changes: - asyncTaskScheduled(recurring) when promise is fulfilled or rejected, - asyncTaskCancelled when promise is collected (since [1] we can be sure that promise will survive scheduled microtasks). Minor changes: - async task type in inspector <-> debugger API transferred by enum instead of string, - Debug manages async task ids based on promise objects. More details: https://docs.google.com/document/d/1u19N45f1gSF7M39mGsycJEK3IPyJgIXCBnWyiPeuJFE [1] https://codereview.chromium.org/2581503003/ BUG=chromium:632829,v8:5738 R=dgozman@chromium.org,yangguo@chromium.org,gsathya@chromium.org Review-Url: https://codereview.chromium.org/2578923002 Cr-Commit-Position: refs/heads/master@{#42178}
2017-01-10 12:54:12 +00:00
(anonymous) (testReject.js:0:0)
[inspector] reworked async instrumentation for promises Old instrumentation was designed to collect promise creation stack and promise scheduled stack together. In DevTools for last 6 months we show only creation stack for promises. We got strong support from users for new model. Now we can drop support for scheduled stacks and simplify implementation. New promise instrumentation is straightforward: - we send kDebugPromiseThen when promise is created by .then call, - we send kDebugPromiseCatch when promise is created by .catch call, - we send kDebugWillHandle before chained callback and kDebugDidHandle after chained callback, - and we send separate kDebugAsyncFunctionPromiseCreated for internal promise inside async await function. Advantages: - we reduce amount of captured stacks (we do not capture stack for promise that constructed not by .then or .catch), - we can consider async task related to .then and .catch as one shot since chained callback is executed once, - on V8 side we can implement required instrumentation using only promise hooks, Disadvantage: - see await-promise test, sometimes scheduled stack was useful since we add catch handler in native code, Implementation details: - on kInit promise hook we need to figure out why promise was created. We analyze builtin functions until first user defined function on current stack. If there is kAsyncFunctionPromiseCreate function then we send kDebugAsyncFunctionPromiseCreated event. If there is kPromiseThen or kPromiseCatch then only if this function is bottom builtin function we send corresponded event to inspector. We need it because Promise.all internally calls .then and in this case we have Promise.all and Promise.then on stack at the same time and we do not need to report this internally created promise to inspector. Bug: chromium:778796 Cq-Include-Trybots: master.tryserver.blink:linux_trusty_blink_rel Change-Id: I53f47ce8c5c4a9897655c3396c249ea59529ae47 Reviewed-on: https://chromium-review.googlesource.com/765208 Commit-Queue: Aleksey Kozyatinskiy <kozyatinskiy@chromium.org> Reviewed-by: Sathya Gunasekaran <gsathya@chromium.org> Reviewed-by: Yang Guo <yangguo@chromium.org> Reviewed-by: Dmitry Gozman <dgozman@chromium.org> Cr-Commit-Position: refs/heads/master@{#49553}
2017-11-21 15:42:43 +00:00
Running test: testFinally1
foo1 (test.js:9:2)
-- Promise.finally --
finally1 (test.js:221:33)
(anonymous) (testFinally1.js:0:0)
Running test: testFinally2
foo1 (test.js:9:2)
-- Promise.finally --
finally2 (test.js:225:34)
(anonymous) (testFinally2.js:0:0)
Reference in New Issue Copy Permalink