cc: Apply the layer's initial CSS scale to the contentsScale to render text at the right resolution.

cc/occlusion_tracker_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "CCOcclusionTracker.h"
 
 #include "CCAnimationTestCommon.h"
 #include "CCGeometryTestUtils.h"
 #include "CCLayerAnimationController.h"
-#include "CCLayerImpl.h"
 #include "CCLayerTreeHostCommon.h"
 #include "CCMathUtil.h"
 #include "CCOcclusionTrackerTestCommon.h"
 #include "CCOverdrawMetrics.h"
 #include "CCSingleThreadProxy.h"
-#include "LayerChromium.h"
+#include "CCTiledLayerImpl.h"
 #include "Region.h"
+#include "TiledLayerChromium.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <public/WebFilterOperation.h>
 #include <public/WebFilterOperations.h>
 #include <public/WebTransformationMatrix.h>
 
 using namespace cc;
 using namespace WebKit;
 using namespace WebKitTests;
 
 namespace {
 
-class TestContentLayerChromium : public LayerChromium {
+class TestContentLayerChromium : public TiledLayerChromium {
 public:
     TestContentLayerChromium()
-        : LayerChromium()
+        : TiledLayerChromium()
         , m_overrideOpaqueContentsRect(false)
     {
     }
 
     virtual bool drawsContent() const OVERRIDE { return true; }
     virtual Region visibleContentOpaqueRegion() const OVERRIDE
     {
         if (m_overrideOpaqueContentsRect)
             return intersection(m_opaqueContentsRect, visibleContentRect());
         return LayerChromium::visibleContentOpaqueRegion();
     }
     void setOpaqueContentsRect(const IntRect& opaqueContentsRect)
     {
         m_overrideOpaqueContentsRect = true;
         m_opaqueContentsRect = opaqueContentsRect;
     }
 
+    virtual LayerTextureUpdater* textureUpdater() const OVERRIDE { return 0; }
+    virtual void createTextureUpdaterIfNeeded() OVERRIDE { }
+
 private:
     virtual ~TestContentLayerChromium()
     {
     }
 
     bool m_overrideOpaqueContentsRect;
     IntRect m_opaqueContentsRect;
 };
 
-class TestContentLayerImpl : public CCLayerImpl {
+class TestContentLayerImpl : public CCTiledLayerImpl {
 public:
     TestContentLayerImpl(int id)
-        : CCLayerImpl(id)
+        : CCTiledLayerImpl(id)
         , m_overrideOpaqueContentsRect(false)
     {
         setDrawsContent(true);
     }
 
     virtual Region visibleContentOpaqueRegion() const OVERRIDE
     {
         if (m_overrideOpaqueContentsRect)
             return intersection(m_opaqueContentsRect, visibleContentRect());
         return CCLayerImpl::visibleContentOpaqueRegion();
@@ skipping 187 matching lines @@
     }
 
     void calcDrawEtc(TestContentLayerImpl* root)
     {
         ASSERT(root == m_root.get());
         int dummyMaxTextureSize = 512;
         CCLayerSorter layerSorter;
 
         ASSERT(!root->renderSurface());
 
-        CCLayerTreeHostCommon::calculateDrawTransforms(root, root->bounds(), 1, &layerSorter, dummyMaxTextureSize, m_renderSurfaceLayerListImpl);
+        CCLayerTreeHostCommon::calculateDrawTransforms(root, root->bounds(), 1, 1, &layerSorter, dummyMaxTextureSize, m_renderSurfaceLayerListImpl);
 
         m_layerIterator = m_layerIteratorBegin = Types::LayerIterator::begin(&m_renderSurfaceLayerListImpl);
     }
 
     void calcDrawEtc(TestContentLayerChromium* root)
     {
         ASSERT(root == m_root.get());
         int dummyMaxTextureSize = 512;
 
         ASSERT(!root->renderSurface());
 
-        CCLayerTreeHostCommon::calculateDrawTransforms(root, root->bounds(), 1, dummyMaxTextureSize, m_renderSurfaceLayerListChromium);
+        CCLayerTreeHostCommon::calculateDrawTransforms(root, root->bounds(), 1, 1, dummyMaxTextureSize, m_renderSurfaceLayerListChromium);
 
         m_layerIterator = m_layerIteratorBegin = Types::LayerIterator::begin(&m_renderSurfaceLayerListChromium);
     }
 
     void enterLayer(typename Types::LayerType* layer, typename Types::OcclusionTrackerType& occlusion)
     {
         ASSERT_EQ(layer, *m_layerIterator);
         ASSERT_TRUE(m_layerIterator.representsItself());
         occlusion.enterLayer(m_layerIterator);
     }
@@ skipping 127 matching lines @@
     }; \
     TEST_F(ClassName##ImplThreadOpaquePaints, runTest) { runMyTest(); }
 
 #define ALL_CCOCCLUSIONTRACKER_TEST(ClassName) \
     RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \
     RUN_TEST_MAIN_THREAD_OPAQUE_PAINTS(ClassName) \
     RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName) \
     RUN_TEST_IMPL_THREAD_OPAQUE_PAINTS(ClassName)
 
 #define MAIN_THREAD_TEST(ClassName) \
-    RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName)
+    RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \
+    RUN_TEST_MAIN_THREAD_OPAQUE_PAINTS(ClassName)
 
 #define IMPL_THREAD_TEST(ClassName) \
-    RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName)
+    RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName) \
+    RUN_TEST_IMPL_THREAD_OPAQUE_PAINTS(ClassName)
 
 #define MAIN_AND_IMPL_THREAD_TEST(ClassName) \
     RUN_TEST_MAIN_THREAD_OPAQUE_LAYERS(ClassName) \
