cc: Switch RenderingStats collection in Layer::Update() to RenderingStatsInstrumentation

cc/layers/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/layers/tiled_layer.h"
 
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/resources/bitmap_content_layer_updater.h"
 #include "cc/resources/layer_painter.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/resource_update_controller.h"
 #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/fake_rendering_stats_instrumentation.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/tiled_layer_test_common.h"
 #include "cc/trees/single_thread_proxy.h" // For DebugScopedSetImplThread
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 namespace {
 
@@ skipping 73 matching lines @@
         m_queue = make_scoped_ptr(new ResourceUpdateQueue);
     }
     void layerPushPropertiesTo(FakeTiledLayer* layer, FakeTiledLayerImpl* layerImpl)
     {
         DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked(proxy_);
         layer->PushPropertiesTo(layerImpl);
     }
     void layerUpdate(FakeTiledLayer* layer, TestOcclusionTracker* occluded)
     {
         DebugScopedSetMainThread mainThread(proxy_);
-        layer->Update(m_queue.get(), occluded, NULL);
+        layer->Update(m_queue.get(), occluded);
     }
 
     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
         resource_manager_->ClearPriorities();
         if (layer1)
             layer1->SetTexturePriorities(m_priorityCalculator);
         if (layer2)
             layer2->SetTexturePriorities(m_priorityCalculator);
         resource_manager_->PrioritizeTextures();
 
         // Update content
         if (layer1)
-            layer1->Update(m_queue.get(), m_occlusion, NULL);
+            layer1->Update(m_queue.get(), m_occlusion);
         if (layer2)
-            layer2->Update(m_queue.get(), m_occlusion, NULL);
+            layer2->Update(m_queue.get(), m_occlusion);
 
         bool needsUpdate = false;
         if (layer1)
             needsUpdate |= layer1->NeedsIdlePaint();
         if (layer2)
             needsUpdate |= layer2->NeedsIdlePaint();
 
         // Update textures and push.
         updateTextures();
         if (layer1)
@@ skipping 391 matching lines @@
 
         // Pretend the layer is animating.
         layer->draw_properties().target_space_transform_is_animating = true;
         layer->draw_properties().visible_content_rect = visibleRect;
         layer->SetLayerTreeHost(layer_tree_host_.get());
 
         // The layer should paint its entire contents on the first paint
         // if it is close to the viewport size and has the available memory.
         layer->SetTexturePriorities(m_priorityCalculator);
         resource_manager_->PrioritizeTextures();
-        layer->Update(m_queue.get(), 0, NULL);
+        layer->Update(m_queue.get(), 0);
         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->draw_properties().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);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), 0, NULL);
+    layer->Update(m_queue.get(), 0);
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 300, 300 * 0.8), layer->update_rect());
     updateTextures();
 
     // After the tiles are updated once, another invalidate only needs to update the bounds of the layer.
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
     layer->InvalidateContentRect(contentBounds);
-    layer->Update(m_queue.get(), 0, NULL);
+    layer->Update(m_queue.get(), 0);
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(layerBounds), layer->update_rect());
     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);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), 0, NULL);
+    layer->Update(m_queue.get(), 0);
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(45, 80, 15, 8), layer->update_rect());
 }
 
 TEST_F(TiledLayerTest, verifyInvalidationWhenContentsScaleChanges)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
     scoped_ptr<FakeTiledLayerImpl> layerImpl = make_scoped_ptr(new FakeTiledLayerImpl(m_hostImpl->active_tree(), 1));
 
     // Create a layer with one tile.
     layer->SetBounds(gfx::Size(100, 100));
     calcDrawProps(layer);
     layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 100, 100), layer->last_needs_display_rect());
 
     // Push the tiles to the impl side and check that there is exactly one.
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), 0, NULL);
+    layer->Update(m_queue.get(), 0);
     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->last_needs_display_rect());
 
     // Change the contents scale.
     layer->UpdateContentsScale(2);
     layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 200, 200);
 
     // The impl side should get 2x2 tiles now.
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), 0, NULL);
+    layer->Update(m_queue.get(), 0);
     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->last_needs_display_rect());
@@ skipping 57 matching lines @@
 TEST_F(TiledLayerTest, resizeToSmaller)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
 
     layer->SetBounds(gfx::Size(700, 700));
     layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 700, 700);
     layer->InvalidateContentRect(gfx::Rect(0, 0, 700, 700));
 
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), 0, NULL);
+    layer->Update(m_queue.get(), 0);
 
     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(resource_manager_.get()));
 
     int size = 1 << 30;
     layer->SetBounds(gfx::Size(size, size));
     layer->draw_properties().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);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), 0, NULL);
