cc/test/fake_picture_layer_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_layer_impl.h"
   6
   7 #include <vector>
   8 #include "cc/resources/tile.h"
   9 #include "cc/trees/layer_tree_impl.h"
  10
  11 namespace cc {
  12
  13 FakePictureLayerImpl::FakePictureLayerImpl(
  14     LayerTreeImpl* tree_impl,
  15     int id,
  16     scoped_refptr<RasterSource> raster_source,
  17     bool is_mask)
  18     : PictureLayerImpl(tree_impl,
  19                        id,
  20                        is_mask,
  21                        new LayerImpl::SyncedScrollOffset),
  22       append_quads_count_(0),
  23       did_become_active_call_count_(0),
  24       has_valid_tile_priorities_(false),
  25       use_set_valid_tile_priorities_flag_(false),
  26       release_resources_count_(0) {
  27   SetBounds(raster_source->GetSize());
  28   SetContentBounds(raster_source->GetSize());
  29   SetRasterSourceOnPending(raster_source, Region());
  30 }
  31
  32 FakePictureLayerImpl::FakePictureLayerImpl(
  33     LayerTreeImpl* tree_impl,
  34     int id,
  35     scoped_refptr<RasterSource> raster_source,
  36     bool is_mask,
  37     const gfx::Size& layer_bounds)
  38     : PictureLayerImpl(tree_impl,
  39                        id,
  40                        is_mask,
  41                        new LayerImpl::SyncedScrollOffset),
  42       append_quads_count_(0),
  43       did_become_active_call_count_(0),
  44       has_valid_tile_priorities_(false),
  45       use_set_valid_tile_priorities_flag_(false),
  46       release_resources_count_(0) {
  47   SetBounds(layer_bounds);
  48   SetContentBounds(layer_bounds);
  49   SetRasterSourceOnPending(raster_source, Region());
  50 }
  51
  52 FakePictureLayerImpl::FakePictureLayerImpl(LayerTreeImpl* tree_impl,
  53                                            int id,
  54                                            bool is_mask)
  55     : FakePictureLayerImpl(tree_impl,
  56                            id,
  57                            is_mask,
  58                            new LayerImpl::SyncedScrollOffset) {
  59 }
  60
  61 FakePictureLayerImpl::FakePictureLayerImpl(
  62     LayerTreeImpl* tree_impl,
  63     int id,
  64     bool is_mask,
  65     scoped_refptr<LayerImpl::SyncedScrollOffset> synced_scroll_offset)
  66     : PictureLayerImpl(tree_impl, id, is_mask, synced_scroll_offset),
  67       append_quads_count_(0),
  68       did_become_active_call_count_(0),
  69       has_valid_tile_priorities_(false),
  70       use_set_valid_tile_priorities_flag_(false),
  71       release_resources_count_(0) {
  72 }
  73
  74 scoped_ptr<LayerImpl> FakePictureLayerImpl::CreateLayerImpl(
  75     LayerTreeImpl* tree_impl) {
  76   return make_scoped_ptr(new FakePictureLayerImpl(tree_impl, id(), is_mask_,
  77                                                   synced_scroll_offset()));
  78 }
  79
  80 void FakePictureLayerImpl::PushPropertiesTo(LayerImpl* layer_impl) {
  81   FakePictureLayerImpl* picture_layer_impl =
  82       static_cast<FakePictureLayerImpl*>(layer_impl);
  83   picture_layer_impl->fixed_tile_size_ = fixed_tile_size_;
  84   PictureLayerImpl::PushPropertiesTo(layer_impl);
  85 }
  86
  87 void FakePictureLayerImpl::AppendQuads(
  88     RenderPass* render_pass,
  89     AppendQuadsData* append_quads_data) {
  90   PictureLayerImpl::AppendQuads(render_pass, append_quads_data);
  91   ++append_quads_count_;
  92 }
  93
  94 gfx::Size FakePictureLayerImpl::CalculateTileSize(
  95     const gfx::Size& content_bounds) const {
  96   if (fixed_tile_size_.IsEmpty()) {
  97     return PictureLayerImpl::CalculateTileSize(content_bounds);
  98   }
  99
 100   return fixed_tile_size_;
 101 }
 102
 103 PictureLayerTiling* FakePictureLayerImpl::HighResTiling() const {
 104   PictureLayerTiling* result = NULL;
 105   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
 106     PictureLayerTiling* tiling = tilings_->tiling_at(i);
 107     if (tiling->resolution() == HIGH_RESOLUTION) {
 108       // There should be only one high res tiling.
 109       CHECK(!result);
 110       result = tiling;
 111     }
 112   }
 113   return result;
 114 }
 115
 116 PictureLayerTiling* FakePictureLayerImpl::LowResTiling() const {
 117   PictureLayerTiling* result = NULL;
 118   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
 119     PictureLayerTiling* tiling = tilings_->tiling_at(i);
 120     if (tiling->resolution() == LOW_RESOLUTION) {
 121       // There should be only one low res tiling.
 122       CHECK(!result);
 123       result = tiling;
 124     }
 125   }
 126   return result;
 127 }
 128
 129 void FakePictureLayerImpl::SetRasterSourceOnPending(
 130     scoped_refptr<RasterSource> raster_source,
 131     const Region& invalidation) {
 132   DCHECK(layer_tree_impl()->IsPendingTree());
 133   Region invalidation_temp = invalidation;
 134   const PictureLayerTilingSet* pending_set = nullptr;
 135   set_gpu_raster_max_texture_size(layer_tree_impl()->device_viewport_size());
 136   UpdateRasterSource(raster_source, &invalidation_temp, pending_set);
 137 }
 138
 139 void FakePictureLayerImpl::SetIsDrawnRenderSurfaceLayerListMember(bool is) {
 140   draw_properties().last_drawn_render_surface_layer_list_id =
 141       is ? layer_tree_impl()->current_render_surface_list_id()
 142          : layer_tree_impl()->current_render_surface_list_id() - 1;
 143 }
 144
 145 void FakePictureLayerImpl::CreateAllTiles() {
 146   for (size_t i = 0; i < num_tilings(); ++i)
 147     tilings_->tiling_at(i)->CreateAllTilesForTesting();
 148 }
 149
 150 void FakePictureLayerImpl::SetAllTilesVisible() {
 151   WhichTree tree =
 152       layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
 153
 154   for (size_t tiling_idx = 0; tiling_idx < tilings_->num_tilings();
 155        ++tiling_idx) {
 156     PictureLayerTiling* tiling = tilings_->tiling_at(tiling_idx);
 157     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 158     for (size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
 159       Tile* tile = tiles[tile_idx];
 160       TilePriority priority;
 161       priority.resolution = HIGH_RESOLUTION;
 162       priority.priority_bin = TilePriority::NOW;
 163       priority.distance_to_visible = 0.f;
 164       tile->SetPriority(tree, priority);
 165     }
 166   }
 167 }
 168
 169 void FakePictureLayerImpl::ResetAllTilesPriorities() {
 170   for (size_t tiling_idx = 0; tiling_idx < tilings_->num_tilings();
 171        ++tiling_idx) {
 172     PictureLayerTiling* tiling = tilings_->tiling_at(tiling_idx);
 173     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 174     for (size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
 175       Tile* tile = tiles[tile_idx];
 176       tile->SetPriority(ACTIVE_TREE, TilePriority());
 177       tile->SetPriority(PENDING_TREE, TilePriority());
 178     }
 179   }
 180 }
 181
 182 void FakePictureLayerImpl::SetAllTilesReady() {
 183   for (size_t tiling_idx = 0; tiling_idx < tilings_->num_tilings();
 184        ++tiling_idx) {
 185     PictureLayerTiling* tiling = tilings_->tiling_at(tiling_idx);
 186     SetAllTilesReadyInTiling(tiling);
 187   }
 188 }
 189
 190 void FakePictureLayerImpl::SetAllTilesReadyInTiling(
 191     PictureLayerTiling* tiling) {
 192   std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 193   for (size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
 194     Tile* tile = tiles[tile_idx];
 195     SetTileReady(tile);
 196   }
 197 }
 198
 199 void FakePictureLayerImpl::SetTileReady(Tile* tile) {
 200   TileDrawInfo& draw_info = tile->draw_info();
 201   draw_info.SetSolidColorForTesting(true);
 202   DCHECK(tile->IsReadyToDraw());
 203 }
 204
 205 void FakePictureLayerImpl::DidBecomeActive() {
 206   PictureLayerImpl::DidBecomeActive();
 207   ++did_become_active_call_count_;
 208 }
 209
 210 bool FakePictureLayerImpl::HasValidTilePriorities() const {
 211   return use_set_valid_tile_priorities_flag_
 212              ? has_valid_tile_priorities_
 213              : PictureLayerImpl::HasValidTilePriorities();
 214 }
 215
 216 size_t FakePictureLayerImpl::CountTilesRequired(
 217     TileRequirementCheck is_tile_required_callback) const {
 218   if (!HasValidTilePriorities())
 219     return 0;
 220
 221   if (!tilings_)
 222     return 0;
 223
 224   if (visible_rect_for_tile_priority_.IsEmpty())
 225     return 0;
 226
 227   gfx::Rect rect = viewport_rect_for_tile_priority_in_content_space_;
 228   rect.Intersect(visible_rect_for_tile_priority_);
 229
 230   size_t count = 0;
 231
 232   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
 233     PictureLayerTiling* tiling = tilings_->tiling_at(i);
 234     if (tiling->resolution() != HIGH_RESOLUTION &&
 235         tiling->resolution() != LOW_RESOLUTION)
 236       continue;
 237
 238     for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f, rect); iter;
 239          ++iter) {
 240       const Tile* tile = *iter;
 241       // A null tile (i.e. missing recording) can just be skipped.
 242       // TODO(vmpstr): Verify this is true if we create tiles in raster
 243       // iterators.
 244       if (!tile)
 245         continue;
 246
 247       // We can't check tile->required_for_activation, because that value might
 248       // be out of date. It is updated in the raster/eviction iterators.
 249       // TODO(vmpstr): Remove the comment once you can't access this information
 250       // from the tile.
 251       if ((tiling->*is_tile_required_callback)(tile))
 252         ++count;
 253     }
 254   }
 255
 256   return count;
 257 }
 258
 259 size_t FakePictureLayerImpl::CountTilesRequiredForActivation() const {
 260   if (!layer_tree_impl()->IsPendingTree())
 261     return 0;
 262
 263   return CountTilesRequired(
 264       &PictureLayerTiling::IsTileRequiredForActivationIfVisible);
 265 }
 266
 267 size_t FakePictureLayerImpl::CountTilesRequiredForDraw() const {
 268   if (!layer_tree_impl()->IsActiveTree())
 269     return 0;
 270
 271   return CountTilesRequired(
 272       &PictureLayerTiling::IsTileRequiredForDrawIfVisible);
 273 }
 274
 275 void FakePictureLayerImpl::ReleaseResources() {
 276   PictureLayerImpl::ReleaseResources();
 277   ++release_resources_count_;
 278 }
 279
 280 }  // namespace cc