Bug 1142211 - Add layerization testing mechanisms to reftest. r=roc

This adds support for class="reftest-opaque-layer" and for
reftest-assigned-layer="some-layer-name" to the reftest harness.

From reftest/README.txt:

Opaque Layer Tests: class="reftest-opaque-layer"
================================================

If an element should be assigned to a PaintedLayer that's opaque, set the class
"reftest-opaque-layer" on it. This checks whether the layer is opaque during
the last paint of the test, and it works whether your test is an invalidation
test or not. In order to pass the test, the element has to have a primary
frame, and that frame's display items must all be assigned to a single painted
layer and no other layers, so it can't be used on elements that create stacking
contexts (active or inactive).

Layerization Tests: reftest-assigned-layer="layer-name"
=======================================================

If two elements should be assigned to the same PaintedLayer, choose any string
value as the layer name and set the attribute reftest-assigned-layer="yourname"
on both elements. Reftest will check whether all elements with the same
reftest-assigned-layer value share the same layer. It will also test whether
elements with different reftest-assigned-layer values are assigned to different
layers.
The same restrictions as with class="reftest-opaque-layer" apply: All elements
must have a primary frame, and that frame's display items must all be assigned
to the same PaintedLayer and no other layers. If these requirements are not
met, the test will fail.

dom/base/nsDOMWindowUtils.cpp

@@ -2940,6 +2940,67 @@ nsDOMWindowUtils::CheckAndClearPaintedState(nsIDOMElement* aElement, bool* aResu
   return NS_OK;
 }
 
