cc: Only consider layer clipped content rect for analysis

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 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/picture_layer_impl.h"
 
 #include <utility>
 
 #include "cc/layers/picture_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
+#include "cc/test/fake_picture_pile_impl.h"
 #include "cc/test/impl_side_painting_settings.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 namespace {
 
 class TestablePictureLayerImpl : public PictureLayerImpl {
@@ skipping 24 matching lines @@
       LayerTreeImpl* tree_impl,
       int id,
       scoped_refptr<PicturePileImpl> pile)
       : PictureLayerImpl(tree_impl, id) {
     pile_ = pile;
     SetBounds(pile_->size());
     CreateTilingSet();
   }
 };
 
-class TestablePicturePileImpl : public PicturePileImpl {
- public:
-  static scoped_refptr<TestablePicturePileImpl> CreateFilledPile(
-      gfx::Size tile_size,
-      gfx::Size layer_bounds) {
-    scoped_refptr<TestablePicturePileImpl> pile(new TestablePicturePileImpl());
-    pile->tiling().SetTotalSize(layer_bounds);
-    pile->tiling().SetMaxTextureSize(tile_size);
-    pile->SetTileGridSize(ImplSidePaintingSettings().default_tile_size);
-    for (int x = 0; x < pile->tiling().num_tiles_x(); ++x) {
-      for (int y = 0; y < pile->tiling().num_tiles_y(); ++y)
-        pile->AddRecordingAt(x, y);
-    }
-    pile->UpdateRecordedRegion();
-    return pile;
-  }
-
-  static scoped_refptr<TestablePicturePileImpl> CreateEmptyPile(
-      gfx::Size tile_size,
-      gfx::Size layer_bounds) {
-    scoped_refptr<TestablePicturePileImpl> pile(new TestablePicturePileImpl());
-    pile->tiling().SetTotalSize(layer_bounds);
-    pile->tiling().SetMaxTextureSize(tile_size);
-    pile->SetTileGridSize(ImplSidePaintingSettings().default_tile_size);
-    pile->UpdateRecordedRegion();
-    return pile;
-  }
-
-  TilingData& tiling() { return tiling_; }
-
-  void AddRecordingAt(int x, int y) {
-    EXPECT_GE(x, 0);
-    EXPECT_GE(y, 0);
-    EXPECT_LT(x, tiling_.num_tiles_x());
-    EXPECT_LT(y, tiling_.num_tiles_y());
-
-    if (HasRecordingAt(x, y))
-      return;
-    gfx::Rect bounds(tiling().TileBounds(x, y));
-    scoped_refptr<Picture> picture(Picture::Create(bounds));
-    picture->Record(&client_, NULL, tile_grid_info_);
-    picture_list_map_[std::pair<int, int>(x, y)].push_back(picture);
-    EXPECT_TRUE(HasRecordingAt(x, y));
-
-    UpdateRecordedRegion();
-  }
-
-  void RemoveRecordingAt(int x, int y) {
-    EXPECT_GE(x, 0);
-    EXPECT_GE(y, 0);
-    EXPECT_LT(x, tiling_.num_tiles_x());
-    EXPECT_LT(y, tiling_.num_tiles_y());
-
-    if (!HasRecordingAt(x, y))
-      return;
-    picture_list_map_.erase(std::pair<int, int>(x, y));
-    EXPECT_FALSE(HasRecordingAt(x, y));
-
-    UpdateRecordedRegion();
-  }
-
-  void add_draw_rect(const gfx::Rect& rect) {
-    client_.add_draw_rect(rect);
-  }
-
- protected:
-  TestablePicturePileImpl() : PicturePileImpl(false) {}
-
-  virtual ~TestablePicturePileImpl() {}
-
-  FakeContentLayerClient client_;
-};
-
 class MockCanvas : public SkCanvas {
  public:
   explicit MockCanvas(SkDevice* device) : SkCanvas(device) {}
 
   virtual void drawRect(const SkRect& rect, const SkPaint& paint) OVERRIDE {
     // Capture calls before SkCanvas quickReject() kicks in.
     rects_.push_back(rect);
   }
 
   std::vector<SkRect> rects_;
@@ skipping 69 matching lines @@
   }
 
  protected:
   void TestTileGridAlignmentCommon() {
     // Layer to span 4 raster tiles in x and in y
     ImplSidePaintingSettings settings;
     gfx::Size layer_size(
         settings.default_tile_size.width() * 7 / 2,
         settings.default_tile_size.height() * 7 / 2);
 
-    scoped_refptr<TestablePicturePileImpl> pending_pile =
-        TestablePicturePileImpl::CreateFilledPile(layer_size, layer_size);
-    scoped_refptr<TestablePicturePileImpl> active_pile =
-        TestablePicturePileImpl::CreateFilledPile(layer_size, layer_size);
+    scoped_refptr<FakePicturePileImpl> pending_pile =
+        FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
+    scoped_refptr<FakePicturePileImpl> active_pile =
+        FakePicturePileImpl::CreateFilledPile(layer_size, layer_size);
 
     SetupTrees(pending_pile, active_pile);
 
     host_impl_.active_tree()->SetPageScaleFactorAndLimits(1.f, 1.f, 1.f);
     float result_scale_x, result_scale_y;
     gfx::Size result_bounds;
     active_layer_->CalculateContentsScale(
         1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
 
     // Add 1x1 rects at the centers of each tile, then re-record pile contents
@@ skipping 49 matching lines @@
 
 TEST_F(PictureLayerImplTest, TileGridAlignmentHiDPI) {
   host_impl_.SetDeviceScaleFactor(2.f);
   TestTileGridAlignmentCommon();
 }
 
 TEST_F(PictureLayerImplTest, CloneNoInvalidation) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
 
-  scoped_refptr<TestablePicturePileImpl> pending_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<TestablePicturePileImpl> active_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
 
   EXPECT_EQ(pending_layer_->tilings().num_tilings(),
             active_layer_->tilings().num_tilings());
 
   const PictureLayerTilingSet& tilings = pending_layer_->tilings();
   EXPECT_GT(tilings.num_tilings(), 0u);
   for (size_t i = 0; i < tilings.num_tilings(); ++i)
     VerifyAllTilesExistAndHavePile(tilings.tiling_at(i), active_pile.get());
 }
 
 TEST_F(PictureLayerImplTest, ClonePartialInvalidation) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   gfx::Rect layer_invalidation(150, 200, 30, 180);
 
-  scoped_refptr<TestablePicturePileImpl> pending_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<TestablePicturePileImpl> active_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
 
   Region invalidation(layer_invalidation);
   AddDefaultTilingsWithInvalidation(invalidation);
 
   const PictureLayerTilingSet& tilings = pending_layer_->tilings();
   EXPECT_GT(tilings.num_tilings(), 0u);
   for (size_t i = 0; i < tilings.num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings.tiling_at(i);
@@ skipping 13 matching lines @@
       else
         EXPECT_EQ(active_pile, iter->picture_pile());
     }
   }
 }
 
 TEST_F(PictureLayerImplTest, CloneFullInvalidation) {
   gfx::Size tile_size(90, 80);
   gfx::Size layer_bounds(300, 500);
 
-  scoped_refptr<TestablePicturePileImpl> pending_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<TestablePicturePileImpl> active_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
 
   Region invalidation((gfx::Rect(layer_bounds)));
   AddDefaultTilingsWithInvalidation(invalidation);
 
   EXPECT_EQ(pending_layer_->tilings().num_tilings(),
             active_layer_->tilings().num_tilings());
 
   const PictureLayerTilingSet& tilings = pending_layer_->tilings();
   EXPECT_GT(tilings.num_tilings(), 0u);
   for (size_t i = 0; i < tilings.num_tilings(); ++i)
     VerifyAllTilesExistAndHavePile(tilings.tiling_at(i), pending_pile.get());
 }
 
 TEST_F(PictureLayerImplTest, NoInvalidationBoundsChange) {
   gfx::Size tile_size(90, 80);
   gfx::Size active_layer_bounds(300, 500);
   gfx::Size pending_layer_bounds(400, 800);
 
-  scoped_refptr<TestablePicturePileImpl> pending_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size,
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size,
                                                 pending_layer_bounds);
