From d273f04b01bf5bf72cceee9e5f74912258aec01c Mon Sep 17 00:00:00 2001 From: Domenic Denicola Date: Wed, 24 Feb 2021 13:01:54 -0500 Subject: [PATCH] Clean up task queuing and document management * Removes uses of "responsible document". This term is on its way out, per https://github.com/whatwg/html/issues/4335. * The straightforward substitution of using the associated Document didn't always make sense, because in many cases there was no sensible settings object (e.g., the algorithms were consulting the "current settings object" but were in parallel, where there is no current settings object). So, this restructures the algorithms to be more clear about what work is done in parallel vs. what work is done in queued tasks. * Similarly, a lot of work was done on main-thread data structures and objects while in parallel, e.g. creating WakeLockSentinel objects or consulting internal slots. That was moved to be done either up front, before the algorithms go in parallel, or in queued tasks. This includes user activation checking, which allows us to eliminate the wrapper "obtain permission" algorithm. --- index.html | 157 ++++++++++++++++++++++------------------------------- 1 file changed, 66 insertions(+), 91 deletions(-) diff --git a/index.html b/index.html index 54d1b09..7320ccb 100644 --- a/index.html +++ b/index.html @@ -203,8 +203,8 @@

Wake Lock permission revocation algorithm, run these steps:

    -
  1. Let |document:Document| be the [=environment settings object / - responsible document=] of the current settings object. +
  2. Let |document:Document| the [=current settings object=]'s + [=associated Document=].
  3. Let |record| be the platform wake lock's state record associated with |document| and wake lock type @@ -213,37 +213,11 @@

  4. [=list/For each=] |lock:WakeLockSentinel| in |record|.{{[[ActiveLocks]]}}:
      -
    1. Run release a wake lock with |lock| and - {{WakeLockType/"screen"}}. +
    2. Run release a wake lock with |document| and |lock|.

-

- To obtain permission for wake lock type |name|, run - these steps in parallel. This async algorithm returns either - {{PermissionState/"granted"}} or {{PermissionState/"denied"}}. -

- -
    -
  1. Let |state:PermissionState| be permission state of the - `"screen-wake-lock"` {{PermissionName}}. -
    2. -
  2. If |state| is not {{PermissionState/"prompt"}}, return |state|. -
    3. -
  3. If the current global object does not have [=transient - activation=], return {{PermissionState/"denied"}}. -
    4. -
  4. Otherwise, return the result of requesting permission to - use the `"screen-wake-lock"` {{PermissionName}}. -
    5. -
@@ -266,8 +240,8 @@

Each platform wake lock (one per wake lock type) has an - associated state record per [=environment settings object / - responsible document=] with the following state record per {{Document}} with the following + internal slots:

@@ -295,8 +269,7 @@

A list of {{WakeLockSentinel}} objects, representing - active wake locks associated with the [=environment settings - object / responsible document=]. + active wake locks associated with the {{Document}}. @@ -337,8 +310,8 @@

|type:WakeLockType|:

    -
  1. Let |document:Document| be the [=environment settings object / - responsible document=] of the current settings object. +
  2. Let |document:Document| the [=current settings object=]'s + [=associated Document=].
    1. If @@ -367,30 +340,36 @@

      return [=a promise rejected with=] {{"NotAllowedError"}} {{DOMException}}.

      2. +
    2. If the current global object does not have [=transient + activation=], return [=a promise rejected with=] + {{"NotAllowedError"}} {{DOMException}}. +
    3. Let |promise:Promise| be [=a new promise=].
      4. -
    4. Return |promise| and run the following steps in parallel: +
    5. Run the following steps in parallel:
      1. Abort when the steps to determine the visibility state return `hidden`.
        2. -
      2. Let |state:PermissionState| be the result of awaiting - obtain permission steps with "`screen-wake-lock`": +
      3. Let |state:PermissionState| be the result of requesting + permission to use the `"screen-wake-lock"` + {{PermissionName}}. +
        4. +
      4. If |state| is + {{PermissionState/"denied"}}, then:
          -
        1. If - |state| is {{PermissionState/"denied"}}, then reject - |promise| with a {{"NotAllowedError"}} {{DOMException}}, and - abort these steps. +
        2. [=Queue a global task=] on the [=screen wake lock task + source=] given |document|'s [=relevant global object=] to + [=reject=] |promise| with a {{"NotAllowedError"}} + {{DOMException}}. +
          3. +
        3. Abort these steps.
        5. -
      5. Let |lock:WakeLockSentinel| be a new {{WakeLockSentinel}} - object with its {{WakeLockSentinel/type}} attribute set to - |type|. -
        6. -
      6. Invoke acquire a wake lock with |lock| and - {{WakeLockType/"screen"}}. +
      7. Invoke acquire a wake lock with |document|, |type|, + and |promise|.
        8. -
      8. Resolve |promise| with |lock|. -
    6. If aborted, reject |promise| with a {{"NotAllowedError"}} {{DOMException}}.
      7. +
    7. Return |promise|. +

