From 1328391a3b80540dc0a5c811a0937247ac9ca1ec Mon Sep 17 00:00:00 2001 From: Kenneth Russell Date: Tue, 11 Dec 2018 15:09:44 -0800 Subject: [PATCH 01/12] Add lowLatency flag to CanvasRenderingContext2DSettings. Developers of stylus-based drawing applications (e.g. Google Keep) have found this hint to be critical in order to be competitive with native applications. It has been prototyped in Chromium and yields significant latency improvements there. Partial fix for #4087. --- source | 40 +++++++++++++++++++++++++++++++++++++--- 1 file changed, 37 insertions(+), 3 deletions(-) diff --git a/source b/source index 51f0e5a6e79..0eb5ceda313 100644 --- a/source +++ b/source @@ -60064,6 +60064,7 @@ enum CanvasFillRule { "CanvasRenderingContext2DSettings { boolean alpha = true; + boolean lowLatency = false; }; enum ImageSmoothingQuality { "low", "medium", "high" }; @@ -60327,6 +60328,12 @@ interface Path2D {

If the alpha setting is provided and set to false, then the canvas is forced to always be opaque.

+

If the lowLatency + setting is provided and set to true, then the user agent will attempt to optimize the rendering + of the canvas to reduce latency, including potentially rendering from the front buffer. This + might desynchronize the canvas's display from the rest of the page and induce tearing on some + displays.