+    layer->Update(m_queue.get(), 0);
 }
 
 class TiledLayerPartialUpdateTest : public TiledLayerTest {
 public:
     TiledLayerPartialUpdateTest()
     {
         m_settings.max_partial_texture_updates = 4;
     }
 };
 
@@ skipping 102 matching lines @@
 TEST_F(TiledLayerTest, tilesPaintedWithoutOcclusion)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->SetBounds(gfx::Size(100, 200));
     calcDrawProps(layer);
 
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), 0, NULL);
+    layer->Update(m_queue.get(), 0);
     EXPECT_EQ(2, layer->fake_layer_updater()->update_count());
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusion)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
 
     // The tile size is 100x100.
 
     layer_tree_host_->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->draw_properties().drawable_content_rect = gfx::Rect(gfx::Point(), layer->content_bounds());
     layer->draw_properties().visible_content_rect = gfx::Rect(gfx::Point(), layer->content_bounds());
     layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
 
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     EXPECT_EQ(36-3, layer->fake_layer_updater()->update_count());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 330000, 1);
     EXPECT_EQ(3, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
     layer->fake_layer_updater()->ClearUpdateCount();
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
 
     occluded.setOcclusion(gfx::Rect(250, 200, 300, 100));
     layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     EXPECT_EQ(36-2, layer->fake_layer_updater()->update_count());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 330000 + 340000, 1);
     EXPECT_EQ(3 + 2, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
     layer->fake_layer_updater()->ClearUpdateCount();
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
 
     occluded.setOcclusion(gfx::Rect(250, 250, 300, 100));
     layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     EXPECT_EQ(36, layer->fake_layer_updater()->update_count());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 330000 + 340000 + 360000, 1);
     EXPECT_EQ(3 + 2, occluded.overdraw_metrics()->tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndVisiblityConstraints)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
 
     // The tile size is 100x100.
 
     layer_tree_host_->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->draw_properties().drawable_content_rect = gfx::Rect(0, 0, 600, 360);
     layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 600, 360);
     layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
 
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     EXPECT_EQ(24-3, layer->fake_layer_updater()->update_count());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 210000, 1);
     EXPECT_EQ(3, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
     layer->fake_layer_updater()->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->draw_properties().drawable_content_rect = gfx::Rect(0, 0, 600, 350);
     layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 600, 350);
     layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     EXPECT_EQ(24-6, layer->fake_layer_updater()->update_count());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 210000 + 180000, 1);
     EXPECT_EQ(3 + 6, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
     layer->fake_layer_updater()->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->draw_properties().drawable_content_rect = gfx::Rect(0, 0, 600, 340);
     layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 600, 340);
     layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     EXPECT_EQ(24-6, layer->fake_layer_updater()->update_count());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 210000 + 180000 + 180000, 1);
     EXPECT_EQ(3 + 6 + 6, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
 }
 
 TEST_F(TiledLayerTest, tilesNotPaintedWithoutInvalidation)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
     TestOcclusionTracker occluded;
     m_occlusion = &occluded;
 
     // The tile size is 100x100.
 
     layer_tree_host_->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->draw_properties().drawable_content_rect = gfx::Rect(0, 0, 600, 600);
     layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 600, 600);
     layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     EXPECT_EQ(36-3, layer->fake_layer_updater()->update_count());
     {
         updateTextures();
     }
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 330000, 1);
     EXPECT_EQ(3, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
     layer->fake_layer_updater()->ClearUpdateCount();
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
 
     // Repaint without marking it dirty. The 3 culled tiles will be pre-painted now.
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     EXPECT_EQ(3, layer->fake_layer_updater()->update_count());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 330000, 1);
     EXPECT_EQ(6, occluded.overdraw_metrics()->tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndTransforms)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
@@ skipping 11 matching lines @@
     screenTransform.Scale(0.5, 0.5);
     layer->draw_properties().screen_space_transform = screenTransform;
     layer->draw_properties().target_space_transform = screenTransform;
 
     occluded.setOcclusion(gfx::Rect(100, 100, 150, 50));
     layer->draw_properties().drawable_content_rect = gfx::Rect(gfx::Point(), layer->content_bounds());
     layer->draw_properties().visible_content_rect = gfx::Rect(gfx::Point(), layer->content_bounds());
     layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     EXPECT_EQ(36-3, layer->fake_layer_updater()->update_count());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 330000, 1);
     EXPECT_EQ(3, occluded.overdraw_metrics()->tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, tilesPaintedWithOcclusionAndScaling)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
