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"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 namespace {
 
@@ skipping 75 matching lines @@
 
   void LayerPushPropertiesTo(FakeTiledLayer* layer,
                              FakeTiledLayerImpl* layer_impl) {
     DebugScopedSetImplThreadAndMainThreadBlocked
     impl_thread_and_main_thread_blocked(proxy_);
     layer->PushPropertiesTo(layer_impl);
   }
 
   void LayerUpdate(FakeTiledLayer* layer, TestOcclusionTracker* occluded) {
     DebugScopedSetMainThread main_thread(proxy_);
-    layer->Update(queue_.get(), occluded, NULL);
+    layer->Update(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) {
     if (layer1 && !layer1->parent())
@@ skipping 28 matching lines @@
     // Get textures
     resource_manager_->ClearPriorities();
     if (layer1)
       layer1->SetTexturePriorities(priority_calculator_);
     if (layer2)
       layer2->SetTexturePriorities(priority_calculator_);
     resource_manager_->PrioritizeTextures();
 
     // Update content
     if (layer1)
-      layer1->Update(queue_.get(), occlusion_, NULL);
+      layer1->Update(queue_.get(), occlusion_);
     if (layer2)
-      layer2->Update(queue_.get(), occlusion_, NULL);
+      layer2->Update(queue_.get(), occlusion_);
 
     bool needs_update = false;
     if (layer1)
       needs_update |= layer1->NeedsIdlePaint();
     if (layer2)
       needs_update |= layer2->NeedsIdlePaint();
 
     // Update textures and push.
     UpdateTextures();
     if (layer1)
@@ skipping 421 matching lines @@
 
     // Pretend the layer is animating.
     layer->draw_properties().target_space_transform_is_animating = true;
     layer->draw_properties().visible_content_rect = visible_rect;
     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(priority_calculator_);
     resource_manager_->PrioritizeTextures();
-    layer->Update(queue_.get(), 0, NULL);
+    layer->Update(queue_.get(), NULL);
     UpdateTextures();
     LayerPushPropertiesTo(layer.get(), layer_impl.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 (!run_out_of_memory[i]) {
       for (int i = 0; i < 5; ++i) {
         for (int j = 0; j < 5; ++j)
           EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(i, j));
@@ skipping 146 matching lines @@
   layer->SetContentBounds(content_bounds.size());
   layer->draw_properties().visible_content_rect = content_bounds;
 
   // On first update, the update_rect includes all tiles, even beyond the
   // boundaries of the layer.
   // However, it should still be in layer space, not content space.
   layer->InvalidateContentRect(content_bounds);
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), 0, NULL);
+  layer->Update(queue_.get(), NULL);
   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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->InvalidateContentRect(content_bounds);
-  layer->Update(queue_.get(), 0, NULL);
+  layer->Update(queue_.get(), NULL);
   EXPECT_FLOAT_RECT_EQ(gfx::RectF(layer_bounds), layer->update_rect());
   UpdateTextures();
 
   // Partial re-paint should also be represented by the update rect in layer
   // space, not content space.
   gfx::Rect partial_damage(30, 100, 10, 10);
   layer->InvalidateContentRect(partial_damage);
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), 0, NULL);
+  layer->Update(queue_.get(), NULL);
   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> layer_impl =
       make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), 0, NULL);
+  layer->Update(queue_.get(), NULL);
   UpdateTextures();
   LayerPushPropertiesTo(layer.get(), layer_impl.get());
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
   EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 1));
   EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(1, 0));
   EXPECT_FALSE(layer_impl->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.f);
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 200, 200);
 
   // The impl side should get 2x2 tiles now.
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), 0, NULL);
+  layer->Update(queue_.get(), NULL);
   UpdateTextures();
   LayerPushPropertiesTo(layer.get(), layer_impl.get());
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1));
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(1, 0));
   EXPECT_TRUE(layer_impl->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),
