cc: Avoid expensive RenderingStats collection.

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/prioritized_resource_manager.h"
-#include "cc/rendering_stats.h"
 #include "cc/resource_update_controller.h"
 #include "cc/single_thread_proxy.h" // For DebugScopedSetImplThread
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_proxy.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/tiled_layer_test_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 78 matching lines @@
         m_queue = make_scoped_ptr(new ResourceUpdateQueue);
     }
     void layerPushPropertiesTo(FakeTiledLayer* layer, FakeTiledLayerImpl* layerImpl)
     {
         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);
+        layer->update(*m_queue.get(), occluded, NULL);
     }
 
     void calcDrawProps(const scoped_refptr<FakeTiledLayer>& layer1)
     {
         scoped_refptr<FakeTiledLayer> layer2;
         calcDrawProps(layer1, layer2);
     }
 
     void calcDrawProps(const scoped_refptr<FakeTiledLayer>& layer1,
                        const scoped_refptr<FakeTiledLayer>& layer2)
@@ skipping 32 matching lines @@
         // Get textures
         m_resourceManager->clearPriorities();
         if (layer1)
             layer1->setTexturePriorities(m_priorityCalculator);
         if (layer2)
             layer2->setTexturePriorities(m_priorityCalculator);
         m_resourceManager->prioritizeTextures();
 
         // Update content
         if (layer1)
-            layer1->update(*m_queue.get(), m_occlusion, m_stats);
+            layer1->update(*m_queue.get(), m_occlusion, NULL);
         if (layer2)
-            layer2->update(*m_queue.get(), m_occlusion, m_stats);
+            layer2->update(*m_queue.get(), m_occlusion, NULL);
 
         bool needsUpdate = false;
         if (layer1)
             needsUpdate |= layer1->needsIdlePaint();
         if (layer2)
             needsUpdate |= layer2->needsIdlePaint();
 
         // Update textures and push.
         updateTextures();
         if (layer1)
             layerPushPropertiesTo(layer1.get(), layerImpl1.get());
         if (layer2)
             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)
 {
@@ skipping 376 matching lines @@
         layer->drawProperties().target_space_transform_is_animating = true;
         layer->setBounds(contentBounds);
         layer->drawProperties().visible_content_rect = visibleRect;
         layer->invalidateContentRect(contentRect);
         layer->setLayerTreeHost(layerTreeHost.get());
 
         // The layer should paint it's entire contents on the first paint
         // if it is close to the viewport size and has the available memory.
         layer->setTexturePriorities(m_priorityCalculator);
         m_resourceManager->prioritizeTextures();
-        layer->update(*m_queue.get(), 0, m_stats);
+        layer->update(*m_queue.get(), 0, NULL);
         updateTextures();
         layerPushPropertiesTo(layer.get(), layerImpl.get());
 
         // We should have all the tiles for the small animated layer.
         // We should still have the visible tiles when we didn't
         // have enough memory for all the tiles.
         if (!runOutOfMemory[i]) {
             for (int i = 0; i < 5; ++i) {
                 for (int j = 0; j < 5; ++j)
                     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(i, j));
@@ skipping 136 matching lines @@
     layer->setBounds(layerBounds.size());
     layer->setContentBounds(contentBounds.size());
     layer->drawProperties().visible_content_rect = contentBounds;
 
     // On first update, the updateRect includes all tiles, even beyond the boundaries of the layer.
     // However, it should still be in layer space, not content space.
     layer->invalidateContentRect(contentBounds);
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
-    layer->update(*m_queue.get(), 0, m_stats);
+    layer->update(*m_queue.get(), 0, NULL);
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 300, 300 * 0.8), layer->updateRect());
     updateTextures();
 
     // After the tiles are updated once, another invalidate only needs to update the bounds of the layer.
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
     layer->invalidateContentRect(contentBounds);
