cc: Remove OverdrawMetrics and --trace-overdraw flag.

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 <limits>
 #include <vector>
 
 #include "base/run_loop.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_output_surface_client.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/occlusion_tracker.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 {
 
 class TestOcclusionTracker : public OcclusionTracker<Layer> {
  public:
-  TestOcclusionTracker() : OcclusionTracker(gfx::Rect(0, 0, 1000, 1000), true) {
+  TestOcclusionTracker() : OcclusionTracker(gfx::Rect(0, 0, 1000, 1000)) {
     stack_.push_back(StackObject());
   }
 
   void SetRenderTarget(Layer* render_target) {
     stack_.back().target = render_target;
   }
 
   void SetOcclusion(const Region& occlusion) {
     stack_.back().occlusion_from_inside_target = occlusion;
   }
@@ skipping 247 matching lines @@
   layer_tree_host_->root_layer()->AddChild(layer);
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
 
     // The tile size is 100x100, so this invalidates and then paints two tiles.
     layer->SetBounds(gfx::Size(100, 200));
     CalcDrawProps(&render_surface_layer_list);
     UpdateAndPush(layer, layer_impl);
 
-    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());
-
     // We should have both tiles on the impl side.
     EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1));
   }
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
 
     // Invalidates part of the top tile...
     layer->InvalidateContentRect(gfx::Rect(0, 0, 50, 50));
     // ....but the area is occluded.
     occluded.SetOcclusion(gfx::Rect(0, 0, 50, 50));
     CalcDrawProps(&render_surface_layer_list);
     UpdateAndPush(layer, layer_impl);
 
-    EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
-    EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(),
-                20000 + 2500,
-                1);
-    EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
-
     // We should still have both tiles, as part of the top tile is still
     // unoccluded.
     EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
     EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 1));
   }
 }
 
 TEST_F(TiledLayerTest, PushDeletedTiles) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
@@ skipping 226 matching lines @@
 
   // The tile size is 100x100, so this invalidates one occluded tile, culls it
   // during paint, but prepaints it.
   occluded.SetOcclusion(gfx::Rect(0, 0, 100, 100));
 
   layer->SetBounds(gfx::Size(100, 100));
   CalcDrawProps(&render_surface_layer_list);
   layer->draw_properties().visible_content_rect = gfx::Rect(0, 0, 100, 100);
   UpdateAndPush(layer, layer_impl);
 
-  // We should have the prepainted tile on the impl side, but culled it during
-  // paint.
   EXPECT_TRUE(layer_impl->HasResourceIdForTileAt(0, 0));
-  EXPECT_EQ(1, occluded.overdraw_metrics()->tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, PushTilesMarkedDirtyDuringPaint) {
   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));
   RenderSurfaceLayerList render_surface_layer_list;
 
   layer_tree_host_->root_layer()->AddChild(layer);
@@ skipping 631 matching lines @@
   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->SavePaintProperties();
   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->SavePaintProperties();
   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->SavePaintProperties();
   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) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   RenderSurfaceLayerList render_surface_layer_list;
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   layer_tree_host_->root_layer()->AddChild(layer);
@@ skipping 10 matching lines @@
   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->SavePaintProperties();
   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->SavePaintProperties();
   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->SavePaintProperties();
   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()));
   RenderSurfaceLayerList render_surface_layer_list;
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   layer_tree_host_->root_layer()->AddChild(layer);
 
   // The tile size is 100x100.
 
   layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
   layer->SetBounds(gfx::Size(600, 600));
   CalcDrawProps(&render_surface_layer_list);
 
   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->SavePaintProperties();
   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());
+  UpdateTextures();
 
   layer->fake_layer_updater()->ClearUpdateCount();
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
 
   // Repaint without marking it dirty. The 3 culled tiles will be pre-painted
   // now.
   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 =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   RenderSurfaceLayerList render_surface_layer_list;
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   layer_tree_host_->root_layer()->AddChild(layer);
@@ skipping 14 matching lines @@
   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->SavePaintProperties();
   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 =
       new FakeTiledLayer(resource_manager_.get());
   RenderSurfaceLayerList render_surface_layer_list;
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
 
   scoped_refptr<FakeTiledLayer> scale_layer =
@@ skipping 25 matching lines @@
   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->SavePaintProperties();
   layer->Update(queue_.get(), &occluded);
   int visible_tiles1 = 6 * 6;
   EXPECT_EQ(visible_tiles1, layer->fake_layer_updater()->update_count());
 
