From e1e23c33424d617d4072dc2d112905681e26fc91 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Wed, 12 Sep 2018 23:11:19 -0400
Subject: [PATCH 01/18] Start working on style sheet done flag

---
 source | 41 +++++++++++++++++++++++++----------------
 1 file changed, 25 insertions(+), 16 deletions(-)

diff --git a/source b/source
index 2f72953c164..2b7a1c87387 100644
--- a/source
+++ b/source
@@ -15157,19 +15157,27 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
 
   <h4>Interactions of styling and scripting</h4>
 
-  <p>Style sheets, whether added by a <code>link</code> element, a <code>style</code> element, an
-  <code>&lt;?xml-stylesheet?></code> PI, an HTTP `<code data-x="http-link">Link</code>` header, or
-  some other mechanism, have a <dfn>style sheet ready</dfn> flag, which is initially unset.</p>
-
-  <p>When a style sheet is ready to be applied, its <span>style sheet ready</span> flag must be set.
-  If the style sheet referenced no other resources (e.g. it was an internal style sheet given by a
-  <code>style</code> element with no <code data-x="">@import</code> rules), then the style rules must
-  be <span>immediately</span> made available to script; otherwise, the style rules must only be made available
-  to script once the <span>event loop</span> reaches its <span>update the rendering</span> step.</p>
-
-  <p>A style sheet in the context of the <code>Document</code> of an <span>HTML parser</span> or
-  <span>XML parser</span> is said to be <dfn>a style sheet that is blocking scripts</dfn> if all of
-  the following conditions occur:</p>
+  <p><span data-x="CSS style sheet">Style sheets</span>, whether added by a <code>link</code>
+  element, a <code>style</code> element, an <code>&lt;?xml-stylesheet?></code> PI, an HTTP
+  `<code data-x="http-link">Link</code>` header, or some other mechanism, have a <dfn>style sheet
+  done</dfn> flag, which is initially unset. When a style sheet is ready to be applied, its
+  <span>style sheet done</span> flag must be set.</p>
+
+  <p class="note">The <span>style sheet done</span> flag is used to indicate when a style sheet has
+  been obtained, if necessary, and is ready to be applied. The purpose of this is to make <span>a
+  style sheet that is blocking scripts</span> no longer a style sheet of this category, so that
+  scripting is no longer blocked. The algorithm that creates and applies the style sheet is
+  responsible for setting this flag.</p>
+
+  If the <span data-x="CSS style sheet">style sheet</span> referenced no other resources (e.g.,
+  it was an internal style sheet given by a <code>style</code> element with no
+  <code data-x="">@import</code> rules), then the style rules must be <span>immediately</span> made
+  available to script; otherwise, the style rules must only be made available to script once the
+  <span>event loop</span> reaches its <span>update the rendering</span> step.
+
+  <p>A <span data-x="CSS style sheet">style sheet</span> in the context of the <code>Document</code>
+  of an <span>HTML parser</span> or <span>XML parser</span> is said to be <dfn>a style sheet that is
+  blocking scripts</dfn> if all of the following conditions occur:</p>
 
   <ul>
    <li><p>The element was created by that <code>Document</code>'s parser.</p></li>
@@ -15184,7 +15192,7 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
 
    <li><p>The element's style sheet was enabled when the element was created by the parser.</p></li>
 
-   <li><p>The element's <span>style sheet ready</span> flag is not yet set.</p></li>
+   <li><p>The element's <span>style sheet done</span> flag is not yet set.</p></li>
 
    <li><p>The last time the <span>event loop</span> reached <a href="#step1">step 1</a>, the
    element's <span>root</span> was that <code>Document</code>.</p></li>
@@ -15198,7 +15206,7 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
   information. For example, if a style sheet sets the color of an element to green, but a script
   that inspects the resulting style is executed before the sheet is loaded, the script will find
   that the element is black (or whatever the default color is), and might thus make poor choices
-  (e.g. deciding to use black as the color elsewhere on the page, instead of green). Implementors
+  (e.g., deciding to use black as the color elsewhere on the page, instead of green). Implementers
   have to balance the likelihood of a script using incorrect information with the performance impact
   of doing nothing while waiting for a slow network request to finish.</p>
 
@@ -24587,7 +24595,8 @@ document.body.appendChild(wbr);</code></pre>
   link</span> that contributes to the styling processing model. This keyword is
   <span>body-ok</span>.</p>
 
-  <p>The specified resource is a CSS style sheet that describes how to present the document.</p>
+  <p>The specified resource is a <span>CSS style sheet</span> that describes how to present the
+  document.</p>
 
   <p>If the <code data-x="rel-alternate">alternate</code> keyword is also specified on the
   <code>link</code> element, then <dfn id="the-link-is-an-alternative-stylesheet">the link is an

From 3758280f0080faefb108dc4b34659616f6b62002 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Thu, 13 Sep 2018 00:23:19 -0400
Subject: [PATCH 02/18] Set style sheet done in <style> semantics

---
 source | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/source b/source
index 2b7a1c87387..3ac786260b3 100644
--- a/source
+++ b/source
@@ -15099,13 +15099,15 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
   complete, or, if the style sheet has no <span>critical subresources</span>, once the style sheet
   has been parsed and processed, the user agent must, if the loads were successful or there were
   none, <span>queue a task</span> to <span data-x="concept-event-fire">fire an event</span> named
-  <code data-x="event-load">load</code> at the <code>style</code> element, or, if one of the style
-  sheet's <span>critical subresources</span> failed to completely load for any reason (e.g. DNS
-  error, HTTP 404 response, a connection being prematurely closed, unsupported Content-Type),
-  <span>queue a task</span> to <span data-x="concept-event-fire">fire an event</span> named <code
-  data-x="event-error">error</code> at the <code>style</code> element. Non-network errors in
-  processing the style sheet or its subresources (e.g. CSS parse errors, PNG decoding errors) are
-  not failures for the purposes of this paragraph.</p>
+  <code data-x="event-load">load</code> at the <code>style</code> element and set the style sheet's
+  <span>style sheet done</span> flag, or, if one of the style sheet's <span>critical
+  subresources</span> failed to completely load for any reason (e.g. DNS error, HTTP 404 response,
+  a connection being prematurely closed, unsupported Content-Type), <span>queue a task</span> to
+  <span data-x="concept-event-fire">fire an event</span> named <code
+  data-x="event-error">error</code> at the <code>style</code> element and set the style sheet's
+  <span>style sheet done</span> flag. Non-network errors in processing the style sheet or its
+  subresources (e.g. CSS parse errors, PNG decoding errors) are not failures for the purposes of
+  this paragraph.</p>
 
   <p>The <span>task source</span> for these <span data-x="concept-task">tasks</span> is the <span>DOM
   manipulation task source</span>.</p>

From f19052a30a7130974e135dfec41c983b9f67ec90 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Sun, 25 Nov 2018 00:11:17 -0500
Subject: [PATCH 03/18] Style elements set the style sheet done flag

---
 source | 47 +++++++++++++++++++++++++++++++++--------------
 1 file changed, 33 insertions(+), 14 deletions(-)

diff --git a/source b/source
index 3ac786260b3..641a01d1d89 100644
--- a/source
+++ b/source
@@ -15094,23 +15094,41 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
 
   </ol>
 
-  <!-- the next few paragraph are similar to text in the <link> section -->
+  <!-- the next few paragraphs are similar to text in the <link> section -->
   <p>Once the attempts to obtain the style sheet's <span>critical subresources</span>, if any, are
   complete, or, if the style sheet has no <span>critical subresources</span>, once the style sheet
   has been parsed and processed, the user agent must, if the loads were successful or there were
-  none, <span>queue a task</span> to <span data-x="concept-event-fire">fire an event</span> named
-  <code data-x="event-load">load</code> at the <code>style</code> element and set the style sheet's
-  <span>style sheet done</span> flag, or, if one of the style sheet's <span>critical
-  subresources</span> failed to completely load for any reason (e.g. DNS error, HTTP 404 response,
-  a connection being prematurely closed, unsupported Content-Type), <span>queue a task</span> to
-  <span data-x="concept-event-fire">fire an event</span> named <code
-  data-x="event-error">error</code> at the <code>style</code> element and set the style sheet's
-  <span>style sheet done</span> flag. Non-network errors in processing the style sheet or its
-  subresources (e.g. CSS parse errors, PNG decoding errors) are not failures for the purposes of
-  this paragraph.</p>
+  none, <span>queue a task</span> to:</p>
 
-  <p>The <span>task source</span> for these <span data-x="concept-task">tasks</span> is the <span>DOM
-  manipulation task source</span>.</p>
+  <ol>
+
+   <li><p><span data-x="concept-event-fire">Fire an event</span> named <code
+   data-x="event-load">load</code> at the <code>style</code> element.</p></li>
+
+   <li><p>Set the <code>style</code> element's <span>associated CSS style sheet</span>'s <span>style
+   sheet done</span> flag.</p></li>
+
+  </ol>
+
+  <p>Otherwise if one of the style sheet's <span>critical subresources</span> failed to completely
+  load for any reason (e.g., DNS error, HTTP 404 response, a connection being prematurely closed,
+  unsupported Content-Type), <span>queue a task</span> to:</p>
+
+  <ol>
+
+   <li><p><span data-x="concept-event-fire">Fire an event</span> named <code
+   data-x="event-error">error</code> at the <code>style</code> element.</p></li>
+
+   <li><p>Set the <code>style</code> element's <span>associated CSS style sheet</span>'s <span>style
+   sheet done</span> flag.</p></li>
+
+  </ol>
+
+  <p>Non-network errors in processing the style sheet or its subresources (e.g., CSS parse errors, PNG
+  decoding errors) are not failures for the purposes of this paragraph.</p>
+
+  <p>The <span>task source</span> for the <span data-x="concept-task">tasks</span> above is the
+  <span>DOM manipulation task source</span>.</p>
 
   <p>The element must <span>delay the load event</span> of the element's <span>node document</span> until all the
   attempts to obtain the style sheet's <span>critical subresources</span>, if any, are complete.</p>
@@ -15194,7 +15212,8 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
 
    <li><p>The element's style sheet was enabled when the element was created by the parser.</p></li>
 
-   <li><p>The element's <span>style sheet done</span> flag is not yet set.</p></li>
+   <li><p>The <span data-x="CSS style sheet">style sheet</span>'s <span>style sheet done</span>
+   flag is not yet set.</p></li>
 
    <li><p>The last time the <span>event loop</span> reached <a href="#step1">step 1</a>, the
    element's <span>root</span> was that <code>Document</code>.</p></li>

From a240a6b12d702bbdf7f6aec3df0853d270faf3f2 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Sun, 25 Nov 2018 02:33:58 -0500
Subject: [PATCH 04/18] First pass of refactoring link rel=stylesheet loading

---
 source | 117 ++++++++++++++++++++++++++++++++++++++++-----------------
 1 file changed, 82 insertions(+), 35 deletions(-)

diff --git a/source b/source
index 641a01d1d89..fe361fc6a95 100644
--- a/source
+++ b/source
@@ -3760,6 +3760,7 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute
      <li><dfn data-x-href="https://drafts.csswg.org/cssom/#the-cssstyledeclaration-interface"><code>CSSStyleDeclaration</code></dfn> interface</li>
      <li><dfn data-x="dom-CSSStyleDeclaration-cssText" data-x-href="https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-csstext"><code>cssText</code></dfn> attribute of <code>CSSStyleDeclaration</code></li>
      <li><dfn data-x-href="https://drafts.csswg.org/cssom/#the-stylesheet-interface"><code>StyleSheet</code></dfn> interface</li>
+     <li><dfn data-x-href="https://drafts.csswg.org/cssom/#add-a-css-style-sheet">add a CSS style sheet</dfn></li>
      <li><dfn data-x-href="https://drafts.csswg.org/cssom/#create-a-css-style-sheet">create a CSS style sheet</dfn></li>
      <li><dfn data-x-href="https://drafts.csswg.org/cssom/#remove-a-css-style-sheet">remove a CSS style sheet</dfn></li>
      <li><dfn data-x-href="https://drafts.csswg.org/cssom/#associated-css-style-sheet">associated CSS style sheet</dfn></li>
@@ -13691,29 +13692,48 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   <p>User agents may opt to only try to obtain such resources when they are needed, instead of
   pro-actively fetching all the external resources that are not applied.</p>
 
-  <p>The semantics of the protocol used (e.g. HTTP) must be followed when fetching external
+  <p>The semantics of the protocol used (e.g., HTTP) must be followed when fetching external
   resources. (For example, redirects will be followed and 404 responses will cause the external
   resource to not be applied.)</p>
 
-  <!-- the next few paragraph are similar to text in the <style> element section -->
+  <!-- the next few paragraphs are similar to text in the <style> element section -->
   <p>Once the attempts to obtain the resource and its <span>critical subresources</span> are
-  complete, the user agent must, if the loads were successful, <span>queue a task</span> to
-  <span data-x="concept-event-fire">fire an event</span> named <code data-x="event-load">load</code>
-  at the <code>link</code> element, or, if the resource or one of its <span>critical
-  subresources</span> failed to completely load for any reason (e.g. DNS error, HTTP 404 response, a
-  connection being prematurely closed, unsupported Content-Type), <span>queue a task</span> to <span
-  data-x="concept-event-fire">fire an event</span> named <code data-x="event-error">error</code> at
-  the <code>link</code> element. Non-network errors in processing the resource or its subresources
-  (e.g. CSS parse errors, PNG decoding errors) are not failures for the purposes of this
-  paragraph.</p>
+  complete, the user agent must, if the loads were successful, <span>queue a task</span> to:</p>
 
-  <p>The <span>task source</span> for these <span data-x="concept-task">tasks</span> is the
+  <ol>
+
+   <li><p><span data-x="concept-event-fire">Fire an event</span> named <code
+   data-x="event-load">load</code> at the <code>link</code> element.</p></li>
+
+   <li><p>If the <code>link</code> element has an <span>associated CSS style sheet</span>, set the
+   <span data-x="CSS style sheet">style sheet</span>'s <span>style sheet done</span> flag.</p></li>
+
+  </ol>
+
+  <p>Otherwise, if the resource or one of its <span>critical subresources</span> failed to
+  completely load for any reason (e.g., DNS error, HTTP 404 response, a connection being
+  prematurely closed, unsupported Content-Type), <span>queue a task</span> to:</p>
+
+  <ol>
+
+   <li><p><span data-x="concept-event-fire">Fire an event</span> named <code
+   data-x="event-error">error</code> at the <code>link</code> element.</p></li>
+
+   <li><p>If the <code>link</code> element has an <span>associated CSS style sheet</span>, set the
+   <span data-x="CSS style sheet">style sheet</span>'s <span>style sheet done</span> flag.</p></li>
+
+  </ol>
+
+  <p>Non-network errors in processing the resource or its subresources (e.g., CSS parse errors,
+  PNG decoding errors) are not failures for the purposes of this paragraph.</p>
+
+  <p>The <span>task source</span> for the <span data-x="concept-task">tasks</span> above is the
   <span>DOM manipulation task source</span>.</p>
 
   <p>Unless otherwise specified for a given <code data-x="attr-link-rel">rel</code> keyword, the
   element must <span>delay the load event</span> of the element's <span>node document</span> until
   all the attempts to obtain the resource and its <span>critical subresources</span> are complete.