@@ -509,20 +488,13 @@

following steps:

    -
  1. If this' {{[[Released]]}} internal slot is `true`, return +
  2. If this's {{[[Released]]}} internal slot is `true`, return a promise resolved with `undefined`.
  3. Otherwise, let |promise:Promise| be a new promise.
    4. -
  4. Run the following steps in parallel: -
      -
    1. Run release a wake lock with |lock:WakeLockSentinel| - set to this and |type:WakeLockType| set to the value of - this' {{WakeLockSentinel/type}} attribute. -
      2. -
    2. Resolve |promise|. -
      3. -
    +
  5. Run release a wake lock given the [=current global + object=]'s [=associated Document=], [=this=], and |promise|.
  6. Return |promise|.
    7. @@ -640,14 +612,10 @@

    Handling document loss of full activity

    - When the user agent determines that a [=environment settings object / - responsible document=] of the current settings object is no - longer [=Document/fully active=], it must run these steps: + When a {{Document}} |document:Document| becomes no longer + [=Document/fully active=], the user agent must run these steps:

      -
    1. Let |document:Document| be the [=environment settings object / - responsible document=] of the current settings object. -
    2. Let |screenRecord| be the platform wake lock's state record associated with |document| and wake lock type {{WakeLockType/"screen"}}. @@ -655,8 +623,7 @@

    3. [=list/For each=] |lock:WakeLockSentinel| in |screenRecord|.{{[[ActiveLocks]]}}:
        -
      1. Run release a wake lock with |lock| and - {{WakeLockType/"screen"}}. +
      2. Run release a wake lock with |document| and |lock|.
      4. @@ -675,14 +642,11 @@

      the latest TR, so we cannot reference them yet. -->

      When the user agent determines that the [=Document/visibility state=] - of the Document of the top-level browsing context has - become `hidden`, the user agent MUST run the following steps after - the now hidden algorithm: + of a {{Document}} |document:Document| of a top-level browsing + context has become `hidden`, the user agent MUST run the + following steps after the now hidden algorithm:

        -
      1. Let |document:Document| be the [=environment settings object / - responsible document=] of the current settings object. -
      2. Let |screenRecord| be the platform wake lock's state record associated with |document| and wake lock type {{WakeLockType/"screen"}}. @@ -690,8 +654,7 @@

      3. [=list/For each=] |lock:WakeLockSentinel| in |screenRecord|.{{[[ActiveLocks]]}}:
          -
        1. Run release a wake lock with |lock| and - {{WakeLockType/"screen"}}. +
        2. Run release a wake lock with |document| and |lock|.
        4. @@ -706,8 +669,8 @@

        Acquire wake lock algorithm

        - To acquire a wake lock for a given |lock:WakeLockSentinel| - and |type:WakeLockType|, run these steps in parallel: + To acquire a wake lock given a |document:Document|, a + |type:WakeLockType|, and a |promise:Promise|:

        1. If the wake lock for type |type| is not applicable, abort @@ -719,13 +682,22 @@

        2. Ask the underlying operating system to acquire the wake lock of type |type|.
          3. -
        3. Let |document:Document| be the [=environment settings object / - responsible document=] of the current settings object. -
          4. -
        4. Let |record| be the platform wake lock's state - record associated with |document| and |type|. -
          5. -
        5. Add |lock| to |record|.{{[[ActiveLocks]]}}. +
        6. [=Queue a global task=] on the [=screen wake lock task source=] + given |document|'s [=relevant global object=] to perform the + following steps: +
            +
          1. Let |record| be the platform wake lock's state + record associated with |document| and |type|. +
            2. +
          2. Let |lock:WakeLockSentinel| be a new {{WakeLockSentinel}} + object with its {{WakeLockSentinel/type}} attribute set to + |type|. +
            3. +
          3. Add |lock| to |record|.{{[[ActiveLocks]]}}. +
            4. +
          4. [=Resolve=] |promise| with |lock|. +
            5. +

        @@ -734,12 +706,12 @@

        Release wake lock algorithm

        - To release a wake lock for a given |lock:WakeLockSentinel| - and |type:WakeLockType|, run these steps in parallel: + To release a wake lock given a |document:Document|, a + |lock:WakeLockSentinel|, and an optional |promise:Promise|:

          -
        1. Let |document:Document| be the [=environment settings object / - responsible document=] of the current settings object. +
        2. Let |type:WakeLockType| be the value of |lock|'s + {{WakeLockSentinel/type}} attribute.
        3. Let |record| be the platform wake lock's state record associated with |document| and |type|. @@ -771,14 +743,17 @@

        4. -
      4. - Queue a task to run the following steps: +
      5. [=Queue a global task=] on the [=screen wake lock task source=] + given |document|'s [=relevant global object=] to run the following + steps:
        1. Set |lock|'s {{[[Released]]}} internal slot to `true`.
        2. Fire an event named "`release`" at |lock|.
          3. +
        3. If |promise| was given, then [=resolve=] |promise|. +