-  EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
-  EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(),
-              visible_tiles1 * 100 * 100,
-              1);
-  EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
-
   layer->fake_layer_updater()->ClearUpdateCount();
 
   // The occlusion of 300x100 will be cover 3 tiles as tiles are 100x100 still.
   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->SavePaintProperties();
   layer->Update(queue_.get(), &occluded);
   int visible_tiles2 = 6 * 6 - 3;
   EXPECT_EQ(visible_tiles2, layer->fake_layer_updater()->update_count());
 
-  EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
-  EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(),
-              visible_tiles2 * 100 * 100 +
-              visible_tiles1 * 100 * 100,
-              1);
-  EXPECT_EQ(3, occluded.overdraw_metrics()->tiles_culled_for_upload());
-
   layer->fake_layer_updater()->ClearUpdateCount();
 
   // This makes sure content scaling and transforms work together.
   // When the tiles are scaled down by half, they are 50x50 each in the
   // screen.
   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;
 
   // An occlusion of 150x100 will cover 3*2 = 6 tiles.
   occluded.SetOcclusion(gfx::Rect(100, 100, 150, 100));
 
   gfx::Rect layer_bounds_rect(layer->bounds());
   layer->draw_properties().drawable_content_rect =
       gfx::ScaleToEnclosingRect(layer_bounds_rect, 0.5f);
   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->SavePaintProperties();
   layer->Update(queue_.get(), &occluded);
   int visible_tiles3 = 6 * 6 - 6;
   EXPECT_EQ(visible_tiles3, layer->fake_layer_updater()->update_count());
-
-  EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
-  EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(),
-              visible_tiles3 * 100 * 100 +
-              visible_tiles2 * 100 * 100 +
-              visible_tiles1 * 100 * 100,
-              1);
-  EXPECT_EQ(6 + 3, occluded.overdraw_metrics()->tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, VisibleContentOpaqueRegion) {
   scoped_refptr<FakeTiledLayer> layer =
       make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
   RenderSurfaceLayerList render_surface_layer_list;
   TestOcclusionTracker occluded;
   occlusion_ = &occluded;
   layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
 
@@ skipping 17 matching lines @@
   // VisibleContentOpaqueRegion should be empty.
   layer->fake_layer_updater()->SetOpaquePaintRect(gfx::Rect());
   layer->InvalidateContentRect(content_bounds);
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->SavePaintProperties();
   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->SavePaintProperties();
   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->SavePaintProperties();
   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->SavePaintProperties();
   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->SavePaintProperties();
   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(),
-              20000 + 20000 - 17100 + 1 + 1,
-              1);
-  EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
-}
-
-TEST_F(TiledLayerTest, PixelsPaintedMetrics) {
-  scoped_refptr<FakeTiledLayer> layer =
-      make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
-  RenderSurfaceLayerList render_surface_layer_list;
-  TestOcclusionTracker occluded;
-  occlusion_ = &occluded;
-  layer_tree_host_->SetViewportSize(gfx::Size(1000, 1000));
-
-  layer_tree_host_->root_layer()->AddChild(layer);
-
-  // The tile size is 100x100, so this invalidates and then paints two tiles in
-  // various ways.
-
-  gfx::Rect opaque_paint_rect;
-  Region opaque_contents;
-
-  gfx::Rect content_bounds = gfx::Rect(0, 0, 100, 300);
-  layer->SetBounds(content_bounds.size());
-  CalcDrawProps(&render_surface_layer_list);
-
-  // 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->SavePaintProperties();
-  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->SavePaintProperties();
-  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);
-  EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(),
-              30000 + 1 + 100,
-              1);
-  EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
 }
 
 TEST_F(TiledLayerTest, DontAllocateContentsWhenTargetSurfaceCantBeAllocated) {
   // Tile size is 100x100.
   gfx::Rect root_rect(0, 0, 300, 200);
   gfx::Rect child_rect(0, 0, 300, 100);
   gfx::Rect child2_rect(0, 100, 300, 100);
 
   scoped_refptr<FakeTiledLayer> root = make_scoped_refptr(
       new FakeTiledLayer(layer_tree_host_->contents_texture_manager()));
@@ skipping 265 matching lines @@
   // 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(), NULL);
 
   EXPECT_RECT_EQ(layer_rect, layer->tracking_layer_painter()->PaintedRect());
 }
 
 }  // namespace
 }  // namespace cc