@@ skipping 15 matching lines @@
     drawTransform.Scale(invScaleFactor, invScaleFactor);
     layer->draw_properties().target_space_transform = drawTransform;
     layer->draw_properties().screen_space_transform = drawTransform;
 
     occluded.setOcclusion(gfx::Rect(200, 200, 300, 100));
     layer->draw_properties().drawable_content_rect = gfx::Rect(gfx::Point(), layer->bounds());
     layer->draw_properties().visible_content_rect = gfx::Rect(gfx::Point(), layer->content_bounds());
     layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     // 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->fake_layer_updater()->update_count());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 90000, 1);
     EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
     layer->fake_layer_updater()->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->draw_properties().drawable_content_rect = gfx::Rect(gfx::Point(), layer->bounds());
     layer->draw_properties().visible_content_rect = gfx::Rect(gfx::Point(), layer->content_bounds());
     layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     EXPECT_EQ(9-1, layer->fake_layer_updater()->update_count());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 90000 + 80000, 1);
     EXPECT_EQ(1, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
     layer->fake_layer_updater()->ClearUpdateCount();
 
     // This makes sure content scaling and transforms work together.
     gfx::Transform screenTransform;
     screenTransform.Scale(0.5, 0.5);
     layer->draw_properties().screen_space_transform = screenTransform;
     layer->draw_properties().target_space_transform = screenTransform;
 
     occluded.setOcclusion(gfx::Rect(100, 100, 150, 100));
 
     gfx::Rect layerBoundsRect(gfx::Point(), layer->bounds());
     layer->draw_properties().drawable_content_rect = gfx::ToEnclosingRect(gfx::ScaleRect(layerBoundsRect, 0.5));
     layer->draw_properties().visible_content_rect = gfx::Rect(gfx::Point(), layer->content_bounds());
     layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     EXPECT_EQ(9-1, layer->fake_layer_updater()->update_count());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 90000 + 80000 + 80000, 1);
     EXPECT_EQ(1 + 1, occluded.overdraw_metrics()->tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, visibleContentOpaqueRegion)
 {
     scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
@@ skipping 12 matching lines @@
     layer->SetBounds(contentBounds.size());
     calcDrawProps(layer);
     layer->draw_properties().drawable_content_rect = visibleBounds;
     layer->draw_properties().visible_content_rect = visibleBounds;
 
     // If the layer doesn't paint opaque content, then the visibleContentOpaqueRegion should be empty.
     layer->fake_layer_updater()->SetOpaquePaintRect(gfx::Rect());
     layer->InvalidateContentRect(contentBounds);
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     opaqueContents = layer->VisibleContentOpaqueRegion();
     EXPECT_TRUE(opaqueContents.IsEmpty());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_painted(), 20000, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 20000, 1);
     EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
     // visibleContentOpaqueRegion should match the visible part of what is painted opaque.
     opaquePaintRect = gfx::Rect(10, 10, 90, 190);
     layer->fake_layer_updater()->SetOpaquePaintRect(opaquePaintRect);
     layer->InvalidateContentRect(contentBounds);
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     updateTextures();
     opaqueContents = layer->VisibleContentOpaqueRegion();
     EXPECT_EQ(gfx::IntersectRects(opaquePaintRect, visibleBounds).ToString(), opaqueContents.ToString());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_painted(), 20000 * 2, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 17100, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 20000 + 20000 - 17100, 1);
     EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
     // If we paint again without invalidating, the same stuff should be opaque.
     layer->fake_layer_updater()->SetOpaquePaintRect(gfx::Rect());
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     updateTextures();
     opaqueContents = layer->VisibleContentOpaqueRegion();
     EXPECT_EQ(gfx::IntersectRects(opaquePaintRect, visibleBounds).ToString(), opaqueContents.ToString());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_painted(), 20000 * 2, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 17100, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 20000 + 20000 - 17100, 1);
     EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
     // 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->fake_layer_updater()->SetOpaquePaintRect(gfx::Rect());
     layer->InvalidateContentRect(gfx::Rect(0, 0, 1, 1));
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     updateTextures();
     opaqueContents = layer->VisibleContentOpaqueRegion();
     EXPECT_EQ(gfx::IntersectRects(opaquePaintRect, visibleBounds).ToString(), opaqueContents.ToString());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_painted(), 20000 * 2 + 1, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 17100, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 20000 + 20000 - 17100 + 1, 1);
     EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
     // 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->fake_layer_updater()->SetOpaquePaintRect(gfx::Rect());
     layer->InvalidateContentRect(gfx::Rect(10, 10, 1, 1));
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     updateTextures();
     opaqueContents = layer->VisibleContentOpaqueRegion();
     EXPECT_EQ(gfx::IntersectRects(gfx::Rect(10, 100, 90, 100), visibleBounds).ToString(), opaqueContents.ToString());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_painted(), 20000 * 2 + 1  + 1, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 17100, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 20000 + 20000 - 17100 + 1 + 1, 1);
     EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
 }
 
