cc: Make occlusion tracker always work in target space.

cc/tiled_layer_unittest.cc

 // Copyright 2011 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 "cc/tiled_layer.h"
 
 #include "cc/bitmap_content_layer_updater.h"
 #include "cc/layer_painter.h"
 #include "cc/overdraw_metrics.h"
 #include "cc/rendering_stats.h"
@@ skipping 14 matching lines @@
 
 namespace cc {
 namespace {
 
 class TestOcclusionTracker : public OcclusionTracker {
 public:
     TestOcclusionTracker()
         : OcclusionTracker(gfx::Rect(0, 0, 1000, 1000), true)
         , m_layerClipRectInTarget(gfx::Rect(0, 0, 1000, 1000))
     {
-        // Pretend we have visited a render surface.
         m_stack.push_back(StackObject());
     }
 
-    void setOcclusion(const Region& occlusion) { m_stack.back().occlusionInTarget = occlusion; }
+    void setRenderTarget(Layer* renderTarget)
+    {
+        m_stack.back().target = renderTarget;
+    }
+
+    void setOcclusion(const Region& occlusion) { m_stack.back().occlusionFromInsideTarget = occlusion; }
 
 protected:
     virtual gfx::Rect layerClipRectInTarget(const Layer* layer) const OVERRIDE { return m_layerClipRectInTarget; }
 
 private:
     gfx::Rect m_layerClipRectInTarget;
 };
 
 class TiledLayerTest : public testing::Test {
 public:
     TiledLayerTest()
         : m_proxy(NULL)
         , m_outputSurface(createFakeOutputSurface())
         , m_queue(make_scoped_ptr(new ResourceUpdateQueue))
         , m_occlusion(0)
     {
     }
 
     virtual void SetUp()
     {
         m_layerTreeHost = LayerTreeHost::create(&m_fakeLayerImplTreeHostClient, m_settings, scoped_ptr<Thread>(NULL));
         m_proxy = m_layerTreeHost->proxy();
         m_resourceManager = PrioritizedResourceManager::create(m_proxy);
         m_layerTreeHost->initializeRendererIfNeeded();
+        m_layerTreeHost->setRootLayer(Layer::create());
+
         DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(m_proxy);
         m_resourceProvider = ResourceProvider::create(m_outputSurface.get());
         m_hostImpl = make_scoped_ptr(new FakeLayerTreeHostImpl(m_proxy));
     }
 
     virtual ~TiledLayerTest()
     {
         resourceManagerClearAllMemory(m_resourceManager.get(), m_resourceProvider.get());
+
         DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(m_proxy);
         m_resourceProvider.reset();
         m_hostImpl.reset();
     }
 
-    class ScopedFakeTiledLayerImpl {
-    public:
-        ScopedFakeTiledLayerImpl(LayerTreeImpl* treeImpl, int id)
-        {
-            m_layerImpl = new FakeTiledLayerImpl(treeImpl, id);
-        }
-        ~ScopedFakeTiledLayerImpl()
-        {
-            delete m_layerImpl;
-        }
-        FakeTiledLayerImpl* get()
-        {
-            return m_layerImpl;
-        }
-        FakeTiledLayerImpl* operator->()
-        {
-            return m_layerImpl;
-        }
-    private:
-        FakeTiledLayerImpl* m_layerImpl;
-    };
     void resourceManagerClearAllMemory(PrioritizedResourceManager* resourceManager, ResourceProvider* resourceProvider)
     {
         {
             DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(m_proxy);
             resourceManager->clearAllMemory(resourceProvider);
             resourceManager->reduceMemory(resourceProvider);
         }
         resourceManager->unlinkAndClearEvictedBackings();
     }
     void updateTextures()
@@ skipping 14 matching lines @@
     {
         DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(m_proxy);
         layer->pushPropertiesTo(layerImpl);
     }
     void layerUpdate(FakeTiledLayer* layer, TestOcclusionTracker* occluded)
     {
         DebugScopedSetMainThread mainThread(m_proxy);
         layer->update(*m_queue.get(), occluded, m_stats);
     }
 
-    bool updateAndPush(FakeTiledLayer* layer1,
-                       FakeTiledLayerImpl* layerImpl1,
-                       FakeTiledLayer* layer2 = 0,
-                       FakeTiledLayerImpl* layerImpl2 = 0)
+    void calcDrawProps(const scoped_refptr<FakeTiledLayer>& layer1)

[enne (OOO), 2012/12/16 19:44:25]

Yay, calling calcDrawProperties.

Although, functions taking const scoped_refptr<>& is a little weird.  Is this
just to avoid typing .get()?

[danakj, 2012/12/16 20:16:52]

It's roughly equivilent to passing by value. I don't feel strongly about either
way. Some of chromium does one, some does the other apparently, judging from the
chromium-dev thread about this.

Want me to switch it?

[enne (OOO), 2012/12/16 20:53:17]

Oh.  I didn't realize that this was an idiom for other folks.  That's fine,
then.

+    {
+        scoped_refptr<FakeTiledLayer> layer2;
+        calcDrawProps(layer1, layer2);
+    }
+
+    void calcDrawProps(const scoped_refptr<FakeTiledLayer>& layer1,
+                       const scoped_refptr<FakeTiledLayer>& layer2)
+    {
+        if (layer1 && !layer1->parent())
+            m_layerTreeHost->rootLayer()->addChild(layer1);
+        if (layer2 && !layer1->parent())
+            m_layerTreeHost->rootLayer()->addChild(layer2);
+        if (m_occlusion)
+            m_occlusion->setRenderTarget(m_layerTreeHost->rootLayer());
+
+        std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
+        LayerTreeHostCommon::calculateDrawProperties(
+            m_layerTreeHost->rootLayer(),
+            m_layerTreeHost->deviceViewportSize(),
+            m_layerTreeHost->deviceScaleFactor(),
+            1, // page_scale_factor
+            m_layerTreeHost->rendererCapabilities().maxTextureSize,
+            false, // can_use_lcd_text
+            renderSurfaceLayerList);
+    }
+
+    bool updateAndPush(const scoped_refptr<FakeTiledLayer>& layer1,
+                       const scoped_ptr<FakeTiledLayerImpl>& layerImpl1)
+    {
+        scoped_refptr<FakeTiledLayer> layer2;
+        scoped_ptr<FakeTiledLayerImpl> layerImpl2;
+        return updateAndPush(layer1, layerImpl1, layer2, layerImpl2);
+    }
+
+    bool updateAndPush(const scoped_refptr<FakeTiledLayer>& layer1,
+                       const scoped_ptr<FakeTiledLayerImpl>& layerImpl1,
+                       const scoped_refptr<FakeTiledLayer>& layer2,
+                       const scoped_ptr<FakeTiledLayerImpl>& layerImpl2)
     {
         // Get textures
         m_resourceManager->clearPriorities();
         if (layer1)
             layer1->setTexturePriorities(m_priorityCalculator);
         if (layer2)
-            layer2->setTexturePriorities(m_priorityCalculator);     
+            layer2->setTexturePriorities(m_priorityCalculator);
         m_resourceManager->prioritizeTextures();
 
         // Update content
         if (layer1)
             layer1->update(*m_queue.get(), m_occlusion, m_stats);
         if (layer2)
             layer2->update(*m_queue.get(), m_occlusion, m_stats);
 
         bool needsUpdate = false;
         if (layer1)
             needsUpdate |= layer1->needsIdlePaint();
         if (layer2)
             needsUpdate |= layer2->needsIdlePaint();
 
         // Update textures and push.
         updateTextures();
         if (layer1)
-            layerPushPropertiesTo(layer1, layerImpl1);
+            layerPushPropertiesTo(layer1.get(), layerImpl1.get());
         if (layer2)
-            layerPushPropertiesTo(layer2, layerImpl2);
+            layerPushPropertiesTo(layer2.get(), layerImpl2.get());
 
         return needsUpdate;
     }
 
 public:
     Proxy* m_proxy;
     LayerTreeSettings m_settings;
     scoped_ptr<OutputSurface> m_outputSurface;
     scoped_ptr<ResourceProvider> m_resourceProvider;
     scoped_ptr<ResourceUpdateQueue> m_queue;
     RenderingStats m_stats;
     PriorityCalculator m_priorityCalculator;
     FakeLayerImplTreeHostClient m_fakeLayerImplTreeHostClient;
     scoped_ptr<LayerTreeHost> m_layerTreeHost;
     scoped_ptr<FakeLayerTreeHostImpl> m_hostImpl;
     scoped_ptr<PrioritizedResourceManager> m_resourceManager;
     TestOcclusionTracker* m_occlusion;
 };
 
 TEST_F(TiledLayerTest, pushDirtyTiles)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->setBounds(gfx::Size(100, 200));
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
     layer->invalidateContentRect(gfx::Rect(0, 0, 100, 200));
-    updateAndPush(layer.get(), layerImpl.get());
+    updateAndPush(layer, layerImpl);
 
     // We should have both tiles on the impl side.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 
     // Invalidates both tiles, but then only update one of them.
     layer->setBounds(gfx::Size(100, 200));
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
     layer->invalidateContentRect(gfx::Rect(0, 0, 100, 200));
-    updateAndPush(layer.get(), layerImpl.get());
+    updateAndPush(layer, layerImpl);
 
     // We should only have the first tile since the other tile was invalidated but not painted.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, pushOccludedDirtyTiles)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->setBounds(gfx::Size(100, 200));
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
     layer->drawProperties().drawable_content_rect = gfx::Rect(0, 0, 100, 200);
     layer->invalidateContentRect(gfx::Rect(0, 0, 100, 200));
-    updateAndPush(layer.get(), layerImpl.get());
+    updateAndPush(layer, layerImpl);
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 20000, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // We should have both tiles on the impl side.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 
     // Invalidates part of the top tile...
     layer->invalidateContentRect(gfx::Rect(0, 0, 50, 50));
     // ....but the area is occluded.
     occluded.setOcclusion(gfx::Rect(0, 0, 50, 50));
-    updateAndPush(layer.get(), layerImpl.get());
+    updateAndPush(layer, layerImpl);
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 20000 + 2500, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // We should still have both tiles, as part of the top tile is still unoccluded.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, pushDeletedTiles)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->setBounds(gfx::Size(100, 200));
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
     layer->invalidateContentRect(gfx::Rect(0, 0, 100, 200));
-    updateAndPush(layer.get(), layerImpl.get());
+    updateAndPush(layer, layerImpl);
 
     // We should have both tiles on the impl side.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 
     m_resourceManager->clearPriorities();
     resourceManagerClearAllMemory(m_resourceManager.get(), m_resourceProvider.get());
     m_resourceManager->setMaxMemoryLimitBytes(4*1024*1024);
 
     // This should drop the tiles on the impl thread.
     layerPushPropertiesTo(layer.get(), layerImpl.get());
 
     // We should now have no textures on the impl thread.
     EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 1));
 
     // This should recreate and update one of the deleted textures.
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
-    updateAndPush(layer.get(), layerImpl.get());
+    updateAndPush(layer, layerImpl);
 
     // We should have one tiles on the impl side.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, pushIdlePaintTiles)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
 
     // The tile size is 100x100. Setup 5x5 tiles with one visible tile in the center.
     // This paints 1 visible of the 25 invalid tiles.
     layer->setBounds(gfx::Size(500, 500));
     layer->drawProperties().visible_content_rect = gfx::Rect(200, 200, 100, 100);
     layer->invalidateContentRect(gfx::Rect(0, 0, 500, 500));