+
context . canvas
@@ -60379,11 +60386,33 @@ interface Path2D { created output bitmap with its alpha flag set to false will result in a fully-opaque gray square.

+

The CanvasRenderingContext2D object also has a lowLatency flag, which can be set to true or false. + Initially, when the context is created, its lowLatency flag must be set to false. When a + CanvasRenderingContext2D object has its lowLatency flag set to true, then the user agent will + attempt to optimize the rendering of the canvas to reduce latency, including potentially rendering + from the front buffer. This might desynchronize the canvas's display from the rest of the page and + induce tearing on some displays.

+ +

The lowLatency setting is useful + and necessary when implementing certain kinds of applications, such as drawing applications, where + the delay between input and rasterization is critical.

+

The getContextAttributes() method, - when invoked, must return a CanvasRenderingContext2DSettings dictionary whose alpha member is set to true if this context's alpha flag is set, and false otherwise.

+ when invoked, must return a CanvasRenderingContext2DSettings dictionary containing + the following members:

+ +
@@ -60446,6 +60475,11 @@ interface Path2D {
alpha
If false, then set context's alpha flag to false.
+ +
lowLatency
+
If true, then set context's lowLatency flag to true.
From 584b75204d4606dbe6d5bfe2f4e7bbd0b7beb13e Mon Sep 17 00:00:00 2001 From: Kenneth Russell Date: Fri, 14 Dec 2018 17:48:04 -0800 Subject: [PATCH 02/12] Address review feedback; add citation for front buffering --- source | 23 +++++++++++++---------- 1 file changed, 13 insertions(+), 10 deletions(-) diff --git a/source b/source index 0eb5ceda313..5e18657155a 100644 --- a/source +++ b/source @@ -60318,7 +60318,7 @@ interface Path2D {
-
context = canvas . getContext('2d' [, { [ alpha: false ] } ] )
+
context = canvas . getContext('2d' [, { [ alpha: false ] [, lowLatency: true ] } ] )
@@ -60329,10 +60329,10 @@ interface Path2D { provided and set to false, then the canvas is forced to always be opaque.

If the lowLatency - setting is provided and set to true, then the user agent will attempt to optimize the rendering - of the canvas to reduce latency, including potentially rendering from the front buffer. This - might desynchronize the canvas's display from the rest of the page and induce tearing on some - displays.

+ setting is provided and set to true, then the user agent might optimize the rendering of the + canvas to reduce latency, including potentially rendering from the front buffer + . This might desynchronize presentation of the canvas from the rest + of the page, and induce tearing on some displays.

@@ -60391,12 +60391,12 @@ interface Path2D { Initially, when the context is created, its lowLatency flag must be set to false. When a CanvasRenderingContext2D object has its lowLatency flag set to true, then the user agent will - attempt to optimize the rendering of the canvas to reduce latency, including potentially rendering - from the front buffer. This might desynchronize the canvas's display from the rest of the page and - induce tearing on some displays.

+ data-x="concept-canvas-lowLatency">lowLatency flag set to true, then the user agent might + optimize the rendering of the canvas to reduce latency, including potentially rendering from the + front buffer . This might desynchronize presentation of + the canvas from the rest of the page, and induce tearing on some displays.

-

The lowLatency setting is useful +

The lowLatency setting is useful and necessary when implementing certain kinds of applications, such as drawing applications, where the delay between input and rasterization is critical.

@@ -121793,6 +121793,9 @@ INSERT INTERFACES HERE
[MQ]
Media Queries, H. Lie, T. Çelik, D. Glazman, A. van Kesteren. W3C.
+
[MULTIPLEBUFFERING]
+
Multiple Buffering, Multiple editors. Wikipedia.
+
[NAVMODEL]
A Model of Navigation History. C. Brewster, A. Jeffrey.
From feeb2233af2a91a305c9df222ec61b16ab13605c Mon Sep 17 00:00:00 2001 From: Kenneth Russell Date: Mon, 21 Jan 2019 10:01:22 -0800 Subject: [PATCH 03/12] Address review feedback from annevk --- source | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/source b/source index 5e18657155a..9ee88f4150e 100644 --- a/source +++ b/source @@ -60330,9 +60330,9 @@ interface Path2D {

If the lowLatency setting is provided and set to true, then the user agent might optimize the rendering of the - canvas to reduce latency, including potentially rendering from the front buffer - . This might desynchronize presentation of the canvas from the rest - of the page, and induce tearing on some displays.

+ canvas to reduce latency, including potentially rendering from the front buffer. + This might desynchronize presentation of the canvas from the rest of the page, and induce + tearing on some displays.

@@ -60391,10 +60391,10 @@ interface Path2D { Initially, when the context is created, its lowLatency flag must be set to false. When a CanvasRenderingContext2D object has its lowLatency flag set to true, then the user agent might + data-x="concept-canvas-lowLatency">lowLatency flag set to true, then the user agent should optimize the rendering of the canvas to reduce latency, including potentially rendering from the - front buffer . This might desynchronize presentation of - the canvas from the rest of the page, and induce tearing on some displays.

+ front buffer. This might desynchronize presentation of the canvas from the rest of + the page, and induce tearing on some displays.

The lowLatency setting is useful and necessary when implementing certain kinds of applications, such as drawing applications, where @@ -121794,7 +121794,7 @@ INSERT INTERFACES HERE

Media Queries, H. Lie, T. Çelik, D. Glazman, A. van Kesteren. W3C.
[MULTIPLEBUFFERING]
-
Multiple Buffering, Multiple editors. Wikipedia.
+
(Non-normative) Multiple Buffering, Multiple editors. Wikipedia.
[NAVMODEL]
A Model of Navigation History. C. Brewster, A. Jeffrey.
From 36e6971e97742c39ba7c1f670b74f96f80cc57d5 Mon Sep 17 00:00:00 2001 From: Anne van Kesteren Date: Tue, 22 Jan 2019 10:36:04 +0100 Subject: [PATCH 04/12] nit --- source | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source b/source index 9ee88f4150e..ea6545b1c35 100644 --- a/source +++ b/source @@ -121794,7 +121794,7 @@ INSERT INTERFACES HERE
Media Queries, H. Lie, T. Çelik, D. Glazman, A. van Kesteren. W3C.
[MULTIPLEBUFFERING]
-
(Non-normative) Multiple Buffering, Multiple editors. Wikipedia.
+
(Non-normative) Multiple buffering. Wikipedia.
[NAVMODEL]
A Model of Navigation History. C. Brewster, A. Jeffrey.
From 757b7c8a478ecc4e0196dcc41b21529f80b234a3 Mon Sep 17 00:00:00 2001 From: Miguel Casas Date: Mon, 4 Mar 2019 19:30:45 -0500 Subject: [PATCH 05/12] Rewritten for more clarity --- source | 56 +++++++++++++++++++++++++++++++++----------------------- 1 file changed, 33 insertions(+), 23 deletions(-) diff --git a/source b/source index ea6545b1c35..2b9514b1c24 100644 --- a/source +++ b/source @@ -60064,7 +60064,7 @@ enum CanvasFillRule { "CanvasRenderingContext2DSettings { boolean alpha = true; - boolean lowLatency = false; + boolean desynchronized = false; }; enum ImageSmoothingQuality { "low", "medium", "high" }; @@ -60318,7 +60318,7 @@ interface Path2D {
-
context = canvas . getContext('2d' [, { [ alpha: false ] [, lowLatency: true ] } ] )
+
context = canvas . getContext('2d' [, { [ alpha: false ] [, desynchronized: false ] } ] )
@@ -60328,12 +60328,10 @@ interface Path2D {

If the alpha setting is provided and set to false, then the canvas is forced to always be opaque.

-

If the lowLatency - setting is provided and set to true, then the user agent might optimize the rendering of the - canvas to reduce latency, including potentially rendering from the front buffer. - This might desynchronize presentation of the canvas from the rest of the page, and induce - tearing on some displays.

- +

If the desynchronized + setting is provided and set to true, then canvas can be + desynchronized.

context . canvas
@@ -60387,18 +60385,30 @@ interface Path2D { flag set to false will result in a fully-opaque gray square.

The CanvasRenderingContext2D object also has a lowLatency flag, which can be set to true or false. - Initially, when the context is created, its lowLatency flag must be set to false. When a + data-x="concept-canvas-desynchronized">desynchronized flag, which can be set to true or + false. Initially, when the context is created, its desynchronized flag must be set to false. When a CanvasRenderingContext2D object has its lowLatency flag set to true, then the user agent should - optimize the rendering of the canvas to reduce latency, including potentially rendering from the - front buffer. This might desynchronize presentation of the canvas from the rest of - the page, and induce tearing on some displays.

+ data-x="concept-canvas-desynchronized">desynchronized flag set to true, then the user + agent should optimize the rendering of the canvas to reduce the latency, as measured from input + events to rasterization, by either decoupling the input event processing from the normal + event processing cycle, bypassing the ordinary user agent/OS rendering algorithm, or both. + Insofar as this mode involves bypassing the usual processing mechanisms of events or + rasterization or both, it might introduce visible tearing artifacts. +

+ +

The user agent/OS usually renders on a buffer which is not being displayed, + quickly swapping it and the one being scanned out for presentation; the former buffer is + called back-buffer and the latter front buffer (see ). + A popular technique for reducing latency is called front buffer rendering, + where rendering happens in parallel and racily with the scanning out process. This technique + reduces the latency at the price of potentially introducing tearing artifacts and can be + used to implement in total or part the desynchronized attribute.

-

The lowLatency setting is useful - and necessary when implementing certain kinds of applications, such as drawing applications, where - the delay between input and rasterization is critical.

+

The desynchronized + setting is useful and necessary when implementing certain kinds of applications, such + as drawing applications, where the latency between input and rasterization is critical.

The getContextAttributes() method, @@ -60409,9 +60419,9 @@ interface Path2D {

  • alpha, set to true if this context's alpha flag is set, and false otherwise.

    • -

  • lowLatency, set to true if this context's - lowLatency flag is set, and false - otherwise.

    • +

  • desynchronized, set to true if this + context's desynchronized flag is set, and + false otherwise.

    • @@ -60477,9 +60487,9 @@ interface Path2D { flag to false.
    lowLatency
    + data-x="dom-CanvasRenderingContext2DSettings-desynchronized">desynchronized
    If true, then set context's lowLatency flag to true.
    + data-x="concept-canvas-desynchronized">desynchronized flag to true.
    From 57dffa07b3131f430db58f9c2921ad25617f4f54 Mon Sep 17 00:00:00 2001 From: Miguel Casas Date: Fri, 8 Mar 2019 12:37:12 -0500 Subject: [PATCH 06/12] churn --- source | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-) diff --git a/source b/source index 2b9514b1c24..3519e4c2187 100644 --- a/source +++ b/source @@ -60390,20 +60390,19 @@ interface Path2D { data-x="concept-canvas-desynchronized">desynchronized     flag must be set to false. When a CanvasRenderingContext2D object has its desynchronized flag set to true, then the user - agent should optimize the rendering of the canvas to reduce the latency, as measured from input - events to rasterization, by either decoupling the input event processing from the normal - event processing cycle, bypassing the ordinary user agent/OS rendering algorithm, or both. - Insofar as this mode involves bypassing the usual processing mechanisms of events or - rasterization or both, it might introduce visible tearing artifacts. -

    + agent should optimize the rendering of the canvas to reduce the latency, as measured from + input events to rasterization, by either desynchronizing the canvas paint cycle from the normal + DOM cycle, bypassing the ordinary user agent/OS rendering algorithm, or both. Insofar as this + mode involves bypassing the usual processing mechanisms of events or rasterization or both, it + might introduce visible tearing artifacts.

    The user agent/OS usually renders on a buffer which is not being displayed, quickly swapping it and the one being scanned out for presentation; the former buffer is called back-buffer and the latter front buffer (see ). - A popular technique for reducing latency is called front buffer rendering, - where rendering happens in parallel and racily with the scanning out process. This technique - reduces the latency at the price of potentially introducing tearing artifacts and can be - used to implement in total or part the front buffer rendering, also + known as single buffer rendering, where rendering happens in parallel and racily + with the scanning out process. This technique reduces the latency at the price of potentially + introducing tearing artifacts and can be used to implement in total or part the desynchronized attribute.

    The desynchronized From f66a50b91a3081330e589bcf16f625252e142e99 Mon Sep 17 00:00:00 2001 From: Miguel Casas Date: Wed, 13 Mar 2019 15:55:27 -0400 Subject: [PATCH 07/12] @travisleithead comment --- source | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source b/source index 3519e4c2187..f1b3f53dc6a 100644 --- a/source +++ b/source @@ -60393,7 +60393,7 @@ interface Path2D { agent should optimize the rendering of the canvas to reduce the latency, as measured from input events to rasterization, by either desynchronizing the canvas paint cycle from the normal DOM cycle, bypassing the ordinary user agent/OS rendering algorithm, or both. Insofar as this - mode involves bypassing the usual processing mechanisms of events or rasterization or both, it + mode involves bypassing the usual paint mechanisms or rasterization or both, it might introduce visible tearing artifacts.

    The user agent/OS usually renders on a buffer which is not being displayed, From f7e7e8ae5c64c0febd45e1d198c87dcbbbee558c Mon Sep 17 00:00:00 2001 From: Miguel Casas Date: Thu, 14 Mar 2019 17:15:54 -0400 Subject: [PATCH 08/12] Clarify |desynchronized| true value --- source | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/source b/source index f1b3f53dc6a..9fb0f306d06 100644 --- a/source +++ b/source @@ -60386,15 +60386,13 @@ interface Path2D {

    The CanvasRenderingContext2D object also has a desynchronized flag, which can be set to true or - false. Initially, when the context is created, its desynchronized flag must be set to false. When a - CanvasRenderingContext2D object has its desynchronized flag set to true, then the user + false. When an CanvasRenderingContext2D object's desynchronized flag is true, then the user agent should optimize the rendering of the canvas to reduce the latency, as measured from - input events to rasterization, by either desynchronizing the canvas paint cycle from the normal - DOM cycle, bypassing the ordinary user agent/OS rendering algorithm, or both. Insofar as this - mode involves bypassing the usual paint mechanisms or rasterization or both, it - might introduce visible tearing artifacts.

    + input events to rasterization, by either desynchronizing the canvas paint cycle from the + normal DOM cycle, bypassing the ordinary user agent/OS rendering algorithm, or both. + Insofar as this mode involves bypassing the usual paint mechanisms or rasterization or both, + it might introduce visible tearing artifacts.

    The user agent/OS usually renders on a buffer which is not being displayed, quickly swapping it and the one being scanned out for presentation; the former buffer is From 353153a2fd755373a8e4a0900114fd15cbe34d7d Mon Sep 17 00:00:00 2001 From: Anne van Kesteren Date: Fri, 15 Mar 2019 10:47:00 +0100 Subject: [PATCH 09/12] review nits as commit --- source | 114 ++++++++++++++++++++++++++------------------------------- 1 file changed, 51 insertions(+), 63 deletions(-) diff --git a/source b/source index 9fb0f306d06..ca29b82504c 100644 --- a/source +++ b/source @@ -60317,40 +60317,38 @@ interface Path2D { objects.

    - -
    context = canvas . getContext('2d' [, { [ alpha: false ] [, desynchronized: false ] } ] )
    - +
    context = canvas . getContext('2d' [, { [ alpha: true ] [, desynchronized: false ] } ] )
    -

    Returns a CanvasRenderingContext2D object that is permanently bound to a particular canvas element.

    -

    If the alpha setting is - provided and set to false, then the canvas is forced to always be opaque.

    +

    If the alpha member is + false, then the context is forced to always be opaque.

    If the desynchronized - setting is provided and set to true, then canvas can be - desynchronized.

    + data-x="dom-CanvasRenderingContext2DSettings-desynchronized">desynchronized member is + true, then the context can be desynchronized.

    context . canvas
    -
    -

    Returns the canvas element.

    -
    attributes = canvas . getContextAttributes()
    -
    +

    Returns an object whose:

    -

    Returns an object whose alpha member is true if - the context has an alpha channel, or false if it was forced to be opaque.

    +
      +
    • alpha member is true if the context has an alpha + channel, or false if it was forced to be opaque.
      • +
    • desynchronized + member is true if the context can be desynchronized.
      • +
    -
    @@ -60366,12 +60364,11 @@ interface Path2D {

    The CanvasRenderingContext2D object also has an alpha flag, which can be set to true or false. Initially, - when the context is created, its alpha flag must be - set to true. When a CanvasRenderingContext2D object has its alpha flag set to false, then its alpha channel must be - fixed to 1.0 (fully opaque) for all pixels, and attempts to change the alpha component of any - pixel must be silently ignored.

    + data-x="concept-canvas-alpha">alpha boolean. When a + CanvasRenderingContext2D object's alpha is false, then its alpha channel must be fixed to 1.0 + (fully opaque) for all pixels, and attempts to change the alpha component of any pixel must be + silently ignored.

    Thus, the bitmap of such a context starts off as opaque black instead of transparent black; clearRect() @@ -60381,31 +60378,30 @@ interface Path2D { fourth byte in its input, and so on. However, the alpha component of styles and images drawn onto the canvas are still honoured up to the point where they would impact the output bitmap's alpha channel; for instance, drawing a 50% transparent white square on a freshly - created output bitmap with its alpha - flag set to false will result in a fully-opaque gray square.

    + created output bitmap with its alpha set + to false will result in a fully-opaque gray square.

    The CanvasRenderingContext2D object also has a desynchronized flag, which can be set to true or - false. When an CanvasRenderingContext2D object's desynchronized flag is true, then the user - agent should optimize the rendering of the canvas to reduce the latency, as measured from - input events to rasterization, by either desynchronizing the canvas paint cycle from the - normal DOM cycle, bypassing the ordinary user agent/OS rendering algorithm, or both. - Insofar as this mode involves bypassing the usual paint mechanisms or rasterization or both, - it might introduce visible tearing artifacts.

    - -

    The user agent/OS usually renders on a buffer which is not being displayed, - quickly swapping it and the one being scanned out for presentation; the former buffer is - called back-buffer and the latter front buffer (see ). - A popular technique for reducing latency is called front buffer rendering, also - known as single buffer rendering, where rendering happens in parallel and racily - with the scanning out process. This technique reduces the latency at the price of potentially - introducing tearing artifacts and can be used to implement in total or part the desynchronized attribute.

    - -

    The desynchronized - setting is useful and necessary when implementing certain kinds of applications, such - as drawing applications, where the latency between input and rasterization is critical.

    + data-x="concept-canvas-desynchronized">desynchronized boolean. When a + CanvasRenderingContext2D object's desynchronized is true, then the user agent should + optimize the rendering of the canvas to reduce the latency, as measured from input events to + rasterization, by desynchronizing the canvas paint cycle from the normal DOM cycle, bypassing the + ordinary user agent rendering algorithm, or both. Insofar as this mode involves bypassing the + usual paint mechanisms, rasterization, or both, it might introduce visible tearing artifacts.

    + +

    The user agent usually renders on a buffer which is not being displayed, quickly + swapping it and the one being scanned out for presentation; the former buffer is called + back buffer and the latter front buffer. A popular technique for reducing latency is called + front buffer rendering, also known as single buffer rendering, where rendering happens in + parallel and racily with the scanning out process. This technique reduces the latency at the price + of potentially introducing tearing artifacts and can be used to implement in total or part of the + desynchronized boolean.

    + +

    The desynchronized boolean is + useful and necessary when implementing certain kinds of applications, such as drawing + applications, where the latency between input and rasterization is critical.

    The getContextAttributes() method, @@ -60413,12 +60409,11 @@ interface Path2D { the following members:

      -

    • alpha, set to true if this context's alpha flag is set, and false otherwise.

      • +

    • alpha, set to this context's alpha.

      • -

    • desynchronized, set to true if this - context's desynchronized flag is set, and - false otherwise.

      • +

    • desynchronized, set to this context's + desynchronized.

    @@ -60475,20 +60470,13 @@ interface Path2D { data-x="attr-canvas-width">width and height content attributes.

    -
  • -

    Process each of the members of settings as follows:

    +

  • Set context's alpha to + settings's alpha.

    • -
    -
    alpha
    -
    If false, then set context's alpha - flag to false.
    - -
    desynchronized
    -
    If true, then set context's desynchronized flag to true.
    -
    - +

  • Set context's desynchronized to settings's desynchronized.

  • Return context.

    • From fd0967f7c71a58b244f389d7c1be55c7c95e1ce0 Mon Sep 17 00:00:00 2001 From: Miguel Casas Date: Mon, 18 Mar 2019 11:29:26 -0400 Subject: [PATCH 10/12] Using where appropriated --- source | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/source b/source index ca29b82504c..8a527bb7ea4 100644 --- a/source +++ b/source @@ -60327,7 +60327,7 @@ interface Path2D {

    If the desynchronized member is - true, then the context can be desynchronized.

    @@ -60384,7 +60384,7 @@ interface Path2D {

    The CanvasRenderingContext2D object also has a desynchronized boolean. When a CanvasRenderingContext2D object's desynchronized is true, then the user agent should + data-x="concept-canvas-desynchronized">desynchronized is true, then the user agent may optimize the rendering of the canvas to reduce the latency, as measured from input events to rasterization, by desynchronizing the canvas paint cycle from the normal DOM cycle, bypassing the ordinary user agent rendering algorithm, or both. Insofar as this mode involves bypassing the @@ -60399,9 +60399,9 @@ interface Path2D { desynchronized boolean.

    -

    The desynchronized boolean is - useful and necessary when implementing certain kinds of applications, such as drawing - applications, where the latency between input and rasterization is critical.

    +

    The desynchronized boolean + can be useful when implementing certain kinds of applications, such as drawing applications, + where the latency between input and rasterization is critical.

    The getContextAttributes() method, From bbd950b670bb3454fb41db4d97d1a7bbbce0d19d Mon Sep 17 00:00:00 2001 From: Miguel Casas Date: Mon, 18 Mar 2019 11:43:31 -0400 Subject: [PATCH 11/12] Using 'may' or 'might' where appropriated --- source | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source b/source index 8a527bb7ea4..182834da0af 100644 --- a/source +++ b/source @@ -60327,7 +60327,7 @@ interface Path2D {

    If the desynchronized member is - true, then the context may be desynchronized.

    From a2ae3f89162555d014592cca40d0327201b4fcab Mon Sep 17 00:00:00 2001 From: Miguel Casas-Sanchez Date: Wed, 20 Mar 2019 10:30:13 -0400 Subject: [PATCH 12/12] s/normal DOM cycle/event loop/ --- source | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source b/source index 182834da0af..8f072676377 100644 --- a/source +++ b/source @@ -60386,7 +60386,7 @@ interface Path2D { CanvasRenderingContext2D object's desynchronized is true, then the user agent may optimize the rendering of the canvas to reduce the latency, as measured from input events to - rasterization, by desynchronizing the canvas paint cycle from the normal DOM cycle, bypassing the + rasterization, by desynchronizing the canvas paint cycle from the event loop, bypassing the ordinary user agent rendering algorithm, or both. Insofar as this mode involves bypassing the usual paint mechanisms, rasterization, or both, it might introduce visible tearing artifacts.