-    layer->update(*m_queue.get(), 0, m_stats);
+    layer->update(*m_queue.get(), 0, NULL);
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(layerBounds), layer->updateRect());
     updateTextures();
 
     // Partial re-paint should also be represented by the updateRect in layer space, not content space.
     gfx::Rect partialDamage(30, 100, 10, 10);
     layer->invalidateContentRect(partialDamage);
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
-    layer->update(*m_queue.get(), 0, m_stats);
+    layer->update(*m_queue.get(), 0, NULL);
     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()));
     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.
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
-    layer->update(*m_queue.get(), 0, m_stats);
+    layer->update(*m_queue.get(), 0, NULL);
     updateTextures();
     layerPushPropertiesTo(layer.get(), layerImpl.get());
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(0, 1));
     EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(1, 0));
     EXPECT_FALSE(layerImpl->hasResourceIdForTileAt(1, 1));
 
     layer->setNeedsDisplayRect(gfx::Rect());
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(), layer->lastNeedsDisplayRect());
 
     // Change the contents scale.
     layer->updateContentsScale(2);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 200, 200);
 
     // The impl side should get 2x2 tiles now.
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
-    layer->update(*m_queue.get(), 0, m_stats);
+    layer->update(*m_queue.get(), 0, NULL);
     updateTextures();
     layerPushPropertiesTo(layer.get(), layerImpl.get());
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(0, 1));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(1, 0));
     EXPECT_TRUE(layerImpl->hasResourceIdForTileAt(1, 1));
 
     // Verify that changing the contents scale caused invalidation, and
     // that the layer-space rectangle requiring painting is not scaled.
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 100, 100), layer->lastNeedsDisplayRect());
@@ skipping 57 matching lines @@
 TEST_F(TiledLayerTest, resizeToSmaller)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
 
     layer->setBounds(gfx::Size(700, 700));
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 700, 700);
     layer->invalidateContentRect(gfx::Rect(0, 0, 700, 700));
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
-    layer->update(*m_queue.get(), 0, m_stats);
+    layer->update(*m_queue.get(), 0, NULL);
 
     layer->setBounds(gfx::Size(200, 200));
     layer->invalidateContentRect(gfx::Rect(0, 0, 200, 200));
 }
 
 TEST_F(TiledLayerTest, hugeLayerUpdateCrash)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
 
     int size = 1 << 30;
     layer->setBounds(gfx::Size(size, size));
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 700, 700);
     layer->invalidateContentRect(gfx::Rect(0, 0, size, size));
 
     // Ensure no crash for bounds where size * size would overflow an int.
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
-    layer->update(*m_queue.get(), 0, m_stats);
+    layer->update(*m_queue.get(), 0, NULL);
 }
 
 class TiledLayerPartialUpdateTest : public TiledLayerTest {
 public:
     TiledLayerPartialUpdateTest()
     {
         m_settings.maxPartialTextureUpdates = 4;
     }
 };
 
@@ skipping 104 matching lines @@
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->setBounds(gfx::Size(100, 200));
     layer->drawProperties().drawable_content_rect = gfx::Rect(0, 0, 100, 200);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 100, 200);
     layer->invalidateContentRect(gfx::Rect(0, 0, 100, 200));
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
-    layer->update(*m_queue.get(), 0, m_stats);
+    layer->update(*m_queue.get(), 0, NULL);
     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.
 
     m_layerTreeHost->setViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
     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);
+    layer->update(*m_queue.get(), &occluded, NULL);
     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());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
 
     occluded.setOcclusion(gfx::Rect(250, 200, 300, 100));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
-    layer->update(*m_queue.get(), &occluded, m_stats);
+    layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(36-2, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 330000 + 340000, 1);
     EXPECT_EQ(3 + 2, occluded.overdrawMetrics().tilesCulledForUpload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
 
     occluded.setOcclusion(gfx::Rect(250, 250, 300, 100));
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
-    layer->update(*m_queue.get(), &occluded, m_stats);
+    layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(36, layer->fakeLayerUpdater()->updateCount());
 
     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.
 
     m_layerTreeHost->setViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
     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);
+    layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(24-3, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 210000, 1);
     EXPECT_EQ(3, occluded.overdrawMetrics().tilesCulledForUpload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
 
     // Now the visible region stops at the edge of the occlusion so the partly visible tiles become fully occluded.
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 150));
     layer->drawProperties().drawable_content_rect = gfx::Rect(0, 0, 600, 350);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 600, 350);
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
-    layer->update(*m_queue.get(), &occluded, m_stats);
+    layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(24-6, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 210000 + 180000, 1);
     EXPECT_EQ(3 + 6, occluded.overdrawMetrics().tilesCulledForUpload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
 
     // Now the visible region is even smaller than the occlusion, it should have the same result.
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 150));
     layer->drawProperties().drawable_content_rect = gfx::Rect(0, 0, 600, 340);
     layer->drawProperties().visible_content_rect = gfx::Rect(0, 0, 600, 340);
     layer->invalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
-    layer->update(*m_queue.get(), &occluded, m_stats);
+    layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(24-6, layer->fakeLayerUpdater()->updateCount());
 
     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.
 
     m_layerTreeHost->setViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
     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);