-    bool needsUpdate = updateAndPush(layer.get(), layerImpl.get());
+    bool needsUpdate = updateAndPush(layer, layerImpl);
     // We should need idle-painting for surrounding tiles.
     EXPECT_TRUE(needsUpdate);
 
     // We should have one tile on the impl side.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(2, 2));
 
     // For the next four updates, we should detect we still need idle painting.
     for (int i = 0; i < 4; i++) {
-        needsUpdate = updateAndPush(layer.get(), layerImpl.get());
+        needsUpdate = updateAndPush(layer, layerImpl);
         EXPECT_TRUE(needsUpdate);
     }
 
     // We should always finish painting eventually.
     for (int i = 0; i < 20; i++)
-        needsUpdate = updateAndPush(layer.get(), layerImpl.get());
+        needsUpdate = updateAndPush(layer, layerImpl);
 
     // We should have pre-painted all of the surrounding tiles.
     for (int i = 0; i < 5; i++) {
         for (int j = 0; j < 5; j++)
             EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(i, j));
     }
 
     EXPECT_FALSE(needsUpdate);
 }
 
 TEST_F(TiledLayerTest, predictivePainting)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
 
     // Prepainting should occur in the scroll direction first, and the
     // visible rect should be extruded only along the dominant axis.
     gfx::Vector2d directions[6] = { gfx::Vector2d(-10, 0),
                                     gfx::Vector2d(10, 0),
                                     gfx::Vector2d(0, -10),
                                     gfx::Vector2d(0, 10),
                                     gfx::Vector2d(10, 20),
                               gfx::Vector2d(-20, 10) };
     // We should push all tiles that touch the extruded visible rect.
