src/cc/test/fake_picture_pile_impl.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/test/fake_picture_pile_impl.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9 #include <utility>
  10
  11 #include "cc/resources/picture_pile.h"
  12 #include "cc/test/impl_side_painting_settings.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace cc {
  16
  17 FakePicturePileImpl::FakePicturePileImpl() {}
  18
  19 FakePicturePileImpl::FakePicturePileImpl(const PicturePileBase* other)
  20     : PicturePileImpl(other),
  21       tile_grid_info_(other->GetTileGridInfoForTesting()) {
  22 }
  23
  24 FakePicturePileImpl::~FakePicturePileImpl() {}
  25
  26 scoped_refptr<FakePicturePileImpl> FakePicturePileImpl::CreateFilledPile(
  27     const gfx::Size& tile_size,
  28     const gfx::Size& layer_bounds) {
  29   PicturePile pile;
  30   pile.tiling().SetTilingSize(layer_bounds);
  31   pile.tiling().SetMaxTextureSize(tile_size);
  32   pile.SetTileGridSize(ImplSidePaintingSettings().default_tile_grid_size);
  33   pile.SetRecordedViewportForTesting(gfx::Rect(layer_bounds));
  34   pile.SetHasAnyRecordingsForTesting(true);
  35
  36   auto pile_impl = make_scoped_refptr(new FakePicturePileImpl(&pile));
  37   for (int x = 0; x < pile_impl->tiling().num_tiles_x(); ++x) {
  38     for (int y = 0; y < pile_impl->tiling().num_tiles_y(); ++y)
  39       pile_impl->AddRecordingAt(x, y);
  40   }
  41   return pile_impl;
  42 }
  43
  44 scoped_refptr<FakePicturePileImpl> FakePicturePileImpl::CreateEmptyPile(
  45     const gfx::Size& tile_size,
  46     const gfx::Size& layer_bounds) {
  47   PicturePile pile;
  48   pile.tiling().SetTilingSize(layer_bounds);
  49   pile.tiling().SetMaxTextureSize(tile_size);
  50   pile.SetTileGridSize(ImplSidePaintingSettings().default_tile_grid_size);
  51   pile.SetRecordedViewportForTesting(gfx::Rect());
  52   pile.SetHasAnyRecordingsForTesting(false);
  53   return make_scoped_refptr(new FakePicturePileImpl(&pile));
  54 }
  55
  56 scoped_refptr<FakePicturePileImpl>
  57 FakePicturePileImpl::CreateEmptyPileThatThinksItHasRecordings(
  58     const gfx::Size& tile_size,
  59     const gfx::Size& layer_bounds) {
  60   PicturePile pile;
  61   pile.tiling().SetTilingSize(layer_bounds);
  62   pile.tiling().SetMaxTextureSize(tile_size);
  63   pile.SetTileGridSize(ImplSidePaintingSettings().default_tile_grid_size);
  64   // This simulates a false positive for this flag.
  65   pile.SetRecordedViewportForTesting(gfx::Rect());
  66   pile.SetHasAnyRecordingsForTesting(true);
  67   return make_scoped_refptr(new FakePicturePileImpl(&pile));
  68 }
  69
  70 scoped_refptr<FakePicturePileImpl>
  71 FakePicturePileImpl::CreateInfiniteFilledPile() {
  72   PicturePile pile;
  73   gfx::Size size(std::numeric_limits<int>::max(),
  74                  std::numeric_limits<int>::max());
  75   pile.tiling().SetTilingSize(size);
  76   pile.tiling().SetMaxTextureSize(size);
  77   pile.SetTileGridSize(size);
  78   pile.SetRecordedViewportForTesting(gfx::Rect(size));
  79   pile.SetHasAnyRecordingsForTesting(true);
  80
  81   auto pile_impl = make_scoped_refptr(new FakePicturePileImpl(&pile));
  82   pile_impl->AddRecordingAt(0, 0);
  83   return pile_impl;
  84 }
  85
  86 void FakePicturePileImpl::AddRecordingAt(int x, int y) {
  87   EXPECT_GE(x, 0);
  88   EXPECT_GE(y, 0);
  89   EXPECT_LT(x, tiling_.num_tiles_x());
  90   EXPECT_LT(y, tiling_.num_tiles_y());
  91
  92   if (HasRecordingAt(x, y))
  93     return;
  94   gfx::Rect bounds(tiling().TileBounds(x, y));
  95   bounds.Inset(-buffer_pixels(), -buffer_pixels());
  96
  97   scoped_refptr<Picture> picture(Picture::Create(
  98       bounds, &client_, tile_grid_info_, true, Picture::RECORD_NORMALLY));
  99   picture_map_[std::pair<int, int>(x, y)].SetPicture(picture);
 100   EXPECT_TRUE(HasRecordingAt(x, y));
 101
 102   has_any_recordings_ = true;
 103 }
 104
 105 void FakePicturePileImpl::RemoveRecordingAt(int x, int y) {
 106   EXPECT_GE(x, 0);
 107   EXPECT_GE(y, 0);
 108   EXPECT_LT(x, tiling_.num_tiles_x());
 109   EXPECT_LT(y, tiling_.num_tiles_y());
 110
 111   if (!HasRecordingAt(x, y))
 112     return;
 113   picture_map_.erase(std::pair<int, int>(x, y));
 114   EXPECT_FALSE(HasRecordingAt(x, y));
 115 }
 116
 117 bool FakePicturePileImpl::HasRecordingAt(int x, int y) const {
 118   PictureMap::const_iterator found = picture_map_.find(PictureMapKey(x, y));
 119   if (found == picture_map_.end())
 120     return false;
 121   return !!found->second.GetPicture();
 122 }
 123
 124 void FakePicturePileImpl::RerecordPile() {
 125   for (int y = 0; y < num_tiles_y(); ++y) {
 126     for (int x = 0; x < num_tiles_x(); ++x) {
 127       RemoveRecordingAt(x, y);
 128       AddRecordingAt(x, y);
 129     }
 130   }
 131 }
 132
 133 void FakePicturePileImpl::SetMinContentsScale(float min_contents_scale) {
 134   if (min_contents_scale_ == min_contents_scale)
 135     return;
 136
 137   // Picture contents are played back scaled. When the final contents scale is
 138   // less than 1 (i.e. low res), then multiple recorded pixels will be used
 139   // to raster one final pixel.  To avoid splitting a final pixel across
 140   // pictures (which would result in incorrect rasterization due to blending), a
 141   // buffer margin is added so that any picture can be snapped to integral
 142   // final pixels.
 143   //
 144   // For example, if a 1/4 contents scale is used, then that would be 3 buffer
 145   // pixels, since that's the minimum number of pixels to add so that resulting
 146   // content can be snapped to a four pixel aligned grid.
 147   int buffer_pixels = static_cast<int>(ceil(1 / min_contents_scale) - 1);
 148   buffer_pixels = std::max(0, buffer_pixels);
 149   SetBufferPixels(buffer_pixels);
 150   min_contents_scale_ = min_contents_scale;
 151 }
 152
 153 void FakePicturePileImpl::SetBufferPixels(int new_buffer_pixels) {
 154   if (new_buffer_pixels == buffer_pixels())
 155     return;
 156
 157   Clear();
 158   tiling_.SetBorderTexels(new_buffer_pixels);
 159 }
 160
 161 void FakePicturePileImpl::Clear() {
 162   picture_map_.clear();
 163   recorded_viewport_ = gfx::Rect();
 164 }
 165
 166 }  // namespace cc