-  (Resources that the user agent has not yet attempted to obtain, e.g. because it is waiting for the
+  (Resources that the user agent has not yet attempted to obtain, e.g., because it is waiting for the
   resource to be needed, do not <span>delay the load event</span>.)</p>
 
   <h5>Processing `<code data-x="http-link">Link</code>` headers</h5>
@@ -24629,7 +24649,7 @@ document.body.appendChild(wbr);</code></pre>
 
   <div w-nodev>
 
-  <p>The appropriate times to <span data-x="concept-link-obtain">obtain</span> the resource are:
+  <p>The appropriate times to <span>obtain a link style sheet</span> resource are:
 
   <!-- has a browsing context: https://software.hixie.ch/utilities/js/live-dom-viewer/?saved=4299 -->
   <ul>
@@ -24674,9 +24694,7 @@ document.body.appendChild(wbr);</code></pre>
   and the <span data-x="Content-Type">Content-Type metadata</span> of the external resource is not a
   supported style sheet type, the user agent must instead assume it to be <code>text/css</code>.</p>
 
-  <p>Once a resource has been <span data-x="concept-link-obtain">obtained</span>, if its <span
-  data-x="Content-Type">Content-Type metadata</span> is <code>text/css</code>, then run these
-  steps:</p>
+  <p>To <dfn>obtain a link style sheet</dfn>, the user agent must run the following steps:</p>
 
   <!-- note that we can only get this far if we have a browsing context, since if you don't have a
   browsing context (and are active) you can't ever get a result back from "fetch", and thus you
@@ -24685,17 +24703,8 @@ document.body.appendChild(wbr);</code></pre>
 
   <ol>
 
-   <li><p>Let <var>element</var> be the <code>link</code> element that created the
-   <span>external resource link</span>.</p></li>
-
-   <li><p>If <var>element</var> has an <span>associated CSS style sheet</span>, <span
-   data-x="remove a CSS style sheet">remove the CSS style sheet</span> in question.</p></li>
-
-   <li><p>If <var>element</var> no longer creates an <span>external resource link</span>
-   that contributes to the styling processing model, or if, since the resource in question was <span
-   data-x="concept-link-obtain">obtained</span>, it has become appropriate to <span
-   data-x="concept-link-obtain">obtain</span> it again (meaning this algorithm is about to be
-   invoked again for a newly obtained resource), then return.</p></li>
+   <li><p>Let <var>element</var> be the <code>link</code> element that created the <span>external
+   resource link</span>.</p></li>
 
    <li>
 
@@ -24757,13 +24766,7 @@ document.body.appendChild(wbr);</code></pre>
      <dd><p>Left at its default value.</p></dd>
 
      <dt><span data-x="concept-css-style-sheet-CSS-rules">CSS rules</span></dt>
-     <dd>
-      <p>Left uninitialized.</p>
-
-      <p class="&#x0058;&#x0058;&#x0058;">This doesn't seem right. Presumably we should be using the
-      response body? Tracked as <a
-      href="https://github.com/whatwg/html/issues/2997">issue #2997</a>.</p>
-     </dd>
+     <dd><p>Left uninitialized.</p></dd>
 
     </dl>
 
@@ -24781,6 +24784,50 @@ document.body.appendChild(wbr);</code></pre>
 
    </li>
 
+   <li>
+
+    <p>Let <var>response</var> be the result of running the general <span
+    data-x="concept-link-obtain">link obtain</span> steps, and wait until <var>response</var> is
+    available to continue.</p>
+
+    <p class="&#x0058;&#x0058;&#x0058;">See <a
+    href="https://github.com/whatwg/html/issues/968">issue #968</a> for plans to use the CSSOM
+    <a href="https://drafts.csswg.org/cssom/#fetching-css-style-sheets">fetch a CSS style sheet</a>
+    algorithm instead of the general link <span data-x="concept-link-obtain">obtain</span>
+    algorithm.</p>
+
+   </li>
+
+   <li>If the <span data-x="Content-Type">Content-Type metadata</span> of the resource is not
+   <code>text/css</code>, then return.</li>
+
+   <li><p>If <var>element</var> has an <span>associated CSS style sheet</span>, <span
+   data-x="remove a CSS style sheet">remove the CSS style sheet</span> in question.</p></li>
+
+   <li><p>If <var>element</var> no longer creates an <span>external resource link</span>
+   that contributes to the styling processing model, or if, since the resource in question was <span
+   data-x="concept-link-obtain">obtained</span>, it has become appropriate to <span
+   data-x="concept-link-obtain">obtain</span> it again (meaning this algorithm is about to be
+   invoked again for a newly obtained resource), then return.</p></li>
+
+   <li><p class="&#x0058;&#x0058;&#x0058;">Presumably we should be using the response body to
+   populate the <span>CSS style sheet</span>'s <span data-x="concept-css-style-sheet-CSS-rules">CSS
+   rules</span>. This is tracked as <a href="https://github.com/whatwg/html/issues/2997">issue
+   #2997</a>.</p></li>
+
+   <li>
+
+    <p><span data-x="add a CSS style sheet">Add</span> the previously-created <span>CSS style
+    sheet</span>.</p>
+
+    <p class="note"><span data-x="add a CSS style sheet">Adding</span> the style sheet here, before
+    the task queued in the general link <span data-x="concept-link-obtain">obtain</span> algorithm
+    runs, ensures that the style sheet's <span data-x="concept-css-style-sheet-CSS-rules">CSS
+    rules</span> are exposed to scripts (including document.styleSheets and element.sheet) before
+    this style sheet is no longer <span>a style sheet that is blocking scripts</span>.</p>
+
+   </li>
+
   </ol>
 
   </div>

From 9c4b4300b51ba46054c226a77d6e66397dde2aa7 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Sun, 25 Nov 2018 02:41:32 -0500
Subject: [PATCH 05/18] Add <p> and change a link

---
 source | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/source b/source
index fe361fc6a95..dff7c78f260 100644
--- a/source
+++ b/source
@@ -24798,16 +24798,16 @@ document.body.appendChild(wbr);</code></pre>
 
    </li>
 
-   <li>If the <span data-x="Content-Type">Content-Type metadata</span> of the resource is not
-   <code>text/css</code>, then return.</li>
+   <li><p>If the <span data-x="Content-Type">Content-Type metadata</span> of the resource is not
+   <code>text/css</code>, then return.</p></li>
 
    <li><p>If <var>element</var> has an <span>associated CSS style sheet</span>, <span
    data-x="remove a CSS style sheet">remove the CSS style sheet</span> in question.</p></li>
 
    <li><p>If <var>element</var> no longer creates an <span>external resource link</span>
    that contributes to the styling processing model, or if, since the resource in question was <span
-   data-x="concept-link-obtain">obtained</span>, it has become appropriate to <span
-   data-x="concept-link-obtain">obtain</span> it again (meaning this algorithm is about to be
+   data-x="obtain a link style sheet">obtained</span>, it has become appropriate to <span
+   data-x="obtain a link style sheet">obtain</span> it again (meaning this algorithm is about to be
    invoked again for a newly obtained resource), then return.</p></li>
 
    <li><p class="&#x0058;&#x0058;&#x0058;">Presumably we should be using the response body to

From de9298b415425d738f1be17dc92e05e86636ea46 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Tue, 4 Dec 2018 16:29:35 -0500
Subject: [PATCH 06/18] Updating parallel ordering thanks to annevk

---
 source | 68 +++++++++++++++++++++++-----------------------------------
 1 file changed, 27 insertions(+), 41 deletions(-)

diff --git a/source b/source
index dff7c78f260..848004d6c76 100644
--- a/source
+++ b/source
@@ -13632,8 +13632,9 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
 
   <p>For external resources that are represented in the DOM (for example, style sheets), the DOM
   representation must be made available (modulo cross-origin restrictions) even if the resource is
-  not applied. To <dfn data-x="concept-link-obtain">obtain the resource</dfn>, the user agent must
-  run the following steps:</p>
+  not applied. To <dfn data-x="concept-link-obtain">obtain the resource</dfn> given an optional
+  <span>CSS style sheet</span> <var>styleSheet</var>, the user agent must run the following
+  steps:</p>
 
   <ol>
 
@@ -13698,38 +13699,38 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
 
   <!-- the next few paragraphs are similar to text in the <style> element section -->
   <p>Once the attempts to obtain the resource and its <span>critical subresources</span> are
-  complete, the user agent must, if the loads were successful, <span>queue a task</span> to:</p>
+  complete, the user agent must, let <var>success</var> be true if the resource and its
+  <span>critical subresources</span>, if any, were loaded successfully, and false otherwise.
+  <span>Queue a task</span> on the <span>networking task source</span> do the following:</p>
 
   <ol>
 
-   <li><p><span data-x="concept-event-fire">Fire an event</span> named <code
-   data-x="event-load">load</code> at the <code>link</code> element.</p></li>
+   <li><p>If <var>styleSheet</var> was passed in:</p></li>
 
-   <li><p>If the <code>link</code> element has an <span>associated CSS style sheet</span>, set the
-   <span data-x="CSS style sheet">style sheet</span>'s <span>style sheet done</span> flag.</p></li>
+    <ol>
 
-  </ol>
+     <li><p>Set the <var>styleSheet</var>'s <span>style sheet done</span> flag.</p></li>
 
-  <p>Otherwise, if the resource or one of its <span>critical subresources</span> failed to
-  completely load for any reason (e.g., DNS error, HTTP 404 response, a connection being
-  prematurely closed, unsupported Content-Type), <span>queue a task</span> to:</p>
+     <li><p>If <var>success</var> is true and the <code>link</code> element has an
+     <span>associated CSS style sheet</span>, <span data-x="remove a CSS style sheet">remove the
+     CSS style sheet</span> in question.</p></li>
 
-  <ol>
+     <li><p>If <var>success</var> is true, <span data-x="add a CSS style sheet">add</span> the
+     <span>associated CSS style sheet</span>.</p>
 
-   <li><p><span data-x="concept-event-fire">Fire an event</span> named <code
-   data-x="event-error">error</code> at the <code>link</code> element.</p></li>
+    </ol>
 
-   <li><p>If the <code>link</code> element has an <span>associated CSS style sheet</span>, set the
-   <span data-x="CSS style sheet">style sheet</span>'s <span>style sheet done</span> flag.</p></li>
+   <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
+   named <code data-x="event-load">load</code> at the <code>link</code> element and return.</p></li>
+
+   <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
+   data-x="event-error">error</code> at the <code>link</code> element.</p></li>
 
   </ol>
 
   <p>Non-network errors in processing the resource or its subresources (e.g., CSS parse errors,
   PNG decoding errors) are not failures for the purposes of this paragraph.</p>
 
-  <p>The <span>task source</span> for the <span data-x="concept-task">tasks</span> above is the
-  <span>DOM manipulation task source</span>.</p>
-
   <p>Unless otherwise specified for a given <code data-x="attr-link-rel">rel</code> keyword, the
   element must <span>delay the load event</span> of the element's <span>node document</span> until
   all the attempts to obtain the resource and its <span>critical subresources</span> are complete.
@@ -24708,7 +24709,8 @@ document.body.appendChild(wbr);</code></pre>
 
    <li>
 
-    <p><span>Create a CSS style sheet</span> with the following properties:</p>
+    <p>Create a <span>CSS style sheet</span> <var>styleSheet</var> with the following
+    properties:</p>
 
     <dl>
 
@@ -24784,26 +24786,23 @@ document.body.appendChild(wbr);</code></pre>
 
    </li>
 
+   <li><p>Continue the rest of this algorithm <span>in parallel</span>.</p></li>
+
    <li>
 
-    <p>Let <var>response</var> be the result of running the general <span
-    data-x="concept-link-obtain">link obtain</span> steps, and wait until <var>response</var> is
-    available to continue.</p>
+    <p>Let <var>response</var> be the result of running the <span data-x="concept-link-obtain">link
+    obtain</span> steps with <var>styleSheet</var>.</p>
 
     <p class="&#x0058;&#x0058;&#x0058;">See <a
     href="https://github.com/whatwg/html/issues/968">issue #968</a> for plans to use the CSSOM
     <a href="https://drafts.csswg.org/cssom/#fetching-css-style-sheets">fetch a CSS style sheet</a>
-    algorithm instead of the general link <span data-x="concept-link-obtain">obtain</span>
-    algorithm.</p>
+    algorithm instead of the <span data-x="concept-link-obtain">link obtain</span> algorithm.</p>
 
    </li>
 
    <li><p>If the <span data-x="Content-Type">Content-Type metadata</span> of the resource is not
    <code>text/css</code>, then return.</p></li>
 
-   <li><p>If <var>element</var> has an <span>associated CSS style sheet</span>, <span
-   data-x="remove a CSS style sheet">remove the CSS style sheet</span> in question.</p></li>
-
    <li><p>If <var>element</var> no longer creates an <span>external resource link</span>
    that contributes to the styling processing model, or if, since the resource in question was <span
    data-x="obtain a link style sheet">obtained</span>, it has become appropriate to <span
@@ -24815,19 +24814,6 @@ document.body.appendChild(wbr);</code></pre>
    rules</span>. This is tracked as <a href="https://github.com/whatwg/html/issues/2997">issue
    #2997</a>.</p></li>
 
-   <li>
-
-    <p><span data-x="add a CSS style sheet">Add</span> the previously-created <span>CSS style
-    sheet</span>.</p>
-
-    <p class="note"><span data-x="add a CSS style sheet">Adding</span> the style sheet here, before
-    the task queued in the general link <span data-x="concept-link-obtain">obtain</span> algorithm
-    runs, ensures that the style sheet's <span data-x="concept-css-style-sheet-CSS-rules">CSS
-    rules</span> are exposed to scripts (including document.styleSheets and element.sheet) before
-    this style sheet is no longer <span>a style sheet that is blocking scripts</span>.</p>
-
-   </li>
-
   </ol>
 
   </div>

From bb7c0022097b123434cbd869577faa0151eab870 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Thu, 3 Jan 2019 12:48:53 -0500
Subject: [PATCH 07/18] Refactor link fetching and processing algorithms; not
 touching style sheet done yet

---
 source | 303 ++++++++++++++++++++++++++++++++-------------------------
 1 file changed, 171 insertions(+), 132 deletions(-)

diff --git a/source b/source
index 848004d6c76..a9fd2425292 100644
--- a/source
+++ b/source
@@ -13435,8 +13435,8 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   <p>The <dfn><code data-x="attr-link-referrerpolicy">referrerpolicy</code></dfn> attribute is a
   <span>referrer policy attribute</span>. It is intended for use with <span data-x="external
   resource link">external resource links</span>, where it helps set the <span>referrer policy</span>
-  used when <span data-x="concept-link-obtain">obtaining</span> the external resource. <ref
-  spec=REFERRERPOLICY>.</p>
+  used when <span data-x="fetch-process-linked-resource">fetching and processing the linked
+  resource</span>. <ref spec=REFERRERPOLICY>.</p>
 
   <p>The <dfn><code data-x="attr-link-title">title</code></dfn> attribute gives the title of the
   link. With one exception, it is purely advisory. The value is text. The exception is for style
@@ -13484,10 +13484,8 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   <code>link</code> elements, it must not be specified.</p>
 
   <p w-nodev>The processing model for how the <code data-x="attr-link-as">as</code> attribute is
-  used is given in the steps to obtain the resource, for <span data-x="concept-link-obtain">for
-  <code data-x="rel-preload">preload</code> links</span> and <a
-  href="#modulepreload-obtain-steps">for <code data-x="rel-modulepreload">modulepreload</code>
-  links</a>, respectively.</p>
+  used is given in the steps to <span data-x="fetch-process-linked-resource">fetch and process the
+  linked resource</span>.</p>
 
   <p class="note">The attribute does not have a <i data-x="missing value default">missing value
   default</i> or <i data-x="invalid value default">invalid value default</i>, meaning that invalid
@@ -13570,15 +13568,16 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   string</span>, e.g. the empty string). If the attribute is omitted, but the <span>external
   resource link</span> type has a default type defined, then the user agent must assume that the
   resource is of that type. If the UA does not support the given <span>MIME type</span> for the
-  given link relationship, then the UA should not <span data-x="concept-link-obtain">obtain</span>
-  the resource; if the UA does support the given <span>MIME type</span> for the given link
-  relationship, then the UA should <span data-x="concept-link-obtain">obtain</span> the resource at
-  the appropriate time as specified for the <span>external resource link</span>'s particular type.
+  given link relationship, then the UA should not <span data-x="fetch-process-linked-resource">fetch
+  and process the linked resource</span>; if the UA does support the given <span>MIME type</span>
+  for the given link relationship, then the UA should <span
+  data-x="fetch-process-linked-resource">fetch and process the linked resource</span> at the
+  appropriate time as specified for the <span>external resource link</span>'s particular type.
   If the attribute is omitted, and the <span>external resource link</span> type does not have a
-  default type defined, but the user agent would <span data-x="concept-link-obtain">obtain</span>
-  the resource if the type was known and supported, then the user agent should <span
-  data-x="concept-link-obtain">obtain</span> the resource under the assumption that it will be
-  supported.</p>
+  default type defined, but the user agent would <span data-x="fetch-process-linked-resource">fetch
+  and process the linked resource</span> if the type was known and supported, then the user agent
+  should <span data-x="fetch-process-linked-resource">fetch and process the linked resource</span>
+  under the assumption that it will be supported.</p>
 
   <p>User agents must not consider the <code data-x="attr-link-type">type</code> attribute
   authoritative &mdash; upon fetching the resource, user agents must not use the <code
@@ -13630,11 +13629,17 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
 
   <h5>Obtaining a resource from a <code>link</code> element</h5>
 
-  <p>For external resources that are represented in the DOM (for example, style sheets), the DOM
-  representation must be made available (modulo cross-origin restrictions) even if the resource is
-  not applied. To <dfn data-x="concept-link-obtain">obtain the resource</dfn> given an optional
-  <span>CSS style sheet</span> <var>styleSheet</var>, the user agent must run the following
-  steps:</p>
+  <p>For <span data-x="external resource link">external resource links</span> that are represented
+  in the DOM (for example, style sheets), the DOM representation must be made available (modulo
+  cross-origin restrictions) even if the resource is not applied.</p>
+
+  <p>All <span data-x="external resource link">external resource links</span> have a <dfn
+  data-x="fetch-process-linked-resource">fetch and process the linked resource</dfn> algorithm which
+  takes a <code>link</code> element <var>el</var>. Individual link types may provide their own <span
+  data-x="fetch-process-linked-resource">fetch and process the linked resource</span> algorithm, but
+  unless explicitly stated, they use the <dfn data-x="default-fetch-process-linked-resource">default
+  fetch and process the linked resource</dfn> algorithm, given a <code>link</code>
+  <var>el</var>:</p>
 
   <ol>
 
@@ -13686,45 +13691,62 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
     </ol>
    </li>
 
-   <!--FETCH--><li><p><span data-x="concept-fetch">Fetch</span> <var>request</var>.</p></li>
+   <li>Run the following steps <span>in parallel</span>:</li>
+
+    <ol>
+
+     <!--FETCH--><li><p>Let <var>response</var> be the result of <span
+     data-x="concept-fetch">fetching</span> <var>request</var>.</p></li>
+
+     <li><p>Let <var>success</var> be true.</p></li>
+
+     <li><p>If <var>response</var> is a <span>network error</span> or its <span
+     data-x="concept-response-status">status</span> is not an <span>ok
+     status</span>, set <var>success</var> to false.</p></li>
+
+     <li><p>If <var>success</var> is true, <span data-x="concept-fetch">fetch</span> of the
+     <span>critical subresources</span> of the <span data-x="external resource link">link
+     resource</span>.</p></li>
+     <!--TODO(domfarolino): Add a note or something of the sort here indicating that this is
+     not interoperably defined at the moment-->
+
+     <li><span data-x="process-linked-resource">Process the linked resource</span> given
+     <var>el</var>, <var>success</var>, and <var>response</var>.</li>
+
+    </ol>
 
   </ol>
 
   <p>User agents may opt to only try to obtain such resources when they are needed, instead of
   pro-actively fetching all the external resources that are not applied.</p>
 
+  <!-- TODO: Can I get rid of this paragraph? I feel like this is covered by fetch -->
   <p>The semantics of the protocol used (e.g., HTTP) must be followed when fetching external
   resources. (For example, redirects will be followed and 404 responses will cause the external
   resource to not be applied.)</p>
 
   <!-- the next few paragraphs are similar to text in the <style> element section -->
-  <p>Once the attempts to obtain the resource and its <span>critical subresources</span> are
-  complete, the user agent must, let <var>success</var> be true if the resource and its
-  <span>critical subresources</span>, if any, were loaded successfully, and false otherwise.
-  <span>Queue a task</span> on the <span>networking task source</span> do the following:</p>
+  <!-- TODO: integrate this better with Fetch's process response definition -->
+  <p>Similar to the <span data-x="fetch-process-linked-resource">fetch and process the linked
+  resource</span> algorithm, all <span data-x="external resource link">external resource
+  links</span> have a <dfn data-x="process-linked-resource">process the linked resource</dfn>
+  algorithm which takes a <code>link</code> element <var>el</var>, boolean <var>success</var>, and
+  <span data-x="concept-response">response</span> <var>response</var>. Unless an individual link
+  type provides its own <span data-x="process-linked-resource">process the linked resource</span>
+  algorithm, the <dfn data-x="default-process-linked-resource">default process the linked
+  resource</dfn>, given a <code>link</code> element <var>el</var>, boolean <var>success</var>, and a
+  <span data-x="concept-response">response</span> <var>response</var> is used:</p>
 
   <ol>
 
-   <li><p>If <var>styleSheet</var> was passed in:</p></li>
-
-    <ol>
-
-     <li><p>Set the <var>styleSheet</var>'s <span>style sheet done</span> flag.</p></li>
-
-     <li><p>If <var>success</var> is true and the <code>link</code> element has an
-     <span>associated CSS style sheet</span>, <span data-x="remove a CSS style sheet">remove the
-     CSS style sheet</span> in question.</p></li>
-
-     <li><p>If <var>success</var> is true, <span data-x="add a CSS style sheet">add</span> the
-     <span>associated CSS style sheet</span>.</p>
-
-    </ol>
+   <li><p><span>Queue a task</span> on the <span>networking task source</span> to do the
+   following:</p></li>
 
    <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
-   named <code data-x="event-load">load</code> at the <code>link</code> element and return.</p></li>
+   named <code data-x="event-load">load</code> at <var>el</var>.</p></li>
 
    <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
-   data-x="event-error">error</code> at the <code>link</code> element.</p></li>
+   data-x="event-error">error</code> at the <var>el</var>.</p></li>
 
   </ol>
 
@@ -15198,11 +15220,10 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
 
   <h4>Interactions of styling and scripting</h4>
 
-  <p><span data-x="CSS style sheet">Style sheets</span>, whether added by a <code>link</code>
-  element, a <code>style</code> element, an <code>&lt;?xml-stylesheet?></code> PI, an HTTP
-  `<code data-x="http-link">Link</code>` header, or some other mechanism, have a <dfn>style sheet
-  done</dfn> flag, which is initially unset. When a style sheet is ready to be applied, its
-  <span>style sheet done</span> flag must be set.</p>
+  <p>Style sheets, whether added by a <code>link</code> element, a <code>style</code> element, an
+  <code>&lt;?xml-stylesheet?></code> PI, an HTTP `<code data-x="http-link">Link</code>` header, or
+  some other mechanism, have a <dfn>style sheet done</dfn> flag, which is initially unset. When a
+  style sheet is ready to be applied, its <span>style sheet done</span> flag must be set.</p>
 
   <p class="note">The <span>style sheet done</span> flag is used to indicate when a style sheet has
   been obtained, if necessary, and is ready to be applied. The purpose of this is to make <span>a
@@ -15210,15 +15231,15 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
   scripting is no longer blocked. The algorithm that creates and applies the style sheet is
   responsible for setting this flag.</p>
 
-  If the <span data-x="CSS style sheet">style sheet</span> referenced no other resources (e.g.,
-  it was an internal style sheet given by a <code>style</code> element with no
-  <code data-x="">@import</code> rules), then the style rules must be <span>immediately</span> made
-  available to script; otherwise, the style rules must only be made available to script once the
-  <span>event loop</span> reaches its <span>update the rendering</span> step.
+  If the style sheet referenced no other resources (e.g., it was an internal style sheet given by
+  a <code>style</code> element with no <code data-x="">@import</code> rules), then the style rules
+  must be <span>immediately</span> made available to script; otherwise, the style rules must only be
+  made available to script once the <span>event loop</span> reaches its <span>update the
+  rendering</span> step.
 
-  <p>A <span data-x="CSS style sheet">style sheet</span> in the context of the <code>Document</code>
-  of an <span>HTML parser</span> or <span>XML parser</span> is said to be <dfn>a style sheet that is
-  blocking scripts</dfn> if all of the following conditions occur:</p>
+  <p>A style sheet in the context of the <code>Document</code> of an <span>HTML parser</span> or
+  <span>XML parser</span> is said to be <dfn>a style sheet that is blocking scripts</dfn> if all of
+  the following conditions occur:</p>
 
   <ul>
    <li><p>The element was created by that <code>Document</code>'s parser.</p></li>
@@ -15233,8 +15254,7 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
 
    <li><p>The element's style sheet was enabled when the element was created by the parser.</p></li>
 
-   <li><p>The <span data-x="CSS style sheet">style sheet</span>'s <span>style sheet done</span>
-   flag is not yet set.</p></li>
+   <li><p>The style sheet <span>style sheet done</span> flag is not yet set.</p></li>
 
    <li><p>The last time the <span>event loop</span> reached <a href="#step1">step 1</a>, the
    element's <span>root</span> was that <code>Document</code>.</p></li>
@@ -22491,7 +22511,10 @@ document.body.appendChild(wbr);</code></pre>
    external resources</dfn></dt>
 
    <dd><p>These are links to resources that are to be used to augment the current document,
-   generally automatically processed by the user agent.</p></dd>
+   generally automatically processed by the user agent. All <span data-x="external resource
+   link">external resource links</span> have a <span data-x="fetch-process-linked-resource">fetch
+   and process the linked resource</span> algorithm which describes how the resource is
+   obtained.</p></dd>
 
    <dt><dfn data-x="hyperlink" data-lt="hyperlink" data-export="">Hyperlinks</dfn></dt>
 
@@ -24354,13 +24377,15 @@ document.body.appendChild(wbr);</code></pre>
   <p class="note">Unlike some other link relations, changing the relevant attributes (such as <code
   data-x="attr-link-as">as</code>, <code data-x="attr-link-crossorigin">crossorigin</code>, and
   <code data-x="attr-link-referrerpolicy">referrerpolicy</code>) of such a <code>link</code>
-  attribute does not trigger a new fetch. This is because the document's <span
+  does not trigger a new fetch. This is because the document's <span
   data-x="concept-document-module-map">module map</span> has already been populated by a previous
   fetch, and so re-fetching would be pointless.</p>
 
   <div w-nodev>
 
-  <p id="modulepreload-obtain-steps">To obtain the resource for such a link:</p>
+  <p>The <span data-x="fetch-process-linked-resource">fetch and process the linked resource</span>
+  algorithm for <code data-x="rel-modulepreload">modulepreload</code> links, given a
+  <code>link</code> element <var>el</var>, is as follows:</p>
 
   <ol>
    <li><p>If the <code data-x="attr-link-href">href</code> attribute's value is the empty string,
@@ -24592,8 +24617,9 @@ document.body.appendChild(wbr);</code></pre>
   data-x="concept-request-destination">destination</span>), as it is highly likely that the user
   will require this resource for the current navigation. <span w-nodev>User agents must implement
   the processing model of the <code data-x="rel-preload">preload</code> keyword described in