@@ skipping 17 matching lines @@
         gfx::Size contentBounds = gfx::Size(500, 500);
         gfx::Rect contentRect = gfx::Rect(0, 0, 500, 500);
         gfx::Rect visibleRect = gfx::Rect(200, 200, 100, 100);
         gfx::Rect previousVisibleRect = gfx::Rect(visibleRect.origin() + directions[k], visibleRect.size());
         gfx::Rect nextVisibleRect = gfx::Rect(visibleRect.origin() - directions[k], visibleRect.size());
 
         // Setup. Use the previousVisibleRect to setup the prediction for next frame.
         layer->setBounds(contentBounds);
         layer->drawProperties().visible_content_rect = previousVisibleRect;
         layer->invalidateContentRect(contentRect);
-        bool needsUpdate = updateAndPush(layer.get(), layerImpl.get());
+        bool needsUpdate = updateAndPush(layer, layerImpl);
 
         // Invalidate and move the visibleRect in the scroll direction.
         // Check that the correct tiles have been painted in the visible pass.
         layer->invalidateContentRect(contentRect);
         layer->drawProperties().visible_content_rect = visibleRect;
-        needsUpdate = updateAndPush(layer.get(), layerImpl.get());
+        needsUpdate = updateAndPush(layer, layerImpl);
         for (int i = 0; i < 5; i++) {
             for (int j = 0; j < 5; j++)
                 EXPECT_EQ(layerImpl->hasResourceIdForTileAt(i, j), pushedVisibleTiles[k].Contains(i, j));
         }
 
         // Move the transform in the same direction without invalidating.
         // Check that non-visible pre-painting occured in the correct direction.
         // Ignore diagonal scrolls here (k > 3) as these have new visible content now.
         if (k <= 3) {
             layer->drawProperties().visible_content_rect = nextVisibleRect;
-            needsUpdate = updateAndPush(layer.get(), layerImpl.get());
+            needsUpdate = updateAndPush(layer, layerImpl);
             for (int i = 0; i < 5; i++) {
                 for (int j = 0; j < 5; j++)
                     EXPECT_EQ(layerImpl->hasResourceIdForTileAt(i, j), pushedPrepaintTiles[k].Contains(i, j));
             }
         }
 
         // We should always finish painting eventually.
         for (int i = 0; i < 20; i++)
-            needsUpdate = updateAndPush(layer.get(), layerImpl.get());
+            needsUpdate = updateAndPush(layer, layerImpl);
         EXPECT_FALSE(needsUpdate);
     }
 }
 
 TEST_F(TiledLayerTest, pushTilesAfterIdlePaintFailed)
 {
     // Start with 2mb of memory, but the test is going to try to use just more than 1mb, so we reduce to 1mb later.
     m_resourceManager->setMaxMemoryLimitBytes(2 * 1024 * 1024);
     scoped_refptr<FakeTiledLayer> layer1 = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl1(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl1 = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
     scoped_refptr<FakeTiledLayer> layer2 = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl2(m_hostImpl->activeTree(), 2);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl2 = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 2));
 
     // For this test we have two layers. layer1 exhausts most texture memory, leaving room for 2 more tiles from
     // layer2, but not all three tiles. First we paint layer1, and one tile from layer2. Then when we idle paint
     // layer2, we will fail on the third tile of layer2, and this should not leave the second tile in a bad state.
 
     // This uses 960000 bytes, leaving 88576 bytes of memory left, which is enough for 2 tiles only in the other layer.
     gfx::Rect layer1Rect(0, 0, 100, 2400);
     
     // This requires 4*30000 bytes of memory.
     gfx::Rect layer2Rect(0, 0, 100, 300);
 
     // Paint a single tile in layer2 so that it will idle paint.
     layer1->setBounds(layer1Rect.size());
     layer1->drawProperties().visible_content_rect = layer1Rect;
     layer2->setBounds(layer2Rect.size());
     layer2->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
