1 files changed, 62 insertions, 199 deletions

diff --git a/chromium/cc/layers/tiled_layer_unittest.cc b/chromium/cc/layers/tiled_layer_unittest.cc
index 42ef29cc93e..bd15f2f1f54 100644
--- a/chromium/cc/layers/tiled_layer_unittest.cc
+++ b/chromium/cc/layers/tiled_layer_unittest.cc
@@ -7,7 +7,7 @@
 #include <limits>
 #include <vector>
 
-#include "cc/debug/overdraw_metrics.h"
+#include "base/run_loop.h"
 #include "cc/resources/bitmap_content_layer_updater.h"
 #include "cc/resources/layer_painter.h"
 #include "cc/resources/prioritized_resource_manager.h"
@@ -20,7 +20,9 @@
 #include "cc/test/fake_proxy.h"
 #include "cc/test/fake_rendering_stats_instrumentation.h"
 #include "cc/test/geometry_test_utils.h"
+#include "cc/test/test_shared_bitmap_manager.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"
@@ -29,9 +31,9 @@
 namespace cc {
 namespace {
 
-class TestOcclusionTracker : public OcclusionTracker {
+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());
   }
 
@@ -44,6 +46,50 @@ class TestOcclusionTracker : public OcclusionTracker {
   }
 };
 