-    RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName)
+    RUN_TEST_MAIN_THREAD_OPAQUE_PAINTS(ClassName) \
+    RUN_TEST_IMPL_THREAD_OPAQUE_LAYERS(ClassName) \
+    RUN_TEST_IMPL_THREAD_OPAQUE_PAINTS(ClassName)
 
 template<class Types, bool opaqueLayers>
 class CCOcclusionTrackerTestIdentityTransforms : public CCOcclusionTrackerTest<Types, opaqueLayers> {
 protected:
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, FloatPoint(0, 0), IntSize(100, 100));
         typename Types::ContentLayerType* layer = this->createDrawingLayer(parent, this->identityMatrix, FloatPoint(30, 30), IntSize(500, 500), true);
         this->calcDrawEtc(parent);
 
@@ skipping 1743 matching lines @@
     void runMyTest()
     {
         WebTransformationMatrix surfaceTransform;
         surfaceTransform.translate(300, 300);
         surfaceTransform.scale(2);
         surfaceTransform.translate(-150, -150);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, FloatPoint(0, 0), IntSize(500, 500));
         typename Types::ContentLayerType* surface = this->createDrawingSurface(parent, surfaceTransform, FloatPoint(0, 0), IntSize(300, 300), false);
         typename Types::ContentLayerType* surface2 = this->createDrawingSurface(parent, this->identityMatrix, FloatPoint(50, 50), IntSize(300, 300), false);
-        surface->setOpaqueContentsRect(IntRect(0, 0, 200, 200));
+        surface->setOpaqueContentsRect(IntRect(0, 0, 400, 400));
         surface2->setOpaqueContentsRect(IntRect(0, 0, 200, 200));
         this->calcDrawEtc(parent);
 
         TestCCOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(IntRect(0, 0, 1000, 1000));
 
         this->visitLayer(surface2, occlusion);
         this->visitContributingSurface(surface2, occlusion);
 
         EXPECT_RECT_EQ(IntRect(50, 50, 200, 200), occlusion.occlusionInScreenSpace().bounds());
         EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size());
         EXPECT_RECT_EQ(IntRect(50, 50, 200, 200), occlusion.occlusionInTargetSurface().bounds());
         EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size());
 
         // Clear any stored occlusion.
         occlusion.setOcclusionInScreenSpace(Region());
         occlusion.setOcclusionInTargetSurface(Region());
 
         this->visitLayer(surface, occlusion);
         this->visitContributingSurface(surface, occlusion);
 
         EXPECT_RECT_EQ(IntRect(0, 0, 400, 400), occlusion.occlusionInScreenSpace().bounds());
         EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size());
         EXPECT_RECT_EQ(IntRect(0, 0, 400, 400), occlusion.occlusionInTargetSurface().bounds());
         EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size());
     }
 };
 
