diff --git a/extensions/WEBGL_shader_pixel_local_storage/extension.xml b/extensions/WEBGL_shader_pixel_local_storage/extension.xml
index 269098711..4f1df45dd 100644
--- a/extensions/WEBGL_shader_pixel_local_storage/extension.xml
+++ b/extensions/WEBGL_shader_pixel_local_storage/extension.xml
@@ -42,6 +42,15 @@
           would become invalidated.
         </div>
       </addendum>
+      <addendum>
+        <div class="note">
+          <code>FramebufferPixelLocalStorageInterruptANGLE</code> and
+          <code>FramebufferPixelLocalStorageRestoreANGLE</code> are not supported.
+        </div>
+        <div class="note rationale">
+          These commands are only intended for internal use by the browser implementation.
+        </div>
+      </addendum>
       <addendum>
         <div class="note">
           When <code>WEBGL_shader_pixel_local_storage</code> is enabled, the following WebGL
@@ -115,14 +124,11 @@ interface WEBGL_shader_pixel_local_storage {
       <param name="level" type="GLint"/>
       <param name="layer" type="GLint"/>
       Establishes the backing texture for the given plane.
-      <div class="note">
-        If <code>texture</code> has been deleted, generates an <code>INVALID_OPERATION</code>
-        error.
-      </div>
-      <div class="note">
-        If <code>texture</code> was generated by a different <code>WebGL2RenderingContext</code>
-        than this one, generates an <code>INVALID_OPERATION</code> error.
-      </div>
+      <p/>
+      If <code>texture</code> has been deleted, generates an <code>INVALID_OPERATION</code> error.
+      <p/>
+      If <code>texture</code> was generated by a different <code>WebGL2RenderingContext</code> than
+      this one, generates an <code>INVALID_OPERATION</code> error.
     </function>
   </newfun>
 
@@ -130,12 +136,11 @@ interface WEBGL_shader_pixel_local_storage {
     <function name="framebufferPixelLocalClearValuefvWEBGL" type="undefined">
       <param name="plane" type="GLint"/>
       <param name="value" type="Float32List"/>
-      <param name="src_offset" type="GLuint" default="0"/>
+      <param name="srcOffset" type="GLuint" default="0"/>
       Sets the floating point clear value for the given plane.
-      <div class="note">
-        If <code>value</code> has less than <code>src_offset + 4</code> elements, generates an
-        <code>INVALID_OPERATION</code> error.
-      </div>
+      <p/>
+      If <code>value</code> has less than <code>srcOffset + 4</code> elements, generates an
+      <code>INVALID_VALUE</code> error.
     </function>
   </newfun>
 
@@ -143,12 +148,10 @@ interface WEBGL_shader_pixel_local_storage {
     <function name="framebufferPixelLocalClearValueivWEBGL" type="undefined">
       <param name="plane" type="GLint"/>
       <param name="value" type="Int32List"/>
-      <param name="src_offset" type="GLuint" default="0"/>
+      <param name="srcOffset" type="GLuint" default="0"/>
       Sets the integer clear value for the given plane.
-      <div class="note">
-        If <code>value</code> has less than <code>src_offset + 4</code> elements, generates an
-        <code>INVALID_OPERATION</code> error.
-      </div>
+      <p/>
+      If <code>value</code> has less than <code>srcOffset + 4</code> elements, generates an
     </function>
   </newfun>
 
@@ -156,12 +159,9 @@ interface WEBGL_shader_pixel_local_storage {
     <function name="framebufferPixelLocalClearValueuivWEBGL" type="undefined">
       <param name="plane" type="GLint"/>
       <param name="value" type="Uint32List"/>
-      <param name="src_offset" type="GLuint" default="0"/>
-      Sets the unsigned integer clear value for the given plane.
-      <div class="note">
-        If <code>value</code> has less than <code>src_offset + 4</code> elements, generates an
-        <code>INVALID_OPERATION</code> error.
-      </div>
+      <param name="srcOffset" type="GLuint" default="0"/>
+      <p/>
+      If <code>value</code> has less than <code>srcOffset + 4</code> elements, generates an
     </function>
   </newfun>
 
diff --git a/sdk/tests/conformance2/extensions/00_test_list.txt b/sdk/tests/conformance2/extensions/00_test_list.txt
index 22dd93388..26acf9add 100644
--- a/sdk/tests/conformance2/extensions/00_test_list.txt
+++ b/sdk/tests/conformance2/extensions/00_test_list.txt
@@ -19,3 +19,4 @@ promoted-extensions-in-shaders.html
 --min-version 2.0.1 webgl-clip-cull-distance.html
 --min-version 2.0.1 webgl-multi-draw-instanced-base-vertex-base-instance.html
 --min-version 2.0.1 webgl-provoking-vertex.html
+--min-version 2.0.1 webgl-shader-pixel-local-storage.html
diff --git a/sdk/tests/conformance2/extensions/webgl-shader-pixel-local-storage.html b/sdk/tests/conformance2/extensions/webgl-shader-pixel-local-storage.html
new file mode 100644
index 000000000..a6ddd736c
--- /dev/null
+++ b/sdk/tests/conformance2/extensions/webgl-shader-pixel-local-storage.html
@@ -0,0 +1,373 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>WebGL WEBGL_shader_pixel_local_storage Conformance Tests</title>
+<link rel="stylesheet" href="../../resources/js-test-style.css"/>
+<script src="../../js/desktop-gl-constants.js"></script>
+<script src="../../js/js-test-pre.js"></script>
+<script src="../../js/webgl-test-utils.js"></script>
+<script src="../../js/tests/compositing-test.js"></script>
+<script src="../../js/tests/invalid-vertex-attrib-test.js"></script>
+</head>
+<body>
+<div id="description"></div>
+<canvas id="canvas" width="128" height="128"> </canvas>
+<div id="console"></div>
+<script>
+"use strict";
+description("This test verifies the functionality of the WEBGL_shader_pixel_local_storage " +
+            "extension, if it is available.");
+
+const wtu = WebGLTestUtils;
+const canvas = document.getElementById("canvas");
+const gl = wtu.create3DContext(canvas, null, 2);
+let pls = null;
+let MAX_PIXEL_LOCAL_STORAGE_PLANES = null;
+let MAX_COLOR_ATTACHMENTS_WITH_ACTIVE_PIXEL_LOCAL_STORAGE = null;
+let MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES = null;
+let MAX_COLOR_ATTACHMENTS = null;
+let MAX_DRAW_BUFFERS = null;
+
+// Outputs a fullscreen quad from a 4-vertex triangle strip.
+const fullscreenQuadVertexShader = `#version 300 es
+void main() {
+    gl_Position.x = (gl_VertexID & 1) == 0 ? -1. : 1.;
+    gl_Position.y = (gl_VertexID & 2) == 0 ? -1. : 1.;
+    gl_Position.zw = vec2(0, 1);
+}`;
+
+function arraysEqual(a, b) {
+  if (typeof a !== typeof b)
+    return false;
+  if (a.length != b.length)
+    return false;
+  for (let i = 0; i < a.length; ++i) {
+    if (a[i] !== b[i])
+      return false;
+  }
+  return true;
+}
+
+function runTest() {
+  if (!gl) {
+    return function() {
+      testFailed("WebGL2 context does not exist");
+    }
+  }
+
+  debug("\nCheck the behavior surrounding WEBGL_shader_pixel_local_storage being enabled.");
+  checkExtensionNotSupportedWhenDisabled();
+  checkDependencyExtensionsEnabled(false);
+  debug("Enable WEBGL_shader_pixel_local_storage.");
+  pls = gl.getExtension("WEBGL_shader_pixel_local_storage");
+  wtu.runExtensionSupportedTest(gl, "WEBGL_shader_pixel_local_storage", pls != null);
+  if (!pls)
+    return;
+  checkDependencyExtensionsEnabled(true);
+
+  debug("\nQuery PLS implementation dependent limits.");
+  MAX_PIXEL_LOCAL_STORAGE_PLANES =
+    gl.getParameter(pls.MAX_PIXEL_LOCAL_STORAGE_PLANES_WEBGL);
+  MAX_COLOR_ATTACHMENTS_WITH_ACTIVE_PIXEL_LOCAL_STORAGE =
+    gl.getParameter(pls.MAX_COLOR_ATTACHMENTS_WITH_ACTIVE_PIXEL_LOCAL_STORAGE_WEBGL);
+  MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES =
+    gl.getParameter(pls.MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES_WEBGL);
+  wtu.glErrorShouldBe(gl, gl.NONE, "Pixel local storage queries should be supported.");
+  MAX_COLOR_ATTACHMENTS = gl.getParameter(gl.MAX_COLOR_ATTACHMENTS);
+  MAX_DRAW_BUFFERS = gl.getParameter(gl.MAX_DRAW_BUFFERS);
+  checkImplementationDependentLimits();
+
+  checkInitialValues();
+  checkWebGLNonNormativeBehavior();
+
+  gl.disable(gl.DITHER);
+  checkRendering();
+}
+
+function checkExtensionNotSupportedWhenDisabled() {
+  debug("\nCheck that a context does not support WEBGL_shader_pixel_local_storage before it is " +
+        "enabled");
+  shouldBeNull("gl.getParameter(0x96E0 /*MAX_PIXEL_LOCAL_STORAGE_PLANES_WEBGL*/)");
+  wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "parameter unknown without enabling the extension");
+  shouldBeNull(
+    "gl.getParameter(0x96E1 /*MAX_COLOR_ATTACHMENTS_WITH_ACTIVE_PIXEL_LOCAL_STORAGE_WEBGL*/)");
+  wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "parameter unknown without enabling the extension");
+  shouldBeNull(
+    "gl.getParameter(0x96E2 /*MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES_WEBGL*/)");
+  wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "parameter unknown without enabling the extension");
+  shouldBeNull(
+    "gl.getParameter(0x96E3 /*PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_WEBGL*/)");
+  wtu.glErrorShouldBe(gl, gl.INVALID_ENUM, "parameter unknown without enabling the extension");
+  wtu.glErrorShouldBe(gl, gl.NONE);
+}
+
+function checkDependencyExtensionsEnabled(enabled) {
+  debug("\nCheck that dependency extensions of WEBGL_shader_pixel_local_storage are " +
+        (enabled ? "enabled" : "disabled"));
+  if (wtu.getSupportedExtensionWithKnownPrefixes(gl, "OES_draw_buffers_indexed") !== undefined) {
+    gl.getIndexedParameter(gl.BLEND_EQUATION_RGB, 1);
+    wtu.glErrorShouldBe(gl, enabled ? gl.NONE : gl.INVALID_ENUM,
+                        "OES_draw_buffers_indexed not enabled or disabled as expected");
+  }
+  if (wtu.getSupportedExtensionWithKnownPrefixes(gl, "EXT_color_buffer_float") !== undefined) {
+    gl.bindRenderbuffer(gl.RENDERBUFFER, gl.createRenderbuffer());
+    gl.renderbufferStorage(gl.RENDERBUFFER, gl.R32F, 1, 1);
+    wtu.glErrorShouldBe(gl, enabled ? gl.NONE : gl.INVALID_ENUM,
+                        "EXT_color_buffer_float not enabled or disabled as expected");
+    gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+  }
+  if (wtu.getSupportedExtensionWithKnownPrefixes(gl, "EXT_color_buffer_half_float") !== undefined) {
+    gl.bindRenderbuffer(gl.RENDERBUFFER, gl.createRenderbuffer());
+    gl.renderbufferStorage(gl.RENDERBUFFER, gl.RG16F, 1, 1);
+    wtu.glErrorShouldBe(gl, enabled ? gl.NONE : gl.INVALID_ENUM,
+                        "EXT_color_buffer_half_float not enabled or disabled as expected");
+    gl.bindRenderbuffer(gl.RENDERBUFFER, null);
+  }
+}
+
+function checkImplementationDependentLimits() {
+  debug("\nVerify conformant implementation-dependent PLS limits.");
+  // Table 6.X: Impementation Dependent Pixel Local Storage Limits.
+  shouldBeTrue("MAX_PIXEL_LOCAL_STORAGE_PLANES >= 4");
+  shouldBeTrue("MAX_COLOR_ATTACHMENTS_WITH_ACTIVE_PIXEL_LOCAL_STORAGE >= 0");
+  shouldBeTrue("MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES >= 4");
+
+  // Logical deductions based on 6.X.
+  shouldBeTrue(`MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES >=
+               MAX_PIXEL_LOCAL_STORAGE_PLANES`);
+  shouldBeTrue(`MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES >=
+               MAX_COLOR_ATTACHMENTS_WITH_ACTIVE_PIXEL_LOCAL_STORAGE`);
+  shouldBeTrue(`MAX_COLOR_ATTACHMENTS + MAX_PIXEL_LOCAL_STORAGE_PLANES >=
+               MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES`);
+  shouldBeTrue(`MAX_DRAW_BUFFERS + MAX_PIXEL_LOCAL_STORAGE_PLANES >=
+               MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES`);
+}
+
+function checkInitialValues() {
+  debug("\nCheck that PLS state has the correct initial values.");
+  shouldBeTrue("gl.getParameter(pls.PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_WEBGL) == 0");
+  wtu.glErrorShouldBe(
+      gl, gl.NONE,
+      "It's valid to query GL_PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_WEBGL even when fbo 0 is bound.");
+
+  // Table 6.Y: Pixel Local Storage State
+  gl.bindFramebuffer(gl.FRAMEBUFFER, gl.createFramebuffer());
+  shouldBeTrue("gl.getParameter(pls.PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_WEBGL) == 0");
+  debug("Check the initial clear values for each plane.");
+  for (let i = 0; i < MAX_PIXEL_LOCAL_STORAGE_PLANES; ++i)
+  {
+    expectTrue(pls.getFramebufferPixelLocalStorageParameterWEBGL(
+        i, pls.PIXEL_LOCAL_FORMAT_WEBGL) == gl.NONE);
+    expectTrue(pls.getFramebufferPixelLocalStorageParameterWEBGL(
+        i, pls.PIXEL_LOCAL_TEXTURE_NAME_WEBGL) == null);
+    expectTrue(pls.getFramebufferPixelLocalStorageParameterWEBGL(
+        i, pls.PIXEL_LOCAL_TEXTURE_LEVEL_WEBGL) == 0);
+    expectTrue(pls.getFramebufferPixelLocalStorageParameterWEBGL(
+        i, pls.PIXEL_LOCAL_TEXTURE_LAYER_WEBGL) == 0);
+    expectTrue(arraysEqual(
+        pls.getFramebufferPixelLocalStorageParameterWEBGL(
+            i, pls.PIXEL_LOCAL_CLEAR_VALUE_FLOAT_WEBGL),
+        new Float32Array([0, 0, 0, 0])));
+    expectTrue(arraysEqual(
+        pls.getFramebufferPixelLocalStorageParameterWEBGL(
+            i, pls.PIXEL_LOCAL_CLEAR_VALUE_INT_WEBGL),
+        new Int32Array([0, 0, 0, 0])));
+    expectTrue(arraysEqual(
+        pls.getFramebufferPixelLocalStorageParameterWEBGL(
+            i, pls.PIXEL_LOCAL_CLEAR_VALUE_UNSIGNED_INT_WEBGL),
+        new Uint32Array([0, 0, 0, 0])));
+  }
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+}
+
+function checkWebGLNonNormativeBehavior() {
+  debug("\nCheck the WebGL-specific behavior not found in the " +
+        "ANGLE_shader_pixel_local_storage specification.");
+  gl.bindFramebuffer(gl.FRAMEBUFFER, gl.createFramebuffer());
+
+  debug("If 'texture' has been deleted, generates an INVALID_OPERATION error.");
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  const tex = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, tex);
+  gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, 1, 1);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  gl.deleteTexture(tex);
+  pls.framebufferTexturePixelLocalStorageWEBGL(0, tex, 0, 0);
+  wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION);
+
+  debug("If 'texture' was generated by a different WebGL2RenderingContext than this one, " +
+        "generates an INVALID_OPERATION error.");
+  const gl2 = wtu.create3DContext(null, null, 2);
+  const tex2 = gl2.createTexture();
+  gl2.bindTexture(gl2.TEXTURE_2D, tex2);
+  gl2.texStorage2D(gl2.TEXTURE_2D, 1, gl2.RGBA8, 1, 1);
+  pls.framebufferTexturePixelLocalStorageWEBGL(0, tex2, 0, 0);
+  wtu.glErrorShouldBe(gl2, gl2.NONE);
+  wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION);
+
+  debug("If value has less than srcOffset + 4 elements, generates an INVALID_VALUE error.");
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  pls.framebufferPixelLocalClearValuefvWEBGL(0, new Float32Array(3));
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
+  pls.framebufferPixelLocalClearValuefvWEBGL(1, [0, 0, 0]);
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
+  pls.framebufferPixelLocalClearValueivWEBGL(2, new Int32Array(3));
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
+  pls.framebufferPixelLocalClearValueivWEBGL(3, [0, 0, 0]);
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
+  pls.framebufferPixelLocalClearValueuivWEBGL(4, new Uint32Array(3));
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
+  pls.framebufferPixelLocalClearValueuivWEBGL(3, [0, 0, 0]);
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
+  pls.framebufferPixelLocalClearValuefvWEBGL(2, new Float32Array(5), 2);
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
+  pls.framebufferPixelLocalClearValuefvWEBGL(1, [0, 0, 0, 0, 0], 2);
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
+  pls.framebufferPixelLocalClearValueivWEBGL(0, new Int32Array(5), 2);
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
+  pls.framebufferPixelLocalClearValueivWEBGL(1, [0, 0, 0, 0, 0], 2);
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
+  pls.framebufferPixelLocalClearValueuivWEBGL(2, new Uint32Array(5), 2);
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
+  pls.framebufferPixelLocalClearValueuivWEBGL(3, [0, 0, 0, 0, 0], 2);
+  wtu.glErrorShouldBe(gl, gl.INVALID_VALUE);
+
+  debug("Check that srcOffset works properly.");
+  const arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+  pls.framebufferPixelLocalClearValuefvWEBGL(0, new Float32Array(arr), 1);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  shouldBeTrue(`arraysEqual(pls.getFramebufferPixelLocalStorageParameterWEBGL(
+                                0, pls.PIXEL_LOCAL_CLEAR_VALUE_FLOAT_WEBGL),
+                            new Float32Array([1, 2, 3, 4]))`);
+  pls.framebufferPixelLocalClearValuefvWEBGL(1, arr, 2);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  shouldBeTrue(`arraysEqual(pls.getFramebufferPixelLocalStorageParameterWEBGL(
+                                1, pls.PIXEL_LOCAL_CLEAR_VALUE_FLOAT_WEBGL),
+                            [2, 3, 4, 5])`);
+  pls.framebufferPixelLocalClearValueivWEBGL(2, new Int32Array(arr), 3);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  shouldBeTrue(`arraysEqual(pls.getFramebufferPixelLocalStorageParameterWEBGL(
+                                2, pls.PIXEL_LOCAL_CLEAR_VALUE_INT_WEBGL),
+                            new Float32Array([3, 4, 5, 6]))`);
+  pls.framebufferPixelLocalClearValueivWEBGL(3, arr, 4);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  shouldBeTrue(`arraysEqual(pls.getFramebufferPixelLocalStorageParameterWEBGL(
+                                3, pls.PIXEL_LOCAL_CLEAR_VALUE_INT_WEBGL),
+                            [4, 5, 6, 7])`);
+  pls.framebufferPixelLocalClearValueuivWEBGL(2, new Uint32Array(arr), 5);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  shouldBeTrue(`arraysEqual(pls.getFramebufferPixelLocalStorageParameterWEBGL(
+                                2, pls.PIXEL_LOCAL_CLEAR_VALUE_UNSIGNED_INT_WEBGL),
+                            new Uint32Array([5, 6, 7, 8]))`);
+  pls.framebufferPixelLocalClearValueuivWEBGL(1, arr, 6);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  shouldBeTrue(`arraysEqual(pls.getFramebufferPixelLocalStorageParameterWEBGL(
+                                1, pls.PIXEL_LOCAL_CLEAR_VALUE_UNSIGNED_INT_WEBGL),
+                            [6, 7, 8, 9])`);
+
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+}
+
+async function checkRendering() {
+  debug("\nCheck very simple rendering.");
+  const tex = gl.createTexture();
+  gl.bindTexture(gl.TEXTURE_2D, tex);
+  gl.texStorage2D(gl.TEXTURE_2D, 1, gl.RGBA8, canvas.width, canvas.height);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+
+  const plsFBO = gl.createFramebuffer();
+  gl.bindFramebuffer(gl.FRAMEBUFFER, plsFBO);
+  pls.framebufferTexturePixelLocalStorageWEBGL(0, tex, 0, 0);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+
+  gl.viewport(0, 0, canvas.width, canvas.height);
+
+  // Adds a uniform color into the existing color in pixel local storage.
+  const fs = `#version 300 es
+  #extension GL_ANGLE_shader_pixel_local_storage : require
+  precision lowp float;
+  uniform vec4 color;
+  layout(binding=0, rgba8) uniform lowp pixelLocalANGLE pls;
+  void main() {
+    vec4 newColor = color + pixelLocalLoadANGLE(pls);
+    pixelLocalStoreANGLE(pls, newColor);
+  }`;
+
+  const program = wtu.setupProgram(gl, [fullscreenQuadVertexShader, fs]);
+  if (!program) {
+    testFailed("Failed to compile program.");
+    return;
+  }
+
+  gl.useProgram(program);
+  const colorUniLocation = gl.getUniformLocation(program, "color");
+  wtu.glErrorShouldBe(gl, gl.NONE);
+
+  pls.beginPixelLocalStorageWEBGL([pls.LOAD_OP_ZERO_WEBGL]);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  shouldBeTrue("gl.getParameter(pls.PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_WEBGL) == 1");
+
+  gl.uniform4f(colorUniLocation, 0, 1, 0, 0);
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+
+  pls.pixelLocalStorageBarrierWEBGL();
+
+  gl.uniform4f(colorUniLocation, 0, 0, 0, 1);
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+
+  pls.endPixelLocalStorageWEBGL([pls.STORE_OP_STORE_WEBGL]);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  shouldBeTrue("gl.getParameter(pls.PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_WEBGL) == 0");
+
+  const blitFBO = gl.createFramebuffer();
+  gl.bindFramebuffer(gl.READ_FRAMEBUFFER, blitFBO);
+  gl.framebufferTexture2D(gl.READ_FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0);
+  gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, null);
+  gl.blitFramebuffer(0, 0, canvas.width, canvas.height, 0, 0, canvas.width, canvas.height,
+                     gl.COLOR_BUFFER_BIT, gl.NEAREST);
+
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+  wtu.checkCanvas(gl, [0, 255, 0, 255]);
+
+  gl.bindFramebuffer(gl.FRAMEBUFFER, plsFBO);
+  pls.beginPixelLocalStorageWEBGL([pls.LOAD_OP_LOAD_WEBGL]);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  shouldBeTrue("gl.getParameter(pls.PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_WEBGL) == 1");
+
+  // The canvas should get cleared after compositing, even if PLS is active.
+  await new Promise(resolve => wtu.waitForComposite(resolve));
+
+  // PLS should still be active on plsFBO even after being interrupted for compositing.
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  shouldBeTrue("gl.getParameter(pls.PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_WEBGL) == 1");
+
+  gl.uniform4f(colorUniLocation, 0, 0, 1, 0);
+  gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
+
+  pls.endPixelLocalStorageWEBGL([pls.STORE_OP_STORE_WEBGL]);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+  shouldBeTrue("gl.getParameter(pls.PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_WEBGL) == 0");
+
+  // The canvas should have gotten cleared while PLS was active.
+  gl.bindFramebuffer(gl.FRAMEBUFFER, null);
+  wtu.checkCanvas(gl, [0, 0, 0, 0]);
+
+  // The additional PLS draw to plsFBO should have still worked after being interrupted for
+  // compositing.
+  gl.bindFramebuffer(gl.READ_FRAMEBUFFER, blitFBO);
+  gl.blitFramebuffer(0, 0, canvas.width, canvas.height, 0, 0, canvas.width, canvas.height,
+                     gl.COLOR_BUFFER_BIT, gl.NEAREST);
+  wtu.checkCanvas(gl, [0, 255, 255, 255]);
+  wtu.glErrorShouldBe(gl, gl.NONE);
+}
+
+runTest();
+var successfullyParsed = true;
+</script>
+<script src="../../js/js-test-post.js"></script>
+</body>
+</html>