-    bool needsUpdate = updateAndPush(layer1.get(), layerImpl1.get(),
-                                     layer2.get(), layerImpl2.get());
+    bool needsUpdate = updateAndPush(layer1, layerImpl1,
+                                     layer2, layerImpl2);
     // We should need idle-painting for both remaining tiles in layer2.
     EXPECT_TRUE(needsUpdate);
 
     // Reduce our memory limits to 1mb.
     m_resourceManager->setMaxMemoryLimitBytes(1024 * 1024);
 
     // Now idle paint layer2. We are going to run out of memory though!
     // Oh well, commit the frame and push.
     for (int i = 0; i < 4; i++) {
-        needsUpdate = updateAndPush(layer1.get(), layerImpl1.get(),
-                                    layer2.get(), layerImpl2.get());
+        needsUpdate = updateAndPush(layer1, layerImpl1,
+                                    layer2, layerImpl2);
     }
 
     // Sanity check, we should have textures for the big layer.
     EXPECT_TRUE(layerImpl1->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl1->hasResourceIdForTileAt(0, 23));
 
     // We should only have the first two tiles from layer2 since
     // it failed to idle update the last tile.
     EXPECT_TRUE(layerImpl2->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl2->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl2->hasResourceIdForTileAt(0, 1));
     EXPECT_TRUE(layerImpl2->hasResourceIdForTileAt(0, 1));
     
     EXPECT_FALSE(needsUpdate);
     EXPECT_FALSE(layerImpl2->hasResourceIdForTileAt(0, 2));
 }
 
 TEST_F(TiledLayerTest, pushIdlePaintedOccludedTiles)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
     
     // The tile size is 100x100, so this invalidates one occluded tile, culls it during paint, but prepaints it.
     occluded.setOcclusion(gfx::Rect(0, 0, 100, 100));
 
     layer->setBounds(gfx::Size(100, 100));
+    calcDrawProps(layer);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
-    updateAndPush(layer.get(), layerImpl.get());
+    updateAndPush(layer, layerImpl);
 
     // We should have the prepainted tile on the impl side, but culled it during paint.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_EQ(1, occluded.overdrawMetrics().tilesCulledForUpload());
 }
 
 TEST_F(TiledLayerTest, pushTilesMarkedDirtyDuringPaint)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     // However, during the paint, we invalidate one of the tiles. This should
     // not prevent the tile from being pushed.
     layer->fakeLayerUpdater()->setRectToInvalidate(gfx::Rect(0, 50, 100, 50), layer.get());
     layer->setBounds(gfx::Size(100, 200));
+    calcDrawProps(layer);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
-    updateAndPush(layer.get(), layerImpl.get());
+    updateAndPush(layer, layerImpl);
 
     // We should have both tiles on the impl side.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, pushTilesLayerMarkedDirtyDuringPaintOnNextLayer)
 {
     scoped_refptr<FakeTiledLayer> layer1 = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     scoped_refptr<FakeTiledLayer> layer2 = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layer1Impl(m_hostImpl->activeTree(), 1);
-    ScopedFakeTiledLayerImpl layer2Impl(m_hostImpl->activeTree(), 2);
+    scoped_ptr<FakeTiledLayerImpl> layer1Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+    scoped_ptr<FakeTiledLayerImpl> layer2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 2));
 
     // Invalidate a tile on layer1, during update of layer 2.
     layer2->fakeLayerUpdater()->setRectToInvalidate(gfx::Rect(0, 50, 100, 50), layer1.get());
     layer1->setBounds(gfx::Size(100, 200));
+    layer2->setBounds(gfx::Size(100, 200));
+    calcDrawProps(layer1, layer2);
     layer1->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
-    layer2->setBounds(gfx::Size(100, 200));
     layer2->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
-    updateAndPush(layer1.get(), layer1Impl.get(),
-                  layer2.get(), layer2Impl.get());
+    updateAndPush(layer1, layer1Impl,
+                  layer2, layer2Impl);
 
     // We should have both tiles on the impl side for all layers.
     EXPECT_TRUE(layer1Impl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layer1Impl->hasResourceIdForTileAt(0, 1));
     EXPECT_TRUE(layer2Impl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layer2Impl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, pushTilesLayerMarkedDirtyDuringPaintOnPreviousLayer)
 {
     scoped_refptr<FakeTiledLayer> layer1 = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     scoped_refptr<FakeTiledLayer> layer2 = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layer1Impl(m_hostImpl->activeTree(), 1);
-    ScopedFakeTiledLayerImpl layer2Impl(m_hostImpl->activeTree(), 2);
+    scoped_ptr<FakeTiledLayerImpl> layer1Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
+    scoped_ptr<FakeTiledLayerImpl> layer2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 2));
 
     layer1->fakeLayerUpdater()->setRectToInvalidate(gfx::Rect(0, 50, 100, 50), layer2.get());
     layer1->setBounds(gfx::Size(100, 200));