-  scoped_refptr<TestablePicturePileImpl> active_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, active_layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, active_layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
 
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
 
   const PictureLayerTilingSet& tilings = pending_layer_->tilings();
   EXPECT_GT(tilings.num_tilings(), 0u);
   for (size_t i = 0; i < tilings.num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings.tiling_at(i);
@@ skipping 15 matching lines @@
         EXPECT_EQ(active_pile, iter->picture_pile());
       }
     }
   }
 }
 
 TEST_F(PictureLayerImplTest, AddTilesFromNewRecording) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
-  scoped_refptr<TestablePicturePileImpl> pending_pile =
-      TestablePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
-  scoped_refptr<TestablePicturePileImpl> active_pile =
-      TestablePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 
   // Fill in some of active pile, but more of pending pile.
   int hole_count = 0;
   for (int x = 0; x < active_pile->tiling().num_tiles_x(); ++x) {
     for (int y = 0; y < active_pile->tiling().num_tiles_y(); ++y) {
       if ((x + y) % 2) {
         pending_pile->AddRecordingAt(x, y);
         active_pile->AddRecordingAt(x, y);
       } else {
         hole_count++;
@@ skipping 34 matching lines @@
       else
         EXPECT_FALSE(*iter);
     }
   }
 }
 
 TEST_F(PictureLayerImplTest, ManageTilingsWithNoRecording) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