+class SynchronousOutputSurfaceLayerTreeHost : public LayerTreeHost {
+ public:
+  static scoped_ptr<SynchronousOutputSurfaceLayerTreeHost> Create(
+      LayerTreeHostClient* client,
+      SharedBitmapManager* manager,
+      const LayerTreeSettings& settings,
+      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
+    return make_scoped_ptr(new SynchronousOutputSurfaceLayerTreeHost(
+        client, manager, settings, impl_task_runner));
+  }
+
+  virtual ~SynchronousOutputSurfaceLayerTreeHost() {}
+
+  bool EnsureOutputSurfaceCreated() {
+    base::MessageLoop::current()->PostDelayedTask(
+        FROM_HERE,
+        run_loop_.QuitClosure(),
+        base::TimeDelta::FromSeconds(5));
+    run_loop_.Run();
+    return output_surface_created_;
+  }
+
+  virtual void OnCreateAndInitializeOutputSurfaceAttempted(
+      bool success) OVERRIDE {
+    LayerTreeHost::OnCreateAndInitializeOutputSurfaceAttempted(success);
+    output_surface_created_ = success;
+    run_loop_.Quit();
+  }
+
+ private:
+  SynchronousOutputSurfaceLayerTreeHost(
+      LayerTreeHostClient* client,
+      SharedBitmapManager* manager,
+      const LayerTreeSettings& settings,
+      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner)
+      : LayerTreeHost(client, manager, settings),
+        output_surface_created_(false) {
+    LayerTreeHost::InitializeThreaded(impl_task_runner);
+  }
+
+  bool output_surface_created_;
+  base::RunLoop run_loop_;
+};
+
 class TiledLayerTest : public testing::Test {
  public:
   TiledLayerTest()
@@ -59,24 +105,27 @@ class TiledLayerTest : public testing::Test {
 
   virtual void SetUp() {
     impl_thread_.Start();
-    layer_tree_host_ = LayerTreeHost::CreateThreaded(
+    shared_bitmap_manager_.reset(new TestSharedBitmapManager());
+    layer_tree_host_ = SynchronousOutputSurfaceLayerTreeHost::Create(
         &fake_layer_tree_host_client_,
-        NULL,
+        shared_bitmap_manager_.get(),
         settings_,
         impl_thread_.message_loop_proxy());
     proxy_ = layer_tree_host_->proxy();
     resource_manager_ = PrioritizedResourceManager::Create(proxy_);
     layer_tree_host_->SetLayerTreeHostClientReady();
-    layer_tree_host_->InitializeOutputSurfaceIfNeeded();
+    CHECK(layer_tree_host_->EnsureOutputSurfaceCreated());
     layer_tree_host_->SetRootLayer(Layer::Create());
 
     CHECK(output_surface_->BindToClient(&output_surface_client_));
 
     DebugScopedSetImplThreadAndMainThreadBlocked
         impl_thread_and_main_thread_blocked(proxy_);
-    resource_provider_ =
-        ResourceProvider::Create(output_surface_.get(), NULL, 0, false, 1);
-    host_impl_ = make_scoped_ptr(new FakeLayerTreeHostImpl(proxy_));
+    resource_provider_ = ResourceProvider::Create(
+        output_surface_.get(), shared_bitmap_manager_.get(), 0, false, 1,
+        false);
+    host_impl_ = make_scoped_ptr(
+        new FakeLayerTreeHostImpl(proxy_, shared_bitmap_manager_.get()));
   }
 
   virtual ~TiledLayerTest() {
@@ -194,12 +243,13 @@ class TiledLayerTest : public testing::Test {
   LayerTreeSettings settings_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<OutputSurface> output_surface_;
+  scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<ResourceUpdateQueue> queue_;
   PriorityCalculator priority_calculator_;
   base::Thread impl_thread_;
   FakeLayerTreeHostClient fake_layer_tree_host_client_;
-  scoped_ptr<LayerTreeHost> layer_tree_host_;
+  scoped_ptr<SynchronousOutputSurfaceLayerTreeHost> layer_tree_host_;
   scoped_ptr<FakeLayerTreeHostImpl> host_impl_;
   scoped_ptr<PrioritizedResourceManager> resource_manager_;
   TestOcclusionTracker* occlusion_;
@@ -253,11 +303,6 @@ TEST_F(TiledLayerTest, PushOccludedDirtyTiles) {
     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));
@@ -273,12 +318,6 @@ TEST_F(TiledLayerTest, PushOccludedDirtyTiles) {
     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));
@@ -525,10 +564,7 @@ TEST_F(TiledLayerTest, PushIdlePaintedOccludedTiles) {
   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) {
@@ -1180,11 +1216,6 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusion) {
   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();
@@ -1195,12 +1226,6 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusion) {
   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();
@@ -1210,12 +1235,6 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusion) {
   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) {
@@ -1246,11 +1265,6 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndVisiblityConstraints) {
   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
@@ -1265,12 +1279,6 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndVisiblityConstraints) {
   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
@@ -1284,12 +1292,6 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndVisiblityConstraints) {
   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) {
@@ -1316,12 +1318,7 @@ TEST_F(TiledLayerTest, TilesNotPaintedWithoutInvalidation) {
   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_);
@@ -1332,11 +1329,6 @@ TEST_F(TiledLayerTest, TilesNotPaintedWithoutInvalidation) {
   // 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) {
@@ -1371,11 +1363,6 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndTransforms) {
   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) {
@@ -1398,7 +1385,6 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndScaling) {
   // This makes sure the painting works when the content space is scaled to
   // a different layer space.
   layer_tree_host_->SetViewportSize(gfx::Size(600, 600));
-  layer->SetAnchorPoint(gfx::PointF());
   layer->SetBounds(gfx::Size(300, 300));
   scale_layer->AddChild(layer);
   CalcDrawProps(&render_surface_layer_list);
@@ -1421,12 +1407,6 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndScaling) {
   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.
@@ -1443,13 +1423,6 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndScaling) {
   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.
@@ -1475,14 +1448,6 @@ TEST_F(TiledLayerTest, TilesPaintedWithOcclusionAndScaling) {
   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) {
@@ -1520,12 +1485,6 @@ TEST_F(TiledLayerTest, VisibleContentOpaqueRegion) {
   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);
@@ -1540,13 +1499,6 @@ TEST_F(TiledLayerTest, 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_);
@@ -1558,13 +1510,6 @@ TEST_F(TiledLayerTest, 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());
@@ -1578,13 +1523,6 @@ TEST_F(TiledLayerTest, 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());
@@ -1598,77 +1536,6 @@ TEST_F(TiledLayerTest, 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) {
@@ -1686,25 +1553,21 @@ TEST_F(TiledLayerTest, DontAllocateContentsWhenTargetSurfaceCantBeAllocated) {
       new FakeTiledLayer(layer_tree_host_->contents_texture_manager()));
 
   root->SetBounds(root_rect.size());
-  root->SetAnchorPoint(gfx::PointF());
   root->draw_properties().drawable_content_rect = root_rect;
   root->draw_properties().visible_content_rect = root_rect;
   root->AddChild(surface);
 
   surface->SetForceRenderSurface(true);
-  surface->SetAnchorPoint(gfx::PointF());
   surface->SetOpacity(0.5);
   surface->AddChild(child);
   surface->AddChild(child2);
 
   child->SetBounds(child_rect.size());
-  child->SetAnchorPoint(gfx::PointF());
   child->SetPosition(child_rect.origin());
   child->draw_properties().visible_content_rect = child_rect;
   child->draw_properties().drawable_content_rect = root_rect;
 
   child2->SetBounds(child2_rect.size());
-  child2->SetAnchorPoint(gfx::PointF());
   child2->SetPosition(child2_rect.origin());
   child2->draw_properties().visible_content_rect = child2_rect;
   child2->draw_properties().drawable_content_rect = root_rect;
@@ -1843,7 +1706,7 @@ class TrackingLayerPainter : public LayerPainter {
   }
 
   virtual void Paint(SkCanvas* canvas,
-                     gfx::Rect content_rect,
+                     const gfx::Rect& content_rect,
                      gfx::RectF* opaque) OVERRIDE {
     painted_rect_ = content_rect;
   }