+    layer2->setBounds(gfx::Size(100, 200));
+    calcDrawProps(layer1, layer2);
     layer1->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
-    layer2->setBounds(gfx::Size(100, 200));
     layer2->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
-    updateAndPush(layer1.get(), layer1Impl.get(),
-                  layer2.get(), layer2Impl.get());
+    updateAndPush(layer1, layer1Impl,
+                  layer2, layer2Impl);
 
     // We should have both tiles on the impl side for all layers.
     EXPECT_TRUE(layer1Impl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layer1Impl->hasResourceIdForTileAt(0, 1));
     EXPECT_TRUE(layer2Impl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layer2Impl->hasResourceIdForTileAt(0, 1));
 }
 
 TEST_F(TiledLayerTest, paintSmallAnimatedLayersImmediately)
 {
@@ skipping 12 matching lines @@
         int memoryForLayer = layerWidth * layerHeight * 4;
         layerTreeHost->setViewportSize(gfx::Size(layerWidth, layerHeight), gfx::Size(layerWidth, layerHeight));
 
         // Use 10x5 tiles to run out of memory.
         if (runOutOfMemory[i])
             layerWidth *= 2;
 
         m_resourceManager->setMaxMemoryLimitBytes(memoryForLayer);
 
         scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-        ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+        scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
 
         // Full size layer with half being visible.
         gfx::Size contentBounds(layerWidth, layerHeight);
         gfx::Rect contentRect(gfx::Point(), contentBounds);
         gfx::Rect visibleRect(gfx::Point(), gfx::Size(layerWidth / 2, layerHeight));
 
         // Pretend the layer is animating.
         layer->drawProperties().target_space_transform_is_animating = true;
         layer->setBounds(contentBounds);
         layer->drawProperties().visible_content_rect = visibleRect;
@@ skipping 21 matching lines @@
                 for (int j = 0; j < 5; ++j)
                     EXPECT_EQ(layerImpl->hasResourceIdForTileAt(i, j), i < 5);
             }
         }
     }
 }
 
 TEST_F(TiledLayerTest, idlePaintOutOfMemory)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
 
     // We have enough memory for only the visible rect, so we will run out of memory in first idle paint.
     int memoryLimit = 4 * 100 * 100; // 1 tiles, 4 bytes per pixel.
     m_resourceManager->setMaxMemoryLimitBytes(memoryLimit);
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     bool needsUpdate = false;
     layer->setBounds(gfx::Size(300, 300));
+    calcDrawProps(layer);
     layer->drawProperties().visible_content_rect = gfx::Rect(100, 100, 100, 100);
     for (int i = 0; i < 2; i++)
-        needsUpdate = updateAndPush(layer.get(), layerImpl.get());
+        needsUpdate = updateAndPush(layer, layerImpl);
 
     // Idle-painting should see no more priority tiles for painting.
     EXPECT_FALSE(needsUpdate);
 
     // We should have one tile on the impl side.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(1, 1));
 }
 
 TEST_F(TiledLayerTest, idlePaintZeroSizedLayer)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
 
     bool animating[2] = {false, true};
     for (int i = 0; i < 2; i++) {
         // Pretend the layer is animating.
         layer->drawProperties().target_space_transform_is_animating = animating[i];
 
         // The layer's bounds are empty.
         // Empty layers don't paint or idle-paint.
         layer->setBounds(gfx::Size());
+        calcDrawProps(layer);
         layer->drawProperties().visible_content_rect = gfx::Rect();
-        bool needsUpdate = updateAndPush(layer.get(), layerImpl.get());
+        bool needsUpdate = updateAndPush(layer, layerImpl);
         
         // Empty layers don't have tiles.
         EXPECT_EQ(0u, layer->numPaintedTiles());
 
         // Empty layers don't need prepaint.
         EXPECT_FALSE(needsUpdate);
 
         // Empty layers don't have tiles.
         EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 0));
     }
 }
 
 TEST_F(TiledLayerTest, idlePaintNonVisibleLayers)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
 
     // Alternate between not visible and visible.
     gfx::Rect v(0, 0, 100, 100);
     gfx::Rect nv(0, 0, 0, 0);
     gfx::Rect visibleRect[10] = {nv, nv, v, v, nv, nv, v, v, nv, nv};
     bool invalidate[10] =  {true, true, true, true, true, true, true, true, false, false };
 
     // We should not have any tiles except for when the layer was visible
     // or after the layer was visible and we didn't invalidate.
     bool haveTile[10] = { false, false, true, true, false, false, true, true, true, true };
     
     for (int i = 0; i < 10; i++) {
         layer->setBounds(gfx::Size(100, 100));
+        calcDrawProps(layer);
         layer->drawProperties().visible_content_rect = visibleRect[i];
 
         if (invalidate[i])
             layer->invalidateContentRect(gfx::Rect(0, 0, 100, 100));
-        bool needsUpdate = updateAndPush(layer.get(), layerImpl.get());
+        bool needsUpdate = updateAndPush(layer, layerImpl);
         
         // We should never signal idle paint, as we painted the entire layer
         // or the layer was not visible.
         EXPECT_FALSE(needsUpdate);
         EXPECT_EQ(layerImpl->hasResourceIdForTileAt(0, 0), haveTile[i]);
     }
 }
 
 TEST_F(TiledLayerTest, invalidateFromPrepare)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->setBounds(gfx::Size(100, 200));