-  scoped_refptr<TestablePicturePileImpl> pending_pile =
-      TestablePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
-  scoped_refptr<TestablePicturePileImpl> active_pile =
-      TestablePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupTrees(pending_pile, active_pile);
 
   // These are included in the scale given to the layer.
   host_impl_.SetDeviceScaleFactor(1.f);
   host_impl_.pending_tree()->SetPageScaleFactorAndLimits(1.f, 1.f, 1.f);
 
   pending_layer_->CalculateContentsScale(
       1.f, false, &result_scale_x, &result_scale_y, &result_bounds);
 
   EXPECT_EQ(0u, pending_layer_->tilings().num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, ManageTilingsCreatesTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
-  scoped_refptr<TestablePicturePileImpl> pending_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<TestablePicturePileImpl> active_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings().num_tilings());
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
@@ skipping 62 matching lines @@
       pending_layer_->tilings().tiling_at(0)->contents_scale());
   EXPECT_FLOAT_EQ(
       1.9f * low_res_factor,
       pending_layer_->tilings().tiling_at(3)->contents_scale());
 }
 
 TEST_F(PictureLayerImplTest, CleanUpTilings) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
-  scoped_refptr<TestablePicturePileImpl> pending_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<TestablePicturePileImpl> active_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
   std::vector<PictureLayerTiling*> used_tilings;
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings().num_tilings());
 
   float low_res_factor = host_impl_.settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
@@ skipping 89 matching lines @@
   ASSERT_EQ(3u, active_layer_->tilings().num_tilings());
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, DidLoseOutputSurface) {
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
-  scoped_refptr<TestablePicturePileImpl> pending_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
-  scoped_refptr<TestablePicturePileImpl> active_pile =
-      TestablePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
+  scoped_refptr<FakePicturePileImpl> active_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   float result_scale_x, result_scale_y;
   gfx::Size result_bounds;
 
   SetupTrees(pending_pile, active_pile);
   EXPECT_EQ(0u, pending_layer_->tilings().num_tilings());
 
   // These are included in the scale given to the layer.
   host_impl_.SetDeviceScaleFactor(1.7f);
   host_impl_.pending_tree()->SetPageScaleFactorAndLimits(3.2f, 3.2f, 3.2f);
 
   pending_layer_->CalculateContentsScale(
       1.3f, false, &result_scale_x, &result_scale_y, &result_bounds);
   EXPECT_EQ(2u, pending_layer_->tilings().num_tilings());
 
   // All tilings should be removed when losing output surface.
   active_layer_->DidLoseOutputSurface();
   EXPECT_EQ(0u, active_layer_->tilings().num_tilings());
   pending_layer_->DidLoseOutputSurface();
   EXPECT_EQ(0u, pending_layer_->tilings().num_tilings());
 
   // This should create new tilings.
   pending_layer_->CalculateContentsScale(
       1.3f, false, &result_scale_x, &result_scale_y, &result_bounds);
   EXPECT_EQ(2u, pending_layer_->tilings().num_tilings());
 }
 
 }  // namespace
 }  // namespace cc