-  <cite>Preload</cite>, as well as in this specification's <span data-x="concept-link-obtain">obtain
-  the resource</span> algorithm.</span> <ref spec=PRELOAD></p>
+  <cite>Preload</cite>, as well as in this specification's <span
+  data-x="fetch-process-linked-resource">fetch and process the linked resource</span>
+  algorithm.</span> <ref spec=PRELOAD></p>
 
   <p>There is no default type for resources given by the <code data-x="rel-preload">preload</code>
   keyword.</p>
@@ -24650,7 +24676,8 @@ document.body.appendChild(wbr);</code></pre>
 
   <div w-nodev>
 
-  <p>The appropriate times to <span>obtain a link style sheet</span> resource are:
+  <p>The appropriate times to <span data-x="fetch-process-linked-resource">fetch and process</span>
+  this type of link are:
 
   <!-- has a browsing context: https://software.hixie.ch/utilities/js/live-dom-viewer/?saved=4299 -->
   <ul>
@@ -24695,7 +24722,16 @@ document.body.appendChild(wbr);</code></pre>
   and the <span data-x="Content-Type">Content-Type metadata</span> of the external resource is not a
   supported style sheet type, the user agent must instead assume it to be <code>text/css</code>.</p>
 
-  <p>To <dfn>obtain a link style sheet</dfn>, the user agent must run the following steps:</p>
+  <p class="&#x0058;&#x0058;&#x0058;">See <a href="https://github.com/whatwg/html/issues/968">issue
+  #968</a> for plans to use the CSSOM <a
+  href="https://drafts.csswg.org/cssom/#fetching-css-style-sheets">fetch a CSS style sheet</a>
+  algorithm instead of the <span data-x="default-fetch-process-linked-resource">default fetch and
+  process the linked resource</span> algorithm.</p>
+
+  <p>To <span data-x="process-linked-resource">process this type of linked resource</span> given a
+  <code>link</code> element <var>el</var>, boolean <var>success</var>, and <span
+  data-x="concept-response">response</span> <var>response</var>, the user agent must run the
+  following steps:</p>
 
   <!-- note that we can only get this far if we have a browsing context, since if you don't have a
   browsing context (and are active) you can't ever get a result back from "fetch", and thus you
@@ -24704,115 +24740,118 @@ document.body.appendChild(wbr);</code></pre>
 
   <ol>
 
-   <li><p>Let <var>element</var> be the <code>link</code> element that created the <span>external
-   resource link</span>.</p></li>
+   <li><p>If the resource's <span data-x="Content-Type">Content-Type metadata</span> is not
+   <code>text/css</code>, then set <var>success</var> to false.</p></li>
 
-   <li>
+   <li><p>If <var>el</var> no longer creates an <span>external resource link</span> that contributes
+   to the styling processing model, or if, since the resource in question was <span
+   data-x="fetch-process-linked-resource">fetched</span>, it has become appropriate to <span
+   data-x="fetch-process-linked-resource">fetch</span> it again (meaning this algorithm is about to
+   be invoked again for a newly obtained resource), then return.</p></li>
 
-    <p>Create a <span>CSS style sheet</span> <var>styleSheet</var> with the following
-    properties:</p>
+   <li><p><span>Queue a task</span> on the <span>networking task source</span> to do the
+   following:</p></li>
 
-    <dl>
+   <ol>
 
-     <dt><span data-x="concept-css-style-sheet-type">type</span></dt>
-     <dd><p><code>text/css</code></p></dd>
+    <li><p>If <var>el</var> has an <span>associated CSS style sheet</span>, <span data-x="remove a
+    CSS style sheet">remove the CSS style sheet</span>.</p></li>
 
-     <dt><span data-x="concept-css-style-sheet-location">location</span></dt>
-     <dd>
+    <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
+    named <code data-x="event-load">load</code> at <var>el</var>.</p></li>
 
-      <p>The <span>resulting URL string</span> determined during the <span
-      data-x="concept-link-obtain">obtain</span> algorithm.</p>
+    <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
+    data-x="event-error">error</code> at <var>el</var>.</p></li>
 
-      <p class="note">This is before any redirects get applied.</p>
+    <li>
 
-     </dd>
+     <p>Create a <span>CSS style sheet</span> with the following properties:</p>
 
-     <dt><span data-x="concept-css-style-sheet-owner-node">owner node</span></dt>
-     <dd><p><var>element</var></p></dd>
+     <dl>
 
-     <dt><span data-x="concept-css-style-sheet-media">media</span></dt>
+      <dt><span data-x="concept-css-style-sheet-type">type</span></dt>
+      <dd><p><code>text/css</code></p></dd>
 
-     <dd>
+      <dt><span data-x="concept-css-style-sheet-location">location</span></dt>
+      <dd>
 
-      <p>The <code data-x="attr-link-media">media</code> attribute of <var>element</var>.</p>
+       <p>The <span>resulting URL string</span> determined during the <span
+       data-x="fetch-process-linked-resource">fetch and process the linked resource</span>
+       algorithm.</p>
 
-      <p class="note">This is a reference to the (possibly absent at this time) attribute, rather
-      than a copy of the attribute's current value. The CSSOM specification defines what happens
-      when the attribute is dynamically set, changed, or removed.</p>
+       <p class="note">This is before any redirects get applied.</p>
 
-     </dd>
+      </dd>
 
-     <dt><span data-x="concept-css-style-sheet-title">title</span></dt>
+      <dt><span data-x="concept-css-style-sheet-owner-node">owner node</span></dt>
+      <dd><p><var>element</var></p></dd>
 
-     <dd>
+      <dt><span data-x="concept-css-style-sheet-media">media</span></dt>
 
-      <p>The <code data-x="attr-link-title">title</code> attribute of <var>element</var>, if
-      <var>element</var> is <span>in a document tree</span>, or the empty string otherwise.</p>
+      <dd>
 
-      <p class="note">This is similarly a reference to the attribute, rather than a copy of the
-      attribute's current value.</p>
+       <p>The <code data-x="attr-link-media">media</code> attribute of <var>element</var>.</p>
 
-     </dd>
+       <p class="note">This is a reference to the (possibly absent at this time) attribute, rather
+       than a copy of the attribute's current value. The CSSOM specification defines what happens
+       when the attribute is dynamically set, changed, or removed.</p>
 
-     <dt><span data-x="concept-css-style-sheet-alternate-flag">alternate flag</span></dt>
-     <dd><p>Set if <span>the link is an alternative style sheet</span>; unset otherwise.</p></dd>
+      </dd>
 
-     <dt><span data-x="concept-css-style-sheet-origin-clean-flag">origin-clean flag</span></dt>
-     <dd><p>Set if the resource is <span>CORS-same-origin</span>; unset otherwise.</p></dd>
+      <dt><span data-x="concept-css-style-sheet-title">title</span></dt>
 
-     <dt><span data-x="concept-css-style-sheet-parent-CSS-style-sheet">parent CSS style sheet</span></dt>
-     <dt><span data-x="concept-css-style-sheet-owner-CSS-rule">owner CSS rule</span></dt>
-     <dd><p>null</p></dd>
+      <dd>
 
-     <dt><span data-x="concept-css-style-sheet-disabeld-flag">disabled flag</span></dt>
-     <dd><p>Left at its default value.</p></dd>
+       <p>The <code data-x="attr-link-title">title</code> attribute of <var>element</var>, if
+       <var>element</var> is <span>in a document tree</span>, or the empty string otherwise.</p>
 
-     <dt><span data-x="concept-css-style-sheet-CSS-rules">CSS rules</span></dt>
-     <dd><p>Left uninitialized.</p></dd>
+       <p class="note">This is similarly a reference to the attribute, rather than a copy of the
+       attribute's current value.</p>
 
-    </dl>
+      </dd>
 
-    <p>The CSS <span>environment encoding</span> is the result of running the following steps: <ref spec=CSSSYNTAX></p>
+      <dt><span data-x="concept-css-style-sheet-alternate-flag">alternate flag</span></dt>
+      <dd><p>Set if <span>the link is an alternative style sheet</span>; unset otherwise.</p></dd>
 
-    <ol>
+      <dt><span data-x="concept-css-style-sheet-origin-clean-flag">origin-clean flag</span></dt>
+      <dd><p>Set if the resource is <span>CORS-same-origin</span>; unset otherwise.</p></dd>
 
-     <li><p>If the element has a <code data-x="attr-link-charset">charset</code> attribute, <span
-     data-x="getting an encoding">get an encoding</span> from that attribute's value. If that
-     succeeds, return the resulting encoding. <ref spec=ENCODING></p></li>
+      <dt>
+       <span data-x="concept-css-style-sheet-parent-CSS-style-sheet">parent CSS style
+       sheet</span>
+      </dt>
+      <dt><span data-x="concept-css-style-sheet-owner-CSS-rule">owner CSS rule</span></dt>
+      <dd><p>null</p></dd>
 
-     <li><p>Otherwise, return the <span>document's character encoding</span>. <ref spec=DOM></p></li>
+      <dt><span data-x="concept-css-style-sheet-disabeld-flag">disabled flag</span></dt>
+      <dd><p>Left at its default value.</p></dd>
 
-    </ol>
+      <dt><span data-x="concept-css-style-sheet-CSS-rules">CSS rules</span></dt>
+       <dd>
+        <p>Left uninitialized.</p>
 
-   </li>
+        <p class="&#x0058;&#x0058;&#x0058;">This doesn't seem right. Presumably we should be using
+        the response body? Tracked as <a href="https://github.com/whatwg/html/issues/2997">issue
+        #2997</a>.</p>
+       </dd>
 
-   <li><p>Continue the rest of this algorithm <span>in parallel</span>.</p></li>
+     </dl>
 
-   <li>
+     <p>The CSS <span>environment encoding</span> is the result of running the following steps: <ref spec=CSSSYNTAX></p>
 
-    <p>Let <var>response</var> be the result of running the <span data-x="concept-link-obtain">link
-    obtain</span> steps with <var>styleSheet</var>.</p>
+     <ol>
 
-    <p class="&#x0058;&#x0058;&#x0058;">See <a
-    href="https://github.com/whatwg/html/issues/968">issue #968</a> for plans to use the CSSOM
-    <a href="https://drafts.csswg.org/cssom/#fetching-css-style-sheets">fetch a CSS style sheet</a>
-    algorithm instead of the <span data-x="concept-link-obtain">link obtain</span> algorithm.</p>
+      <li><p>If the element has a <code data-x="attr-link-charset">charset</code> attribute, <span
+      data-x="getting an encoding">get an encoding</span> from that attribute's value. If that
+      succeeds, return the resulting encoding. <ref spec=ENCODING></p></li>
 
-   </li>
+      <li><p>Otherwise, return the <span>document's character encoding</span>. <ref spec=DOM></p></li>
 
-   <li><p>If the <span data-x="Content-Type">Content-Type metadata</span> of the resource is not
-   <code>text/css</code>, then return.</p></li>
+     </ol>
 