+    calcDrawProps(layer);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
-    updateAndPush(layer.get(), layerImpl.get());
+    updateAndPush(layer, layerImpl);
 
     // We should have both tiles on the impl side.
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
 
     layer->fakeLayerUpdater()->clearPrepareCount();
     // Invoke update again. As the layer is valid update shouldn't be invoked on
     // the LayerUpdater.
-    updateAndPush(layer.get(), layerImpl.get());
+    updateAndPush(layer, layerImpl);
     EXPECT_EQ(0, layer->fakeLayerUpdater()->prepareCount());
 
     // setRectToInvalidate triggers invalidateContentRect() being invoked from update.
     layer->fakeLayerUpdater()->setRectToInvalidate(gfx::Rect(25, 25, 50, 50), layer.get());
     layer->fakeLayerUpdater()->clearPrepareCount();
     layer->invalidateContentRect(gfx::Rect(0, 0, 50, 50));
-    updateAndPush(layer.get(), layerImpl.get());
+    updateAndPush(layer, layerImpl);
     EXPECT_EQ(1, layer->fakeLayerUpdater()->prepareCount());
     layer->fakeLayerUpdater()->clearPrepareCount();
 
     // The layer should still be invalid as update invoked invalidate.
-    updateAndPush(layer.get(), layerImpl.get()); // visible
+    updateAndPush(layer, layerImpl); // visible
     EXPECT_EQ(1, layer->fakeLayerUpdater()->prepareCount());
 }
 
 TEST_F(TiledLayerTest, verifyUpdateRectWhenContentBoundsAreScaled)
 {
     // The updateRect (that indicates what was actually painted) should be in
     // layer space, not the content space.
     scoped_refptr<FakeTiledLayerWithScaledBounds> layer = make_scoped_refptr(new FakeTiledLayerWithScaledBounds(m_resourceManager.get()));
 
     gfx::Rect layerBounds(0, 0, 300, 200);
@@ skipping 26 matching lines @@
     layer->invalidateContentRect(partialDamage);
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), 0, m_stats);
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(45, 80, 15, 8), layer->updateRect());
 }
 
 TEST_F(TiledLayerTest, verifyInvalidationWhenContentsScaleChanges)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
-    ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+    scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
 
     // Create a layer with one tile.
     layer->setBounds(gfx::Size(100, 100));
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
 
     // Invalidate the entire layer.
     layer->setNeedsDisplay();
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 100, 100), layer->lastNeedsDisplayRect());
 
     // Push the tiles to the impl side and check that there is exactly one.
@@ skipping 131 matching lines @@
     layer->drawProperties().visible_content_rect = contentRect;
     layer->invalidateContentRect(contentRect);
 
     m_layerTreeHost->setRootLayer(layer);
     m_layerTreeHost->setViewportSize(gfx::Size(300, 200), gfx::Size(300, 200));
 
     // Full update of all 6 tiles.
     m_layerTreeHost->updateLayers(
         *m_queue.get(), std::numeric_limits<size_t>::max());
     {
-        ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+        scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
         EXPECT_EQ(6, m_queue->fullUploadSize());
         EXPECT_EQ(0, m_queue->partialUploadSize());
         updateTextures();
         EXPECT_EQ(6, layer->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
         layer->fakeLayerUpdater()->clearUpdateCount();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
     m_layerTreeHost->commitComplete();
 
     // Full update of 3 tiles and partial update of 3 tiles.
     layer->invalidateContentRect(gfx::Rect(0, 0, 300, 150));
     m_layerTreeHost->updateLayers(*m_queue.get(), std::numeric_limits<size_t>::max());
     {
-        ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+        scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
         EXPECT_EQ(3, m_queue->fullUploadSize());
         EXPECT_EQ(3, m_queue->partialUploadSize());
         updateTextures();
         EXPECT_EQ(6, layer->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
         layer->fakeLayerUpdater()->clearUpdateCount();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
     m_layerTreeHost->commitComplete();
 
     // Partial update of 6 tiles.
     layer->invalidateContentRect(gfx::Rect(50, 50, 200, 100));
     {
-        ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+        scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
         m_layerTreeHost->updateLayers(*m_queue.get(), std::numeric_limits<size_t>::max());
         EXPECT_EQ(2, m_queue->fullUploadSize());
         EXPECT_EQ(4, m_queue->partialUploadSize());
         updateTextures();
         EXPECT_EQ(6, layer->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
         layer->fakeLayerUpdater()->clearUpdateCount();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
     m_layerTreeHost->commitComplete();
 
     // Checkerboard all tiles.
     layer->invalidateContentRect(gfx::Rect(0, 0, 300, 200));
     {
-        ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+        scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
     m_layerTreeHost->commitComplete();
 
     // Partial update of 6 checkerboard tiles.
     layer->invalidateContentRect(gfx::Rect(50, 50, 200, 100));
     {
-        ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+        scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
         m_layerTreeHost->updateLayers(*m_queue.get(), std::numeric_limits<size_t>::max());
         EXPECT_EQ(6, m_queue->fullUploadSize());
         EXPECT_EQ(0, m_queue->partialUploadSize());
         updateTextures();
         EXPECT_EQ(6, layer->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
         layer->fakeLayerUpdater()->clearUpdateCount();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
     m_layerTreeHost->commitComplete();
 
     // Partial update of 4 tiles.
     layer->invalidateContentRect(gfx::Rect(50, 50, 100, 100));
     {
-        ScopedFakeTiledLayerImpl layerImpl(m_hostImpl->activeTree(), 1);
+        scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), 1));
         m_layerTreeHost->updateLayers(*m_queue.get(), std::numeric_limits<size_t>::max());
         EXPECT_EQ(0, m_queue->fullUploadSize());
         EXPECT_EQ(4, m_queue->partialUploadSize());
         updateTextures();
         EXPECT_EQ(4, layer->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
         layer->fakeLayerUpdater()->clearUpdateCount();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
     }
     m_layerTreeHost->commitComplete();
@@ skipping 15 matching lines @@
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), 0, m_stats);
     EXPECT_EQ(2, layer->fakeLayerUpdater()->updateCount());
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusion)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     TestOcclusionTracker occluded;
+    m_occlusion = &occluded;
 
     // The tile size is 100x100.
 
     layer->setBounds(gfx::Size(600, 600));
+    calcDrawProps(layer);
 
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 100));
     layer->drawProperties().drawable_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
     layer->drawProperties().visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(36-3, layer->fakeLayerUpdater()->updateCount());
@@ skipping 26 matching lines @@
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 330000 + 340000 + 360000, 1);
     EXPECT_EQ(3 + 2, occluded.overdrawMetrics().tilesCulledForUpload());
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndVisiblityConstraints)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     TestOcclusionTracker occluded;
+    m_occlusion = &occluded;
 
     // The tile size is 100x100.
 
     layer->setBounds(gfx::Size(600, 600));