@@ skipping 60 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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), 0, NULL);
+  layer->Update(queue_.get(), 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(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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), 0, NULL);
+  layer->Update(queue_.get(), NULL);
 }
 
 class TiledLayerPartialUpdateTest : public TiledLayerTest {
  public:
   TiledLayerPartialUpdateTest() { settings_.max_partial_texture_updates = 4; }
 };
 
 TEST_F(TiledLayerPartialUpdateTest, PartialUpdates) {
   // Create one 300 x 200 tiled layer with 3 x 2 tiles.
   gfx::Size content_bounds(300, 200);
@@ skipping 110 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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), 0, NULL);
+  layer->Update(queue_.get(), NULL);
   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;
   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(layer->content_bounds());
   layer->draw_properties().visible_content_rect =
       gfx::Rect(layer->content_bounds());
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
 
   occluded.SetOcclusion(gfx::Rect(250, 200, 300, 100));
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
 
   occluded.SetOcclusion(gfx::Rect(250, 250, 300, 100));
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(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) {
@@ skipping 10 matching lines @@
 
   // 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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(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;
   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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
 
   // Repaint without marking it dirty. The 3 culled tiles will be pre-painted
   // now.
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(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 =
@@ skipping 14 matching lines @@
   layer->draw_properties().target_space_transform = screen_transform;
 
   occluded.SetOcclusion(gfx::Rect(100, 100, 150, 50));
   layer->draw_properties().drawable_content_rect =
       gfx::Rect(layer->content_bounds());
   layer->draw_properties().visible_content_rect =
       gfx::Rect(layer->content_bounds());
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(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 =
@@ skipping 18 matching lines @@
   layer->draw_properties().screen_space_transform = draw_transform;
 
   occluded.SetOcclusion(gfx::Rect(200, 200, 300, 100));
   layer->draw_properties().drawable_content_rect =
       gfx::Rect(layer->bounds());
   layer->draw_properties().visible_content_rect =
       gfx::Rect(layer->content_bounds());
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(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(layer->bounds());
   layer->draw_properties().visible_content_rect =
       gfx::Rect(layer->content_bounds());
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(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 screen_transform;
   screen_transform.Scale(0.5, 0.5);
   layer->draw_properties().screen_space_transform = screen_transform;
   layer->draw_properties().target_space_transform = screen_transform;
 
   occluded.SetOcclusion(gfx::Rect(100, 100, 150, 100));
 
   gfx::Rect layer_bounds_rect(layer->bounds());
   layer->draw_properties().drawable_content_rect =
       gfx::ToEnclosingRect(gfx::ScaleRect(layer_bounds_rect, 0.5));
   layer->draw_properties().visible_content_rect =
       gfx::Rect(layer->content_bounds());
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(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) {
@@ skipping 17 matching lines @@
   CalcDrawProps(layer);
   layer->draw_properties().drawable_content_rect = visible_bounds;
   layer->draw_properties().visible_content_rect = visible_bounds;
 
   // If the layer doesn't paint opaque content, then the
   // VisibleContentOpaqueRegion should be empty.
   layer->fake_layer_updater()->SetOpaquePaintRect(gfx::Rect());
   layer->InvalidateContentRect(content_bounds);
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(queue_.get(), &occluded);
   opaque_contents = layer->VisibleContentOpaqueRegion();
   EXPECT_TRUE(opaque_contents.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.
   opaque_paint_rect = gfx::Rect(10, 10, 90, 190);
   layer->fake_layer_updater()->SetOpaquePaintRect(opaque_paint_rect);
   layer->InvalidateContentRect(content_bounds);
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(queue_.get(), &occluded);
   UpdateTextures();
   opaque_contents = layer->VisibleContentOpaqueRegion();
   EXPECT_EQ(gfx::IntersectRects(opaque_paint_rect, visible_bounds).ToString(),
             opaque_contents.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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(queue_.get(), &occluded);
   UpdateTextures();
   opaque_contents = layer->VisibleContentOpaqueRegion();
   EXPECT_EQ(gfx::IntersectRects(opaque_paint_rect, visible_bounds).ToString(),
             opaque_contents.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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(queue_.get(), &occluded);
   UpdateTextures();
   opaque_contents = layer->VisibleContentOpaqueRegion();
   EXPECT_EQ(gfx::IntersectRects(opaque_paint_rect, visible_bounds).ToString(),
             opaque_contents.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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(queue_.get(), &occluded);
   UpdateTextures();
   opaque_contents = layer->VisibleContentOpaqueRegion();
   EXPECT_EQ(gfx::IntersectRects(gfx::Rect(10, 100, 90, 100),
                                 visible_bounds).ToString(),
             opaque_contents.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(),
@@ skipping 18 matching lines @@
 
   gfx::Rect content_bounds = gfx::Rect(0, 0, 100, 300);
   layer->SetBounds(content_bounds.size());
   CalcDrawProps(layer);
 
   // Invalidates and paints the whole layer.
   layer->fake_layer_updater()->SetOpaquePaintRect(gfx::Rect());
   layer->InvalidateContentRect(content_bounds);
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(queue_.get(), &occluded);
   UpdateTextures();
   opaque_contents = layer->VisibleContentOpaqueRegion();
   EXPECT_TRUE(opaque_contents.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(priority_calculator_);
   resource_manager_->PrioritizeTextures();
-  layer->Update(queue_.get(), &occluded, NULL);
+  layer->Update(queue_.get(), &occluded);
   UpdateTextures();
   opaque_contents = layer->VisibleContentOpaqueRegion();
   EXPECT_TRUE(opaque_contents.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);
@@ skipping 181 matching lines @@
   gfx::Rect painted_rect_;
 };
 
 class UpdateTrackingTiledLayer : public FakeTiledLayer {
  public:
   explicit UpdateTrackingTiledLayer(PrioritizedResourceManager* manager)
       : FakeTiledLayer(manager) {
     scoped_ptr<TrackingLayerPainter> painter(TrackingLayerPainter::Create());
     tracking_layer_painter_ = painter.get();
     layer_updater_ =
-        BitmapContentLayerUpdater::Create(painter.PassAs<LayerPainter>());
+        BitmapContentLayerUpdater::Create(painter.PassAs<LayerPainter>(),
+                                          &stats_instrumentation_);
   }
 
   TrackingLayerPainter* tracking_layer_painter() const {
     return tracking_layer_painter_;
   }
 
  private:
   virtual LayerUpdater* Updater() const OVERRIDE {
     return layer_updater_.get();
   }
   virtual ~UpdateTrackingTiledLayer() {}
 
   TrackingLayerPainter* tracking_layer_painter_;
   scoped_refptr<BitmapContentLayerUpdater> layer_updater_;
+  FakeRenderingStatsInstrumentation stats_instrumentation_;
 };
 
 TEST_F(TiledLayerTest, NonIntegerContentsScaleIsNotDistortedDuringPaint) {
   scoped_refptr<UpdateTrackingTiledLayer> layer =
       make_scoped_refptr(new UpdateTrackingTiledLayer(resource_manager_.get()));
 
   gfx::Rect layer_rect(0, 0, 30, 31);
   layer->SetPosition(layer_rect.origin());
   layer->SetBounds(layer_rect.size());
   layer->UpdateContentsScale(1.5f);
 
   gfx::Rect content_rect(0, 0, 45, 47);
   EXPECT_EQ(content_rect.size(), layer->content_bounds());
   layer->draw_properties().visible_content_rect = content_rect;
   layer->draw_properties().drawable_content_rect = content_rect;
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
 
   // Update the whole tile.
-  layer->Update(queue_.get(), 0, NULL);
+  layer->Update(queue_.get(), NULL);
   layer->tracking_layer_painter()->ResetPaintedRect();
 
   EXPECT_RECT_EQ(gfx::Rect(), layer->tracking_layer_painter()->PaintedRect());
   UpdateTextures();
 
   // Invalidate the entire layer in content space. When painting, the rect given
   // to webkit should match the layer's bounds.
   layer->InvalidateContentRect(content_rect);
-  layer->Update(queue_.get(), 0, NULL);
+  layer->Update(queue_.get(), NULL);
 
   EXPECT_RECT_EQ(layer_rect, layer->tracking_layer_painter()->PaintedRect());
 }
 
 TEST_F(TiledLayerTest,
        NonIntegerContentsScaleIsNotDistortedDuringInvalidation) {
   scoped_refptr<UpdateTrackingTiledLayer> layer =
       make_scoped_refptr(new UpdateTrackingTiledLayer(resource_manager_.get()));
 
   gfx::Rect layer_rect(0, 0, 30, 31);
   layer->SetPosition(layer_rect.origin());
   layer->SetBounds(layer_rect.size());
   layer->UpdateContentsScale(1.3f);
 
   gfx::Rect content_rect(layer->content_bounds());
   layer->draw_properties().visible_content_rect = content_rect;
   layer->draw_properties().drawable_content_rect = content_rect;
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
 
   // Update the whole tile.
-  layer->Update(queue_.get(), 0, NULL);
+  layer->Update(queue_.get(), NULL);
   layer->tracking_layer_painter()->ResetPaintedRect();
 
   EXPECT_RECT_EQ(gfx::Rect(), layer->tracking_layer_painter()->PaintedRect());
   UpdateTextures();
 
   // Invalidate the entire layer in layer space. When painting, the rect given
   // to webkit should match the layer's bounds.
   layer->SetNeedsDisplayRect(layer_rect);
-  layer->Update(queue_.get(), 0, NULL);
+  layer->Update(queue_.get(), NULL);
 
   EXPECT_RECT_EQ(layer_rect, layer->tracking_layer_painter()->PaintedRect());
 }
 
 }  // namespace
 }  // namespace cc