Bug 1323238 - disable MOZ_GTEST_BENCH tests as we are not looking at the data. r=wlach
authorJoel Maher <jmaher@mozilla.com>
Fri, 02 Jun 2017 13:27:20 -0400
changeset 412520 8d3633639df8296949135ddd353a3254df02984c
parent 412519 c5cefe156423e8bc688cba4511847ba4f4c5571a
child 412521 d4f850a4aa290da1c5391681f746b64b90841186
push id1490
push usermtabara@mozilla.com
push dateMon, 31 Jul 2017 14:08:16 +0000
treeherdermozilla-release@70e32e6bf15e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerswlach
bugs1323238
milestone55.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1323238 - disable MOZ_GTEST_BENCH tests as we are not looking at the data. r=wlach MozReview-Commit-ID: xYRHpWVaa7
gfx/tests/gtest/TestCompositor.cpp
gfx/tests/gtest/TestRegion.cpp
gfx/tests/gtest/TestTextureCompatibility.cpp
gfx/tests/gtest/TestTreeTraversal.cpp
--- a/gfx/tests/gtest/TestCompositor.cpp
+++ b/gfx/tests/gtest/TestCompositor.cpp
@@ -1,17 +1,16 @@
 /* vim:set ts=2 sw=2 sts=2 et: */
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 #include "gfxPrefs.h"
 #include "gfxUtils.h"
 #include "gtest/gtest.h"
-#include "gtest/MozGTestBench.h"
 #include "TestLayers.h"
 #include "mozilla/gfx/2D.h"
 #include "mozilla/RefPtr.h"
 #include "mozilla/layers/BasicCompositor.h"  // for BasicCompositor
 #include "mozilla/layers/Compositor.h"  // for Compositor
 #include "mozilla/layers/CompositorOGL.h"  // for CompositorOGL
 #include "mozilla/layers/CompositorTypes.h"
 #include "mozilla/layers/LayerManagerComposite.h"
@@ -162,56 +161,49 @@ static bool CompositeAndCompare(RefPtr<L
   return true;
 }
 
 TEST(Gfx, CompositorConstruct)
 {
   auto layerManagers = GetLayerManagers(GetPlatformBackends());
 }
 
-static void CompositorSimpleTree() {
-  const int benchmarkRepeatCount = 30;
-
-  RefPtr<DrawTarget> refDT = CreateDT();
-  refDT->FillRect(Rect(0, 0, gCompWidth, gCompHeight), ColorPattern(Color(1.f, 0.f, 1.f, 1.f)));
-  refDT->FillRect(Rect(0, 0, 100, 100), ColorPattern(Color(1.f, 0.f, 0.f, 1.f)));
-  refDT->FillRect(Rect(0, 50, 100, 100), ColorPattern(Color(0.f, 0.f, 1.f, 1.f)));
-
+TEST(Gfx, CompositorSimpleTree)
+{
   auto layerManagers = GetLayerManagers(GetPlatformBackends());
   for (size_t i = 0; i < layerManagers.size(); i++) {
-    // Benchmark n composites
-    for (size_t n = 0; n < benchmarkRepeatCount; n++) {
-      RefPtr<LayerManagerComposite> layerManager = layerManagers[i].mLayerManager;
-      RefPtr<LayerManager> lmBase = layerManager.get();
-      nsTArray<RefPtr<Layer>> layers;
-      nsIntRegion layerVisibleRegion[] = {
-        nsIntRegion(IntRect(0, 0, gCompWidth, gCompHeight)),
-        nsIntRegion(IntRect(0, 0, gCompWidth, gCompHeight)),
-        nsIntRegion(IntRect(0, 0, 100, 100)),
-        nsIntRegion(IntRect(0, 50, 100, 100)),
-      };
-      RefPtr<Layer> root = CreateLayerTree("c(ooo)", layerVisibleRegion, nullptr, lmBase, layers);
+    RefPtr<LayerManagerComposite> layerManager = layerManagers[i].mLayerManager;
+    RefPtr<LayerManager> lmBase = layerManager.get();
+    nsTArray<RefPtr<Layer>> layers;
+    nsIntRegion layerVisibleRegion[] = {
+      nsIntRegion(IntRect(0, 0, gCompWidth, gCompHeight)),
+      nsIntRegion(IntRect(0, 0, gCompWidth, gCompHeight)),
+      nsIntRegion(IntRect(0, 0, 100, 100)),
+      nsIntRegion(IntRect(0, 50, 100, 100)),
+    };
+    RefPtr<Layer> root = CreateLayerTree("c(ooo)", layerVisibleRegion, nullptr, lmBase, layers);
 
-      { // background
-        ColorLayer* colorLayer = layers[1]->AsColorLayer();
-        colorLayer->SetColor(Color(1.f, 0.f, 1.f, 1.f));
-        colorLayer->SetBounds(colorLayer->GetVisibleRegion().ToUnknownRegion().GetBounds());
-      }
+    { // background
+      ColorLayer* colorLayer = layers[1]->AsColorLayer();
+      colorLayer->SetColor(Color(1.f, 0.f, 1.f, 1.f));
+      colorLayer->SetBounds(colorLayer->GetVisibleRegion().ToUnknownRegion().GetBounds());
+    }
 
-      {
-        ColorLayer* colorLayer = layers[2]->AsColorLayer();
-        colorLayer->SetColor(Color(1.f, 0.f, 0.f, 1.f));
-        colorLayer->SetBounds(colorLayer->GetVisibleRegion().ToUnknownRegion().GetBounds());
-      }
+    {
+      ColorLayer* colorLayer = layers[2]->AsColorLayer();
+      colorLayer->SetColor(Color(1.f, 0.f, 0.f, 1.f));
+      colorLayer->SetBounds(colorLayer->GetVisibleRegion().ToUnknownRegion().GetBounds());
+    }
 
-      {
-        ColorLayer* colorLayer = layers[3]->AsColorLayer();
-        colorLayer->SetColor(Color(0.f, 0.f, 1.f, 1.f));
-        colorLayer->SetBounds(colorLayer->GetVisibleRegion().ToUnknownRegion().GetBounds());
-      }
+    {
+      ColorLayer* colorLayer = layers[3]->AsColorLayer();
+      colorLayer->SetColor(Color(0.f, 0.f, 1.f, 1.f));
+      colorLayer->SetBounds(colorLayer->GetVisibleRegion().ToUnknownRegion().GetBounds());
+    }
 
-      EXPECT_TRUE(CompositeAndCompare(layerManager, refDT));
-    }
+    RefPtr<DrawTarget> refDT = CreateDT();
+    refDT->FillRect(Rect(0, 0, gCompWidth, gCompHeight), ColorPattern(Color(1.f, 0.f, 1.f, 1.f)));
+    refDT->FillRect(Rect(0, 0, 100, 100), ColorPattern(Color(1.f, 0.f, 0.f, 1.f)));
+    refDT->FillRect(Rect(0, 50, 100, 100), ColorPattern(Color(0.f, 0.f, 1.f, 1.f)));
+    EXPECT_TRUE(CompositeAndCompare(layerManager, refDT));
   }
-};
+}
 