-MAIN_AND_IMPL_THREAD_TEST(CCOcclusionTrackerTestSurfaceOcclusionTranslatesToParent);
+// Scale transforms require main thread+commit to get contentBounds right.
+MAIN_THREAD_TEST(CCOcclusionTrackerTestSurfaceOcclusionTranslatesToParent);
 
 template<class Types, bool opaqueLayers>
 class CCOcclusionTrackerTestSurfaceOcclusionTranslatesWithClipping : public CCOcclusionTrackerTest<Types, opaqueLayers> {
 protected:
     void runMyTest()
     {
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, FloatPoint(0, 0), IntSize(300, 300));
         parent->setMasksToBounds(true);
         typename Types::ContentLayerType* surface = this->createDrawingSurface(parent, this->identityMatrix, FloatPoint(0, 0), IntSize(500, 300), false);
         surface->setOpaqueContentsRect(IntRect(0, 0, 400, 200));
@@ skipping 321 matching lines @@
         this->visitLayer(occludingLayer2, occlusion);
         this->visitLayer(occludingLayer1, occlusion);
 
         EXPECT_RECT_EQ(IntRect(0, 0, 300, 150), occlusion.occlusionInScreenSpace().bounds());
         EXPECT_EQ(5u, occlusion.occlusionInScreenSpace().rects().size());
         EXPECT_RECT_EQ(IntRect(0, 0, 300, 150), occlusion.occlusionInTargetSurface().bounds());
         EXPECT_EQ(5u, occlusion.occlusionInTargetSurface().rects().size());
 
         // Everything outside the surface/replica is occluded but the surface/replica itself is not.
         this->enterLayer(filteredSurface, occlusion);
-        EXPECT_RECT_EQ(IntRect(1, 0, 99, 100), occlusion.unoccludedContentRect(filteredSurface, IntRect(1, 0, 100, 100)));
-        EXPECT_RECT_EQ(IntRect(0, 1, 100, 99), occlusion.unoccludedContentRect(filteredSurface, IntRect(0, 1, 100, 100)));
-        EXPECT_RECT_EQ(IntRect(0, 0, 99, 100), occlusion.unoccludedContentRect(filteredSurface, IntRect(-1, 0, 100, 100)));
-        EXPECT_RECT_EQ(IntRect(0, 0, 100, 99), occlusion.unoccludedContentRect(filteredSurface, IntRect(0, -1, 100, 100)));
+        EXPECT_RECT_EQ(IntRect(1, 0, 49, 50), occlusion.unoccludedContentRect(filteredSurface, IntRect(1, 0, 50, 50)));
+        EXPECT_RECT_EQ(IntRect(0, 1, 50, 49), occlusion.unoccludedContentRect(filteredSurface, IntRect(0, 1, 50, 50)));
+        EXPECT_RECT_EQ(IntRect(0, 0, 49, 50), occlusion.unoccludedContentRect(filteredSurface, IntRect(-1, 0, 50, 50)));
+        EXPECT_RECT_EQ(IntRect(0, 0, 50, 49), occlusion.unoccludedContentRect(filteredSurface, IntRect(0, -1, 50, 50)));
 
-        EXPECT_RECT_EQ(IntRect(300 + 1, 0, 99, 100), occlusion.unoccludedContentRect(filteredSurface, IntRect(300 + 1, 0, 100, 100)));
-        EXPECT_RECT_EQ(IntRect(300 + 0, 1, 100, 99), occlusion.unoccludedContentRect(filteredSurface, IntRect(300 + 0, 1, 100, 100)));
-        EXPECT_RECT_EQ(IntRect(300 + 0, 0, 99, 100), occlusion.unoccludedContentRect(filteredSurface, IntRect(300 - 1, 0, 100, 100)));
-        EXPECT_RECT_EQ(IntRect(300 + 0, 0, 100, 99), occlusion.unoccludedContentRect(filteredSurface, IntRect(300 + 0, -1, 100, 100)));
+        EXPECT_RECT_EQ(IntRect(150 + 1, 0, 49, 50), occlusion.unoccludedContentRect(filteredSurface, IntRect(150 + 1, 0, 50, 50)));
+        EXPECT_RECT_EQ(IntRect(150 + 0, 1, 50, 49), occlusion.unoccludedContentRect(filteredSurface, IntRect(150 + 0, 1, 50, 50)));
+        EXPECT_RECT_EQ(IntRect(150 + 0, 0, 49, 50), occlusion.unoccludedContentRect(filteredSurface, IntRect(150 - 1, 0, 50, 50)));
+        EXPECT_RECT_EQ(IntRect(150 + 0, 0, 50, 49), occlusion.unoccludedContentRect(filteredSurface, IntRect(150 + 0, -1, 50, 50)));
         this->leaveLayer(filteredSurface, occlusion);
 
         // The filtered layer/replica does not occlude.
         EXPECT_RECT_EQ(IntRect(0, 0, 300, 150), occlusion.occlusionInScreenSpace().bounds());
         EXPECT_EQ(5u, occlusion.occlusionInScreenSpace().rects().size());
         EXPECT_RECT_EQ(IntRect(0, 0, 0, 0), occlusion.occlusionInTargetSurface().bounds());
         EXPECT_EQ(0u, occlusion.occlusionInTargetSurface().rects().size());
 
         // The surface has a background blur, so it needs pixels that are currently considered occluded in order to be drawn. So the pixels
-        // it needs should be removed some the occluded area so that when we get to the parent they are drawn.
+        // it needs should be removed from the occluded area so that when we get to the parent they are drawn.
         this->visitContributingSurface(filteredSurface, occlusion);
 
         this->enterLayer(parent, occlusion);
         EXPECT_RECT_EQ(IntRect(0, 0, 300, 150), occlusion.occlusionInScreenSpace().bounds());
         EXPECT_EQ(5u, occlusion.occlusionInScreenSpace().rects().size());
         EXPECT_RECT_EQ(IntRect(0, 0, 300, 150), occlusion.occlusionInTargetSurface().bounds());
         EXPECT_EQ(5u, occlusion.occlusionInTargetSurface().rects().size());
 
         IntRect outsetRect;
         IntRect testRect;
@@ skipping 35 matching lines @@
         testRect.move(-1, 0);
         testRect.expand(1, 0);
         EXPECT_RECT_EQ(outsetRect, occlusion.unoccludedContentRect(parent, testRect));
         testRect = outsetRect;
         testRect.move(0, -1);
         testRect.expand(0, 1);
         EXPECT_RECT_EQ(outsetRect, occlusion.unoccludedContentRect(parent, testRect));
     }
 };
 
