Enable universal accelerated overflow scroll

LayoutTests/compositing/overflow/resources/automatically-opt-into-composited-scrolling.js

Index: LayoutTests/compositing/overflow/resources/automatically-opt-into-composited-scrolling.js
diff --git a/LayoutTests/compositing/overflow/resources/automatically-opt-into-composited-scrolling.js b/LayoutTests/compositing/overflow/resources/automatically-opt-into-composited-scrolling.js
deleted file mode 100644
index 01746d326ff3ae813a35e15e65e616cb3bb07ad7..0000000000000000000000000000000000000000
--- a/LayoutTests/compositing/overflow/resources/automatically-opt-into-composited-scrolling.js
+++ /dev/null
@@ -1,245 +0,0 @@
-var debugMode = false;
-
-if (window.testRunner)
-  testRunner.dumpAsText();
-
-function write(str)
-{
-  var pre = document.getElementById('console');
-  var text = document.createTextNode(str + '\n');
-  pre.appendChild(text);
-}
-
-function didOptIn(element)
-{
-  var nonFastScrollableRects = window.internals.nonFastScrollableRects(document);
-  var elementBoundingBox = window.internals.boundingBox(element);
-
-  for (var i = 0; i < nonFastScrollableRects.length; ++i) {
-    var rect = nonFastScrollableRects[i];
-
-    if (rect.top === elementBoundingBox.top && rect.left === elementBoundingBox.left &&
-        rect.bottom === elementBoundingBox.bottom && rect.right === elementBoundingBox.right)
-      return false;
-  }
-
-  return true;
-}
-
-function getStackingOrder(element)
-{
-  var divElements = [];
-
-  var stackingOrder = window.internals.nodesFromRect(document, 100, 75, 200, 200, 200, 200, false, false, false);
-
-  for (var i = 0; i < stackingOrder.length; ++i)
-    if (stackingOrder[i].nodeName === "DIV")
-      divElements.push(stackingOrder[i]);
-
-  return divElements;
-}
-
-function addDomElement(elementType, className, id, parent)
-{
-  var element = document.createElement(elementType);
-  element.setAttribute("class", className);
-  element.setAttribute("id", id);
-  if (parent === "body")
-    document.body.appendChild(element);
-  else
-    document.getElementById(parent).appendChild(element);
-}
-
-function buildDom()
-{
-  addDomElement("div", "", "ancestor", "body");
-  addDomElement("div", "positioned", "predecessor", "ancestor");
-  addDomElement("div", "container", "container", "ancestor");
-  addDomElement("div", "scrolled", "firstChild", "container");
-  addDomElement("div", "scrolled", "secondChild", "container");
-  addDomElement("div", "", "normalFlow", "container");
-  addDomElement("div", "positioned", "successor", "ancestor");
-  addDomElement("pre", "", "console", "body");
-}
-
-var permutationIteration = 0;
-
-// We've already decided on the ordering of the elements, now we need to do the
-// rest of the permutations.
-function permuteWithFixedOrdering(testPermutation, siblingIndex, containerIndex, firstChildIndex, secondChildIndex, numElementsWithZIndexZero)
-{
-  if (firstChildIndex > secondChildIndex)
-    return;
-  // One of the two children must be immediately to the right of us.
-  if (numElementsWithZIndexZero === 3 && containerIndex !== firstChildIndex - 1 && containerIndex !== secondChildIndex - 1)
-    return;
-  // If we have 2 elements with z-index:0, they will be the container and the
-  // sibling (we don't care about the case when the container and a child are
-  // both z-index:0 because the tree order would ensure that ordering anyway).
-  // The two elements with z-index:0 need to be adjacent in the ordering.
-  if (numElementsWithZIndexZero === 2 && containerIndex !== siblingIndex - 1 && containerIndex !== siblingIndex + 1)
-    return;
-
-  for (var containerIsPositioned = 0; containerIsPositioned <= 1; ++containerIsPositioned) {
-    for (var hasPositionedAncestor = 0; hasPositionedAncestor <= 1; ++hasPositionedAncestor) {
-      if (containerIsPositioned === 1 && hasPositionedAncestor === 1)
-        continue;
-      for (var siblingPrecedesContainer = 0; siblingPrecedesContainer <= 1; ++siblingPrecedesContainer) {
-        // If the sibling and the container both have z-index: 0, we only have
-        // one choice for who gets to be the sibling. For example, if the
-        // sibling is supposed to precede us in paint order, but we both have
-        // z-index: 0, the order will depend entirely on tree order, so we have
-        // to choose the predecessor as the sibling. If all elements have unique
-        // z-indices, either the predecessor or the successor could be our
-        // sibling; the z-indices will ensure that the paint order is correct.
-        if (numElementsWithZIndexZero >= 2 && siblingPrecedesContainer === 1)
-          continue;
-
-        var sibling = predecessor;
-        var toHide = successor;
-        if ((numElementsWithZIndexZero === 1 && siblingPrecedesContainer === 0) ||
-            (numElementsWithZIndexZero >= 2 && siblingIndex > containerIndex)) {
-          sibling = successor;
-          toHide = predecessor;
-        }
-
-        var ordering = [ null, null, null, null ];
-        ordering[siblingIndex] = sibling;
-        ordering[containerIndex] = hasPositionedAncestor === 1 ? ancestor : container;
-        ordering[firstChildIndex] = firstChild;
-        ordering[secondChildIndex] = secondChild;
-
-        toHide.style.display = 'none';
-        sibling.style.display = '';
-
-        var positioned = null;
-        if (containerIsPositioned === 1) {
-          container.style.position = 'relative';
-          positioned = container;
-        } else
-          container.style.position = '';
-
-        if (hasPositionedAncestor === 1) {
-          ancestor.style.position = 'relative';
-          positioned = ancestor;
-        } else
-          ancestor.style.position = '';
-
-        var currentZIndex = siblingPrecedesContainer === 1 ? 0 : -1;
-        for (var currentIndex = containerIndex - 1; currentIndex >= 0; --currentIndex) {
-          ordering[currentIndex].style.zIndex = currentZIndex.toString();
-          currentZIndex--;
-        }
-
-        currentZIndex = 1;
-        for (var currentIndex = containerIndex + 1; currentIndex < 4; ++currentIndex) {
-          ordering[currentIndex].style.zIndex = currentZIndex.toString();
-          currentZIndex++;
-        }
-
-        if (numElementsWithZIndexZero >= 1)
-          ordering[containerIndex].style.zIndex = '0';
-
-        if (numElementsWithZIndexZero >= 2)
-            ordering[siblingIndex].style.zIndex = '0';
-
-        // We want the first descendant succeeding us in the ordering to get
-        // z-index: 0.
-        if (numElementsWithZIndexZero === 3) {
-          if (firstChildIndex > containerIndex)
-            ordering[firstChildIndex].style.zIndex = '0';
-          else
-            ordering[secondChildIndex].style.zIndex = '0';
-        }
-
-        testPermutation(permutationIteration, ordering, hasPositionedAncestor, containerIsPositioned);
-        permutationIteration++;
-      }
-    }
-  }
-}
-
-function testOptInPermutation(count, ordering, hasPositionedAncestor, containerIsPositioned)
-{
-  if (!window.internals)
-    return;
-
-  window.internals.forceCompositingUpdate(document);
-
-  var container = document.getElementById('container');
-  var containerOptedIn = didOptIn(container);
-
-  window.internals.setNeedsCompositedScrolling(container,
-      window.internals.COMPOSITED_SCROLLING_ALWAYS_OFF);
-
-  var oldStackingOrder = getStackingOrder(container);
-
-  window.internals.setNeedsCompositedScrolling(container,
-      window.internals.COMPOSITED_SCROLLING_ALWAYS_ON);
-
-  var newStackingOrder = getStackingOrder(container);
-
-  window.internals.setNeedsCompositedScrolling(container,
-      window.internals.DO_NOT_FORCE_COMPOSITED_SCROLLING);
-
-  var shouldOptIn = oldStackingOrder.length === newStackingOrder.length;
-  for (var i = 0; i < oldStackingOrder.length; ++i) {
-    if (oldStackingOrder[i] !== newStackingOrder[i]) {
-      shouldOptIn = false;
-      break;
-    }
-  }
-
-  if (shouldOptIn !== containerOptedIn) {
-    if (shouldOptIn)
-      write("FAIL - should've automatically opted in but didn't " + count);
-    else
-      write('FAIL - automatically opted in and changed stacking order ' + count);
-
-    var additionalFailureInfo = "\tOrdering:";
-    for(var i = 0; i < ordering.length; ++i) {
-      additionalFailureInfo += " " + ordering[i].id + " (z-index: " + ordering[i].style.zIndex + ")";
-      if(i < ordering.length - 1)
-        additionalFailureInfo += ",";
-    }
-
-    additionalFailureInfo += "\n\thasPositionedAncestor: " + hasPositionedAncestor + "; containerIsPositioned: " + containerIsPositioned;
-    write(additionalFailureInfo);
-  } else {
-    if (shouldOptIn)
-      write("PASS iteration " + count + ": opted in, since doing so does not change the stacking order.");
-    else
-      write("PASS iteration " + count + ": did not opt in, since doing so would change the stacking order.");
-  }
-}
-
-function runPermutationSet(testPermutation, siblingIndex)
-{
-  var ancestor = document.getElementById('ancestor');
-  var predecessor = document.getElementById('predecessor');
-  var successor = document.getElementById('successor');
-  var container = document.getElementById('container');
-  var firstChild = document.getElementById('firstChild');
-  var secondChild = document.getElementById('secondChild');
-
-  write('Testing permutation set ' + siblingIndex + ' - this means that the "sibling" will be placed at the index ' + siblingIndex + ' of the paint order.')
-
-  var indices = [ 0, 1, 2, 3 ];
-  var siblingIndices = indices.slice(0);
-  siblingIndices.splice(siblingIndex, 1);
-  for (var containerSubindex = 0; containerSubindex < siblingIndices.length; ++containerSubindex) {
-    var containerIndices = siblingIndices.slice(0);
-    var containerIndex = containerIndices[containerSubindex];
-    containerIndices.splice(containerSubindex, 1);
-    var firstChildIndex = containerIndices[0];
-    var secondChildIndex = containerIndices[1];
-
-    permuteWithFixedOrdering(testPermutation, siblingIndex, containerIndex, firstChildIndex, secondChildIndex, 1);
-    permuteWithFixedOrdering(testPermutation, siblingIndex, containerIndex, firstChildIndex, secondChildIndex, 2);
-    permuteWithFixedOrdering(testPermutation, siblingIndex, containerIndex, firstChildIndex, secondChildIndex, 3);
-  }
-} // function doTest
-
-function runOptInPermutationSet(permutationSet) {
-  runPermutationSet(testOptInPermutation, permutationSet);
-}