+    calcDrawProps(layer);
 
     // The partially occluded tiles (by the 150 occlusion height) are visible beyond the occlusion, so not culled.
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 150));
     layer->drawProperties().drawable_content_rect = gfx::Rect(0, 0, 600, 360);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 600, 360);
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
@@ skipping 34 matching lines @@
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 210000 + 180000 + 180000, 1);
     EXPECT_EQ(3 + 6 + 6, occluded.overdrawMetrics().tilesCulledForUpload());
 
 }
 
 TEST_F(TiledLayerTest, tilesNotPaintedWithoutInvalidation)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     TestOcclusionTracker occluded;
+    m_occlusion = &occluded;
 
     // The tile size is 100x100.
 
     layer->setBounds(gfx::Size(600, 600));
+    calcDrawProps(layer);
 
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 100));
     layer->drawProperties().drawable_content_rect = gfx::Rect(0, 0, 600, 600);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 600, 600);
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(36-3, layer->fakeLayerUpdater()->updateCount());
     {
@@ skipping 14 matching lines @@
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 330000, 1);
     EXPECT_EQ(6, occluded.overdrawMetrics().tilesCulledForUpload());
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndTransforms)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     TestOcclusionTracker occluded;
+    m_occlusion = &occluded;
 
     // The tile size is 100x100.
 
     // This makes sure the painting works when the occluded region (in screen space)
     // is transformed differently than the layer.
     layer->setBounds(gfx::Size(600, 600));
+    calcDrawProps(layer);
     gfx::Transform screenTransform;
     screenTransform.Scale(0.5, 0.5);
     layer->drawProperties().screen_space_transform = screenTransform;
     layer->drawProperties().target_space_transform = screenTransform;
 
     occluded.setOcclusion(gfx::Rect(100, 100, 150, 50));
     layer->drawProperties().drawable_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
     layer->drawProperties().visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     EXPECT_EQ(36-3, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 330000, 1);
     EXPECT_EQ(3, occluded.overdrawMetrics().tilesCulledForUpload());
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndScaling)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
     TestOcclusionTracker occluded;
+    m_occlusion = &occluded;
 
     // The tile size is 100x100.
 
     // This makes sure the painting works when the content space is scaled to
     // a different layer space. In this case tiles are scaled to be 200x200
     // pixels, which means none should be occluded.
+    layer->setBounds(gfx::Size(600, 600));
+    calcDrawProps(layer);
     layer->setContentsScale(0.5);
     EXPECT_FLOAT_EQ(layer->contentsScaleX(), layer->contentsScaleY());
-    layer->setBounds(gfx::Size(600, 600));
     gfx::Transform drawTransform;
     double invScaleFactor = 1 / layer->contentsScaleX();
     drawTransform.Scale(invScaleFactor, invScaleFactor);
     layer->drawProperties().target_space_transform = drawTransform;

[enne (OOO), 2012/12/16 19:44:25]

If you're calling calcDrawProperties, can all this manual setting of draw
properties get removed?

[danakj, 2012/12/16 20:16:52]

Yes, but then it needs to move to other properties. This might require a bit
more thought. I don't mind the "set draw props then override the ones i care
about testing" pattern here. It can be more clear than setting up elaborate
layer scenes just to get the right output from calcDrawProps, and requires
internal knowledge about how to generate a draw transform in calcDrawProps,
which maybe is not useful and breaks the encapsulation a bit, since this is not
testing calcDraw? (not that it would be elaborate here, just thinking about the
pattern)

[enne (OOO), 2012/12/16 20:53:17]

Yeah, I think it breaks the encapsulation a little bit.  I'm willing to punt,
but it seems like it'd be cleaner if drawable properties were only set by
calcDrawProperties.  I think if you're ever in a case where "calling
calcDrawProperties will break this carefully constructed scene" then maybe
you're doing something wrong and fragile.  I'm willing to punt on changing it in
this patch, though.

     layer->drawProperties().screen_space_transform = drawTransform;
 
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 100));
     layer->drawProperties().drawable_content_rect = gfx::Rect(gfx::Point(), layer->bounds());
     layer->drawProperties().visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->update(*m_queue.get(), &occluded, m_stats);
     // The content is half the size of the layer (so the number of tiles is fewer).