-ALL_CCOCCLUSIONTRACKER_TEST(CCOcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter);
+// Scale transforms require main thread+commit to get contentBounds right.
+MAIN_THREAD_TEST(CCOcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilter);
 
 template<class Types, bool opaqueLayers>
 class CCOcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice : public CCOcclusionTrackerTest<Types, opaqueLayers> {
 protected:
     void runMyTest()
     {
         WebTransformationMatrix scaleByHalf;
         scaleByHalf.scale(0.5);
 
         // Makes two surfaces that completely cover |parent|. The occlusion both above and below the filters will be reduced by each of them.
-        typename Types::ContentLayerType* root = this->createRoot(this->identityMatrix, FloatPoint(0, 0), IntSize(75, 75));
-        typename Types::LayerType* parent = this->createSurface(root, scaleByHalf, FloatPoint(0, 0), IntSize(150, 150));
+        typename Types::ContentLayerType* root = this->createRoot(this->identityMatrix, FloatPoint(0, 0), IntSize(150, 150));
+        typename Types::LayerType* parent = this->createDrawingSurface(root, scaleByHalf, FloatPoint(0, 0), IntSize(300, 300), false);
         parent->setMasksToBounds(true);
-        typename Types::LayerType* filteredSurface1 = this->createDrawingLayer(parent, scaleByHalf, FloatPoint(0, 0), IntSize(300, 300), false);
-        typename Types::LayerType* filteredSurface2 = this->createDrawingLayer(parent, scaleByHalf, FloatPoint(0, 0), IntSize(300, 300), false);
-        typename Types::LayerType* occludingLayerAbove = this->createDrawingLayer(parent, this->identityMatrix, FloatPoint(100, 100), IntSize(50, 50), true);
+        typename Types::LayerType* filteredSurface1 = this->createDrawingLayer(parent, scaleByHalf, FloatPoint(0, 0), IntSize(600, 600), false);
+        typename Types::LayerType* filteredSurface2 = this->createDrawingLayer(parent, scaleByHalf, FloatPoint(0, 0), IntSize(600, 600), false);
+        typename Types::LayerType* occludingLayerAbove = this->createDrawingLayer(parent, this->identityMatrix, FloatPoint(200, 200), IntSize(100, 100), true);
 
         // Filters make the layers own surfaces.
         WebFilterOperations filters;
         filters.append(WebFilterOperation::createBlurFilter(3));
         filteredSurface1->setBackgroundFilters(filters);
         filteredSurface2->setBackgroundFilters(filters);
 
         // Save the distance of influence for the blur effect.
         int outsetTop, outsetRight, outsetBottom, outsetLeft;
         filters.getOutsets(outsetTop, outsetRight, outsetBottom, outsetLeft);
 
         this->calcDrawEtc(root);
 
         TestCCOcclusionTrackerWithClip<typename Types::LayerType, typename Types::RenderSurfaceType> occlusion(IntRect(0, 0, 1000, 1000));
         occlusion.setLayerClipRect(IntRect(0, 0, 1000, 1000));
 
         this->visitLayer(occludingLayerAbove, occlusion);
-        EXPECT_RECT_EQ(IntRect(100 / 2, 100 / 2, 50 / 2, 50 / 2), occlusion.occlusionInScreenSpace().bounds());
+        EXPECT_RECT_EQ(IntRect(200 / 2, 200 / 2, 100 / 2, 100 / 2), occlusion.occlusionInScreenSpace().bounds());
         EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size());
-        EXPECT_RECT_EQ(IntRect(100, 100, 50, 50), occlusion.occlusionInTargetSurface().bounds());
+        EXPECT_RECT_EQ(IntRect(200 / 2, 200 / 2, 100 / 2, 100 / 2), occlusion.occlusionInTargetSurface().bounds());
         EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size());
 
         this->visitLayer(filteredSurface2, occlusion);
         this->visitContributingSurface(filteredSurface2, occlusion);
         this->visitLayer(filteredSurface1, occlusion);
         this->visitContributingSurface(filteredSurface1, occlusion);
 
         ASSERT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size());
         ASSERT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size());
 