+NS_IMETHODIMP
+nsDOMWindowUtils::IsPartOfOpaqueLayer(nsIDOMElement* aElement, bool* aResult)
+{
+  MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
+
+  if (!aElement) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsIContent> content = do_QueryInterface(aElement, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsIFrame* frame = content->GetPrimaryFrame();
+  if (!frame) {
+    return NS_ERROR_FAILURE;
+  }
+
+  Layer* layer = FrameLayerBuilder::GetDebugSingleOldLayerForFrame(frame);
+  if (!layer || !layer->AsPaintedLayer()) {
+    return NS_ERROR_FAILURE;
+  }
+
+  *aResult = (layer->GetContentFlags() & Layer::CONTENT_OPAQUE);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDOMWindowUtils::NumberOfAssignedPaintedLayers(nsIDOMElement** aElements,
+                                                uint32_t aCount,
+                                                uint32_t* aResult)
+{
+  MOZ_RELEASE_ASSERT(nsContentUtils::IsCallerChrome());
+
+  if (!aElements) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  nsTHashtable<nsPtrHashKey<PaintedLayer>> layers;
+  nsresult rv;
+  for (uint32_t i = 0; i < aCount; i++) {
+    nsCOMPtr<nsIContent> content = do_QueryInterface(aElements[i], &rv);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    nsIFrame* frame = content->GetPrimaryFrame();
+    if (!frame) {
+      return NS_ERROR_FAILURE;
+    }
+
+    Layer* layer = FrameLayerBuilder::GetDebugSingleOldLayerForFrame(frame);
+    if (!layer || !layer->AsPaintedLayer()) {
+      return NS_ERROR_FAILURE;
+    }
+
+    layers.PutEntry(layer->AsPaintedLayer());
+  }
+
+  *aResult = layers.Count();
+  return NS_OK;
+}
+
 NS_IMETHODIMP
 nsDOMWindowUtils::EnableDialogs()
 {

dom/interfaces/base/nsIDOMWindowUtils.idl

@@ -50,7 +50,7 @@ interface nsITranslationNodeList;
 interface nsIJSRAIIHelper;
 interface nsIContentPermissionRequest;
 
-[scriptable, uuid(aa7a399f-7178-4006-9e37-d3959afed2ee)]
+[scriptable, uuid(b39cb73f-ff99-4744-9780-2c26f830c6f7)]
 interface nsIDOMWindowUtils : nsISupports {
 
   /**
@@ -1447,6 +1447,23 @@ interface nsIDOMWindowUtils : nsISupports {
    */
   boolean checkAndClearPaintedState(in nsIDOMElement aElement);
 
+  /**
+   * Check whether all display items of the primary frame of aElement have been
+   * assigned to the same single PaintedLayer in the last paint. If that is the
+   * case, returns whether that PaintedLayer is opaque; if it's not the case, an
+   * exception is thrown.
+   */
+  boolean isPartOfOpaqueLayer(in nsIDOMElement aElement);
+
+  /**
+   * Count the number of different PaintedLayers that the supplied elements have
+   * been assigned to in the last paint. Throws an exception if any of the
+   * elements doesn't have a primary frame, or if that frame's display items are
+   * assigned to any other layers than just a single PaintedLayer per element.
+   */
+  unsigned long numberOfAssignedPaintedLayers([array, size_is(count)] in nsIDOMElement aElements,
+                                              in uint32_t count);
+
   /**
    * Get internal id of the stored blob, file or file handle.
    */

layout/base/FrameLayerBuilder.cpp

@@ -1592,6 +1592,27 @@ FrameLayerBuilder::GetDebugOldLayerFor(nsIFrame* aFrame, uint32_t aDisplayItemKe
   return nullptr;
 }
 
+/* static */ Layer*
+FrameLayerBuilder::GetDebugSingleOldLayerForFrame(nsIFrame* aFrame)
+{
+  nsTArray<DisplayItemData*>* array =
+    reinterpret_cast<nsTArray<DisplayItemData*>*>(aFrame->Properties().Get(LayerManagerDataProperty()));
+
+  if (!array) {
+    return nullptr;
+  }
+
+  Layer* layer = nullptr;
+  for (DisplayItemData* data : *array) {
+    if (layer && layer != data->mLayer) {
+      // More than one layer assigned, bail.
+      return nullptr;
+    }
+    layer = data->mLayer;
+  }
+  return layer;
+}
+
 already_AddRefed<ColorLayer>
 ContainerState::CreateOrRecycleColorLayer(PaintedLayer *aPainted)
 {

layout/base/FrameLayerBuilder.h

@@ -347,6 +347,14 @@ public:
 
   static Layer* GetDebugOldLayerFor(nsIFrame* aFrame, uint32_t aDisplayItemKey);
 
+  /**
+   * Return the layer that all display items of aFrame were assigned to in the
+   * last paint, or nullptr if there was no single layer assigned to all of the
+   * frame's display items (i.e. zero, or more than one).
+   * This function is for testing purposes and not performance sensitive.
+   */
+  static Layer* GetDebugSingleOldLayerForFrame(nsIFrame* aFrame);
+
   /**
    * Destroy any stored LayerManagerDataProperty and the associated data for
    * aFrame.

layout/reftests/reftest-sanity/reftest-assigned-layer-fail-1.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html lang="en">
+<meta charset="utf-8">
+<title>This test will fail because .high-z is not in the same layer as .low-z</title>
+
+<style>
+
+.content {
+  box-sizing: border-box;
+  width: 200px;
+  height: 200px;
+  border: 1px solid black;
+  margin: 10px;
+}
+
+.relative {
+  position: relative;
+}
+
+.fixed {
+  position: fixed;
+  top: 140px;
+  left: 140px;
+}
+
+.low-z {
+  z-index: 1;
+}
+
+.mid-z {
+  z-index: 2;
+}
+
+.high-z {
+  z-index: 3;
+}
+
+.opaque-background {
+  background-color: white;
+}
+
+body {
+  height: 4000px;
+}
+
+</style>
+
+<div class="content relative low-z" reftest-assigned-layer="page-background"></div>
+
+<div class="fixed opaque-background content mid-z" reftest-assigned-layer="fixed-layer"></div>
+
+<div class="content relative high-z" reftest-assigned-layer="page-background"></div>

layout/reftests/reftest-sanity/reftest-assigned-layer-fail-2.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html lang="en">
+<meta charset="utf-8">
+<title>This test will fail because .mid-z is not in the same layer as .low-z</title>
+
+<style>
+
+.content {
+  box-sizing: border-box;
+  width: 200px;
+  height: 200px;
+  border: 1px solid black;
+  margin: 10px;
+}
+
+.relative {
+  position: relative;
+}
+
+.fixed {
+  position: fixed;
+  top: 140px;
+  left: 140px;
+}
+
+.low-z {
+  z-index: 1;
+}
+
+.mid-z {
+  z-index: 2;
+}
+
+.high-z {
+  z-index: 3;
+}
+
+.opaque-background {
+  background-color: white;
+}
+
+body {
+  height: 4000px;
+}
+
+</style>
+
+<div class="content relative low-z" reftest-assigned-layer="page-background"></div>
+
+<div class="fixed opaque-background content mid-z" reftest-assigned-layer="page-background"></div>
+
+<div class="content relative low-z" reftest-assigned-layer="page-background"></div>

layout/reftests/reftest-sanity/reftest-assigned-layer-fail-3.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html lang="en">
+<meta charset="utf-8">
+<title>This test will fail because .high-z is not in the same layer as .mid-z</title>
+
+<style>
+
+.content {
+  box-sizing: border-box;
+  width: 200px;
+  height: 200px;
+  border: 1px solid black;
+  margin: 10px;
+}
+
+.relative {
+  position: relative;
+}
+
+.fixed {
+  position: fixed;
+  top: 140px;
+  left: 140px;
+}
+
+.low-z {
+  z-index: 1;
+}
+
+.mid-z {
+  z-index: 2;
+}
+
+.high-z {
+  z-index: 3;
+}
+
+.opaque-background {
+  background-color: white;
+}
+
+body {
+  height: 4000px;
+}
+
+</style>
+
+<div class="content relative low-z" reftest-assigned-layer="page-background"></div>
+
+<div class="fixed opaque-background content mid-z" reftest-assigned-layer="fixed-layer"></div>
+
+<div class="content relative low-z" reftest-assigned-layer="fixed-layer"></div>

layout/reftests/reftest-sanity/reftest-assigned-layer-fail-4.html

@@ -0,0 +1,52 @@
+<!DOCTYPE html>
+<html lang="en">
+<meta charset="utf-8">
+<title>This test will fail because the some-other-layer gets merged into the page background layer</title>
+
+<style>
+
+.content {
+  box-sizing: border-box;
+  width: 200px;
+  height: 200px;
+  border: 1px solid black;
+  margin: 10px;
+}
+
+.relative {
+  position: relative;
+}
+
+.fixed {
+  position: fixed;
+  top: 140px;
+  left: 140px;
+}
+
+.low-z {
+  z-index: 1;
+}
+
+.mid-z {
+  z-index: 2;
+}
+
+.high-z {
+  z-index: 3;
+}
+
+.opaque-background {
+  background-color: white;
+}
+
+body {
+  height: 4000px;
+}
+
+</style>
+
+<div class="content relative low-z" reftest-assigned-layer="page-background"></div>
+
+<div class="fixed opaque-background content mid-z" reftest-assigned-layer="fixed-layer"></div>
+
+<div class="content relative low-z" reftest-assigned-layer="some-other-layer"></div>

layout/reftests/reftest-sanity/reftest-assigned-layer-pass.html

@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html lang="en">
+<meta charset="utf-8">
+<title>Both divs should be part of opaque layers.</title>
+
+<style>
+
+.content {
+  box-sizing: border-box;
+  width: 200px;
+  height: 200px;
+  border: 1px solid black;
+  margin: 10px;
+}
+
+.relative {
+  position: relative;
+}
+
+.fixed {
+  position: fixed;
+  top: 140px;
+  left: 140px;
+}
+
+.low-z {
+  z-index: 1;
+}
+
+.high-z {
+  z-index: 2;
+}
+
+.opaque-background {
+  background-color: white;
+}
+
+body {
+  height: 4000px;
+}
+
+</style>
+
+<div class="content relative low-z" reftest-assigned-layer="page-background"></div>
+
+<div class="fixed opaque-background content high-z" reftest-assigned-layer="fixed-layer"></div>
+
+<div class="content relative low-z" reftest-assigned-layer="page-background"></div>

layout/reftests/reftest-sanity/reftest-opaque-layer-fail.html

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+<html lang="en">
+<meta charset="utf-8">
+<title>The fixed layer can't be opaque, so this test must fail.</title>
+
+<style>
+
+.content {
+  box-sizing: border-box;
+  width: 200px;
+  height: 200px;
+  border: 1px solid black;
+}
+
+.fixed {
+  position: fixed;
+  top: 20px;
+  left: 140px;
+}
+
+body {
+  height: 4000px;
+}
+
+</style>
+
+<div class="content reftest-opaque-layer"></div>
+
+<div class="fixed content reftest-opaque-layer"></div>

layout/reftests/reftest-sanity/reftest-opaque-layer-pass.html

@@ -0,0 +1,33 @@
+<!DOCTYPE html>
+<html lang="en">
+<meta charset="utf-8">
+<title>Both divs should be part of opaque layers.</title>
+
+<style>
+
+.content {
+  box-sizing: border-box;
+  width: 200px;
+  height: 200px;
+  border: 1px solid black;
+}
+
+.fixed {
+  position: fixed;
+  top: 20px;
+  left: 140px;
+}
+
+.opaque-background {
+  background-color: white;
+}
+
+body {
+  height: 4000px;
+}
+
+</style>
+
+<div class="content reftest-opaque-layer"></div>
+
+<div class="fixed opaque-background content reftest-opaque-layer"></div>

layout/reftests/reftest-sanity/reftest-opaque-layer-wait-fail.html

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html lang="en" class="reftest-wait">
+<meta charset="utf-8">
+<title>The fixed layer can't be opaque in the final paint, so this test must fail.</title>
+
+<style>
+
+.content {
+  box-sizing: border-box;
+  width: 200px;
+  height: 200px;
+  border: 1px solid black;
+}
+
+.fixed {
+  position: fixed;
+  top: 20px;
+  left: 140px;
+}
+
+.reftest-wait .reftest-opaque-layer {
+  /* make the layer opaque until the final paint */
+  background-color: white;
+}
+
+body {
+  height: 4000px;
+}
+
+</style>
+
+<div class="content reftest-opaque-layer"></div>
+
+<div class="fixed content reftest-opaque-layer"></div>
+
+<script>
+
+function doTest() {
+  document.documentElement.removeAttribute("class");
+}
+document.addEventListener("MozReftestInvalidate", doTest, false);
+
+</script>

layout/reftests/reftest-sanity/reftest-opaque-layer-wait-pass.html

@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html lang="en" class="reftest-wait">
+<meta charset="utf-8">
+<title>Both divs should be part of opaque layers in the final paint.</title>
+
+<style>
+
+.content {
+  box-sizing: border-box;
+  width: 200px;
+  height: 200px;
+  border: 1px solid black;
+}
+
+.fixed {
+  position: fixed;
+  top: 20px;
+  left: 140px;
+}
+
+.opaque-background {
+  background-color: white;
+}
+
+.reftest-wait .opaque-background {
+  /* make the layer start out transparent */
+  background-color: transparent;
+}
+
+body {
+  height: 4000px;
+}
+
+</style>
+
+<div class="content reftest-opaque-layer"></div>
+
+<div class="fixed opaque-background content reftest-opaque-layer"></div>
+
+<script>
+
+function doTest() {
+  document.documentElement.removeAttribute("class");
+}
+document.addEventListener("MozReftestInvalidate", doTest, false);
+
+</script>
+

layout/reftests/reftest-sanity/reftest.list

@@ -165,3 +165,30 @@ skip-if(!asyncPanZoom||!browserIsRemote) == async-scroll-1a.html async-scroll-1-
 default-preferences pref(layers.low-precision-buffer,false)
 skip-if(!asyncPanZoom||!browserIsRemote) != async-scroll-1b.html async-scroll-1-ref.html
 default-preferences
+
+# reftest-opaque-layer
+== reftest-opaque-layer-pass.html reftest-opaque-layer-pass.html
+!= reftest-opaque-layer-pass.html about:blank
+!= about:blank reftest-opaque-layer-pass.html
+fails == reftest-opaque-layer-fail.html reftest-opaque-layer-fail.html
+
+# If reftest-opaque-layer fails (no matter whether it fails in the test or in the reference),
+# it shouldn't matter whether the test matches the reference.
+fails != reftest-opaque-layer-fail.html reftest-opaque-layer-fail.html
+fails == reftest-opaque-layer-fail.html about:blank
+fails == about:blank reftest-opaque-layer-fail.html
+fails != reftest-opaque-layer-fail.html about:blank
+fails != about:blank reftest-opaque-layer-fail.html
+
+# reftest-opaque-layer and reftest-wait
+== reftest-opaque-layer-wait-pass.html reftest-opaque-layer-pass.html
+!= reftest-opaque-layer-wait-pass.html about:blank
+fails == reftest-opaque-layer-wait-fail.html reftest-opaque-layer-fail.html
+fails != reftest-opaque-layer-wait-fail.html about:blank
+
+# reftest-assigned-layer
+!= reftest-assigned-layer-pass.html about:blank
+fails != reftest-assigned-layer-fail-1.html about:blank
+fails != reftest-assigned-layer-fail-2.html about:blank
+fails != reftest-assigned-layer-fail-3.html about:blank
+fails != reftest-assigned-layer-fail-4.html about:blank

layout/tools/reftest/README.txt

@@ -459,6 +459,31 @@ when doing an invalidation test. Causing a repaint in your
 MozReftestInvalidate handler (for example, by changing the body's background
 colour) will accurately test whether the element is painted.
 
+Opaque Layer Tests: class="reftest-opaque-layer"
+================================================
+
+If an element should be assigned to a PaintedLayer that's opaque, set the class
+"reftest-opaque-layer" on it. This checks whether the layer is opaque during
+the last paint of the test, and it works whether your test is an invalidation
+test or not. In order to pass the test, the element has to have a primary
+frame, and that frame's display items must all be assigned to a single painted
+layer and no other layers, so it can't be used on elements that create stacking
+contexts (active or inactive).
+
+Layerization Tests: reftest-assigned-layer="layer-name"
+=======================================================
+
+If two elements should be assigned to the same PaintedLayer, choose any string
+value as the layer name and set the attribute reftest-assigned-layer="yourname"
+on both elements. Reftest will check whether all elements with the same
+reftest-assigned-layer value share the same layer. It will also test whether
+elements with different reftest-assigned-layer values are assigned to different
+layers.
+The same restrictions as with class="reftest-opaque-layer" apply: All elements
+must have a primary frame, and that frame's display items must all be assigned
+to the same PaintedLayer and no other layers. If these requirements are not
+met, the test will fail.
+
 Snapshot The Whole Window: class="reftest-snapshot-all"
 =======================================================
 

layout/tools/reftest/reftest-content.js

@@ -316,7 +316,25 @@ function shouldSnapshotWholePage(contentRootElement) {
 }
 
 function getNoPaintElements(contentRootElement) {
-  return contentRootElement.getElementsByClassName('reftest-no-paint');
+    return contentRootElement.getElementsByClassName('reftest-no-paint');
+}
+
+function getOpaqueLayerElements(contentRootElement) {
+    return contentRootElement.getElementsByClassName('reftest-opaque-layer');
+}
+
+function getAssignedLayerMap(contentRootElement) {
+    var layerNameToElementsMap = {};
+    var elements = contentRootElement.querySelectorAll('[reftest-assigned-layer]');
+    for (var i = 0; i < elements.length; ++i) {
+        var element = elements[i];
+        var layerName = element.getAttribute('reftest-assigned-layer');
+        if (!(layerName in layerNameToElementsMap)) {
+            layerNameToElementsMap[layerName] = [];
+        }
+        layerNameToElementsMap[layerName].push(element);
+    }
+    return layerNameToElementsMap;
 }
 
 // Initial state. When the document has loaded and all MozAfterPaint events and
@@ -525,6 +543,7 @@ function WaitForTestEnd(contentRootElement, inPrintMode, spellCheckedElements) {
                       SendFailedNoPaint();
                   }
               }
+              CheckLayerAssertions(contentRootElement);
             }
             LogInfo("MakeProgress: Completed");
             state = STATE_COMPLETED;
@@ -631,7 +650,8 @@ function OnDocumentLoad(event)
             // Go into reftest-wait mode belatedly.
             WaitForTestEnd(contentRootElement, inPrintMode, []);
         } else {
-            CheckForProcessCrashExpectation();
+            CheckLayerAssertions(contentRootElement);
+            CheckForProcessCrashExpectation(contentRootElement);
             RecordResult();
         }
     }