@@ skipping 11 matching lines @@
 
     gfx::Rect contentBounds = gfx::Rect(0, 0, 100, 300);
     layer->SetBounds(contentBounds.size());
     calcDrawProps(layer);
 
     // Invalidates and paints the whole layer.
     layer->fake_layer_updater()->SetOpaquePaintRect(gfx::Rect());
     layer->InvalidateContentRect(contentBounds);
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     updateTextures();
     opaqueContents = layer->VisibleContentOpaqueRegion();
     EXPECT_TRUE(opaqueContents.IsEmpty());
 
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_painted(), 30000, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 30000, 1);
     EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
     // 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->fake_layer_updater()->SetOpaquePaintRect(gfx::Rect());
     layer->InvalidateContentRect(gfx::Rect(0, 0, 1, 1));
     layer->InvalidateContentRect(gfx::Rect(50, 200, 10, 10));
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
-    layer->Update(m_queue.get(), &occluded, NULL);
+    layer->Update(m_queue.get(), &occluded);
     updateTextures();
     opaqueContents = layer->VisibleContentOpaqueRegion();
     EXPECT_TRUE(opaqueContents.IsEmpty());
 
     // The middle tile was painted even though not invalidated.
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_painted(), 30000 + 60 * 210, 1);
     // The pixels uploaded will not include the non-invalidated tile in the middle.
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
     EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(), 30000 + 1 + 100, 1);
     EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
@@ skipping 161 matching lines @@
     gfx::Rect m_paintedRect;
 };
 
 class UpdateTrackingTiledLayer : public FakeTiledLayer {
 public:
     explicit UpdateTrackingTiledLayer(PrioritizedResourceManager* manager)
         : FakeTiledLayer(manager)
     {
         scoped_ptr<TrackingLayerPainter> trackingLayerPainter(TrackingLayerPainter::Create());
         m_trackingLayerPainter = trackingLayerPainter.get();
-        m_layerUpdater = BitmapContentLayerUpdater::Create(trackingLayerPainter.PassAs<LayerPainter>());
+        m_layerUpdater = BitmapContentLayerUpdater::Create(trackingLayerPainter.PassAs<LayerPainter>(), &m_statsInstrumentation);
     }
 
     TrackingLayerPainter* trackingLayerPainter() const { return m_trackingLayerPainter; }
 
 protected:
     virtual ~UpdateTrackingTiledLayer() { }
 
     virtual LayerUpdater* Updater() const OVERRIDE { return m_layerUpdater.get(); }
 
 private:
     TrackingLayerPainter* m_trackingLayerPainter;
     scoped_refptr<BitmapContentLayerUpdater> m_layerUpdater;
+    FakeRenderingStatsInstrumentation m_statsInstrumentation;
 };
 
 TEST_F(TiledLayerTest, nonIntegerContentsScaleIsNotDistortedDuringPaint)
 {
     scoped_refptr<UpdateTrackingTiledLayer> layer = make_scoped_refptr(new UpdateTrackingTiledLayer(resource_manager_.get()));
 
     gfx::Rect layerRect(0, 0, 30, 31);
     layer->SetPosition(layerRect.origin());
     layer->SetBounds(layerRect.size());
     layer->UpdateContentsScale(1.5);
 
     gfx::Rect contentRect(0, 0, 45, 47);
     EXPECT_EQ(contentRect.size(), layer->content_bounds());
     layer->draw_properties().visible_content_rect = contentRect;
     layer->draw_properties().drawable_content_rect = contentRect;
 
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
 
     // Update the whole tile.
-    layer->Update(m_queue.get(), 0, NULL);
+    layer->Update(m_queue.get(), 0);

[danakj, 2013/03/23 01:56:32]

can you make these 0's into NULL's while you're here?

[egraether, 2013/03/25 21:07:44]

Done.

     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, NULL);
+    layer->Update(m_queue.get(), 0);
 
     EXPECT_RECT_EQ(layerRect, layer->trackingLayerPainter()->paintedRect());
 }
 
 TEST_F(TiledLayerTest, nonIntegerContentsScaleIsNotDistortedDuringInvalidation)
 {
     scoped_refptr<UpdateTrackingTiledLayer> layer = make_scoped_refptr(new UpdateTrackingTiledLayer(resource_manager_.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->content_bounds());
     layer->draw_properties().visible_content_rect = contentRect;
     layer->draw_properties().drawable_content_rect = contentRect;
 
     layer->SetTexturePriorities(m_priorityCalculator);
     resource_manager_->PrioritizeTextures();
 
     // Update the whole tile.
-    layer->Update(m_queue.get(), 0, NULL);
+    layer->Update(m_queue.get(), 0);
     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, NULL);
+    layer->Update(m_queue.get(), 0);
 
     EXPECT_RECT_EQ(layerRect, layer->trackingLayerPainter()->paintedRect());
 }
 
 }  // namespace
 }  // namespace cc