-        // Test expectations in the target.
-        IntRect expectedOcclusion = IntRect(100 + outsetRight * 2, 100 + outsetBottom * 2, 50 - (outsetLeft + outsetRight) * 2, 50 - (outsetTop + outsetBottom) * 2);
+        // Test expectations in the target. The target is scaled in half so the occlusion should be scaled within its contents as well.
+        IntRect expectedOcclusion = IntRect(200 / 2 + outsetRight * 2, 200 / 2 + outsetBottom * 2, 100 / 2 - (outsetLeft + outsetRight) * 2, 100 / 2 - (outsetTop + outsetBottom) * 2);
         EXPECT_RECT_EQ(expectedOcclusion, occlusion.occlusionInTargetSurface().rects()[0]);
 
-        // Test expectations in the screen. Take the ceiling of half of the outsets.
-        outsetTop = (outsetTop + 1) / 2;
-        outsetRight = (outsetRight + 1) / 2;
-        outsetBottom = (outsetBottom + 1) / 2;
-        outsetLeft = (outsetLeft + 1) / 2;
-        expectedOcclusion = IntRect(100 / 2 + outsetRight * 2, 100 / 2 + outsetBottom * 2, 50 / 2 - (outsetLeft + outsetRight) * 2, 50 /2 - (outsetTop + outsetBottom) * 2);
-
+        // Test expectations in the screen. The parent is scaled in half so it will scale the occlusion to the screen as well.
+        expectedOcclusion = IntRect(200 / 2 + outsetRight * 2, 200 / 2 + outsetBottom * 2, 100 / 2 - (outsetLeft + outsetRight) * 2, 100 / 2 - (outsetTop + outsetBottom) * 2);
         EXPECT_RECT_EQ(expectedOcclusion, occlusion.occlusionInScreenSpace().rects()[0]);
     }
 };
 
-ALL_CCOCCLUSIONTRACKER_TEST(CCOcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice);
+// Scale transforms require main thread+commit to get contentBounds right.
+MAIN_THREAD_TEST(CCOcclusionTrackerTestTwoBackgroundFiltersReduceOcclusionTwice);
 
 template<class Types, bool opaqueLayers>
 class CCOcclusionTrackerTestDontOccludePixelsNeededForBackgroundFilterWithClip : public CCOcclusionTrackerTest<Types, opaqueLayers> {
 protected:
     void runMyTest()
     {
         // Make a surface and its replica, each 50x50, that are completely surrounded by opaque layers which are above them in the z-order.
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, FloatPoint(0, 0), IntSize(300, 150));
         // We stick the filtered surface inside a clipping surface so that we can make sure the clip is honored when exposing pixels for
         // the background filter.
@@ skipping 153 matching lines @@
         IntRect occlusionBehindReplica = IntRect(210, 60, 30, 30);
 
         IntRect expectedOpaqueBounds = unionRect(occlusionBehindSurface, occlusionBehindReplica);
         EXPECT_RECT_EQ(expectedOpaqueBounds, occlusion.occlusionInScreenSpace().bounds());
         EXPECT_EQ(2u, occlusion.occlusionInScreenSpace().rects().size());
         EXPECT_RECT_EQ(expectedOpaqueBounds, occlusion.occlusionInTargetSurface().bounds());
         EXPECT_EQ(2u, occlusion.occlusionInTargetSurface().rects().size());
     }
 };
 