+    layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(36-3, layer->fakeLayerUpdater()->updateCount());
     {
         updateTextures();
     }
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 330000, 1);
     EXPECT_EQ(3, occluded.overdrawMetrics().tilesCulledForUpload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
 
     // Repaint without marking it dirty. The 3 culled tiles will be pre-painted now.
-    layer->update(*m_queue.get(), &occluded, m_stats);
+    layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(3, layer->fakeLayerUpdater()->updateCount());
 
     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()));
@@ skipping 11 matching lines @@
     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);
+    layer->update(*m_queue.get(), &occluded, NULL);
     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()));
@@ skipping 15 matching lines @@
     drawTransform.Scale(invScaleFactor, invScaleFactor);
     layer->drawProperties().target_space_transform = drawTransform;
     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);
+    layer->update(*m_queue.get(), &occluded, NULL);
     // The content is half the size of the layer (so the number of tiles is fewer).
     // In this case, the content is 300x300, and since the tile size is 100, the
     // number of tiles 3x3.
     EXPECT_EQ(9, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 90000, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
 
     // This makes sure the painting works when the content space is scaled to
     // a different layer space. In this case the occluded region catches the
     // blown up tiles.
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 200));
     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);
+    layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(9-1, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 90000 + 80000, 1);
     EXPECT_EQ(1, occluded.overdrawMetrics().tilesCulledForUpload());
 
     layer->fakeLayerUpdater()->clearUpdateCount();
 
     // This makes sure content scaling and transforms work together.
     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, 100));
 
     gfx::Rect layerBoundsRect(gfx::Point(), layer->bounds());
     layer->drawProperties().drawable_content_rect = gfx::ToEnclosingRect(gfx::ScaleRect(layerBoundsRect, 0.5));
     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);
+    layer->update(*m_queue.get(), &occluded, NULL);
     EXPECT_EQ(9-1, layer->fakeLayerUpdater()->updateCount());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 90000 + 80000 + 80000, 1);
     EXPECT_EQ(1 + 1, occluded.overdrawMetrics().tilesCulledForUpload());
 }
 
 TEST_F(TiledLayerTest, visibleContentOpaqueRegion)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(m_resourceManager.get()));
@@ skipping 11 matching lines @@
     layer->drawProperties().drawable_content_rect = visibleBounds;
     layer->drawProperties().visible_content_rect = visibleBounds;
     layer->drawProperties().opacity = 1;
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
 
     // If the layer doesn't paint opaque content, then the visibleContentOpaqueRegion should be empty.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(contentBounds);
-    layer->update(*m_queue.get(), &occluded, m_stats);
+    layer->update(*m_queue.get(), &occluded, NULL);
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_TRUE(opaqueContents.IsEmpty());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsPainted(), 20000, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 20000, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // visibleContentOpaqueRegion should match the visible part of what is painted opaque.
     opaquePaintRect = gfx::Rect(10, 10, 90, 190);
     layer->fakeLayerUpdater()->setOpaquePaintRect(opaquePaintRect);
     layer->invalidateContentRect(contentBounds);
-    layer->update(*m_queue.get(), &occluded, m_stats);
+    layer->update(*m_queue.get(), &occluded, NULL);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_EQ(gfx::IntersectRects(opaquePaintRect, visibleBounds).ToString(), opaqueContents.ToString());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsPainted(), 20000 * 2, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 17100, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 20000 + 20000 - 17100, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // If we paint again without invalidating, the same stuff should be opaque.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
-    layer->update(*m_queue.get(), &occluded, m_stats);
+    layer->update(*m_queue.get(), &occluded, NULL);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_EQ(gfx::IntersectRects(opaquePaintRect, visibleBounds).ToString(), opaqueContents.ToString());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsPainted(), 20000 * 2, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 17100, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 20000 + 20000 - 17100, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // If we repaint a non-opaque part of the tile, then it shouldn't lose its opaque-ness. And other tiles should
     // not be affected.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(gfx::Rect(0, 0, 1, 1));
-    layer->update(*m_queue.get(), &occluded, m_stats);
+    layer->update(*m_queue.get(), &occluded, NULL);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_EQ(gfx::IntersectRects(opaquePaintRect, visibleBounds).ToString(), opaqueContents.ToString());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsPainted(), 20000 * 2 + 1, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 17100, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 20000 + 20000 - 17100 + 1, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // If we repaint an opaque part of the tile, then it should lose its opaque-ness. But other tiles should still
     // not be affected.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(gfx::Rect(10, 10, 1, 1));