-MOZ_GTEST_BENCH(GfxBench, CompositorSimpleTree, &CompositorSimpleTree);
-
--- a/gfx/tests/gtest/TestRegion.cpp
+++ b/gfx/tests/gtest/TestRegion.cpp
@@ -2,18 +2,16 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include <algorithm>
 
 #include "PingPongRegion.h"
 #include "gtest/gtest.h"
-#include "gtest/MozGTestBench.h"
-#include "nsRect.h"
 #include "nsRegion.h"
 #include "RegionBuilder.h"
 #include "mozilla/gfx/TiledRegion.h"
 #include "mozilla/UniquePtr.h"
 
 using namespace std;
 using namespace mozilla::gfx;
 
@@ -765,73 +763,8 @@ TEST(Gfx, TiledRegionNegativeRect) {
   // Rects with negative widths/heights are treated as empty and ignored
   tiledRegion.Add(nsIntRect(0, 0, -500, -500));
   EXPECT_FALSE(tiledRegion.Contains(nsIntRect(-1, -1, 1, 1)));
   EXPECT_FALSE(tiledRegion.Contains(nsIntRect(0, 0, 1, 1)));
   // Empty rects are always contained
   EXPECT_TRUE(tiledRegion.Contains(nsIntRect(0, 0, -1, -1)));
   EXPECT_TRUE(tiledRegion.Contains(nsIntRect(100, 100, -1, -1)));
 }
-
-MOZ_GTEST_BENCH(GfxBench, RegionOr, []{
-  const int size = 5000;
-
-  nsRegion r;
-  for (int i = 0; i < size; i++) {
-    r = r.Or(r, nsRect(i, i, i + 10, i + 10));
-  }
-
-  nsIntRegion rInt;
-  for (int i = 0; i < size; i++) {
-    rInt = rInt.Or(rInt, nsIntRect(i, i, i + 10, i + 10));
-  }
-});
-
-MOZ_GTEST_BENCH(GfxBench, RegionAnd, []{
-  const int size = 5000;
-  nsRegion r(nsRect(0, 0, size, size));
-  for (int i = 0; i < size; i++) {
-    nsRegion rMissingPixel(nsRect(0, 0, size, size));
-    rMissingPixel = rMissingPixel.Sub(rMissingPixel, nsRect(i, i, 1, 1));
-    r = r.And(r, rMissingPixel);
-  }
-});
-
-void BenchRegionBuilderOr() {
-  const int size = 5000;
-
-  RegionBuilder<nsRegion> r;
-  for (int i = 0; i < size; i++) {
-    r.OrWith(nsRect(i, i, i + 10, i + 10));
-  }
-  r.ToRegion();
-
-  RegionBuilder<nsIntRegion> rInt;
-  for (int i = 0; i < size; i++) {
-    rInt.OrWith(nsIntRect(i, i, i + 10, i + 10));
-  }
-  rInt.ToRegion();
-}
-
-MOZ_GTEST_BENCH(GfxBench, RegionBuilderOr, []{
-  BenchRegionBuilderOr();
-});
-
-void BenchPingPongRegionOr() {
-  const int size = 5000;
-
-  PingPongRegion<nsRegion> r;
-  for (int i = 0; i < size; i++) {
-    r.OrWith(nsRect(i, i, i + 10, i + 10));
-  }
-  r.Region();
-
-  PingPongRegion<nsIntRegion> rInt;
-  for (int i = 0; i < size; i++) {
-    rInt.OrWith(nsIntRect(i, i, i + 10, i + 10));
-  }
-  rInt.Region();
-}
-
-MOZ_GTEST_BENCH(GfxBench, PingPongRegionOr, []{
-  BenchPingPongRegionOr();
-});
-
--- a/gfx/tests/gtest/TestTextureCompatibility.cpp
+++ b/gfx/tests/gtest/TestTextureCompatibility.cpp
@@ -2,17 +2,16 @@
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "gfxConfig.h"
 #include "gfxPlatform.h"
 #include "gtest/gtest.h"
-#include "gtest/MozGTestBench.h"
 #include "MockWidget.h"
 #include "mozilla/layers/BasicCompositor.h"
 #include "mozilla/layers/Compositor.h"
 #include "mozilla/layers/LayersTypes.h"
 #include "mozilla/layers/TextureClient.h"
 #include "mozilla/layers/TextureHost.h"
 #include "mozilla/RefPtr.h"
 #include "TextureHelper.h"
--- a/gfx/tests/gtest/TestTreeTraversal.cpp
+++ b/gfx/tests/gtest/TestTreeTraversal.cpp
@@ -1,12 +1,11 @@
 #include <vector>
 #include "mozilla/RefPtr.h"
 #include "gtest/gtest.h"
-#include "gtest/MozGTestBench.h"
 #include "nsRegion.h"
 #include "nsRect.h"
 #include "TreeTraversal.h"
 #include <stack>
 #include <queue>
 
 const int PERFORMANCE_TREE_DEPTH = 20;
 const int PERFORMANCE_TREE_CHILD_COUNT = 2;
@@ -265,37 +264,16 @@ void TestNodeBase<T>::SetValue(int aValu
 
 typedef TestNodeBase<SearchNodeType> SearchTestNode;
 typedef TestNodeBase<ForEachNodeType> ForEachTestNode;
 typedef TestNodeReverse<SearchNodeType> SearchTestNodeReverse;
 typedef TestNodeReverse<ForEachNodeType> ForEachTestNodeReverse;
 typedef TestNodeForward<SearchNodeType> SearchTestNodeForward;
 typedef TestNodeForward<ForEachNodeType> ForEachTestNodeForward;
 
-template <typename Node, typename Action>
-void CreateBenchmarkTreeRecursive(RefPtr<Node> aNode, int aDepth, int aChildrenCount, Action aAction)
-{
-  if (aDepth > 0) {
-    for (int i = 0; i < aChildrenCount; i++) {
-      RefPtr<Node> newNode = new Node();
-      aNode->AddChild(newNode);
-      CreateBenchmarkTreeRecursive(newNode, aDepth-1, aChildrenCount, aAction);
-    }
-  }
-  aAction(aNode);
-}
-
-template <typename Node, typename Action>
-RefPtr<Node> CreateBenchmarkTree(int aDepth, int aChildrenCount, Action aAction)
-{
-  RefPtr<Node> rootNode = new Node();
-  CreateBenchmarkTreeRecursive(rootNode, aDepth, aChildrenCount, aAction);
-  return rootNode;
-}
-
 TEST(TreeTraversal, DepthFirstSearchNull)
 {
   RefPtr<SearchTestNodeReverse> nullNode;
   RefPtr<SearchTestNodeReverse> result = DepthFirstSearch<layers::ReverseIterator>(nullNode.get(),
       [](SearchTestNodeReverse* aNode)
       {
         return aNode->GetType() == SearchNodeType::Needle;
       });
@@ -1338,47 +1316,16 @@ static RefPtr<Node> DepthFirstSearchForw
       node = node->GetNextSibling()) {
     if (RefPtr<Node> foundNode = DepthFirstSearchForwardRecursive(node)) {
       return foundNode;
     }
   }
   return nullptr;
 }
 
-static void Plain_ForwardDepthFirstSearchPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeForward> needleNode;
-  RefPtr<SearchTestNodeForward> root = CreateBenchmarkTree<SearchTestNodeForward>(depth, childrenCount,
-      AssignSearchNodeTypesWithLastLeafAsNeedle{needleNode});
-  needleNode->SetType(SearchNodeType::Needle);
-  RefPtr<SearchTestNodeForward> foundNode =
-    DepthFirstSearchForwardRecursive<SearchTestNodeForward>(root.get());
-  ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle);
-  ASSERT_EQ(needleNode, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardDepthFirstSearchPerformance, &Plain_ForwardDepthFirstSearchPerformance);
-
-static void TreeTraversal_ForwardDepthFirstSearchPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeForward> needleNode;
-  RefPtr<SearchTestNodeForward> root = CreateBenchmarkTree<SearchTestNodeForward>(depth, childrenCount,
-      AssignSearchNodeTypesWithLastLeafAsNeedle{needleNode});
-  needleNode->SetType(SearchNodeType::Needle);
-  RefPtr<SearchTestNodeForward> foundNode = DepthFirstSearch<layers::ForwardIterator>(root.get(), &FindNeedle);
-  ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle);
-  ASSERT_EQ(needleNode, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardDepthFirstSearchPerformance, &TreeTraversal_ForwardDepthFirstSearchPerformance);
-
 template <typename Node>
 static RefPtr<Node> DepthFirstSearchCaptureVariablesForwardRecursive(RefPtr<Node> aNode,
     int a, int b, int c, int d, int e, int f,
     int g, int h, int i, int j, int k, int l,
     int m, int& n, int& o, int& p, int& q, int& r,
     int& s, int& t, int& u, int& v, int& w, int& x,
     int& y, int& z)
 {
@@ -1393,116 +1340,32 @@ static RefPtr<Node> DepthFirstSearchCapt
           a, b, c, d, e, f, g, h, i, j, k, l, m,
           n, o, p, q, r, s, t, u, v, w, x, y, z)) {
       return foundNode;
     }
   }
   return nullptr;
 }
 
-static void Plain_ForwardDepthFirstSearchCaptureVariablesPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int a = 1; int b = 1; int c = 1; int d = 1; int e = 1; int f = 1;
-  int g = 1; int h = 1; int i = 1; int j = 1; int k = 1; int l = 1;
-  int m = 1; int n = 1; int o = 1; int p = 1; int q = 1; int r = 1;
-  int s = 1; int t = 1; int u = 1; int v = 1; int w = 1; int x = 1;
-  int y = 1; int z = 1;
-  int needleTotal = a + b + c + d + e + f + g + h + i + j + k + l + m +
-      n + o + p + q + r + s + t + u + v + w + x + y + z;
-  int hayTotal = 0;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeForward> needleNode;
-  RefPtr<SearchTestNodeForward> root = CreateBenchmarkTree<SearchTestNodeForward>(depth, childrenCount,
-      AssignSearchNodeValuesAllFalseValuesForward{hayTotal, needleNode});
-  needleNode->SetValue(needleTotal);
-  RefPtr<SearchTestNodeForward> foundNode =
-      DepthFirstSearchCaptureVariablesForwardRecursive<SearchTestNodeForward>(root.get(),
-          a, b, c, d, e, f, g, h, i, j, k, l, m,
-          n, o, p, q, r, s, t, u, v, w, x, y, z);
-  ASSERT_EQ(foundNode->GetValue(), needleTotal);
-  ASSERT_EQ(needleNode, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardDepthFirstSearchCaptureVariablesPerformance, &Plain_ForwardDepthFirstSearchCaptureVariablesPerformance);
-
-static void TreeTraversal_ForwardDepthFirstSearchCaptureVariablesPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int a = 1; int b = 1; int c = 1; int d = 1; int e = 1; int f = 1;
-  int g = 1; int h = 1; int i = 1; int j = 1; int k = 1; int l = 1;
-  int m = 1; int n = 1; int o = 1; int p = 1; int q = 1; int r = 1;
-  int s = 1; int t = 1; int u = 1; int v = 1; int w = 1; int x = 1;
-  int y = 1; int z = 1;
-  int needleTotal = a + b + c + d + e + f + g + h + i + j + k + l + m +
-      n + o + p + q + r + s + t + u + v + w + x + y + z;
-  int hayTotal = 0;
-  RefPtr<SearchTestNodeForward> needleNode;
-  RefPtr<SearchTestNodeForward> root = CreateBenchmarkTree<SearchTestNodeForward>(depth, childrenCount,
-      AssignSearchNodeValuesAllFalseValuesForward{hayTotal, needleNode});
-  needleNode->SetValue(needleTotal);
-  RefPtr<SearchTestNodeForward> foundNode = DepthFirstSearch<layers::ForwardIterator>(root.get(),
-      [a, b, c, d, e, f, g, h, i, j, k, l, m,
-      &n, &o, &p, &q, &r, &s, &t, &u, &v, &w, &x, &y, &z]
-      (SearchTestNodeForward* aNode) {
-        return aNode->GetValue() == a + b + c + d + e + f + g + h + i + j + k + l + m +
-            n + o + p + q + r + s + t + u + v + w + x + y + z;
-      });
-  ASSERT_EQ(foundNode->GetValue(), needleTotal);
-  ASSERT_EQ(needleNode, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardDepthFirstSearchCaptureVariablesPerformance, &TreeTraversal_ForwardDepthFirstSearchCaptureVariablesPerformance);
-
 template <typename Node>
 static RefPtr<Node> DepthFirstSearchPostOrderForwardRecursive(RefPtr<Node> aNode)
 {
   for (RefPtr<Node> node = aNode->GetFirstChild();
       node != nullptr;
       node = node->GetNextSibling()) {
     if (RefPtr<Node> foundNode = DepthFirstSearchPostOrderForwardRecursive(node)) {
       return foundNode;
     }
   }
   if (aNode->GetType() == SearchNodeType::Needle) {
     return aNode;
   }
   return nullptr;
 }
 
