Fixing tile grid size used by cc:Picture to make it respect current tile configuration

cc/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/picture_layer_impl.h"
 
 #include "cc/layer_tree_impl.h"
+#include "cc/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 "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
 namespace {
 
@@ skipping 26 matching lines @@
       LayerTreeImpl* treeImpl,
       int id,
       scoped_refptr<PicturePileImpl> pile)
       : PictureLayerImpl(treeImpl, id) {
     pile_ = pile;
     setBounds(pile_->size());
     CreateTilingSet();
   }
 };
 
+class ImplSidePaintingSettings : public LayerTreeSettings {
+ public:
+  ImplSidePaintingSettings() {
+    implSidePainting = true;
+  }
+};
+
 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->ApplyLayerTreeSettings(ImplSidePaintingSettings());
     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->ApplyLayerTreeSettings(ImplSidePaintingSettings());
     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));
-    FakeContentLayerClient client;
-    picture->Record(&client, NULL);
+    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 addDrawRect(const gfx::Rect& rect) {
+    client_.addDrawRect(rect);
+  }
+
  protected:
   virtual ~TestablePicturePileImpl() {
   }
+
+  FakeContentLayerClient client_;
 };
 
-class ImplSidePaintingSettings : public LayerTreeSettings {
+class MockCanvas : public SkCanvas {
  public:
-  ImplSidePaintingSettings() {
-    implSidePainting = true;
+  explicit MockCanvas(SkDevice* device) : SkCanvas(device) { }
+
+  virtual void drawRect(const SkRect& rect, const SkPaint& paint) {
+    // Capture calls before SkCanvas quickReject kicks in
+    rects_.push_back(rect);
   }
+
+  std::vector<SkRect> rects_;
 };
 
 class PictureLayerImplTest : public testing::Test {
  public:
   PictureLayerImplTest()
       : host_impl_(ImplSidePaintingSettings(), &proxy_),
         id_(7) {
     host_impl_.initializeRenderer(createFakeOutputSurface());
   }
 
@@ skipping 53 matching lines @@
     gfx::Size result_bounds;
     pending_layer_->calculateContentsScale(
         scale, animating_transform,
         &result_scale_x, &result_scale_y, &result_bounds);
     active_layer_->calculateContentsScale(
         scale, animating_transform,
         &result_scale_x, &result_scale_y, &result_bounds);
   }
 
  protected:
+  void TestTileGridAlignmentCommon() {
+    // Layer to span 4 raster tiles in x and in y
+    ImplSidePaintingSettings settings;
+    gfx::Size layer_size(
+        settings.defaultTileSize.width() * 7 / 2,
+        settings.defaultTileSize.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);
+
+    SetupTrees(pending_pile, active_pile);
+
+    host_impl_.activeTree()->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
+    std::vector<Tile*> tiles =
+        active_layer_->tilings().tiling_at(0)->AllTilesForTesting();
+    EXPECT_EQ(16, tiles.size());
+    std::vector<SkRect> rects;
+    std::vector<Tile*>::const_iterator tile_iter;
+    for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
+      gfx::Point tile_center = (*tile_iter)->content_rect().CenterPoint();
+      gfx::Rect rect(tile_center.x(), tile_center.y(), 1, 1);
+      active_pile->addDrawRect(rect);
+      rects.push_back(SkRect::MakeXYWH(rect.x(), rect.y(), 1, 1));
+    }
+    // Force re-record with newly injected content
+    active_pile->RemoveRecordingAt(0, 0);
+    active_pile->AddRecordingAt(0, 0);
+
+    SkBitmap store;
+    store.setConfig(SkBitmap::kNo_Config, 1000, 1000);
+    SkDevice device(store);
+    int64 pixelsRasterized;
+
+    std::vector<SkRect>::const_iterator rect_iter = rects.begin();
+    for (tile_iter = tiles.begin(); tile_iter < tiles.end(); tile_iter++) {
+      MockCanvas mock_canvas(&device);
+      active_pile->Raster(&mock_canvas, (*tile_iter)->content_rect(),
+          1.0f, &pixelsRasterized);
+
+      // This test verifies that when drawing the contents of a specific tile
+      // at content scale 1.0, the playback canvas never receives content from
+      // neighboring tiles which indicates that the tile grid embedded in
+      // SkPicture is perfectly aligned with the compositor's tiles.
+      // Note: There are two rects: the initial clear and the explicitly
+      // recorded rect. We only care about the second one.
+      EXPECT_EQ(2, mock_canvas.rects_.size());
+      EXPECT_EQ(*rect_iter, mock_canvas.rects_[1]);
+      rect_iter++;
+    }
+  }
+
   FakeImplProxy proxy_;
   FakeLayerTreeHostImpl host_impl_;
   int id_;
   TestablePictureLayerImpl* pending_layer_;
   TestablePictureLayerImpl* active_layer_;
 
   DISALLOW_COPY_AND_ASSIGN(PictureLayerImplTest);
 };
 
+TEST_F(PictureLayerImplTest, tileGridAlignment) {
+  host_impl_.setDeviceScaleFactor(1.f);
+  TestTileGridAlignmentCommon();
+}
+
+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);
 
   SetupTrees(pending_pile, active_pile);
@@ skipping 387 matching lines @@
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer_->tilings().num_tilings());
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
   
 }
 
 }  // namespace
 }  // namespace cc