@@ -661,9 +681,60 @@ function OnDocumentLoad(event)
     }
 }
 
-function CheckForProcessCrashExpectation()
+function CheckLayerAssertions(contentRootElement)
+{
+    if (!contentRootElement) {
+        return;
+    }
+
+    var opaqueLayerElements = getOpaqueLayerElements(contentRootElement);
+    for (var i = 0; i < opaqueLayerElements.length; ++i) {
+        var elem = opaqueLayerElements[i];
+        try {
+            if (!windowUtils().isPartOfOpaqueLayer(elem)) {
+                SendFailedOpaqueLayer(elementDescription(elem) + ' is not part of an opaque layer');
+            }
+        } catch (e) {
+            SendFailedOpaqueLayer('got an exception while checking whether ' + elementDescription(elem) + ' is part of an opaque layer');
+        }
+    }
+    var layerNameToElementsMap = getAssignedLayerMap(contentRootElement);
+    var oneOfEach = [];
+    // Check that elements with the same reftest-assigned-layer share the same PaintedLayer.
+    for (var layerName in layerNameToElementsMap) {
+        try {
+            var elements = layerNameToElementsMap[layerName];
+            oneOfEach.push(elements[0]);
+            var numberOfLayers = windowUtils().numberOfAssignedPaintedLayers(elements, elements.length);
+            if (numberOfLayers !== 1) {
+                SendFailedAssignedLayer('these elements are assigned to ' + numberOfLayers +
+                                        ' different layers, instead of sharing just one layer: ' +
+                                        elements.map(elementDescription).join(', '));
+            }
+        } catch (e) {
+            SendFailedAssignedLayer('got an exception while checking whether these elements share a layer: ' +
+                                    elements.map(elementDescription).join(', '));
+        }
+    }
+    // Check that elements with different reftest-assigned-layer are assigned to different PaintedLayers.
+    if (oneOfEach.length > 0) {
+        try {
+            var numberOfLayers = windowUtils().numberOfAssignedPaintedLayers(oneOfEach, oneOfEach.length);
+            if (numberOfLayers !== oneOfEach.length) {
+                SendFailedAssignedLayer('these elements are assigned to ' + numberOfLayers +
+                                        ' different layers, instead of having none in common (expected ' +
+                                        oneOfEach.length + ' different layers): ' +
+                                        oneOfEach.map(elementDescription).join(', '));
+            }
+        } catch (e) {
+            SendFailedAssignedLayer('got an exception while checking whether these elements are assigned to different layers: ' +
+                                    oneOfEach.map(elementDescription).join(', '));
+        }
+    }
+}
+
+function CheckForProcessCrashExpectation(contentRootElement)
 {
-    var contentRootElement = content.document.documentElement;
     if (contentRootElement &&
         contentRootElement.hasAttribute('class') &&
         contentRootElement.getAttribute('class').split(/\s+/)
@@ -872,6 +943,16 @@ function SendFailedNoPaint()
     sendAsyncMessage("reftest:FailedNoPaint");
 }
 
+function SendFailedOpaqueLayer(why)
+{
+    sendAsyncMessage("reftest:FailedOpaqueLayer", { why: why });
+}
+
+function SendFailedAssignedLayer(why)
+{
+    sendAsyncMessage("reftest:FailedAssignedLayer", { why: why });
+}
+
 // Return true if a snapshot was taken.
 function SendInitCanvasWithSnapshot()
 {
@@ -918,6 +999,14 @@ function roundTo(x, fraction)
     return Math.round(x/fraction)*fraction;
 }
 
+function elementDescription(element)
+{
+    return '<' + element.localName +
+        [].slice.call(element.attributes).map((attr) =>
+            ` ${attr.nodeName}="${attr.value}"`).join('') +
+        '>';
+}
+
 function SendUpdateCanvasForEvent(event, contentRootElement)
 {
     var win = content;

layout/tools/reftest/reftest.js

@@ -113,6 +113,10 @@ var gExpectedCrashDumpFiles = [];
 var gUnexpectedCrashDumpFiles = { };
 var gCrashDumpDir;
 var gFailedNoPaint = false;
+var gFailedOpaqueLayer = false;
+var gFailedOpaqueLayerMessages = [];
+var gFailedAssignedLayer = false;
+var gFailedAssignedLayerMessages = [];
 
 // The enabled-state of the test-plugins, stored so they can be reset later
 var gTestPluginEnabledStates = null;
@@ -1658,20 +1662,34 @@ function RecordResult(testRunTime, errorMsg, scriptResults)
                 gDumpLog("REFTEST fuzzy match\n");
             }
 
+            var failedExtraCheck = gFailedNoPaint || gFailedOpaqueLayer || gFailedAssignedLayer;
+
             // whether the comparison result matches what is in the manifest
-            var test_passed = (equal == (gURLs[0].type == TYPE_REFTEST_EQUAL)) && !gFailedNoPaint;
+            var test_passed = (equal == (gURLs[0].type == TYPE_REFTEST_EQUAL)) && !failedExtraCheck;
 
             output = outputs[expected][test_passed];
 
             ++gTestResults[output.n];
 
-            // It's possible that we failed both reftest-no-paint and the normal comparison, but we don't
-            // have a way to annotate these separately, so just print an error for the no-paint failure.
-            if (gFailedNoPaint) {
+            // It's possible that we failed both an "extra check" and the normal comparison, but we don't
+            // have a way to annotate these separately, so just print an error for the extra check failures.
+            if (failedExtraCheck) {
+                var failures = [];
+                if (gFailedNoPaint) {
+                    failures.push("failed reftest-no-paint");
+                }
+                // The gFailed*Messages arrays will contain messages from both the test and the reference.
+                if (gFailedOpaqueLayer) {
+                    failures.push("failed reftest-opaque-layer: " + gFailedOpaqueLayerMessages.join(", "));
+                }
+                if (gFailedAssignedLayer) {
+                    failures.push("failed reftest-assigned-layer: " + gFailedAssignedLayerMessages.join(", "));
+                }
+                var failureString = failures.join(", ");
                 if (expected == EXPECTED_FAIL) {
-                    gDumpLog("REFTEST TEST-KNOWN-FAIL | " + gURLs[0].prettyPath + " | failed reftest-no-paint\n");
+                    gDumpLog("REFTEST TEST-KNOWN-FAIL | " + gURLs[0].prettyPath + " | " + failureString + "\n");
                 } else {
-                    gDumpLog("REFTEST TEST-UNEXPECTED-FAIL | " + gURLs[0].prettyPath + " | failed reftest-no-paint\n");
+                    gDumpLog("REFTEST TEST-UNEXPECTED-FAIL | " + gURLs[0].prettyPath + " | " + failureString + "\n");
                 }
             } else {
                 var result = "REFTEST " + output.s + " | " +
@@ -1701,19 +1719,19 @@ function RecordResult(testRunTime, errorMsg, scriptResults)
                 }
 
                 gDumpLog(result);
+
+                if (gURLs[0].prefSettings1.length == 0) {
+                    UpdateCanvasCache(gURLs[0].url1, gCanvas1);
+                }
+                if (gURLs[0].prefSettings2.length == 0) {
+                    UpdateCanvasCache(gURLs[0].url2, gCanvas2);
+                }
             }
 
             if ((!test_passed && expected == EXPECTED_PASS) || (test_passed && expected == EXPECTED_FAIL)) {
                 FlushTestLog();
             }
 
-            if (gURLs[0].prefSettings1.length == 0) {
-                UpdateCanvasCache(gURLs[0].url1, gCanvas1);
-            }
-            if (gURLs[0].prefSettings2.length == 0) {
-                UpdateCanvasCache(gURLs[0].url2, gCanvas2);
-            }
-
             CleanUpCrashDumpFiles();
             FinishTestItem();
             break;
@@ -1795,6 +1813,10 @@ function FinishTestItem()
     // and tests will continue.
     SendClear();
     gFailedNoPaint = false;
+    gFailedOpaqueLayer = false;
+    gFailedOpaqueLayerMessages = [];
+    gFailedAssignedLayer = false;
+    gFailedAssignedLayerMessages = [];
 }
 
 function DoAssertionCheck(numAsserts)