-   <li><p>If <var>element</var> no longer creates an <span>external resource link</span>
-   that contributes to the styling processing model, or if, since the resource in question was <span
-   data-x="obtain a link style sheet">obtained</span>, it has become appropriate to <span
-   data-x="obtain a link style sheet">obtain</span> it again (meaning this algorithm is about to be
-   invoked again for a newly obtained resource), then return.</p></li>
+    </li>
 
-   <li><p class="&#x0058;&#x0058;&#x0058;">Presumably we should be using the response body to
-   populate the <span>CSS style sheet</span>'s <span data-x="concept-css-style-sheet-CSS-rules">CSS
-   rules</span>. This is tracked as <a href="https://github.com/whatwg/html/issues/2997">issue
-   #2997</a>.</p></li>
+   </ol>
 
   </ol>
 

From 0a7f35b2a8ff951364befbd9db3cdd427b847c10 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Thu, 3 Jan 2019 13:20:09 -0500
Subject: [PATCH 08/18] default-process-linked-resource ignore response, fix
 <ol> nesting

---
 source | 139 +++++++++++++++++++++++++++++----------------------------
 1 file changed, 71 insertions(+), 68 deletions(-)

diff --git a/source b/source
index a9fd2425292..b45900ff88b 100644
--- a/source
+++ b/source
@@ -13734,8 +13734,8 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   <span data-x="concept-response">response</span> <var>response</var>. Unless an individual link
   type provides its own <span data-x="process-linked-resource">process the linked resource</span>
   algorithm, the <dfn data-x="default-process-linked-resource">default process the linked
-  resource</dfn>, given a <code>link</code> element <var>el</var>, boolean <var>success</var>, and a
-  <span data-x="concept-response">response</span> <var>response</var> is used:</p>
+  resource</dfn>, given a <code>link</code> element <var>el</var>, and boolean <var>success</var>
+  (ignoring response) is used:</p>
 
   <ol>
 
@@ -24749,109 +24749,112 @@ document.body.appendChild(wbr);</code></pre>
    data-x="fetch-process-linked-resource">fetch</span> it again (meaning this algorithm is about to
    be invoked again for a newly obtained resource), then return.</p></li>
 
-   <li><p><span>Queue a task</span> on the <span>networking task source</span> to do the
-   following:</p></li>
+   <li>
+    <p><span>Queue a task</span> on the <span>networking task source</span> to do the
+    following:</p>
 
-   <ol>
+    <ol>
 
-    <li><p>If <var>el</var> has an <span>associated CSS style sheet</span>, <span data-x="remove a
-    CSS style sheet">remove the CSS style sheet</span>.</p></li>
+     <li><p>If <var>el</var> has an <span>associated CSS style sheet</span>, <span data-x="remove a
+     CSS style sheet">remove the CSS style sheet</span>.</p></li>
 
-    <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
-    named <code data-x="event-load">load</code> at <var>el</var>.</p></li>
+     <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
+     named <code data-x="event-load">load</code> at <var>el</var>.</p></li>
 
-    <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
-    data-x="event-error">error</code> at <var>el</var>.</p></li>
+     <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
+     data-x="event-error">error</code> at <var>el</var>.</p></li>
 
-    <li>
+     <li>
 
-     <p>Create a <span>CSS style sheet</span> with the following properties:</p>
+      <p>Create a <span>CSS style sheet</span> with the following properties:</p>
 
-     <dl>
+      <dl>
 
-      <dt><span data-x="concept-css-style-sheet-type">type</span></dt>
-      <dd><p><code>text/css</code></p></dd>
+       <dt><span data-x="concept-css-style-sheet-type">type</span></dt>
+       <dd><p><code>text/css</code></p></dd>
 
-      <dt><span data-x="concept-css-style-sheet-location">location</span></dt>
-      <dd>
+       <dt><span data-x="concept-css-style-sheet-location">location</span></dt>
+       <dd>
 
-       <p>The <span>resulting URL string</span> determined during the <span
-       data-x="fetch-process-linked-resource">fetch and process the linked resource</span>
-       algorithm.</p>
+        <p>The <span>resulting URL string</span> determined during the <span
+        data-x="fetch-process-linked-resource">fetch and process the linked resource</span>
+        algorithm.</p>
 
-       <p class="note">This is before any redirects get applied.</p>
+        <p class="note">This is before any redirects get applied.</p>
 
-      </dd>
+       </dd>
 
-      <dt><span data-x="concept-css-style-sheet-owner-node">owner node</span></dt>
-      <dd><p><var>element</var></p></dd>
+       <dt><span data-x="concept-css-style-sheet-owner-node">owner node</span></dt>
+       <dd><p><var>element</var></p></dd>
 
-      <dt><span data-x="concept-css-style-sheet-media">media</span></dt>
+       <dt><span data-x="concept-css-style-sheet-media">media</span></dt>
 
-      <dd>
+       <dd>
 
-       <p>The <code data-x="attr-link-media">media</code> attribute of <var>element</var>.</p>
+        <p>The <code data-x="attr-link-media">media</code> attribute of <var>element</var>.</p>
 
-       <p class="note">This is a reference to the (possibly absent at this time) attribute, rather
-       than a copy of the attribute's current value. The CSSOM specification defines what happens
-       when the attribute is dynamically set, changed, or removed.</p>
+        <p class="note">This is a reference to the (possibly absent at this time) attribute, rather
+        than a copy of the attribute's current value. The CSSOM specification defines what happens
+        when the attribute is dynamically set, changed, or removed.</p>
 
-      </dd>
+       </dd>
 
-      <dt><span data-x="concept-css-style-sheet-title">title</span></dt>
+       <dt><span data-x="concept-css-style-sheet-title">title</span></dt>
 
-      <dd>
+       <dd>
 
-       <p>The <code data-x="attr-link-title">title</code> attribute of <var>element</var>, if
-       <var>element</var> is <span>in a document tree</span>, or the empty string otherwise.</p>
+        <p>The <code data-x="attr-link-title">title</code> attribute of <var>element</var>, if
+        <var>element</var> is <span>in a document tree</span>, or the empty string otherwise.</p>
 
-       <p class="note">This is similarly a reference to the attribute, rather than a copy of the
-       attribute's current value.</p>
+        <p class="note">This is similarly a reference to the attribute, rather than a copy of the
+        attribute's current value.</p>
 
-      </dd>
+       </dd>
 
-      <dt><span data-x="concept-css-style-sheet-alternate-flag">alternate flag</span></dt>
-      <dd><p>Set if <span>the link is an alternative style sheet</span>; unset otherwise.</p></dd>
+       <dt><span data-x="concept-css-style-sheet-alternate-flag">alternate flag</span></dt>
+       <dd><p>Set if <span>the link is an alternative style sheet</span>; unset otherwise.</p></dd>
 
-      <dt><span data-x="concept-css-style-sheet-origin-clean-flag">origin-clean flag</span></dt>
-      <dd><p>Set if the resource is <span>CORS-same-origin</span>; unset otherwise.</p></dd>
+       <dt><span data-x="concept-css-style-sheet-origin-clean-flag">origin-clean flag</span></dt>
+       <dd><p>Set if the resource is <span>CORS-same-origin</span>; unset otherwise.</p></dd>
 
-      <dt>
-       <span data-x="concept-css-style-sheet-parent-CSS-style-sheet">parent CSS style
-       sheet</span>
-      </dt>
-      <dt><span data-x="concept-css-style-sheet-owner-CSS-rule">owner CSS rule</span></dt>
-      <dd><p>null</p></dd>
+       <dt>
+        <span data-x="concept-css-style-sheet-parent-CSS-style-sheet">parent CSS style
+        sheet</span>
+       </dt>
+       <dt><span data-x="concept-css-style-sheet-owner-CSS-rule">owner CSS rule</span></dt>
+       <dd><p>null</p></dd>
 
-      <dt><span data-x="concept-css-style-sheet-disabeld-flag">disabled flag</span></dt>
-      <dd><p>Left at its default value.</p></dd>
+       <dt><span data-x="concept-css-style-sheet-disabeld-flag">disabled flag</span></dt>
+       <dd><p>Left at its default value.</p></dd>
 
-      <dt><span data-x="concept-css-style-sheet-CSS-rules">CSS rules</span></dt>
-       <dd>
-        <p>Left uninitialized.</p>
+       <dt><span data-x="concept-css-style-sheet-CSS-rules">CSS rules</span></dt>
+        <dd>
+         <p>Left uninitialized.</p>
 
-        <p class="&#x0058;&#x0058;&#x0058;">This doesn't seem right. Presumably we should be using
-        the response body? Tracked as <a href="https://github.com/whatwg/html/issues/2997">issue
-        #2997</a>.</p>
-       </dd>
+         <p class="&#x0058;&#x0058;&#x0058;">This doesn't seem right. Presumably we should be using
+         the response body? Tracked as <a href="https://github.com/whatwg/html/issues/2997">issue
+         #2997</a>.</p>
+        </dd>
 
-     </dl>
+      </dl>
 
-     <p>The CSS <span>environment encoding</span> is the result of running the following steps: <ref spec=CSSSYNTAX></p>
+      <p>The CSS <span>environment encoding</span> is the result of running the following steps: <ref spec=CSSSYNTAX></p>
 
-     <ol>
+      <ol>
 
-      <li><p>If the element has a <code data-x="attr-link-charset">charset</code> attribute, <span
-      data-x="getting an encoding">get an encoding</span> from that attribute's value. If that
-      succeeds, return the resulting encoding. <ref spec=ENCODING></p></li>
+       <li><p>If the element has a <code data-x="attr-link-charset">charset</code> attribute, <span
+       data-x="getting an encoding">get an encoding</span> from that attribute's value. If that
+       succeeds, return the resulting encoding. <ref spec=ENCODING></p></li>
 
-      <li><p>Otherwise, return the <span>document's character encoding</span>. <ref spec=DOM></p></li>
+       <li><p>Otherwise, return the <span>document's character encoding</span>. <ref spec=DOM></p></li>
 
-     </ol>
+      </ol>
 
-    </li>
+     </li>
 
-   </ol>
+    </ol>
+
+   </li>
 
   </ol>
 

From b7d464d19d8da79a588ee18269b60f208d109db6 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Thu, 3 Jan 2019 13:31:38 -0500
Subject: [PATCH 09/18] Fix more <ol> nesting

---
 source | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/source b/source
index b45900ff88b..f8858ddbd50 100644
--- a/source
+++ b/source
@@ -13691,7 +13691,8 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
     </ol>
    </li>
 
-   <li>Run the following steps <span>in parallel</span>:</li>
+   <li>
+    <p>Run the following steps <span>in parallel</span>:</p>
 
     <ol>
 
@@ -13715,6 +13716,8 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
 
     </ol>
 
+   </li>
+
   </ol>
 
   <p>User agents may opt to only try to obtain such resources when they are needed, instead of

From 9510d4cc274df1a61d14df445104080dc50ac430 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Thu, 3 Jan 2019 23:15:08 -0500
Subject: [PATCH 10/18] Use script-blocking style sheet counter + custom linked
 resource fetch steps

---
 source | 240 ++++++++++++++++++++++++++++++++++-----------------------
 1 file changed, 142 insertions(+), 98 deletions(-)

diff --git a/source b/source
index f8858ddbd50..ff99b6ae6b9 100644
--- a/source
+++ b/source
@@ -2022,6 +2022,16 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute
   available to be correctly processed. Which resources are considered critical or not is defined by
   the specification that defines the resource's format.</p>
 
+  <p>For <span data-x="CSS style sheet">CSS style sheets</span>, we tentatively define here that
+  their critical subresources are other style sheets imported via <code data-x="">@import</code>
+  rules, including those indirectly imported by other imported style sheets.</p>
+
+  <p class="&#x0058;&#x0058;&#x0058;">This definition is not fully interoperable; furthermore, some
+  user agents seem to count resources like background images or web fonts as critical subresources.
+  Ideally, the CSS Working Group should define this; see <a
+  href="https://github.com/w3c/csswg-drafts/issues/1088">w3c/csswg-drafts #1088</a> to track
+  progress on that front.</p>
+
 
   <h4 id="xml">XML compatibility</h4>
 
@@ -13635,53 +13645,53 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
 
   <p>All <span data-x="external resource link">external resource links</span> have a <dfn
   data-x="fetch-process-linked-resource">fetch and process the linked resource</dfn> algorithm which
-  takes a <code>link</code> element <var>el</var>. Individual link types may provide their own <span
-  data-x="fetch-process-linked-resource">fetch and process the linked resource</span> algorithm, but
-  unless explicitly stated, they use the <dfn data-x="default-fetch-process-linked-resource">default
-  fetch and process the linked resource</dfn> algorithm, given a <code>link</code>
-  <var>el</var>:</p>
+  takes a <code>link</code> element <var>el</var>, and optionally a set of <dfn>custom linked
+  resource fetch steps</dfn> to run before the resource is fetched. Individual link types may
+  provide their own <span data-x="fetch-process-linked-resource">fetch and process the linked
+  resource</span> algorithm, but unless explicitly stated, they use the <dfn
+  data-x="default-fetch-process-linked-resource">default fetch and process the linked resource</dfn>
+  algorithm, given a <code>link</code> element <var>el</var>, and optionally some <span>custom
+  linked resource fetch steps</span>:</p>
 
   <ol>
 
-   <li><p>If the <code data-x="attr-link-href">href</code> attribute's value is the empty string,
-   then return.</p></li>
+   <li><p>If <var>el</var>'s <code data-x="attr-link-href">href</code> attribute's value is the
+   empty string, then return.</p></li>
 
-   <li><p><span data-x="parse a url">Parse</span> the <span>URL</span> given by the <code
-   data-x="attr-link-href">href</code> attribute, relative to the element's <span>node
-   document</span>. If that fails, then return. Otherwise, let <var>url</var> be the
-   <span>resulting URL record</span>.</p></li>
+   <li><p><span data-x="parse a url">Parse</span> the <span>URL</span> given by <var>el</var>'s
+   <code data-x="attr-link-href">href</code> attribute, relative to <var>el</var>'s <span>node
+   document</span>. If that fails, then return. Otherwise, let <var>url</var> be the <span>resulting
+   URL record</span>.</p></li>
 
-   <li><p>Let <var>corsAttributeState</var> be the current state of the element's <code
+   <li><p>Let <var>corsAttributeState</var> be the current state of the <var>el</var>'s <code
    data-x="attr-link-crossorigin">crossorigin</code> content attribute.</p></li>
 
    <li><p>Let <var>request</var> be the result of <span
    data-x="create a potential-CORS request">creating a potential-CORS request</span> given
    <var>url</var>, the empty string, and <var>corsAttributeState</var>.</p></li>
 
-   <li><p>Set <var>request</var>'s <span data-x="concept-request-client">client</span> to the
-   <code>link</code> element's <span>node document</span>'s <span>relevant settings
-   object</span>.</p></li>
+   <li><p>Set <var>request</var>'s <span data-x="concept-request-client">client</span> to
+   <var>el</var>'s <span>node document</span>'s <span>relevant settings object</span>.</p></li>
 
    <li><p>Set <var>request</var>'s <span data-x="concept-request-nonce-metadata">cryptographic
-   nonce metadata</span> to the current value of the <code>link</code> element's
-   <span>[[CryptographicNonce]]</span> internal slot.</p></li>
+   nonce metadata</span> to the current value of <var>el</var>'s <span>[[CryptographicNonce]]</span>
+   internal slot.</p></li>
 
    <li><p>Set <var>request</var>'s <span data-x="concept-request-integrity-metadata">integrity
-   metadata</span> to the current value of the <code>link</code> element's <code
+   metadata</span> to the current value of <var>el</var>'s <code
    data-x="attr-link-integrity">integrity</code> content attribute.</p></li>
 
    <li><p>Set <var>request</var>'s
    <span data-x="concept-request-referrer-policy">referrer policy</span> to the current state of the
-   <code>link</code> element's <code data-x="attr-link-referrerpolicy">referrerpolicy</code>
-   attribute.</p></li>
+   <var>el</var>'s <code data-x="attr-link-referrerpolicy">referrerpolicy</code> attribute.</p></li>
 
    <li>
-    <p>If the <code data-x="attr-link-rel">rel</code> attribute contains the <code
+    <p>If <var>el</var>'s <code data-x="attr-link-rel">rel</code> attribute contains the <code
     data-x="rel-preload">preload</code> keyword, then:</p>
 
     <ol>
-     <li><p>Let <var>as</var> be the current state of the <code data-x="attr-link-as">as</code>
-     attribute.</p></li>
+     <li><p>Let <var>as</var> be the current state of <var>el</var>'s <code
+     data-x="attr-link-as">as</code> attribute.</p></li>
 
      <li><p>If <var>as</var> is no state, then return.</p></li>
 
@@ -13691,11 +13701,13 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
     </ol>
    </li>
 
+   <li><p>If the caller provided <span>custom linked resource fetch steps</span>, run them
+   now, given <var>el</var>.<p></li>
+
    <li>
     <p>Run the following steps <span>in parallel</span>:</p>
 
     <ol>
-
      <!--FETCH--><li><p>Let <var>response</var> be the result of <span
      data-x="concept-fetch">fetching</span> <var>request</var>.</p></li>
 
@@ -13708,14 +13720,10 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
      <li><p>If <var>success</var> is true, <span data-x="concept-fetch">fetch</span> of the
      <span>critical subresources</span> of the <span data-x="external resource link">link
      resource</span>.</p></li>
-     <!--TODO(domfarolino): Add a note or something of the sort here indicating that this is
-     not interoperably defined at the moment-->
 
      <li><span data-x="process-linked-resource">Process the linked resource</span> given
      <var>el</var>, <var>success</var>, and <var>response</var>.</li>
-
     </ol>
-
    </li>
 
   </ol>
@@ -13723,11 +13731,6 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   <p>User agents may opt to only try to obtain such resources when they are needed, instead of
   pro-actively fetching all the external resources that are not applied.</p>
 