@@ skipping 236 matching lines @@
         updateTextures();
         EXPECT_EQ(6, root->fakeLayerUpdater()->updateCount());
         EXPECT_EQ(3, child->fakeLayerUpdater()->updateCount());
         EXPECT_EQ(3, child2->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
 
         root->fakeLayerUpdater()->clearUpdateCount();
         child->fakeLayerUpdater()->clearUpdateCount();
         child2->fakeLayerUpdater()->clearUpdateCount();
 
-        ScopedFakeTiledLayerImpl rootImpl(m_hostImpl->activeTree(), root->id());
-        ScopedFakeTiledLayerImpl childImpl(m_hostImpl->activeTree(), child->id());
-        ScopedFakeTiledLayerImpl child2Impl(m_hostImpl->activeTree(), child2->id());
+        scoped_ptr<FakeTiledLayerImpl> rootImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), root->id()));
+        scoped_ptr<FakeTiledLayerImpl> childImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), child->id()));
+        scoped_ptr<FakeTiledLayerImpl> child2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), child2->id()));
         layerPushPropertiesTo(root.get(), rootImpl.get());
         layerPushPropertiesTo(child.get(), childImpl.get());
         layerPushPropertiesTo(child2.get(), child2Impl.get());
 
         for (unsigned i = 0; i < 3; ++i) {
             for (unsigned j = 0; j < 2; ++j)
                 EXPECT_TRUE(rootImpl->hasResourceIdForTileAt(i, j));
             EXPECT_TRUE(childImpl->hasResourceIdForTileAt(i, 0));
             EXPECT_TRUE(child2Impl->hasResourceIdForTileAt(i, 0));
         }
@@ skipping 12 matching lines @@
         updateTextures();
         EXPECT_EQ(6, root->fakeLayerUpdater()->updateCount());
         EXPECT_EQ(0, child->fakeLayerUpdater()->updateCount());
         EXPECT_EQ(0, child2->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
 
         root->fakeLayerUpdater()->clearUpdateCount();
         child->fakeLayerUpdater()->clearUpdateCount();
         child2->fakeLayerUpdater()->clearUpdateCount();
 
-        ScopedFakeTiledLayerImpl rootImpl(m_hostImpl->activeTree(), root->id());
-        ScopedFakeTiledLayerImpl childImpl(m_hostImpl->activeTree(), child->id());
-        ScopedFakeTiledLayerImpl child2Impl(m_hostImpl->activeTree(), child2->id());
+        scoped_ptr<FakeTiledLayerImpl> rootImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), root->id()));
+        scoped_ptr<FakeTiledLayerImpl> childImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), child->id()));
+        scoped_ptr<FakeTiledLayerImpl> child2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), child2->id()));
         layerPushPropertiesTo(root.get(), rootImpl.get());
         layerPushPropertiesTo(child.get(), childImpl.get());
         layerPushPropertiesTo(child2.get(), child2Impl.get());
 
         for (unsigned i = 0; i < 3; ++i) {
             for (unsigned j = 0; j < 2; ++j)
                 EXPECT_TRUE(rootImpl->hasResourceIdForTileAt(i, j));
             EXPECT_FALSE(childImpl->hasResourceIdForTileAt(i, 0));
             EXPECT_FALSE(child2Impl->hasResourceIdForTileAt(i, 0));
         }
@@ skipping 13 matching lines @@
         updateTextures();
         EXPECT_EQ(0, root->fakeLayerUpdater()->updateCount());
         EXPECT_EQ(0, child->fakeLayerUpdater()->updateCount());
         EXPECT_EQ(0, child2->fakeLayerUpdater()->updateCount());
         EXPECT_FALSE(m_queue->hasMoreUpdates());
 
         root->fakeLayerUpdater()->clearUpdateCount();
         child->fakeLayerUpdater()->clearUpdateCount();
         child2->fakeLayerUpdater()->clearUpdateCount();
 
-        ScopedFakeTiledLayerImpl rootImpl(m_hostImpl->activeTree(), root->id());
-        ScopedFakeTiledLayerImpl childImpl(m_hostImpl->activeTree(), child->id());
-        ScopedFakeTiledLayerImpl child2Impl(m_hostImpl->activeTree(), child2->id());
+        scoped_ptr<FakeTiledLayerImpl> rootImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), root->id()));
+        scoped_ptr<FakeTiledLayerImpl> childImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), child->id()));
+        scoped_ptr<FakeTiledLayerImpl> child2Impl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->activeTree(), child2->id()));
         layerPushPropertiesTo(root.get(), rootImpl.get());
         layerPushPropertiesTo(child.get(), childImpl.get());
         layerPushPropertiesTo(child2.get(), child2Impl.get());
 
         for (unsigned i = 0; i < 3; ++i) {
             for (unsigned j = 0; j < 2; ++j)
                 EXPECT_FALSE(rootImpl->hasResourceIdForTileAt(i, j));
             EXPECT_FALSE(childImpl->hasResourceIdForTileAt(i, 0));
             EXPECT_FALSE(child2Impl->hasResourceIdForTileAt(i, 0));
         }
@@ skipping 100 matching lines @@
 
     // Invalidate the entire layer in layer space. When painting, the rect given to webkit should match the layer's bounds.
     layer->setNeedsDisplayRect(layerRect);
     layer->update(*m_queue.get(), 0, m_stats);
 
     EXPECT_RECT_EQ(layerRect, layer->trackingLayerPainter()->paintedRect());
 }
 
 }  // namespace
 }  // namespace cc