-static void Plain_ForwardDepthFirstSearchPostOrderPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeForward> root = CreateBenchmarkTree<SearchTestNodeForward>(depth, childrenCount,
-      AssignSearchNodeTypesAllHay{});
-  root->SetType(SearchNodeType::Needle);
-  RefPtr<SearchTestNodeForward> foundNode =
-    DepthFirstSearchPostOrderForwardRecursive<SearchTestNodeForward>(root.get());
-  ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle);
-  ASSERT_EQ(root, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardDepthFirstSearchPostOrderPerformance, &Plain_ForwardDepthFirstSearchPostOrderPerformance);
-
-static void TreeTraversal_ForwardDepthFirstSearchPostOrderPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeForward> root = CreateBenchmarkTree<SearchTestNodeForward>(depth, childrenCount,
-      AssignSearchNodeTypesAllHay{});
-  root->SetType(SearchNodeType::Needle);
-  RefPtr<SearchTestNodeForward> foundNode = DepthFirstSearchPostOrder<layers::ForwardIterator>(root.get(), &FindNeedle);
-  ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle);
-  ASSERT_EQ(root, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardDepthFirstSearchPostOrderPerformance, &TreeTraversal_ForwardDepthFirstSearchPostOrderPerformance);
-
 template <typename Node>
 static RefPtr<Node> BreadthFirstSearchForwardQueue(RefPtr<Node> aNode)
 {
   queue<RefPtr<Node>> nodes;
   nodes.push(aNode);
   while(!nodes.empty()) {
     RefPtr<Node> node = nodes.front();
     nodes.pop();
@@ -1513,321 +1376,32 @@ static RefPtr<Node> BreadthFirstSearchFo
         childNode != nullptr;
         childNode = childNode->GetNextSibling()) {
       nodes.push(childNode);
     }
   }
   return nullptr;
 }
 
-static void Plain_ForwardBreadthFirstSearchPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeForward> needleNode;
-  RefPtr<SearchTestNodeForward> root = CreateBenchmarkTree<SearchTestNodeForward>(depth, childrenCount,
-      AssignSearchNodeTypesWithLastLeafAsNeedle{needleNode});
-  needleNode->SetType(SearchNodeType::Needle);
-  RefPtr<SearchTestNodeForward> foundNode =
-      BreadthFirstSearchForwardQueue<SearchTestNodeForward>(root.get());
-  ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle);
-  ASSERT_EQ(needleNode, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardBreadthFirstSearchPerformance, &Plain_ForwardBreadthFirstSearchPerformance);
-
-static void TreeTraversal_ForwardBreadthFirstSearchPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeForward> needleNode;
-  RefPtr<SearchTestNodeForward> root = CreateBenchmarkTree<SearchTestNodeForward>(depth, childrenCount,
-      AssignSearchNodeTypesWithLastLeafAsNeedle{needleNode});
-  needleNode->SetType(SearchNodeType::Needle);
-  RefPtr<SearchTestNodeForward> foundNode = BreadthFirstSearch<layers::ForwardIterator>(root.get(), &FindNeedle);
-  ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle);
-  ASSERT_EQ(needleNode, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardBreadthFirstSearchPerformance, &TreeTraversal_ForwardBreadthFirstSearchPerformance);
-
-// This test ((Plain|TreeTraversal)_ForwardForEachNodePostOrderPerformance)
-// uses the following benchmark:
-//
-// Starting with a tree whose leaves only are augmented with region data
-// (arranged as a series of 1x1 blocks stacked in rows of 100000), calculate
-// each ancestor's region as the union of its child regions.
-template <typename Node>
-static void ForEachNodePostOrderForwardRecursive(RefPtr<Node> aNode)
-{
-  if (!aNode->IsLeaf()) {
-    nsRegion newRegion;
-    for (RefPtr<Node> node = aNode->GetFirstChild();
-        node != nullptr;
-        node = node->GetNextSibling()) {
-      ForEachNodePostOrderForwardRecursive(node);
-      nsRegion childRegion = node->GetRegion();
-      newRegion.OrWith(childRegion);
-    }
-    aNode->SetRegion(newRegion);
-  }
-}
-
-static void Plain_ForwardForEachNodePostOrderPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int squareCount = 0;
-  int xWrap = PERFORMANCE_REGION_XWRAP;
-  RefPtr<ForEachTestNodeForward> root = CreateBenchmarkTree<ForEachTestNodeForward>(depth, childrenCount,
-      AllocateUnitRegionsToLeavesOnly{xWrap, squareCount});
-  ForEachNodePostOrderForwardRecursive(root);
-  ASSERT_EQ(root->GetRegion(), nsRegion(nsRect(0, 0, PERFORMANCE_REGION_XWRAP, PERFORMANCE_REGION_XWRAP)));
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardForEachNodePostOrderPerformance, &Plain_ForwardForEachNodePostOrderPerformance);
-
-static void TreeTraversal_ForwardForEachNodePostOrderPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int squareCount = 0;
-  int xWrap = PERFORMANCE_REGION_XWRAP;
-  RefPtr<ForEachTestNodeForward> root = CreateBenchmarkTree<ForEachTestNodeForward>(depth, childrenCount,
-      AllocateUnitRegionsToLeavesOnly{xWrap, squareCount});
-  ForEachNodePostOrder<layers::ForwardIterator>(root.get(),
-      [](ForEachTestNodeForward* aNode) {
-        if (!aNode->IsLeaf()) {
-          nsRegion newRegion;
-          for (RefPtr<ForEachTestNodeForward> node = aNode->GetFirstChild();
-              node != nullptr;
-              node = node->GetNextSibling()) {
-            nsRegion childRegion = node->GetRegion();
-            newRegion.OrWith(childRegion);
-          }
-          aNode->SetRegion(newRegion);
-        }
-      });
-  ASSERT_EQ(root->GetRegion(), nsRegion(nsRect(0, 0, PERFORMANCE_REGION_XWRAP, PERFORMANCE_REGION_XWRAP)));
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardForEachNodePostOrderPerformance, &TreeTraversal_ForwardForEachNodePostOrderPerformance);
-
-// This test ((Plain|TreeTraversal)_ForwardForEachNodePerformance) uses the
-// following benchmark:
-//
-// Starting with a tree whose root has a rectangular region of size
-// PERFORMANCE_TREE_LEAF_COUNT x 1, for each node, split the region into
-// PERFORMANCE_TREE_CHILD_COUNT separate regions of equal width and assign to
-// each child left-to-right. In the end, every node's region should equal the
-// sum of its childrens' regions, and each level of depth's regions should sum
-// to the root's region.
-template <typename Node>
-static void ForEachNodeForwardRecursive(RefPtr<Node> aNode)
-{
-  if (!aNode->IsLeaf()) {
-    int nChildren = 0;
-    for (RefPtr<Node> node = aNode->GetFirstChild();
-        node != nullptr;
-        node = node->GetNextSibling()) {
-      nChildren++;
-    }
-    nsRect bounds = aNode->GetRegion().GetBounds();
-    int childWidth = bounds.width / nChildren;
-    int x = bounds.x;
-    for (RefPtr<Node> node = aNode->GetFirstChild();
-        node != nullptr;
-        node = node->GetNextSibling()) {
-      node->SetRegion(nsRegion(nsRect(x, 0, childWidth, 1)));
-      ForEachNodeForwardRecursive(node);
-      x += childWidth;
-    }
-  }
-}
-
-static void Plain_ForwardForEachNodePerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT;
-  RefPtr<ForEachTestNodeForward> root = CreateBenchmarkTree<ForEachTestNodeForward>(depth, childrenCount,
-      &ForEachNodeDoNothing);
-  root->SetRegion(nsRegion(nsRect(0, 0, rectangleWidth, 1)));
-  ForEachNodeForwardRecursive(root);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardForEachNodePerformance, &Plain_ForwardForEachNodePerformance);
-
-static void TreeTraversal_ForwardForEachNodePerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT;
-  RefPtr<ForEachTestNodeForward> root = CreateBenchmarkTree<ForEachTestNodeForward>(depth, childrenCount,
-      &ForEachNodeDoNothing);
-  root->SetRegion(nsRegion(nsRect(0, 0, rectangleWidth, 1)));
-  ForEachNode<layers::ForwardIterator>(root.get(),
-      [](ForEachTestNodeForward* aNode) {
-        if (!aNode->IsLeaf()) {
-          int nChildren = 0;
-          for (RefPtr<ForEachTestNodeForward> node = aNode->GetFirstChild();
-              node != nullptr;
-              node = node->GetNextSibling()) {
-            nChildren++;
-          }
-          nsRect bounds = aNode->GetRegion().GetBounds();
-          int childWidth = bounds.width / nChildren;
-          int x = bounds.x;
-          for (RefPtr<ForEachTestNodeForward> node = aNode->GetFirstChild();
-              node != nullptr;
-              node = node->GetNextSibling()) {
-            node->SetRegion(nsRegion(nsRect(x, 0, childWidth, 1)));
-            x += childWidth;
-          }
-        }
-      });
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardForEachNodePerformance, &TreeTraversal_ForwardForEachNodePerformance);
-
-// This test ((Plain|TreeTraversal)_ForwardForEachNodeStackPerformance) uses
-// the following benchmark:
-//
-// Starting with an unattached region equal to PERFORMANCE_TREE_LEAF_COUNT x 1,
-// a starting width of PERFORMANCE_TREE_LEAF_COUNT, and an empty tree, create a
-// tree with the same conditions as
-// ((Plain|TreeTraversal)_ForwardForEachNodePerformance) by assigning regions
-// of the current width, starting from the min x and min y coordinates. For
-// each level of depth, decrease the current width by a factor of
-// PERFORMANCE_TREE_CHILD_COUNT, and maintain a stack of ancestor regions.
-// Use the stack to track the portion of each region still available to assign
-// to children, which determines the aforementioned min x and min y coordinates.
-// Compare this to using the program stack.
-template <typename Node>
-static void ForEachNodeForwardStackRecursive(RefPtr<Node> aNode, int& aRectangleWidth, nsRegion aRegion, int aChildrenCount)
-{
-  nsRect parentRect = aRegion.GetBounds();
-  nsRect newRectangle(parentRect.x, parentRect.y, aRectangleWidth, 1);
-  nsRegion newRegion(newRectangle);
-  aNode->SetRegion(nsRegion(newRegion));
-
-  aRectangleWidth /= aChildrenCount;
-
-  for (RefPtr<Node> node = aNode->GetFirstChild();
-      node != nullptr;
-      node = node->GetNextSibling()) {
-    ForEachNodeForwardStackRecursive(node, aRectangleWidth, newRegion, aChildrenCount);
-    newRegion.SubOut(node->GetRegion());
-  }
-
-  // Handle case where rectangle width is truncated if power falls below 0,
-  // so we dont lose the regions in future iterations
-  if (aRectangleWidth == 0) {
-    aRectangleWidth = 1;
-  }
-  else {
-    aRectangleWidth *= aChildrenCount;
-  }
-}
-
-static void Plain_ForwardForEachNodeStackPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT;
-  RefPtr<ForEachTestNodeForward> root = CreateBenchmarkTree<ForEachTestNodeForward>(depth, childrenCount,
-      &ForEachNodeDoNothing);
-  nsRegion startRegion(nsRect(0, 0, rectangleWidth, 1));
-  ForEachNodeForwardStackRecursive(root, rectangleWidth, startRegion, childrenCount);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardForEachNodeStackPerformance, &Plain_ForwardForEachNodeStackPerformance);
-
-static void TreeTraversal_ForwardForEachNodeStackPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT;
-  stack<nsRegion> regionStack;
-  RefPtr<ForEachTestNodeForward> root = CreateBenchmarkTree<ForEachTestNodeForward>(depth, childrenCount,
-      &ForEachNodeDoNothing);
-  regionStack.push(nsRegion(nsRect(0, 0, rectangleWidth, 1)));
-  ForEachNode<layers::ForwardIterator>(root.get(),
-      [&regionStack, &rectangleWidth, childrenCount](ForEachTestNodeForward* aNode) {
-        nsRegion parentRegion = regionStack.top();
-        nsRect parentRect = parentRegion.GetBounds();
-        nsRect newRect(parentRect.x, parentRect.y, rectangleWidth, 1);
-        nsRegion newRegion(newRect);
-        aNode->SetRegion(newRegion);
-        regionStack.top().SubOut(newRegion);
-        regionStack.push(newRegion);
-        rectangleWidth /= childrenCount;
-      },
-      [&regionStack, &rectangleWidth, childrenCount](ForEachTestNodeForward* aNode) {
-        regionStack.pop();
-        // Handle case where rectangle width is truncated if power falls below 0,
-        // so we dont lose the regions in future iterations
-        if (rectangleWidth == 0) {
-            rectangleWidth = 1;
-          }
-        else {
-          rectangleWidth *= childrenCount;
-        }
-      });
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardForEachNodeStackPerformance, &TreeTraversal_ForwardForEachNodeStackPerformance);
-
 template <typename Node>
 static RefPtr<Node> DepthFirstSearchReverseRecursive(RefPtr<Node> aNode)
 {
   if (aNode->GetType() == SearchNodeType::Needle) {
     return aNode;
   }
   for (RefPtr<Node> node = aNode->GetLastChild();
       node != nullptr;
       node = node->GetPrevSibling()) {
     if (RefPtr<Node> foundNode = DepthFirstSearchReverseRecursive(node)) {
       return foundNode;
     }
   }
   return nullptr;
 }
 
-static void Plain_ReverseDepthFirstSearchPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeReverse> needleNode;
-  RefPtr<SearchTestNodeReverse> root = CreateBenchmarkTree<SearchTestNodeReverse>(depth, childrenCount,
-      AssignSearchNodeTypesWithFirstLeafAsNeedle{needleNode});
-  needleNode->SetType(SearchNodeType::Needle);
-  RefPtr<SearchTestNodeReverse> foundNode =
-    DepthFirstSearchReverseRecursive<SearchTestNodeReverse>(root.get());
-  ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle);
-  ASSERT_EQ(needleNode, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseDepthFirstSearchPerformance, &Plain_ReverseDepthFirstSearchPerformance);
-
-static void TreeTraversal_ReverseDepthFirstSearchPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeReverse> needleNode;
-  RefPtr<SearchTestNodeReverse> root = CreateBenchmarkTree<SearchTestNodeReverse>(depth, childrenCount,
-      AssignSearchNodeTypesWithFirstLeafAsNeedle{needleNode});
-  needleNode->SetType(SearchNodeType::Needle);
-  RefPtr<SearchTestNodeReverse> foundNode = DepthFirstSearch<layers::ReverseIterator>(root.get(),
-      &FindNeedle);
-  ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle);
-  ASSERT_EQ(needleNode, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseDepthFirstSearchPerformance, &TreeTraversal_ReverseDepthFirstSearchPerformance);
 
 template <typename Node>
 static RefPtr<Node> DepthFirstSearchCaptureVariablesReverseRecursive(RefPtr<Node> aNode,
     int a, int b, int c, int d, int e, int f,
     int g, int h, int i, int j, int k, int l,
     int m, int& n, int& o, int& p, int& q, int& r,
     int& s, int& t, int& u, int& v, int& w, int& x,
     int& y, int& z)
@@ -1843,69 +1417,16 @@ static RefPtr<Node> DepthFirstSearchCapt
             a, b, c, d, e, f, g, h, i, j, k, l, m,
             n, o, p, q, r, s, t, u, v, w, x, y, z)) {
       return foundNode;
     }
   }
   return nullptr;
 }
 
-static void Plain_ReverseDepthFirstSearchCaptureVariablesPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int a = 1; int b = 1; int c = 1; int d = 1; int e = 1; int f = 1;
-  int g = 1; int h = 1; int i = 1; int j = 1; int k = 1; int l = 1;
-  int m = 1; int n = 1; int o = 1; int p = 1; int q = 1; int r = 1;
-  int s = 1; int t = 1; int u = 1; int v = 1; int w = 1; int x = 1;
-  int y = 1; int z = 1;
-  int needleTotal = a + b + c + d + e + f + g + h + i + j + k + l + m +
-      n + o + p + q + r + s + t + u + v + w + x + y + z;
-  int hayTotal = 0;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeReverse> needleNode;
-  RefPtr<SearchTestNodeReverse> root = CreateBenchmarkTree<SearchTestNodeReverse>(depth, childrenCount,
-      AssignSearchNodeValuesAllFalseValuesReverse{hayTotal, needleNode});
-  needleNode->SetValue(needleTotal);
-  RefPtr<SearchTestNodeReverse> foundNode =
-      DepthFirstSearchCaptureVariablesReverseRecursive<SearchTestNodeReverse>(root.get(),
-          a, b, c, d, e, f, g, h, i, j, k, l, m,
-          n, o, p, q, r, s, t, u, v, w, x, y, z);
-  ASSERT_EQ(foundNode->GetValue(), needleTotal);
-  ASSERT_EQ(needleNode, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseDepthFirstSearchCaptureVariablesPerformance, &Plain_ReverseDepthFirstSearchCaptureVariablesPerformance);
-
-static void TreeTraversal_ReverseDepthFirstSearchCaptureVariablesPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int a = 1; int b = 1; int c = 1; int d = 1; int e = 1; int f = 1;
-  int g = 1; int h = 1; int i = 1; int j = 1; int k = 1; int l = 1;
-  int m = 1; int n = 1; int o = 1; int p = 1; int q = 1; int r = 1;
-  int s = 1; int t = 1; int u = 1; int v = 1; int w = 1; int x = 1;
-  int y = 1; int z = 1;
-  int needleTotal = a + b + c + d + e + f + g + h + i + j + k + l + m +
-      n + o + p + q + r + s + t + u + v + w + x + y + z;
-  int hayTotal = 0;
-  RefPtr<SearchTestNodeReverse> needleNode;
-  RefPtr<SearchTestNodeReverse> root = CreateBenchmarkTree<SearchTestNodeReverse>(depth, childrenCount,
-      AssignSearchNodeValuesAllFalseValuesReverse{hayTotal, needleNode});
-  needleNode->SetValue(needleTotal);
-  RefPtr<SearchTestNodeReverse> foundNode = DepthFirstSearch<layers::ReverseIterator>(root.get(),
-      [a, b, c, d, e, f, g, h, i, j, k, l, m,
-      &n, &o, &p, &q, &r, &s, &t, &u, &v, &w, &x, &y, &z] (SearchTestNodeReverse* aNode) {
-        return aNode->GetValue() == a + b + c + d + e + f + g + h + i + j + k + l +
-            m + n + o + p + q + r + s + t + u + v + w + x + y + z;
-      });
-  ASSERT_EQ(foundNode->GetValue(), needleTotal);
-  ASSERT_EQ(needleNode, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseDepthFirstSearchCaptureVariablesPerformance, &TreeTraversal_ReverseDepthFirstSearchCaptureVariablesPerformance);
 
 template <typename Node>
 static RefPtr<Node> DepthFirstSearchPostOrderReverseRecursive(RefPtr<Node> aNode)
 {
   for (RefPtr<Node> node = aNode->GetLastChild();
       node != nullptr;
       node = node->GetPrevSibling()) {
     if (RefPtr<Node> foundNode = DepthFirstSearchPostOrderReverseRecursive(node)) {
@@ -1913,44 +1434,16 @@ static RefPtr<Node> DepthFirstSearchPost
     }
   }
   if (aNode->GetType() == SearchNodeType::Needle) {
     return aNode;
   }
   return nullptr;
 }
 