-  <!-- TODO: Can I get rid of this paragraph? I feel like this is covered by fetch -->
-  <p>The semantics of the protocol used (e.g., HTTP) must be followed when fetching external
-  resources. (For example, redirects will be followed and 404 responses will cause the external
-  resource to not be applied.)</p>
-
   <!-- the next few paragraphs are similar to text in the <style> element section -->
   <!-- TODO: integrate this better with Fetch's process response definition -->
   <p>Similar to the <span data-x="fetch-process-linked-resource">fetch and process the linked
@@ -13742,14 +13745,20 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
 
   <ol>
 
-   <li><p><span>Queue a task</span> on the <span>networking task source</span> to do the
-   following:</p></li>
+   <li>
+    <p><span>Queue a task</span> on the <span>networking task source</span> to run these steps:</p>
+
+    <ol>
+
+     <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
+     named <code data-x="event-load">load</code> at <var>el</var>.</p></li>
+
+     <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
+     data-x="event-error">error</code> at <var>el</var>.</p></li>
 
-   <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
-   named <code data-x="event-load">load</code> at <var>el</var>.</p></li>
+    </ol>
 
-   <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
-   data-x="event-error">error</code> at the <var>el</var>.</p></li>
+   </li>
 
   </ol>
 
@@ -13773,6 +13782,12 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   headers is distinct from <a href="#linkTypes">HTML link types</a>, and thus their semantics can be
   different from same-named HTML types.</p>
 
+  <p class="&#x0058;&#x0058;&#x0058;">The processing of `<code data-x="http-link">Link</code>`
+  headers, in particular their influence on a <code>Document</code>'s <span>script-blocking style
+  sheet counter</span> isn't defined. See <a href="https://github.com/whatwg/html/issues/4224">Issue
+  #4224</a> for discussion on integrating this into the spec.</p>
+
+
   </div>
 
   <h5>Providing users with a means to follow hyperlinks created using the <code>link</code>
@@ -15140,41 +15155,49 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
 
   </ol>
 
-  <!-- the next few paragraphs are similar to text in the <link> section -->
+  <!-- the following steps are similar to the text in the <link> element's default process the
+  linked resource algorithm -->
   <p>Once the attempts to obtain the style sheet's <span>critical subresources</span>, if any, are
   complete, or, if the style sheet has no <span>critical subresources</span>, once the style sheet
-  has been parsed and processed, the user agent must, if the loads were successful or there were
-  none, <span>queue a task</span> to:</p>
+  has been parsed and processed, the user agent must run these steps:</p>
 
   <ol>
 
-   <li><p><span data-x="concept-event-fire">Fire an event</span> named <code
-   data-x="event-load">load</code> at the <code>style</code> element.</p></li>
+   <li><p>Let <var>success</var> be true.</p></li>
 
-   <li><p>Set the <code>style</code> element's <span>associated CSS style sheet</span>'s <span>style
-   sheet done</span> flag.</p></li>
+   <li><p>If the attempts to obtain any of the style sheet's <span>critical subresources</span>
+   failed for any reason (e.g., DNS error, HTTP 404 response, a connection being prematurely closed,
+   unsupported Content-Type), set <var>success</var> to false.</p></li>
 
-  </ol>
+   <li>
+    <p><span>Queue a task</span> on the <span>networking task source</span> to run these steps:</p>
 
-  <p>Otherwise if one of the style sheet's <span>critical subresources</span> failed to completely
-  load for any reason (e.g., DNS error, HTTP 404 response, a connection being prematurely closed,
-  unsupported Content-Type), <span>queue a task</span> to:</p>
+    <ol>
+     <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
+     named <code data-x="event-load">load</code> at the <var>element</var>.</p></li>
 
-  <ol>
+     <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
+     data-x="event-error">error</code> at the <var>element</var>.</p></li>
 
-   <li><p><span data-x="concept-event-fire">Fire an event</span> named <code
-   data-x="event-error">error</code> at the <code>style</code> element.</p></li>
+     <li>
+      <p>If the <var>element</var> <span>contributes a script-blocking style sheet</span>:</p>
 
-   <li><p>Set the <code>style</code> element's <span>associated CSS style sheet</span>'s <span>style
-   sheet done</span> flag.</p></li>
+      <ol>
+       <li><p>Assert: <var>element</var>'s <span>node document</span>'s <span>script-blocking style
+       sheet counter</span> is greater than 0.</p></li>
+
+       <li><p>Decrement <var>element</var>'s <span>node document</span>'s <span>script-blocking
+       style sheet counter</span> by one.</p></li>
+
+      </ol>
+     </li>
+    </ol>
+   </li>
 
   </ol>
 
   <p>Non-network errors in processing the style sheet or its subresources (e.g., CSS parse errors, PNG
-  decoding errors) are not failures for the purposes of this paragraph.</p>
-
-  <p>The <span>task source</span> for the <span data-x="concept-task">tasks</span> above is the
-  <span>DOM manipulation task source</span>.</p>
+  decoding errors) are not failures for the purposes of the above paragraph.</p>
 
   <p>The element must <span>delay the load event</span> of the element's <span>node document</span> until all the
   attempts to obtain the style sheet's <span>critical subresources</span>, if any, are complete.</p>
@@ -15223,47 +15246,35 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
 
   <h4>Interactions of styling and scripting</h4>
 
-  <p>Style sheets, whether added by a <code>link</code> element, a <code>style</code> element, an
-  <code>&lt;?xml-stylesheet?></code> PI, an HTTP `<code data-x="http-link">Link</code>` header, or
-  some other mechanism, have a <dfn>style sheet done</dfn> flag, which is initially unset. When a
-  style sheet is ready to be applied, its <span>style sheet done</span> flag must be set.</p>
-
-  <p class="note">The <span>style sheet done</span> flag is used to indicate when a style sheet has
-  been obtained, if necessary, and is ready to be applied. The purpose of this is to make <span>a
-  style sheet that is blocking scripts</span> no longer a style sheet of this category, so that
-  scripting is no longer blocked. The algorithm that creates and applies the style sheet is
-  responsible for setting this flag.</p>
-
   If the style sheet referenced no other resources (e.g., it was an internal style sheet given by
   a <code>style</code> element with no <code data-x="">@import</code> rules), then the style rules
   must be <span>immediately</span> made available to script; otherwise, the style rules must only be
   made available to script once the <span>event loop</span> reaches its <span>update the
   rendering</span> step.
 
-  <p>A style sheet in the context of the <code>Document</code> of an <span>HTML parser</span> or
-  <span>XML parser</span> is said to be <dfn>a style sheet that is blocking scripts</dfn> if all of
-  the following conditions occur:</p>
+  <p>An element <var>el</var> in the context of a <code>Document</code> of an <span>HTML
+  parser</span> or <span>XML parser</span> <dfn>contributes a script-blocking style sheet</dfn> if
+  all of the following conditions are true:</p>
 
   <ul>
-   <li><p>The element was created by that <code>Document</code>'s parser.</p></li>
+   <li><p><var>el</var> was created by that <code>Document</code>'s parser.</p></li>
 
-   <li><p>The element is either a <code>style</code> element or a <code>link</code> element that was
-   an <span data-x="rel-stylesheet">external resource link that contributes to the styling
-   processing model</span> when the element was created by the parser.</p></li>
+   <li><p><var>el</var> is either a <code>style</code> element or a <code>link</code> element that
+   was an <span data-x="rel-stylesheet">external resource link that contributes to the styling
+   processing model</span> when the <var>el</var> was created by the parser.</p></li>
 
-   <li><p>If the element is a <code>link</code> element, it's <code
+   <li><p>If the <var>el</var> is a <code>link</code> element, it's <code
    data-x="attr-link-media">media</code> attribute's value <span>matches the
    environment</span>.</p></li>
 
-   <li><p>The element's style sheet was enabled when the element was created by the parser.</p></li>
+   <li><p><var>el</var>'s style sheet was enabled when the element was created by the
+   parser.</p></li>
 
-   <li><p>The style sheet <span>style sheet done</span> flag is not yet set.</p></li>
+   <li><p>The last time the <span>event loop</span> reached <a href="#step1">step 1</a>,
+   <var>el</var>'s <span>root</span> was that <code>Document</code>.</p></li>
 
-   <li><p>The last time the <span>event loop</span> reached <a href="#step1">step 1</a>, the
-   element's <span>root</span> was that <code>Document</code>.</p></li>
-
-   <li><p>The user agent hasn't given up on that particular style sheet yet. A user agent may give
-   up on a style sheet at any time.</p></li>
+   <li><p>The user agent hasn't given up on loading that particular style sheet yet. A user agent
+   may give up on loading a style sheet at any time.</p></li>
   </ul>
 
   <p class="note">Giving up on a style sheet before the style sheet loads, if the style sheet
@@ -15275,12 +15286,14 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
   have to balance the likelihood of a script using incorrect information with the performance impact
   of doing nothing while waiting for a slow network request to finish.</p>
 
-  <p>A <code>Document</code> <dfn>has a style sheet that is blocking scripts</dfn> if there is
-  either <span>a style sheet that is blocking scripts</span> in the context of that
-  <code>Document</code>, or if that <code>Document</code> has a <span
-  data-x="concept-document-bc">browsing context</span> that has a <span>parent browsing
-  context</span>, and the <span>active document</span> of that <span>parent browsing context</span>
-  itself <span>has a style sheet that is blocking scripts</span>.</p>
+  <p>A <code>Document</code> has a <dfn>script-blocking style sheet counter</dfn>, which is a
+  number, initially 0.</p>
+
+  <p>A <code>Document</code> <dfn>has a style sheet that is blocking scripts</dfn> if its
+  <span>script-blocking style sheet counter</span> is greater than 0, or if that
+  <code>Document</code> has a <span data-x="concept-document-bc">browsing context</span> that has a
+  <span>parent browsing context</span>, and the <span>active document</span> of that <span>parent
+  browsing context</span>'s <span>script-blocking style sheet counter</span> is greater than 0.</p>
 
   <p>A <code>Document</code> <dfn>has no style sheet that is blocking scripts</dfn> if it does not
   <span data-x="has a style sheet that is blocking scripts">have a style sheet that is blocking
@@ -24725,6 +24738,22 @@ document.body.appendChild(wbr);</code></pre>
   and the <span data-x="Content-Type">Content-Type metadata</span> of the external resource is not a
   supported style sheet type, the user agent must instead assume it to be <code>text/css</code>.</p>
 
+  <p>Let the <span>custom linked resource fetch steps</span> for this type of linked resource be the
+  following, given a <code>link</code> element <var>el</var>:</p>
+
+  <ol>
+
+   <li><p>If <var>el</var> <span>contributes a script-blocking style sheet</span>, increment
+   <var>el</var>'s <span>node document</span>'s <span>script-blocking style sheet counter</span> by
+   one.</p></li>
+
+  </ol>
+
+  <p>To <span data-x="fetch-process-linked-resource">fetch and process</span> this type of linked
+  resource, user agents must run the <span data-x="default-fetch-process-linked-resource">default
+  fetch and process the linked resource</span> algorithm with the above <span>custom linked
+  resource fetch steps</span>.
+
   <p class="&#x0058;&#x0058;&#x0058;">See <a href="https://github.com/whatwg/html/issues/968">issue
   #968</a> for plans to use the CSSOM <a
   href="https://drafts.csswg.org/cssom/#fetching-css-style-sheets">fetch a CSS style sheet</a>
@@ -24753,8 +24782,7 @@ document.body.appendChild(wbr);</code></pre>
    be invoked again for a newly obtained resource), then return.</p></li>
 
    <li>
-    <p><span>Queue a task</span> on the <span>networking task source</span> to do the
-    following:</p>
+    <p><span>Queue a task</span> on the <span>networking task source</span> to run these steps:</p>
 
     <ol>
 
@@ -24767,6 +24795,22 @@ document.body.appendChild(wbr);</code></pre>
      <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
      data-x="event-error">error</code> at <var>el</var>.</p></li>
 
+     <li>
+      <p>If <var>el</var> <span>contributes a script-blocking style sheet</span>, run these
+      steps:</p>
+
+      <ol>
+
+       <li><p>Assert: <var>el</var>'s <span>node document</span>'s <span>script-blocking style sheet
+       counter</span> is greater than 0.</p></li>
+
+       <li><p>Decrement <var>el</var>'s <span>node document</span>'s <span>script-blocking style
+       sheet counter</span> by one.</p></li>
+
+      </ol>
+
+     </li>
+
      <li>
 
       <p>Create a <span>CSS style sheet</span> with the following properties:</p>
@@ -58505,11 +58549,11 @@ o............A....e
   <p class="note">If a <code>script</code> element that blocks a parser gets moved to another
   <code>Document</code> before it would normally have stopped blocking that parser, it nonetheless
   continues blocking that parser until the condition that causes it to be blocking the parser no
-  longer applies (e.g. if the script is a <span>pending parsing-blocking script</span> because there
-  was <span>a style sheet that is blocking scripts</span> when it was parsed, but then the script is
-  moved to another <code>Document</code> before the style sheet loads, the script still blocks the
-  parser until the style sheets are all loaded, at which time the script executes and the parser is
-  unblocked).</p>
+  longer applies (e.g., if the script is a <span>pending parsing-blocking script</span> because the
+  original <code>Document</code> <span>has a style sheet that is blocking scripts</span> when it was
+  parsed, but then the script is moved to another <code>Document</code> before the blocking style
+  sheet(s) loaded, the script still blocks the parser until the style sheets are all loaded, at
+  which time the script executes and the parser is unblocked).</p>
 
   <!-- also (and this would be worth testing): the way the spec is written, if you do not have a
   style sheet that is blocking scripts, then you parse a <script src>, then while waiting for the

From b8ad3425da7672a8d4151baa61953792dd2b7142 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Thu, 3 Jan 2019 23:19:42 -0500
Subject: [PATCH 11/18] Remove add a CSS style sheet dfn x-ref

---
 source | 1 -
 1 file changed, 1 deletion(-)

diff --git a/source b/source
index ff99b6ae6b9..a0571977260 100644
--- a/source
+++ b/source
@@ -3770,7 +3770,6 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute
      <li><dfn data-x-href="https://drafts.csswg.org/cssom/#the-cssstyledeclaration-interface"><code>CSSStyleDeclaration</code></dfn> interface</li>
      <li><dfn data-x="dom-CSSStyleDeclaration-cssText" data-x-href="https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-csstext"><code>cssText</code></dfn> attribute of <code>CSSStyleDeclaration</code></li>
      <li><dfn data-x-href="https://drafts.csswg.org/cssom/#the-stylesheet-interface"><code>StyleSheet</code></dfn> interface</li>
-     <li><dfn data-x-href="https://drafts.csswg.org/cssom/#add-a-css-style-sheet">add a CSS style sheet</dfn></li>
      <li><dfn data-x-href="https://drafts.csswg.org/cssom/#create-a-css-style-sheet">create a CSS style sheet</dfn></li>
      <li><dfn data-x-href="https://drafts.csswg.org/cssom/#remove-a-css-style-sheet">remove a CSS style sheet</dfn></li>
      <li><dfn data-x-href="https://drafts.csswg.org/cssom/#associated-css-style-sheet">associated CSS style sheet</dfn></li>

From 3c2fa8f7d80dd41e3d6df662fdb272fbf91f2c97 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Fri, 4 Jan 2019 00:14:58 -0500
Subject: [PATCH 12/18] Minor changes/fixes

---
 source | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/source b/source
index a0571977260..40667f90952 100644
--- a/source
+++ b/source
@@ -13716,7 +13716,7 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
      data-x="concept-response-status">status</span> is not an <span>ok
      status</span>, set <var>success</var> to false.</p></li>
 
-     <li><p>If <var>success</var> is true, <span data-x="concept-fetch">fetch</span> of the
+     <li><p>If <var>success</var> is true, <span data-x="concept-fetch">fetch</span> the
      <span>critical subresources</span> of the <span data-x="external resource link">link
      resource</span>.</p></li>
 
@@ -13748,21 +13748,18 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
     <p><span>Queue a task</span> on the <span>networking task source</span> to run these steps:</p>
 
     <ol>
-
      <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
      named <code data-x="event-load">load</code> at <var>el</var>.</p></li>
 
      <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
      data-x="event-error">error</code> at <var>el</var>.</p></li>
-
     </ol>
-
    </li>
 
   </ol>
 
   <p>Non-network errors in processing the resource or its subresources (e.g., CSS parse errors,
-  PNG decoding errors) are not failures for the purposes of this paragraph.</p>
+  PNG decoding errors) are not failures for the purposes of the above paragraph.</p>
 
   <p>Unless otherwise specified for a given <code data-x="attr-link-rel">rel</code> keyword, the
   element must <span>delay the load event</span> of the element's <span>node document</span> until
@@ -13783,8 +13780,9 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
 
   <p class="&#x0058;&#x0058;&#x0058;">The processing of `<code data-x="http-link">Link</code>`
   headers, in particular their influence on a <code>Document</code>'s <span>script-blocking style
-  sheet counter</span> isn't defined. See <a href="https://github.com/whatwg/html/issues/4224">Issue
-  #4224</a> for discussion on integrating this into the spec.</p>
+  sheet counter</span>, is not defined. See <a
+  href="https://github.com/whatwg/html/issues/4224">Issue #4224</a> for discussion on integrating
+  this into the spec.</p>
 
 
   </div>
@@ -15179,7 +15177,7 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
      data-x="event-error">error</code> at the <var>element</var>.</p></li>
 
      <li>
-      <p>If the <var>element</var> <span>contributes a script-blocking style sheet</span>:</p>
+      <p>If <var>element</var> <span>contributes a script-blocking style sheet</span>:</p>
 
       <ol>
        <li><p>Assert: <var>element</var>'s <span>node document</span>'s <span>script-blocking style
@@ -24761,8 +24759,8 @@ document.body.appendChild(wbr);</code></pre>
 
   <p>To <span data-x="process-linked-resource">process this type of linked resource</span> given a
   <code>link</code> element <var>el</var>, boolean <var>success</var>, and <span