@@ -1894,6 +1916,14 @@ function RegisterMessageListenersAndLoadContentScript()
         "reftest:FailedNoPaint",
         function (m) { RecvFailedNoPaint(); }
     );
+    gBrowserMessageManager.addMessageListener(
+        "reftest:FailedOpaqueLayer",
+        function (m) { RecvFailedOpaqueLayer(m.json.why); }
+    );
+    gBrowserMessageManager.addMessageListener(
+        "reftest:FailedAssignedLayer",
+        function (m) { RecvFailedAssignedLayer(m.json.why); }
+    );
     gBrowserMessageManager.addMessageListener(
         "reftest:InitCanvasWithSnapshot",
         function (m) { return RecvInitCanvasWithSnapshot(); }
@@ -1953,6 +1983,16 @@ function RecvFailedNoPaint()
     gFailedNoPaint = true;
 }
 
+function RecvFailedOpaqueLayer(why) {
+    gFailedOpaqueLayer = true;
+    gFailedOpaqueLayerMessages.push(why);
+}
+
+function RecvFailedAssignedLayer(why) {
+    gFailedAssignedLayer = true;
+    gFailedAssignedLayerMessages.push(why);
+}
+
 function RecvInitCanvasWithSnapshot()
 {
     var painted = InitCurrentCanvasWithSnapshot();