-static void Plain_ReverseDepthFirstSearchPostOrderPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeReverse> root = CreateBenchmarkTree<SearchTestNodeReverse>(depth, childrenCount,
-      AssignSearchNodeTypesAllHay{});
-  root->SetType(SearchNodeType::Needle);
-  RefPtr<SearchTestNodeReverse> foundNode =
-    DepthFirstSearchPostOrderReverseRecursive<SearchTestNodeReverse>(root.get());
-  ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle);
-  ASSERT_EQ(root, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseDepthFirstSearchPostOrderPerformance, &Plain_ReverseDepthFirstSearchPostOrderPerformance);
-
-static void TreeTraversal_ReverseDepthFirstSearchPostOrderPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeReverse> root = CreateBenchmarkTree<SearchTestNodeReverse>(depth, childrenCount,
-      AssignSearchNodeTypesAllHay{});
-  root->SetType(SearchNodeType::Needle);
-  RefPtr<SearchTestNodeReverse> foundNode = DepthFirstSearchPostOrder<layers::ReverseIterator>(root.get(), &FindNeedle);
-  ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle);
-  ASSERT_EQ(root, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseDepthFirstSearchPostOrderPerformance, &TreeTraversal_ReverseDepthFirstSearchPostOrderPerformance);
 
 template <typename Node>
 static RefPtr<Node> BreadthFirstSearchReverseQueue(RefPtr<Node> aNode)
 {
   queue<RefPtr<Node>> nodes;
   nodes.push(aNode);
   while(!nodes.empty()) {
     RefPtr<Node> node = nodes.front();
@@ -1962,264 +1455,8 @@ static RefPtr<Node> BreadthFirstSearchRe
         childNode != nullptr;
         childNode = childNode->GetPrevSibling()) {
       nodes.push(childNode);
     }
   }
   return nullptr;
 }
 
-static void Plain_ReverseBreadthFirstSearchPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeReverse> needleNode;
-  RefPtr<SearchTestNodeReverse> root = CreateBenchmarkTree<SearchTestNodeReverse>(depth, childrenCount,
-      AssignSearchNodeTypesWithFirstLeafAsNeedle{needleNode});
-  needleNode->SetType(SearchNodeType::Needle);
-  RefPtr<SearchTestNodeReverse> foundNode =
-    BreadthFirstSearchReverseQueue<SearchTestNodeReverse>(root.get());
-  ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle);
-  ASSERT_EQ(needleNode, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseBreadthFirstSearchPerformance, &Plain_ReverseBreadthFirstSearchPerformance);
-
-static void TreeTraversal_ReverseBreadthFirstSearchPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  RefPtr<SearchTestNodeReverse> needleNode;
-  RefPtr<SearchTestNodeReverse> root = CreateBenchmarkTree<SearchTestNodeReverse>(depth, childrenCount,
-      AssignSearchNodeTypesWithFirstLeafAsNeedle{needleNode});
-  needleNode->SetType(SearchNodeType::Needle);
-  RefPtr<SearchTestNodeReverse> foundNode = BreadthFirstSearch<layers::ReverseIterator>(root.get(), &FindNeedle);
-  ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle);
-  ASSERT_EQ(needleNode, foundNode);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseBreadthFirstSearchPerformance, &TreeTraversal_ReverseBreadthFirstSearchPerformance);
-
-// This test ((Plain|TreeTraversal)_ReverseForEachNodePostOrderPerformance)
-// uses the following benchmark:
-//
-// Starting with a tree whose leaves only are augmented with region data
-// (arranged as a series of 1x1 blocks stacked in rows of 100000), calculate
-// each ancestor's region as the union of its child regions.
-template <typename Node>
-static void ForEachNodePostOrderReverseRecursive(RefPtr<Node> aNode)
-{
-  if (!aNode->IsLeaf()) {
-    nsRegion newRegion;
-    for (RefPtr<Node> node = aNode->GetLastChild();
-        node != nullptr;
-        node = node->GetPrevSibling()) {
-      ForEachNodePostOrderReverseRecursive(node);
-      nsRegion childRegion = node->GetRegion();
-      newRegion.OrWith(childRegion);
-    }
-    aNode->SetRegion(newRegion);
-  }
-}
-
-static void Plain_ReverseForEachNodePostOrderPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int squareCount = 0;
-  int xWrap = PERFORMANCE_REGION_XWRAP;
-  RefPtr<ForEachTestNodeReverse> root = CreateBenchmarkTree<ForEachTestNodeReverse>(depth, childrenCount,
-      AllocateUnitRegionsToLeavesOnly{xWrap, squareCount});
-  ForEachNodePostOrderReverseRecursive(root);
-  ASSERT_EQ(root->GetRegion(), nsRegion(nsRect(0, 0, PERFORMANCE_REGION_XWRAP, PERFORMANCE_REGION_XWRAP)));
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseForEachNodePostOrderPerformance, &Plain_ReverseForEachNodePostOrderPerformance);
-
-static void TreeTraversal_ReverseForEachNodePostOrderPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int squareCount = 0;
-  int xWrap = PERFORMANCE_REGION_XWRAP;
-  RefPtr<ForEachTestNodeReverse> root = CreateBenchmarkTree<ForEachTestNodeReverse>(depth, childrenCount,
-      AllocateUnitRegionsToLeavesOnly{xWrap, squareCount});
-  ForEachNodePostOrder<layers::ReverseIterator>(root.get(),
-      [](ForEachTestNodeReverse* aNode) {
-        if (!aNode->IsLeaf()) {
-          nsRegion newRegion;
-          for (RefPtr<ForEachTestNodeReverse> node = aNode->GetLastChild();
-              node != nullptr;
-              node = node->GetPrevSibling()) {
-            nsRegion childRegion = node->GetRegion();
-            newRegion.OrWith(childRegion);
-          }
-          aNode->SetRegion(newRegion);
-        }
-      });
-  ASSERT_EQ(root->GetRegion(), nsRegion(nsRect(0, 0, PERFORMANCE_REGION_XWRAP, PERFORMANCE_REGION_XWRAP)));
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseForEachNodePostOrderPerformance, &TreeTraversal_ReverseForEachNodePostOrderPerformance);
-
-// This test ((Plain|TreeTraversal)_ReverseForEachNodePerformance) uses the
-// following benchmark:
-//
-// Starting with a tree whose root has a rectangular region of size
-// PERFORMANCE_TREE_LEAF_COUNT x 1, for each node, split the region into
-// PERFORMANCE_TREE_CHILD_COUNT separate regions of equal width and assign to
-// each child left-to-right. In the end, every node's region should equal the
-// sum of its childrens' regions, and each level of depth's regions should sum
-// to the root's region.
-template <typename Node>
-static void ForEachNodeReverseRecursive(RefPtr<Node> aNode)
-{
-  if (!aNode->IsLeaf()) {
-    int nChildren = 0;
-    for (RefPtr<Node> node = aNode->GetLastChild();
-        node != nullptr;
-        node = node->GetPrevSibling()) {
-      nChildren++;
-    }
-    nsRect bounds = aNode->GetRegion().GetBounds();
-    int childWidth = bounds.width / nChildren;
-    int x = bounds.x;
-    for (RefPtr<Node> node = aNode->GetLastChild();
-        node != nullptr;
-        node = node->GetPrevSibling()) {
-      node->SetRegion(nsRegion(nsRect(x, 0, childWidth, 1)));
-      ForEachNodeReverseRecursive(node);
-      x += childWidth;
-    }
-  }
-}
-
-static void Plain_ReverseForEachNodePerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT;
-  RefPtr<ForEachTestNodeReverse> root = CreateBenchmarkTree<ForEachTestNodeReverse>(depth, childrenCount,
-      &ForEachNodeDoNothing);
-  root->SetRegion(nsRegion(nsRect(0, 0, rectangleWidth, 1)));
-  ForEachNodeReverseRecursive(root);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseForEachNodePerformance, &Plain_ReverseForEachNodePerformance);
-
-static void TreeTraversal_ReverseForEachNodePerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT;
-  RefPtr<ForEachTestNodeReverse> root = CreateBenchmarkTree<ForEachTestNodeReverse>(depth, childrenCount,
-      &ForEachNodeDoNothing);
-  root->SetRegion(nsRegion(nsRect(0, 0, rectangleWidth, 1)));
-  ForEachNode<layers::ReverseIterator>(root.get(),
-      [](ForEachTestNodeReverse* aNode) {
-        if (!aNode->IsLeaf()) {
-          int nChildren = 0;
-          for (RefPtr<ForEachTestNodeReverse> node = aNode->GetLastChild();
-              node != nullptr;
-              node = node->GetPrevSibling()) {
-            nChildren++;
-          }
-          nsRect bounds = aNode->GetRegion().GetBounds();
-          int childWidth = bounds.width / nChildren;
-          int x = bounds.x;
-          for (RefPtr<ForEachTestNodeReverse> node = aNode->GetLastChild();
-              node != nullptr;
-              node = node->GetPrevSibling()) {
-            node->SetRegion(nsRegion(nsRect(x, 0, childWidth, 1)));
-            x += childWidth;
-          }
-        }
-      });
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseForEachNodePerformance, &TreeTraversal_ReverseForEachNodePerformance);
-
-// This test ((Plain|TreeTraversal)_ReverseForEachNodeStackPerformance) uses
-// the following benchmark:
-//
-// Starting with an unattached region equal to PERFORMANCE_TREE_LEAF_COUNT x 1,
-// a starting width of PERFORMANCE_TREE_LEAF_COUNT, and an empty tree, create a
-// tree with the same conditions as
-// ((Plain|TreeTraversal)_ReverseForEachNodePerformance) by assigning regions
-// of the current width, starting from the min x and min y coordinates. For
-// each level of depth, decrease the current width by a factor of
-// PERFORMANCE_TREE_CHILD_COUNT, and maintain a stack of ancestor regions.
-// Use the stack to track the portion of each region still available to assign
-// to children, which determines the aforementioned min x and min y coordinates.
-// Compare this to using the program stack.
-template <typename Node>
-static void ForEachNodeReverseStackRecursive(RefPtr<Node> aNode, int& aRectangleWidth, nsRegion aRegion, int aChildrenCount)
-{
-  nsRect parentRect = aRegion.GetBounds();
-  nsRect newRectangle(parentRect.x, parentRect.y, aRectangleWidth, 1);
-  nsRegion newRegion(newRectangle);
-  aNode->SetRegion(nsRegion(newRegion));
-
-  aRectangleWidth /= aChildrenCount;
-
-  for (RefPtr<Node> node = aNode->GetLastChild();
-      node != nullptr;
-      node = node->GetPrevSibling()) {
-    ForEachNodeReverseStackRecursive(node, aRectangleWidth, newRegion, aChildrenCount);
-    newRegion.SubOut(node->GetRegion());
-  }
-  // Handle case where rectangle width is truncated if power falls below 0,
-  // so we dont lose the regions in future iterations
-  if (aRectangleWidth == 0) {
-    aRectangleWidth = 1;
-  }
-  else {
-    aRectangleWidth *= aChildrenCount;
-  }
-}
-
-static void Plain_ReverseForEachNodeStackPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT;
-  RefPtr<ForEachTestNodeReverse> root = CreateBenchmarkTree<ForEachTestNodeReverse>(depth, childrenCount,
-      &ForEachNodeDoNothing);
-  nsRegion startRegion(nsRect(0, 0, rectangleWidth, 1));
-  ForEachNodeReverseStackRecursive(root, rectangleWidth, startRegion, childrenCount);
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseForEachNodeStackPerformance, &Plain_ReverseForEachNodeStackPerformance);
-
-static void TreeTraversal_ReverseForEachNodeStackPerformance()
-{
-  int depth = PERFORMANCE_TREE_DEPTH;
-  int childrenCount = PERFORMANCE_TREE_CHILD_COUNT;
-  int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT;
-  stack<nsRegion> regionStack;
-  RefPtr<ForEachTestNodeReverse> root = CreateBenchmarkTree<ForEachTestNodeReverse>(depth, childrenCount,
-      &ForEachNodeDoNothing);
-  regionStack.push(nsRegion(nsRect(0, 0, rectangleWidth, 1)));
-  ForEachNode<layers::ReverseIterator>(root.get(),
-      [&regionStack, &rectangleWidth, childrenCount](ForEachTestNodeReverse* aNode) {
-        nsRegion parentRegion = regionStack.top();
-        nsRect parentRect = parentRegion.GetBounds();
-        nsRect newRect(parentRect.x, parentRect.y, rectangleWidth, 1);
-        nsRegion newRegion(newRect);
-        aNode->SetRegion(newRegion);
-        regionStack.top().SubOut(newRegion);
-        regionStack.push(newRegion);
-        rectangleWidth /= childrenCount;
-      },
-      [&regionStack, &rectangleWidth, childrenCount](ForEachTestNodeReverse* aNode) {
-        regionStack.pop();
-        // Handle case where rectangle width is truncated if power falls below 0,
-        // so we dont lose the regions in future iterations
-        if (rectangleWidth == 0) {
-          rectangleWidth = 1;
-        }
-        else {
-          rectangleWidth *= childrenCount;
-        }
-      });
-}
-
-MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseForEachNodeStackPerformance, &TreeTraversal_ReverseForEachNodeStackPerformance);