-  data-x="concept-response">response</span> <var>response</var>, the user agent must run the
-  following steps:</p>
+  data-x="concept-response">response</span> <var>response</var>, the user agent must run these
+  steps:</p>
 
   <!-- note that we can only get this far if we have a browsing context, since if you don't have a
   browsing context (and are active) you can't ever get a result back from "fetch", and thus you

From c70d9de9e515e6b1f70cab6d04cbd56604460df9 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Thu, 10 Jan 2019 01:59:04 -0500
Subject: [PATCH 13/18] Fix low-hanging fruit

---
 source | 92 +++++++++++++++++++++++++++++++++-------------------------
 1 file changed, 53 insertions(+), 39 deletions(-)

diff --git a/source b/source
index 40667f90952..dddd45cc481 100644
--- a/source
+++ b/source
@@ -2028,7 +2028,7 @@ a.setAttribute('href', 'https://example.com/'); // change the content attribute
 
   <p class="&#x0058;&#x0058;&#x0058;">This definition is not fully interoperable; furthermore, some
   user agents seem to count resources like background images or web fonts as critical subresources.
-  Ideally, the CSS Working Group should define this; see <a
+  Ideally, the CSS Working Group would define this; see <a
   href="https://github.com/w3c/csswg-drafts/issues/1088">w3c/csswg-drafts #1088</a> to track
   progress on that front.</p>
 
@@ -13642,15 +13642,17 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   in the DOM (for example, style sheets), the DOM representation must be made available (modulo
   cross-origin restrictions) even if the resource is not applied.</p>
 
-  <p>All <span data-x="external resource link">external resource links</span> have a <dfn
-  data-x="fetch-process-linked-resource">fetch and process the linked resource</dfn> algorithm which
-  takes a <code>link</code> element <var>el</var>, and optionally a set of <dfn>custom linked
-  resource fetch steps</dfn> to run before the resource is fetched. Individual link types may
-  provide their own <span data-x="fetch-process-linked-resource">fetch and process the linked
-  resource</span> algorithm, but unless explicitly stated, they use the <dfn
+  <p id="concept-link-obtain">All <span data-x="external resource link">external resource
+  links</span> have <dfn>custom linked resource fetch steps</dfn> which take a <code>link</code>
+  element <var>el</var> and <span data-x="concept-request">request</span> <var>request</var>, as
+  well as a <dfn data-x="fetch-process-linked-resource">fetch and process the linked resource</dfn>
+  algorithm, which takes a <code>link</code> element <var>el</var>. Individual link types may
+  provide their own <span>custom linked resource fetch steps</span>, but unless explicitly stated,
+  these steps are empty. Similarly, individual link types may provide their own <span
+  data-x="fetch-process-linked-resource">fetch and process the linked resource</span> algorithm, but
+  unless explicitly stated, they use the following <dfn
   data-x="default-fetch-process-linked-resource">default fetch and process the linked resource</dfn>
-  algorithm, given a <code>link</code> element <var>el</var>, and optionally some <span>custom
-  linked resource fetch steps</span>:</p>
+  algorithm, given a <code>link</code> element <var>el</var>:</p>
 
   <ol>
 
@@ -13700,8 +13702,8 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
     </ol>
    </li>
 
-   <li><p>If the caller provided <span>custom linked resource fetch steps</span>, run them
-   now, given <var>el</var>.<p></li>
+   <li><p>Run the <span>custom linked resource fetch steps</span>, given <var>el</var> and
+   <var>request</var>.<p></li>
 
    <li>
     <p>Run the following steps <span>in parallel</span>:</p>
@@ -13716,9 +13718,13 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
      data-x="concept-response-status">status</span> is not an <span>ok
      status</span>, set <var>success</var> to false.</p></li>
 
-     <li><p>If <var>success</var> is true, <span data-x="concept-fetch">fetch</span> the
-     <span>critical subresources</span> of the <span data-x="external resource link">link
-     resource</span>.</p></li>
+     <li>
+      <p>If <var>success</var> is true, <span data-x="concept-fetch">fetch</span> the <span>critical
+      subresources</span> of the <span data-x="external resource link">link resource</span>.</p>
+
+      <p class="note">Note that content-specific errors, e.g., CSS parse errors or PNG decoding
+      errors, do not affect <var>success</var>.</p>
+     </li>
 
      <li><span data-x="process-linked-resource">Process the linked resource</span> given
      <var>el</var>, <var>success</var>, and <var>response</var>.</li>
@@ -13739,8 +13745,8 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   <span data-x="concept-response">response</span> <var>response</var>. Unless an individual link
   type provides its own <span data-x="process-linked-resource">process the linked resource</span>
   algorithm, the <dfn data-x="default-process-linked-resource">default process the linked
-  resource</dfn>, given a <code>link</code> element <var>el</var>, and boolean <var>success</var>
-  (ignoring response) is used:</p>
+  resource</dfn> algorithm, given a <code>link</code> element <var>el</var>, and boolean
+  <var>success</var> (ignoring <var>response</var>) is used:</p>
 
   <ol>
 
@@ -13758,14 +13764,12 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
 
   </ol>
 
-  <p>Non-network errors in processing the resource or its subresources (e.g., CSS parse errors,
-  PNG decoding errors) are not failures for the purposes of the above paragraph.</p>
-
   <p>Unless otherwise specified for a given <code data-x="attr-link-rel">rel</code> keyword, the
   element must <span>delay the load event</span> of the element's <span>node document</span> until
-  all the attempts to obtain the resource and its <span>critical subresources</span> are complete.
-  (Resources that the user agent has not yet attempted to obtain, e.g., because it is waiting for the
-  resource to be needed, do not <span>delay the load event</span>.)</p>
+  all the attempts to <span data-x="fetch-process-linked-resource">fetch and process the linked
+  resource</span> and its <span>critical subresources</span> are complete. (Resources that the
+  user agent has not yet attempted to obtain, e.g., because it is waiting for the resource to be
+  needed, do not <span>delay the load event</span>.)</p>
 
   <h5>Processing `<code data-x="http-link">Link</code>` headers</h5>
 
@@ -15160,21 +15164,29 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
 
   <ol>
 
+   <li><p>Let <var>element</var> be the <code>style</code> element associated with the style sheet
+   in question.</p></li>
+
    <li><p>Let <var>success</var> be true.</p></li>
 
-   <li><p>If the attempts to obtain any of the style sheet's <span>critical subresources</span>
-   failed for any reason (e.g., DNS error, HTTP 404 response, a connection being prematurely closed,
-   unsupported Content-Type), set <var>success</var> to false.</p></li>
+   <li>
+    <p>If the attempts to obtain any of the style sheet's <span>critical subresources</span> failed
+    for any reason (e.g., DNS error, HTTP 404 response, a connection being prematurely closed,
+    unsupported Content-Type), set <var>success</var> to false.</p>
+
+    <p>Note that content-specific errors, e.g., CSS parse errors or PNG decoding errors, do not
+    affect <var>success</var>.</p>
+   </li>
 
    <li>
     <p><span>Queue a task</span> on the <span>networking task source</span> to run these steps:</p>
 
     <ol>
      <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
-     named <code data-x="event-load">load</code> at the <var>element</var>.</p></li>
+     named <code data-x="event-load">load</code> at <var>element</var>.</p></li>
 
      <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
-     data-x="event-error">error</code> at the <var>element</var>.</p></li>
+     data-x="event-error">error</code> at <var>element</var>.</p></li>
 
      <li>
       <p>If <var>element</var> <span>contributes a script-blocking style sheet</span>:</p>
@@ -15184,7 +15196,7 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
        sheet counter</span> is greater than 0.</p></li>
 
        <li><p>Decrement <var>element</var>'s <span>node document</span>'s <span>script-blocking
-       style sheet counter</span> by one.</p></li>
+       style sheet counter</span> by 1.</p></li>
 
       </ol>
      </li>
@@ -15193,9 +15205,6 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
 
   </ol>
 
-  <p>Non-network errors in processing the style sheet or its subresources (e.g., CSS parse errors, PNG
-  decoding errors) are not failures for the purposes of the above paragraph.</p>
-
   <p>The element must <span>delay the load event</span> of the element's <span>node document</span> until all the
   attempts to obtain the style sheet's <span>critical subresources</span>, if any, are complete.</p>
 
@@ -15243,15 +15252,15 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
 
   <h4>Interactions of styling and scripting</h4>
 