-ALL_CCOCCLUSIONTRACKER_TEST(CCOcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter);
+// Scale transforms require main thread+commit to get contentBounds right.
+MAIN_THREAD_TEST(CCOcclusionTrackerTestDontReduceOcclusionBelowBackgroundFilter);
 
 template<class Types, bool opaqueLayers>
 class CCOcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded : public CCOcclusionTrackerTest<Types, opaqueLayers> {
 protected:
     void runMyTest()
     {
         WebTransformationMatrix scaleByHalf;
         scaleByHalf.scale(0.5);
 
         // Make a surface and its replica, each 50x50, that are completely occluded by opaque layers which are above them in the z-order.
@@ skipping 27 matching lines @@
         IntRect occlusionAboveReplica = IntRect(200, 50, 50, 50);
 
         IntRect expectedOpaqueBounds = unionRect(occlusionAboveSurface, occlusionAboveReplica);
         EXPECT_RECT_EQ(expectedOpaqueBounds, occlusion.occlusionInScreenSpace().bounds());
         EXPECT_EQ(2u, occlusion.occlusionInScreenSpace().rects().size());
         EXPECT_RECT_EQ(expectedOpaqueBounds, occlusion.occlusionInTargetSurface().bounds());
         EXPECT_EQ(2u, occlusion.occlusionInTargetSurface().rects().size());
     }
 };
 
-ALL_CCOCCLUSIONTRACKER_TEST(CCOcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded);
+// Scale transforms require main thread+commit to get contentBounds right.
+MAIN_THREAD_TEST(CCOcclusionTrackerTestDontReduceOcclusionIfBackgroundFilterIsOccluded);
 
 template<class Types, bool opaqueLayers>
 class CCOcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded : public CCOcclusionTrackerTest<Types, opaqueLayers> {
 protected:
     void runMyTest()
     {
         WebTransformationMatrix scaleByHalf;
         scaleByHalf.scale(0.5);
 
         // Make a surface and its replica, each 50x50, that are partially occluded by opaque layers which are above them in the z-order.
@@ skipping 51 matching lines @@
         for (size_t i = 0; i < expectedOcclusion.rects().size(); ++i) {
             IntRect expectedRect = expectedOcclusion.rects()[i];
             IntRect screenRect = occlusion.occlusionInScreenSpace().rects()[i];
             IntRect targetRect = occlusion.occlusionInTargetSurface().rects()[i];
             EXPECT_EQ(expectedRect, screenRect);
             EXPECT_EQ(expectedRect, targetRect);
         }
     }
 };
 
-ALL_CCOCCLUSIONTRACKER_TEST(CCOcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded);
+// Scale transforms require main thread+commit to get contentBounds right.
+MAIN_THREAD_TEST(CCOcclusionTrackerTestReduceOcclusionWhenBackgroundFilterIsPartiallyOccluded);
 
 template<class Types, bool opaqueLayers>
 class CCOcclusionTrackerTestMinimumTrackingSize : public CCOcclusionTrackerTest<Types, opaqueLayers> {
 protected:
     void runMyTest()
     {
         IntSize trackingSize(100, 100);
         IntSize belowTrackingSize(99, 99);
 
         typename Types::ContentLayerType* parent = this->createRoot(this->identityMatrix, FloatPoint(0, 0), IntSize(400, 400));
@@ skipping 19 matching lines @@
         EXPECT_RECT_EQ(IntRect(IntPoint(), trackingSize), occlusion.occlusionInScreenSpace().bounds());
         EXPECT_EQ(1u, occlusion.occlusionInScreenSpace().rects().size());
         EXPECT_RECT_EQ(IntRect(IntPoint(), trackingSize), occlusion.occlusionInTargetSurface().bounds());
         EXPECT_EQ(1u, occlusion.occlusionInTargetSurface().rects().size());
     }
 };
 
 ALL_CCOCCLUSIONTRACKER_TEST(CCOcclusionTrackerTestMinimumTrackingSize);
 
 } // namespace