-    layer->update(*m_queue.get(), &occluded, m_stats);
+    layer->update(*m_queue.get(), &occluded, NULL);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_EQ(gfx::IntersectRects(gfx::Rect(10, 100, 90, 100), visibleBounds).ToString(), opaqueContents.ToString());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsPainted(), 20000 * 2 + 1  + 1, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 17100, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 20000 + 20000 - 17100 + 1 + 1, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 }
 
@@ skipping 14 matching lines @@
     layer->drawProperties().drawable_content_rect = visibleBounds;
     layer->drawProperties().visible_content_rect = visibleBounds;
     layer->drawProperties().opacity = 1;
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
 
     // Invalidates and paints the whole layer.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(contentBounds);
-    layer->update(*m_queue.get(), &occluded, m_stats);
+    layer->update(*m_queue.get(), &occluded, NULL);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_TRUE(opaqueContents.IsEmpty());
 
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsPainted(), 30000, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 30000, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
 
     // Invalidates an area on the top and bottom tile, which will cause us to paint the tile in the middle,
     // even though it is not dirty and will not be uploaded.
     layer->fakeLayerUpdater()->setOpaquePaintRect(gfx::Rect());
     layer->invalidateContentRect(gfx::Rect(0, 0, 1, 1));
     layer->invalidateContentRect(gfx::Rect(50, 200, 10, 10));
-    layer->update(*m_queue.get(), &occluded, m_stats);
+    layer->update(*m_queue.get(), &occluded, NULL);
     updateTextures();
     opaqueContents = layer->visibleContentOpaqueRegion();
     EXPECT_TRUE(opaqueContents.IsEmpty());
 
     // The middle tile was painted even though not invalidated.
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsPainted(), 30000 + 60 * 210, 1);
     // The pixels uploaded will not include the non-invalidated tile in the middle.
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedOpaque(), 0, 1);
     EXPECT_NEAR(occluded.overdrawMetrics().pixelsUploadedTranslucent(), 30000 + 1 + 100, 1);
     EXPECT_EQ(0, occluded.overdrawMetrics().tilesCulledForUpload());
@@ skipping 197 matching lines @@
 
     gfx::Rect contentRect(0, 0, 45, 47);
     EXPECT_EQ(contentRect.size(), layer->contentBounds());
     layer->drawProperties().visible_content_rect = contentRect;
     layer->drawProperties().drawable_content_rect = contentRect;
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
 
     // Update the whole tile.
-    layer->update(*m_queue.get(), 0, m_stats);
+    layer->update(*m_queue.get(), 0, NULL);
     layer->trackingLayerPainter()->resetPaintedRect();
 
     EXPECT_RECT_EQ(gfx::Rect(), layer->trackingLayerPainter()->paintedRect());
     updateTextures();
 
     // Invalidate the entire layer in content space. When painting, the rect given to webkit should match the layer's bounds.
     layer->invalidateContentRect(contentRect);
-    layer->update(*m_queue.get(), 0, m_stats);
+    layer->update(*m_queue.get(), 0, NULL);
 
     EXPECT_RECT_EQ(layerRect, layer->trackingLayerPainter()->paintedRect());
 }
 
 TEST_F(TiledLayerTest, nonIntegerContentsScaleIsNotDistortedDuringInvalidation)
 {
     scoped_refptr<UpdateTrackingTiledLayer> layer = make_scoped_refptr(new UpdateTrackingTiledLayer(m_resourceManager.get()));
 
     gfx::Rect layerRect(0, 0, 30, 31);
     layer->setPosition(layerRect.origin());
     layer->setBounds(layerRect.size());
     layer->updateContentsScale(1.3f);
 
     gfx::Rect contentRect(gfx::Point(), layer->contentBounds());
     layer->drawProperties().visible_content_rect = contentRect;
     layer->drawProperties().drawable_content_rect = contentRect;
 
     layer->setTexturePriorities(m_priorityCalculator);
     m_resourceManager->prioritizeTextures();
 
     // Update the whole tile.
-    layer->update(*m_queue.get(), 0, m_stats);
+    layer->update(*m_queue.get(), 0, NULL);
     layer->trackingLayerPainter()->resetPaintedRect();
 
     EXPECT_RECT_EQ(gfx::Rect(), layer->trackingLayerPainter()->paintedRect());
     updateTextures();
 
     // 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);
+    layer->update(*m_queue.get(), 0, NULL);
 
     EXPECT_RECT_EQ(layerRect, layer->trackingLayerPainter()->paintedRect());
 }
 
 }  // namespace
 }  // namespace cc