-  If the style sheet referenced no other resources (e.g., it was an internal style sheet given by
+  <p>If the style sheet referenced no other resources (e.g., it was an internal style sheet given by
   a <code>style</code> element with no <code data-x="">@import</code> rules), then the style rules
   must be <span>immediately</span> made available to script; otherwise, the style rules must only be
   made available to script once the <span>event loop</span> reaches its <span>update the
-  rendering</span> step.
+  rendering</span> step.</p>
 
-  <p>An element <var>el</var> in the context of a <code>Document</code> of an <span>HTML
-  parser</span> or <span>XML parser</span> <dfn>contributes a script-blocking style sheet</dfn> if
-  all of the following conditions are true:</p>
+  <p id="a-style-sheet-that-is-blocking-scripts">An element <var>el</var> in the context of a
+  <code>Document</code> of an <span>HTML parser</span> or <span>XML parser</span> <dfn>contributes a
+  script-blocking style sheet</dfn> if all of the following conditions are true:</p>
 
   <ul>
    <li><p><var>el</var> was created by that <code>Document</code>'s parser.</p></li>
@@ -15274,6 +15283,10 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
    may give up on loading a style sheet at any time.</p></li>
   </ul>
 
+  <p class="&#x0058;&#x0058;&#x0058;">It is expected that counterparts to the above rules also apply
+  to <code>&lt;?xml-stylesheet?></code> PIs and HTTP `<code data-x="http-link">Link</code>` headers,
+  however this has not yet been thoroughly investigated.</p>
+
   <p class="note">Giving up on a style sheet before the style sheet loads, if the style sheet
   eventually does still load, means that the script might end up operating with incorrect
   information. For example, if a style sheet sets the color of an element to green, but a script
@@ -15289,8 +15302,8 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
   <p>A <code>Document</code> <dfn>has a style sheet that is blocking scripts</dfn> if its
   <span>script-blocking style sheet counter</span> is greater than 0, or if that
   <code>Document</code> has a <span data-x="concept-document-bc">browsing context</span> that has a
-  <span>parent browsing context</span>, and the <span>active document</span> of that <span>parent
-  browsing context</span>'s <span>script-blocking style sheet counter</span> is greater than 0.</p>
+  <span>parent browsing context</span>, and the <span>script-blocking style sheet counter</span> of
+  the <span>parent browsing context</span>'s <span>active document</span> is greater than 0.</p>
 
   <p>A <code>Document</code> <dfn>has no style sheet that is blocking scripts</dfn> if it does not
   <span data-x="has a style sheet that is blocking scripts">have a style sheet that is blocking
@@ -24736,7 +24749,8 @@ document.body.appendChild(wbr);</code></pre>
   supported style sheet type, the user agent must instead assume it to be <code>text/css</code>.</p>
 
   <p>Let the <span>custom linked resource fetch steps</span> for this type of linked resource be the
-  following, given a <code>link</code> element <var>el</var>:</p>
+  following, given a <code>link</code> element <var>el</var> (ignoring the <span
+  data-x="concept-request">request</span>):</p>
 
   <ol>
 

From 23c6fa56f46b33a6dc30dac7569cd339b655ecf6 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Thu, 10 Jan 2019 02:17:33 -0500
Subject: [PATCH 14/18] Increment by 1, not one

---
 source | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source b/source
index dddd45cc481..0ca590a878e 100644
--- a/source
+++ b/source
@@ -24756,7 +24756,7 @@ document.body.appendChild(wbr);</code></pre>
 
    <li><p>If <var>el</var> <span>contributes a script-blocking style sheet</span>, increment
    <var>el</var>'s <span>node document</span>'s <span>script-blocking style sheet counter</span> by
-   one.</p></li>
+   1.</p></li>
 
   </ol>
 
@@ -24816,7 +24816,7 @@ document.body.appendChild(wbr);</code></pre>
        counter</span> is greater than 0.</p></li>
 
        <li><p>Decrement <var>el</var>'s <span>node document</span>'s <span>script-blocking style
-       sheet counter</span> by one.</p></li>
+       sheet counter</span> by 1.</p></li>
 
       </ol>
 

From 9dc01ac53bfcd6ce439bc8b1e8d24f839dabed62 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Tue, 15 Jan 2019 15:48:48 -0500
Subject: [PATCH 15/18] Move a note, add a warning WRT critical subresources

---
 source | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/source b/source
index 0ca590a878e..d16b57210f1 100644
--- a/source
+++ b/source
@@ -13636,7 +13636,8 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
 
   </div>
 
-  <h5>Obtaining a resource from a <code>link</code> element</h5>
+  <h5 id="obtaining-a-resource-from-a-link-element">Fetching and processing a resource from a
+  <code>link</code> element</h5>
 
   <p>For <span data-x="external resource link">external resource links</span> that are represented
   in the DOM (for example, style sheets), the DOM representation must be made available (modulo
@@ -13671,6 +13672,8 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
    data-x="create a potential-CORS request">creating a potential-CORS request</span> given
    <var>url</var>, the empty string, and <var>corsAttributeState</var>.</p></li>
 
+   <li><p>Set <var>request</var>'s <span>synchronous flag</span>.</p></li>
+
    <li><p>Set <var>request</var>'s <span data-x="concept-request-client">client</span> to
    <var>el</var>'s <span>node document</span>'s <span>relevant settings object</span>.</p></li>
 
@@ -13714,18 +13717,28 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
 
      <li><p>Let <var>success</var> be true.</p></li>
 
-     <li><p>If <var>response</var> is a <span>network error</span> or its <span
-     data-x="concept-response-status">status</span> is not an <span>ok
-     status</span>, set <var>success</var> to false.</p></li>
-
      <li>
-      <p>If <var>success</var> is true, <span data-x="concept-fetch">fetch</span> the <span>critical
-      subresources</span> of the <span data-x="external resource link">link resource</span>.</p>
+      <p>If <var>response</var> is a <span>network error</span> or its <span
+      data-x="concept-response-status">status</span> is not an <span>ok
+      status</span>, set <var>success</var> to false.</p>
 
       <p class="note">Note that content-specific errors, e.g., CSS parse errors or PNG decoding
       errors, do not affect <var>success</var>.</p>
      </li>
 
+     <li>
+      <p>If <var>success</var> is true, wait for the <span data-x="external resource link">link
+      resource</span>'s <span>critical subresources</span> to finish loading.</p>
+
+      <p class="&#x0058;&#x0058;&#x0058;">The specification that defines a link type's
+      <span>critical subresources</span> (e.g., CSS Working Group) is expected to describe how these
+      subresources are fetched and processed, however since this is not currently explicit, this
+      specification describes waiting for a <span data-x="external resource link">link
+      resource</span>'s <span>critical subresources</span> to be fetched and processed, with the
+      expectation that this will be done correctly.
+      </p>
+     </li>
+
      <li><span data-x="process-linked-resource">Process the linked resource</span> given
      <var>el</var>, <var>success</var>, and <var>response</var>.</li>
     </ol>

From 9150ec7574f1b61b433452f7c81d93e15a4a9c7c Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Tue, 15 Jan 2019 16:42:55 -0500
Subject: [PATCH 16/18] Add empty span for link permanence

---
 source | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source b/source
index d16b57210f1..682841a4649 100644
--- a/source
+++ b/source
@@ -13636,8 +13636,8 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
 
   </div>
 
-  <h5 id="obtaining-a-resource-from-a-link-element">Fetching and processing a resource from a
-  <code>link</code> element</h5>
+  <h5><span id="obtaining-a-resource-from-a-link-element"></span>Fetching and processing a resource
+  from a <code>link</code> element</h5>
 
   <p>For <span data-x="external resource link">external resource links</span> that are represented
   in the DOM (for example, style sheets), the DOM representation must be made available (modulo

From 5ee9057911bc61bee814d39b5cb48d962a45ec86 Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Tue, 15 Jan 2019 20:01:52 -0500
Subject: [PATCH 17/18] Address latest review and fix some things, including
 actually calling "Create a CSS style sheet" in link-type-stylesheet

---
 source | 299 ++++++++++++++++++++++++++++-----------------------------
 1 file changed, 145 insertions(+), 154 deletions(-)

diff --git a/source b/source
index 682841a4649..2ccc8f47048 100644
--- a/source
+++ b/source
@@ -13444,7 +13444,7 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   <p>The <dfn><code data-x="attr-link-referrerpolicy">referrerpolicy</code></dfn> attribute is a
   <span>referrer policy attribute</span>. It is intended for use with <span data-x="external
   resource link">external resource links</span>, where it helps set the <span>referrer policy</span>
-  used when <span data-x="fetch-process-linked-resource">fetching and processing the linked
+  used when <span data-x="fetch and process the linked resource">fetching and processing the linked
   resource</span>. <ref spec=REFERRERPOLICY>.</p>
 
   <p>The <dfn><code data-x="attr-link-title">title</code></dfn> attribute gives the title of the
@@ -13493,8 +13493,7 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   <code>link</code> elements, it must not be specified.</p>
 
   <p w-nodev>The processing model for how the <code data-x="attr-link-as">as</code> attribute is
-  used is given in the steps to <span data-x="fetch-process-linked-resource">fetch and process the
-  linked resource</span>.</p>
+  used is given in the steps to <span>fetch and process the linked resource</span>.</p>
 
   <p class="note">The attribute does not have a <i data-x="missing value default">missing value
   default</i> or <i data-x="invalid value default">invalid value default</i>, meaning that invalid
@@ -13577,16 +13576,14 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   string</span>, e.g. the empty string). If the attribute is omitted, but the <span>external
   resource link</span> type has a default type defined, then the user agent must assume that the
   resource is of that type. If the UA does not support the given <span>MIME type</span> for the
-  given link relationship, then the UA should not <span data-x="fetch-process-linked-resource">fetch
-  and process the linked resource</span>; if the UA does support the given <span>MIME type</span>
-  for the given link relationship, then the UA should <span
-  data-x="fetch-process-linked-resource">fetch and process the linked resource</span> at the
+  given link relationship, then the UA should not <span>fetch and process the linked
+  resource</span>; if the UA does support the given <span>MIME type</span> for the given link
+  relationship, then the UA should <span>fetch and process the linked resource</span> at the
   appropriate time as specified for the <span>external resource link</span>'s particular type.
   If the attribute is omitted, and the <span>external resource link</span> type does not have a
-  default type defined, but the user agent would <span data-x="fetch-process-linked-resource">fetch
-  and process the linked resource</span> if the type was known and supported, then the user agent
-  should <span data-x="fetch-process-linked-resource">fetch and process the linked resource</span>
-  under the assumption that it will be supported.</p>
+  default type defined, but the user agent would <span>fetch and process the linked resource</span>
+  if the type was known and supported, then the user agent should <span>fetch and process the linked
+  resource</span> under the assumption that it will be supported.</p>
 
   <p>User agents must not consider the <code data-x="attr-link-type">type</code> attribute
   authoritative &mdash; upon fetching the resource, user agents must not use the <code
@@ -13639,21 +13636,18 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   <h5><span id="obtaining-a-resource-from-a-link-element"></span>Fetching and processing a resource
   from a <code>link</code> element</h5>
 
-  <p>For <span data-x="external resource link">external resource links</span> that are represented
-  in the DOM (for example, style sheets), the DOM representation must be made available (modulo
-  cross-origin restrictions) even if the resource is not applied.</p>
-
   <p id="concept-link-obtain">All <span data-x="external resource link">external resource
-  links</span> have <dfn>custom linked resource fetch steps</dfn> which take a <code>link</code>
-  element <var>el</var> and <span data-x="concept-request">request</span> <var>request</var>, as
-  well as a <dfn data-x="fetch-process-linked-resource">fetch and process the linked resource</dfn>
-  algorithm, which takes a <code>link</code> element <var>el</var>. Individual link types may
-  provide their own <span>custom linked resource fetch steps</span>, but unless explicitly stated,
-  these steps are empty. Similarly, individual link types may provide their own <span
-  data-x="fetch-process-linked-resource">fetch and process the linked resource</span> algorithm, but
-  unless explicitly stated, they use the following <dfn
-  data-x="default-fetch-process-linked-resource">default fetch and process the linked resource</dfn>
-  algorithm, given a <code>link</code> element <var>el</var>:</p>
+  links</span> have a <dfn>fetch and process the linked resource</dfn> algorithm, which takes a
+  <code>link</code> element <var>el</var>. They also have <dfn>linked resource fetch setup
+  steps</dfn> which take a <code>link</code> element <var>el</var> and <span
+  data-x="concept-request">request</span> <var>request</var>. Individual link types may provide
+  their own <span>fetch and process the linked resource</span> algorithm, but unless explicitly
+  stated, they use the <span>default fetch and process the linked resource</span> algorithm.
+  Similarly, individual link types may provide their own <span>linked resource fetch setup
+  steps</span>, but unless explicitly stated, these steps are empty.</p>
+
+  <p>The <dfn>default fetch and process the linked resource</dfn>, given a <code>link</code> element
+  <var>el</var>, is as follows:</p>
 
   <ol>
 
@@ -13705,7 +13699,7 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
     </ol>
    </li>
 
-   <li><p>Run the <span>custom linked resource fetch steps</span>, given <var>el</var> and
+   <li><p>Run the <span>linked resource fetch setup steps</span>, given <var>el</var> and
    <var>request</var>.<p></li>
 
    <li>
@@ -13731,35 +13725,34 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
       resource</span>'s <span>critical subresources</span> to finish loading.</p>
 
       <p class="&#x0058;&#x0058;&#x0058;">The specification that defines a link type's
-      <span>critical subresources</span> (e.g., CSS Working Group) is expected to describe how these
-      subresources are fetched and processed, however since this is not currently explicit, this
+      <span>critical subresources</span> (e.g., CSS) is expected to describe how these
+      subresources are fetched and processed. However, since this is not currently explicit, this
       specification describes waiting for a <span data-x="external resource link">link
       resource</span>'s <span>critical subresources</span> to be fetched and processed, with the
       expectation that this will be done correctly.
       </p>
      </li>
 
-     <li><span data-x="process-linked-resource">Process the linked resource</span> given
-     <var>el</var>, <var>success</var>, and <var>response</var>.</li>
+     <li><span>Process the linked resource</span> given <var>el</var>, <var>success</var>, and
+     <var>response</var>.</li>
     </ol>
    </li>
 
   </ol>
 
-  <p>User agents may opt to only try to obtain such resources when they are needed, instead of
-  pro-actively fetching all the external resources that are not applied.</p>
+  <p>User agents may opt to only try to <span data-x="fetch and process the linked resource">fetch
+  and process</span> such resources when they are needed, instead of pro-actively fetching all the
+  <span data-x="external resource link">external resources</span> that are not applied.</p>
 
   <!-- the next few paragraphs are similar to text in the <style> element section -->
   <!-- TODO: integrate this better with Fetch's process response definition -->
-  <p>Similar to the <span data-x="fetch-process-linked-resource">fetch and process the linked
-  resource</span> algorithm, all <span data-x="external resource link">external resource
-  links</span> have a <dfn data-x="process-linked-resource">process the linked resource</dfn>
-  algorithm which takes a <code>link</code> element <var>el</var>, boolean <var>success</var>, and
-  <span data-x="concept-response">response</span> <var>response</var>. Unless an individual link
-  type provides its own <span data-x="process-linked-resource">process the linked resource</span>
-  algorithm, the <dfn data-x="default-process-linked-resource">default process the linked
-  resource</dfn> algorithm, given a <code>link</code> element <var>el</var>, and boolean
-  <var>success</var> (ignoring <var>response</var>) is used:</p>
+  <p>Similar to the <span>fetch and process the linked resource</span> algorithm, all <span
+  data-x="external resource link">external resource links</span> have a <dfn>process the linked
+  resource</dfn> algorithm which takes a <code>link</code> element <var>el</var>, boolean
+  <var>success</var>, and <span data-x="concept-response">response</span> <var>response</var>.
+  Unless an individual link type provides its own <span>process the linked resource</span>
+  algorithm, the <dfn>default process the linked resource</dfn> algorithm, given a <code>link</code>
+  element <var>el</var>, and boolean <var>success</var> (ignoring <var>response</var>) is used:</p>
 
   <ol>
 
@@ -13779,10 +13772,10 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
 
   <p>Unless otherwise specified for a given <code data-x="attr-link-rel">rel</code> keyword, the
   element must <span>delay the load event</span> of the element's <span>node document</span> until
-  all the attempts to <span data-x="fetch-process-linked-resource">fetch and process the linked
-  resource</span> and its <span>critical subresources</span> are complete. (Resources that the
-  user agent has not yet attempted to obtain, e.g., because it is waiting for the resource to be
-  needed, do not <span>delay the load event</span>.)</p>
+  all the attempts to <span>fetch and process the linked resource</span> and its <span>critical
+  subresources</span> are complete. (Resources that the user agent has not yet attempted to fetch
+  and process, e.g., because it is waiting for the resource to be needed, do not <span>delay the
+  load event</span>.)</p>
 
   <h5>Processing `<code data-x="http-link">Link</code>` headers</h5>
 
@@ -13798,7 +13791,7 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   <p class="&#x0058;&#x0058;&#x0058;">The processing of `<code data-x="http-link">Link</code>`
   headers, in particular their influence on a <code>Document</code>'s <span>script-blocking style
   sheet counter</span>, is not defined. See <a
-  href="https://github.com/whatwg/html/issues/4224">Issue #4224</a> for discussion on integrating
+  href="https://github.com/whatwg/html/issues/4224">issue #4224</a> for discussion on integrating
   this into the spec.</p>
 
 
@@ -15187,8 +15180,8 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
     for any reason (e.g., DNS error, HTTP 404 response, a connection being prematurely closed,
     unsupported Content-Type), set <var>success</var> to false.</p>
 
-    <p>Note that content-specific errors, e.g., CSS parse errors or PNG decoding errors, do not
-    affect <var>success</var>.</p>
+    <p class="note">Note that content-specific errors, e.g., CSS parse errors or PNG decoding
+    errors, do not affect <var>success</var>.</p>
    </li>
 
    <li>
@@ -15292,23 +15285,25 @@ interface <dfn>HTMLStyleElement</dfn> : <span>HTMLElement</span> {
    <li><p>The last time the <span>event loop</span> reached <a href="#step1">step 1</a>,
    <var>el</var>'s <span>root</span> was that <code>Document</code>.</p></li>
 
-   <li><p>The user agent hasn't given up on loading that particular style sheet yet. A user agent
-   may give up on loading a style sheet at any time.</p></li>
+   <li>
+    <p>The user agent hasn't given up on loading that particular style sheet yet. A user agent
+    may give up on loading a style sheet at any time.</p>
+
+    <p class="note">Giving up on a style sheet before the style sheet loads, if the style sheet
+    eventually does still load, means that the script might end up operating with incorrect
+    information. For example, if a style sheet sets the color of an element to green, but a script
+    that inspects the resulting style is executed before the sheet is loaded, the script will find
+    that the element is black (or whatever the default color is), and might thus make poor choices
+    (e.g., deciding to use black as the color elsewhere on the page, instead of green). Implementers
+    have to balance the likelihood of a script using incorrect information with the performance impact
+    of doing nothing while waiting for a slow network request to finish.</p>
+   </li>
   </ul>
 
   <p class="&#x0058;&#x0058;&#x0058;">It is expected that counterparts to the above rules also apply
   to <code>&lt;?xml-stylesheet?></code> PIs and HTTP `<code data-x="http-link">Link</code>` headers,
   however this has not yet been thoroughly investigated.</p>
 
-  <p class="note">Giving up on a style sheet before the style sheet loads, if the style sheet
-  eventually does still load, means that the script might end up operating with incorrect
-  information. For example, if a style sheet sets the color of an element to green, but a script
-  that inspects the resulting style is executed before the sheet is loaded, the script will find
-  that the element is black (or whatever the default color is), and might thus make poor choices
-  (e.g., deciding to use black as the color elsewhere on the page, instead of green). Implementers
-  have to balance the likelihood of a script using incorrect information with the performance impact
-  of doing nothing while waiting for a slow network request to finish.</p>
-
   <p>A <code>Document</code> has a <dfn>script-blocking style sheet counter</dfn>, which is a
   number, initially 0.</p>
 
@@ -22551,9 +22546,8 @@ document.body.appendChild(wbr);</code></pre>
 
    <dd><p>These are links to resources that are to be used to augment the current document,
    generally automatically processed by the user agent. All <span data-x="external resource
-   link">external resource links</span> have a <span data-x="fetch-process-linked-resource">fetch
-   and process the linked resource</span> algorithm which describes how the resource is
-   obtained.</p></dd>
+   link">external resource links</span> have a <span>fetch and process the linked resource</span>
+   algorithm which describes how the resource is obtained.</p></dd>
 
    <dt><dfn data-x="hyperlink" data-lt="hyperlink" data-export="">Hyperlinks</dfn></dt>
 
@@ -24397,7 +24391,8 @@ document.body.appendChild(wbr);</code></pre>
 
   <div w-nodev>
 
-  <p>The appropriate times to fetch the resource for such a link are:</p>
+  <p>The appropriate times to <span>fetch and process the linked resource</span> for such a link
+  are:</p>
 
   <ul>
    <li><p>When the <span>external resource link</span> is created on a <code>link</code> element
@@ -24422,9 +24417,9 @@ document.body.appendChild(wbr);</code></pre>
 
   <div w-nodev>
 
-  <p>The <span data-x="fetch-process-linked-resource">fetch and process the linked resource</span>
-  algorithm for <code data-x="rel-modulepreload">modulepreload</code> links, given a
-  <code>link</code> element <var>el</var>, is as follows:</p>
+  <p>The <span>fetch and process the linked resource</span> algorithm for <code
+  data-x="rel-modulepreload">modulepreload</code> links, given a <code>link</code> element
+  <var>el</var>, is as follows:</p>
 
   <ol>
    <li><p>If the <code data-x="attr-link-href">href</code> attribute's value is the empty string,
@@ -24656,9 +24651,8 @@ document.body.appendChild(wbr);</code></pre>
   data-x="concept-request-destination">destination</span>), as it is highly likely that the user
   will require this resource for the current navigation. <span w-nodev>User agents must implement
   the processing model of the <code data-x="rel-preload">preload</code> keyword described in
-  <cite>Preload</cite>, as well as in this specification's <span
-  data-x="fetch-process-linked-resource">fetch and process the linked resource</span>
-  algorithm.</span> <ref spec=PRELOAD></p>
+  <cite>Preload</cite>, as well as in this specification's <span>fetch and process the linked
+  resource</span> algorithm.</span> <ref spec=PRELOAD></p>
 
   <p>There is no default type for resources given by the <code data-x="rel-preload">preload</code>
   keyword.</p>
@@ -24715,8 +24709,8 @@ document.body.appendChild(wbr);</code></pre>
 
   <div w-nodev>
 
-  <p>The appropriate times to <span data-x="fetch-process-linked-resource">fetch and process</span>
-  this type of link are:
+  <p>The appropriate times to <span data-x="fetch and process the linked resource">fetch and
+  process</span> this type of link are:
 
   <!-- has a browsing context: https://software.hixie.ch/utilities/js/live-dom-viewer/?saved=4299 -->
   <ul>
@@ -24761,9 +24755,9 @@ document.body.appendChild(wbr);</code></pre>
   and the <span data-x="Content-Type">Content-Type metadata</span> of the external resource is not a
   supported style sheet type, the user agent must instead assume it to be <code>text/css</code>.</p>
 
-  <p>Let the <span>custom linked resource fetch steps</span> for this type of linked resource be the
-  following, given a <code>link</code> element <var>el</var> (ignoring the <span
-  data-x="concept-request">request</span>):</p>
+  <p>The <span>linked resource fetch setup steps</span> for this type of linked resource, given a
+  <code>link</code> element <var>el</var> (ignoring the <span
+  data-x="concept-request">request</span>) are:</p>
 
   <ol>
 
@@ -24773,19 +24767,13 @@ document.body.appendChild(wbr);</code></pre>
 
   </ol>
 
-  <p>To <span data-x="fetch-process-linked-resource">fetch and process</span> this type of linked
-  resource, user agents must run the <span data-x="default-fetch-process-linked-resource">default
-  fetch and process the linked resource</span> algorithm with the above <span>custom linked
-  resource fetch steps</span>.
-
   <p class="&#x0058;&#x0058;&#x0058;">See <a href="https://github.com/whatwg/html/issues/968">issue
   #968</a> for plans to use the CSSOM <a
   href="https://drafts.csswg.org/cssom/#fetching-css-style-sheets">fetch a CSS style sheet</a>
-  algorithm instead of the <span data-x="default-fetch-process-linked-resource">default fetch and
-  process the linked resource</span> algorithm.</p>
+  algorithm instead of the <span>default fetch and process the linked resource</span> algorithm.</p>
 
-  <p>To <span data-x="process-linked-resource">process this type of linked resource</span> given a
-  <code>link</code> element <var>el</var>, boolean <var>success</var>, and <span
+  <p>To <span data-x="process the linked resource">process this type of linked resource</span>
+  given a <code>link</code> element <var>el</var>, boolean <var>success</var>, and <span
   data-x="concept-response">response</span> <var>response</var>, the user agent must run these
   steps:</p>
 
@@ -24801,123 +24789,126 @@ document.body.appendChild(wbr);</code></pre>
 
    <li><p>If <var>el</var> no longer creates an <span>external resource link</span> that contributes
    to the styling processing model, or if, since the resource in question was <span
-   data-x="fetch-process-linked-resource">fetched</span>, it has become appropriate to <span
-   data-x="fetch-process-linked-resource">fetch</span> it again (meaning this algorithm is about to
-   be invoked again for a newly obtained resource), then return.</p></li>
+   data-x="fetch and process the linked resource">fetched</span>, it has become appropriate to <span
+   data-x="fetch and process the linked resource">fetch</span> it again then return.</p></li>
 
    <li>
     <p><span>Queue a task</span> on the <span>networking task source</span> to run these steps:</p>
 
     <ol>
-
      <li><p>If <var>el</var> has an <span>associated CSS style sheet</span>, <span data-x="remove a
      CSS style sheet">remove the CSS style sheet</span>.</p></li>
 
-     <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
-     named <code data-x="event-load">load</code> at <var>el</var>.</p></li>
-
-     <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
-     data-x="event-error">error</code> at <var>el</var>.</p></li>
-
      <li>
-      <p>If <var>el</var> <span>contributes a script-blocking style sheet</span>, run these
-      steps:</p>
+
+      <p>If <var>success</var> is true, then:</p>
 
       <ol>
+       <li><p><span>Create a CSS style sheet</span> with the following properties:</p>
 
-       <li><p>Assert: <var>el</var>'s <span>node document</span>'s <span>script-blocking style sheet
-       counter</span> is greater than 0.</p></li>
+       <dl>
 
-       <li><p>Decrement <var>el</var>'s <span>node document</span>'s <span>script-blocking style
-       sheet counter</span> by 1.</p></li>
+        <dt><span data-x="concept-css-style-sheet-type">type</span></dt>
+        <dd><p><code>text/css</code></p></dd>
 
-      </ol>
+        <dt><span data-x="concept-css-style-sheet-location">location</span></dt>
+        <dd>
 
-     </li>
+         <p>The <span>resulting URL string</span> determined during the <span>fetch and process the
+         linked resource</span> algorithm.</p>
 
-     <li>
+         <p class="note">This is before any redirects get applied.</p>
 
-      <p>Create a <span>CSS style sheet</span> with the following properties:</p>
+        </dd>
 
-      <dl>
+        <dt><span data-x="concept-css-style-sheet-owner-node">owner node</span></dt>
+        <dd><p><var>element</var></p></dd>
 
-       <dt><span data-x="concept-css-style-sheet-type">type</span></dt>
-       <dd><p><code>text/css</code></p></dd>
+        <dt><span data-x="concept-css-style-sheet-media">media</span></dt>
 
-       <dt><span data-x="concept-css-style-sheet-location">location</span></dt>
-       <dd>
+        <dd>
 
-        <p>The <span>resulting URL string</span> determined during the <span
-        data-x="fetch-process-linked-resource">fetch and process the linked resource</span>
-        algorithm.</p>
+         <p>The <code data-x="attr-link-media">media</code> attribute of <var>element</var>.</p>
 
-        <p class="note">This is before any redirects get applied.</p>
+         <p class="note">This is a reference to the (possibly absent at this time) attribute, rather
+         than a copy of the attribute's current value. The CSSOM specification defines what happens
+         when the attribute is dynamically set, changed, or removed.</p>
 
-       </dd>
+        </dd>
 
-       <dt><span data-x="concept-css-style-sheet-owner-node">owner node</span></dt>
-       <dd><p><var>element</var></p></dd>
+        <dt><span data-x="concept-css-style-sheet-title">title</span></dt>
 
-       <dt><span data-x="concept-css-style-sheet-media">media</span></dt>
+        <dd>
 
-       <dd>
+         <p>The <code data-x="attr-link-title">title</code> attribute of <var>element</var>, if
+         <var>element</var> is <span>in a document tree</span>, or the empty string otherwise.</p>
 
-        <p>The <code data-x="attr-link-media">media</code> attribute of <var>element</var>.</p>
+         <p class="note">This is similarly a reference to the attribute, rather than a copy of the
+         attribute's current value.</p>
 
-        <p class="note">This is a reference to the (possibly absent at this time) attribute, rather
-        than a copy of the attribute's current value. The CSSOM specification defines what happens
-        when the attribute is dynamically set, changed, or removed.</p>
+        </dd>
 
-       </dd>
+        <dt><span data-x="concept-css-style-sheet-alternate-flag">alternate flag</span></dt>
+        <dd><p>Set if <span>the link is an alternative style sheet</span>; unset otherwise.</p></dd>
 
-       <dt><span data-x="concept-css-style-sheet-title">title</span></dt>
+        <dt><span data-x="concept-css-style-sheet-origin-clean-flag">origin-clean flag</span></dt>
+        <dd><p>Set if the resource is <span>CORS-same-origin</span>; unset otherwise.</p></dd>
 
-       <dd>
+        <dt>
+         <span data-x="concept-css-style-sheet-parent-CSS-style-sheet">parent CSS style
+         sheet</span>
+        </dt>
+        <dt><span data-x="concept-css-style-sheet-owner-CSS-rule">owner CSS rule</span></dt>
+        <dd><p>null</p></dd>
 
-        <p>The <code data-x="attr-link-title">title</code> attribute of <var>element</var>, if
-        <var>element</var> is <span>in a document tree</span>, or the empty string otherwise.</p>
+        <dt><span data-x="concept-css-style-sheet-disabeld-flag">disabled flag</span></dt>
+        <dd><p>Left at its default value.</p></dd>
 
-        <p class="note">This is similarly a reference to the attribute, rather than a copy of the
-        attribute's current value.</p>
+        <dt><span data-x="concept-css-style-sheet-CSS-rules">CSS rules</span></dt>
+         <dd>
+          <p>Left uninitialized.</p>
 
-       </dd>
+          <p class="&#x0058;&#x0058;&#x0058;">This doesn't seem right. Presumably we should be using
+          the response body? Tracked as <a href="https://github.com/whatwg/html/issues/2997">issue
+          #2997</a>.</p>
+         </dd>
 
-       <dt><span data-x="concept-css-style-sheet-alternate-flag">alternate flag</span></dt>
-       <dd><p>Set if <span>the link is an alternative style sheet</span>; unset otherwise.</p></dd>
+       </dl>
 
-       <dt><span data-x="concept-css-style-sheet-origin-clean-flag">origin-clean flag</span></dt>
-       <dd><p>Set if the resource is <span>CORS-same-origin</span>; unset otherwise.</p></dd>
+       <p>The CSS <span>environment encoding</span> is the result of running the following steps: <ref spec=CSSSYNTAX></p>
 
-       <dt>
-        <span data-x="concept-css-style-sheet-parent-CSS-style-sheet">parent CSS style
-        sheet</span>
-       </dt>
-       <dt><span data-x="concept-css-style-sheet-owner-CSS-rule">owner CSS rule</span></dt>
-       <dd><p>null</p></dd>
+       <ol>
 
-       <dt><span data-x="concept-css-style-sheet-disabeld-flag">disabled flag</span></dt>
-       <dd><p>Left at its default value.</p></dd>
+        <li><p>If the element has a <code data-x="attr-link-charset">charset</code> attribute, <span
+        data-x="getting an encoding">get an encoding</span> from that attribute's value. If that
+        succeeds, return the resulting encoding. <ref spec=ENCODING></p></li>
 
-       <dt><span data-x="concept-css-style-sheet-CSS-rules">CSS rules</span></dt>
-        <dd>
-         <p>Left uninitialized.</p>
+        <li><p>Otherwise, return the <span>document's character encoding</span>. <ref spec=DOM></p></li>
 
-         <p class="&#x0058;&#x0058;&#x0058;">This doesn't seem right. Presumably we should be using
-         the response body? Tracked as <a href="https://github.com/whatwg/html/issues/2997">issue
-         #2997</a>.</p>
-        </dd>
+       </ol>
+       </li>
 
-      </dl>
+       <li><p><span data-x="concept-event-fire">Fire an event</span> named <code
+       data-x="event-load">load</code> at <var>el</var>.</p></li>
+
+      </ol>
+
+     </li>
 
-      <p>The CSS <span>environment encoding</span> is the result of running the following steps: <ref spec=CSSSYNTAX></p>
+     <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
+     data-x="event-error">error</code> at <var>el</var>.</p></li>
+
+     <li>
+      <p>If <var>el</var> <span>contributes a script-blocking style sheet</span>, run these
+      steps:</p>
 
       <ol>
 
-       <li><p>If the element has a <code data-x="attr-link-charset">charset</code> attribute, <span
-       data-x="getting an encoding">get an encoding</span> from that attribute's value. If that
-       succeeds, return the resulting encoding. <ref spec=ENCODING></p></li>
+       <li><p>Assert: <var>el</var>'s <span>node document</span>'s <span>script-blocking style sheet
+       counter</span> is greater than 0.</p></li>
 
-       <li><p>Otherwise, return the <span>document's character encoding</span>. <ref spec=DOM></p></li>
+       <li><p>Decrement <var>el</var>'s <span>node document</span>'s <span>script-blocking style
+       sheet counter</span> by 1.</p></li>
 
       </ol>
 

From 816e8f3723d3c99e190706e72d80c46b7afeb5ad Mon Sep 17 00:00:00 2001
From: Dominic Farolino <domfarolino@gmail.com>
Date: Tue, 15 Jan 2019 22:44:04 -0500
Subject: [PATCH 18/18] Fix nits; queue a task in default fetch and process...

---
 source | 169 ++++++++++++++++++++++++++-------------------------------
 1 file changed, 76 insertions(+), 93 deletions(-)

diff --git a/source b/source
index 2ccc8f47048..d8ce2801f7b 100644
--- a/source
+++ b/source
@@ -13733,8 +13733,8 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
       </p>
      </li>
 
-     <li><span>Process the linked resource</span> given <var>el</var>, <var>success</var>, and
-     <var>response</var>.</li>
+     <li><span>Queue a task</span> on the <span>networking task source</span> to <span>process the
+     linked resource</span> given <var>el</var>, <var>success</var>, and <var>response</var>.</li>
     </ol>
    </li>
 
@@ -13755,19 +13755,11 @@ interface <dfn>HTMLLinkElement</dfn> : <span>HTMLElement</span> {
   element <var>el</var>, and boolean <var>success</var> (ignoring <var>response</var>) is used:</p>
 
   <ol>
+   <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
+   named <code data-x="event-load">load</code> at <var>el</var>.</p></li>
 
-   <li>
-    <p><span>Queue a task</span> on the <span>networking task source</span> to run these steps:</p>
-
-    <ol>
-     <li><p>If <var>success</var> is true, <span data-x="concept-event-fire">fire an event</span>
-     named <code data-x="event-load">load</code> at <var>el</var>.</p></li>
-
-     <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
-     data-x="event-error">error</code> at <var>el</var>.</p></li>
-    </ol>
-   </li>
-
+   <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
+   data-x="event-error">error</code> at <var>el</var>.</p></li>
   </ol>
 
   <p>Unless otherwise specified for a given <code data-x="attr-link-rel">rel</code> keyword, the
@@ -24790,129 +24782,120 @@ document.body.appendChild(wbr);</code></pre>
    <li><p>If <var>el</var> no longer creates an <span>external resource link</span> that contributes
    to the styling processing model, or if, since the resource in question was <span
    data-x="fetch and process the linked resource">fetched</span>, it has become appropriate to <span
-   data-x="fetch and process the linked resource">fetch</span> it again then return.</p></li>
+   data-x="fetch and process the linked resource">fetch</span> it again, then return.</p></li>
+
+   <li><p>If <var>el</var> has an <span>associated CSS style sheet</span>, <span data-x="remove a
+   CSS style sheet">remove the CSS style sheet</span>.</p></li>
 
    <li>
-    <p><span>Queue a task</span> on the <span>networking task source</span> to run these steps:</p>
+    <p>If <var>success</var> is true, then:</p>
 
     <ol>
-     <li><p>If <var>el</var> has an <span>associated CSS style sheet</span>, <span data-x="remove a
-     CSS style sheet">remove the CSS style sheet</span>.</p></li>
-
      <li>
 
-      <p>If <var>success</var> is true, then:</p>
+      <p><span>Create a CSS style sheet</span> with the following properties:</p>
 
-      <ol>
-       <li><p><span>Create a CSS style sheet</span> with the following properties:</p>
-
-       <dl>
+      <dl>
 
-        <dt><span data-x="concept-css-style-sheet-type">type</span></dt>
-        <dd><p><code>text/css</code></p></dd>
+       <dt><span data-x="concept-css-style-sheet-type">type</span></dt>
+       <dd><p><code>text/css</code></p></dd>
 
-        <dt><span data-x="concept-css-style-sheet-location">location</span></dt>
-        <dd>
-
-         <p>The <span>resulting URL string</span> determined during the <span>fetch and process the
-         linked resource</span> algorithm.</p>
+       <dt><span data-x="concept-css-style-sheet-location">location</span></dt>
+       <dd>
 
-         <p class="note">This is before any redirects get applied.</p>
+        <p>The <span>resulting URL string</span> determined during the <span>fetch and process the
+        linked resource</span> algorithm.</p>
 
-        </dd>
+        <p class="note">This is before any redirects get applied.</p>
 
-        <dt><span data-x="concept-css-style-sheet-owner-node">owner node</span></dt>
-        <dd><p><var>element</var></p></dd>
-
-        <dt><span data-x="concept-css-style-sheet-media">media</span></dt>
+       </dd>
 
-        <dd>
+       <dt><span data-x="concept-css-style-sheet-owner-node">owner node</span></dt>
+       <dd><p><var>element</var></p></dd>
 
-         <p>The <code data-x="attr-link-media">media</code> attribute of <var>element</var>.</p>
+       <dt><span data-x="concept-css-style-sheet-media">media</span></dt>
 
-         <p class="note">This is a reference to the (possibly absent at this time) attribute, rather
-         than a copy of the attribute's current value. The CSSOM specification defines what happens
-         when the attribute is dynamically set, changed, or removed.</p>
+       <dd>
 
-        </dd>
+        <p>The <code data-x="attr-link-media">media</code> attribute of <var>element</var>.</p>
 
-        <dt><span data-x="concept-css-style-sheet-title">title</span></dt>
+        <p class="note">This is a reference to the (possibly absent at this time) attribute, rather
+        than a copy of the attribute's current value. The CSSOM specification defines what happens
+        when the attribute is dynamically set, changed, or removed.</p>
 
-        <dd>
+       </dd>
 
-         <p>The <code data-x="attr-link-title">title</code> attribute of <var>element</var>, if
-         <var>element</var> is <span>in a document tree</span>, or the empty string otherwise.</p>
+       <dt><span data-x="concept-css-style-sheet-title">title</span></dt>
 
-         <p class="note">This is similarly a reference to the attribute, rather than a copy of the
-         attribute's current value.</p>
+       <dd>
 
-        </dd>
+        <p>The <code data-x="attr-link-title">title</code> attribute of <var>element</var>, if
+        <var>element</var> is <span>in a document tree</span>, or the empty string otherwise.</p>
 
-        <dt><span data-x="concept-css-style-sheet-alternate-flag">alternate flag</span></dt>
-        <dd><p>Set if <span>the link is an alternative style sheet</span>; unset otherwise.</p></dd>
+        <p class="note">This is similarly a reference to the attribute, rather than a copy of the
+        attribute's current value.</p>
 
-        <dt><span data-x="concept-css-style-sheet-origin-clean-flag">origin-clean flag</span></dt>
-        <dd><p>Set if the resource is <span>CORS-same-origin</span>; unset otherwise.</p></dd>
+       </dd>
 
-        <dt>
-         <span data-x="concept-css-style-sheet-parent-CSS-style-sheet">parent CSS style
-         sheet</span>
-        </dt>
-        <dt><span data-x="concept-css-style-sheet-owner-CSS-rule">owner CSS rule</span></dt>
-        <dd><p>null</p></dd>
+       <dt><span data-x="concept-css-style-sheet-alternate-flag">alternate flag</span></dt>
+       <dd><p>Set if <span>the link is an alternative style sheet</span>; unset otherwise.</p></dd>
 
-        <dt><span data-x="concept-css-style-sheet-disabeld-flag">disabled flag</span></dt>
-        <dd><p>Left at its default value.</p></dd>
+       <dt><span data-x="concept-css-style-sheet-origin-clean-flag">origin-clean flag</span></dt>
+       <dd><p>Set if the resource is <span>CORS-same-origin</span>; unset otherwise.</p></dd>
 
-        <dt><span data-x="concept-css-style-sheet-CSS-rules">CSS rules</span></dt>
-         <dd>
-          <p>Left uninitialized.</p>
+       <dt>
+        <span data-x="concept-css-style-sheet-parent-CSS-style-sheet">parent CSS style
+        sheet</span>
+       </dt>
+       <dt><span data-x="concept-css-style-sheet-owner-CSS-rule">owner CSS rule</span></dt>
+       <dd><p>null</p></dd>
 
-          <p class="&#x0058;&#x0058;&#x0058;">This doesn't seem right. Presumably we should be using
-          the response body? Tracked as <a href="https://github.com/whatwg/html/issues/2997">issue
-          #2997</a>.</p>
-         </dd>
+       <dt><span data-x="concept-css-style-sheet-disabeld-flag">disabled flag</span></dt>
+       <dd><p>Left at its default value.</p></dd>
 
-       </dl>
+       <dt><span data-x="concept-css-style-sheet-CSS-rules">CSS rules</span></dt>
+        <dd>
+         <p>Left uninitialized.</p>
 
-       <p>The CSS <span>environment encoding</span> is the result of running the following steps: <ref spec=CSSSYNTAX></p>
+         <p class="&#x0058;&#x0058;&#x0058;">This doesn't seem right. Presumably we should be using
+         the response body? Tracked as <a href="https://github.com/whatwg/html/issues/2997">issue
+         #2997</a>.</p>
+        </dd>
 
-       <ol>
+      </dl>
 
-        <li><p>If the element has a <code data-x="attr-link-charset">charset</code> attribute, <span
-        data-x="getting an encoding">get an encoding</span> from that attribute's value. If that
-        succeeds, return the resulting encoding. <ref spec=ENCODING></p></li>
+      <p>The CSS <span>environment encoding</span> is the result of running the following steps: <ref spec=CSSSYNTAX></p>
 
-        <li><p>Otherwise, return the <span>document's character encoding</span>. <ref spec=DOM></p></li>
+      <ol>
 
-       </ol>
-       </li>
+       <li><p>If the element has a <code data-x="attr-link-charset">charset</code> attribute, <span
+       data-x="getting an encoding">get an encoding</span> from that attribute's value. If that
+       succeeds, return the resulting encoding. <ref spec=ENCODING></p></li>
 
-       <li><p><span data-x="concept-event-fire">Fire an event</span> named <code
-       data-x="event-load">load</code> at <var>el</var>.</p></li>
+       <li><p>Otherwise, return the <span>document's character encoding</span>. <ref spec=DOM></p></li>
 
       </ol>
-
      </li>
 
-     <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
-     data-x="event-error">error</code> at <var>el</var>.</p></li>
+     <li><p><span data-x="concept-event-fire">Fire an event</span> named <code
+     data-x="event-load">load</code> at <var>el</var>.</p></li>
 
-     <li>
-      <p>If <var>el</var> <span>contributes a script-blocking style sheet</span>, run these
-      steps:</p>
+    </ol>
+   </li>
 
-      <ol>
+   <li><p>Otherwise, <span data-x="concept-event-fire">fire an event</span> named <code
+   data-x="event-error">error</code> at <var>el</var>.</p></li>
 
-       <li><p>Assert: <var>el</var>'s <span>node document</span>'s <span>script-blocking style sheet
-       counter</span> is greater than 0.</p></li>
+   <li>
+    <p>If <var>el</var> <span>contributes a script-blocking style sheet</span>, then:</p>
 
-       <li><p>Decrement <var>el</var>'s <span>node document</span>'s <span>script-blocking style
-       sheet counter</span> by 1.</p></li>
+    <ol>
 
-      </ol>
+     <li><p>Assert: <var>el</var>'s <span>node document</span>'s <span>script-blocking style sheet
+     counter</span> is greater than 0.</p></li>
 
-     </li>
+     <li><p>Decrement <var>el</var>'s <span>node document</span>'s <span>script-blocking style
+     sheet counter</span> by 1.</p></li>
 
     </ol>