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   for (size_t tiling_idx = 0; tiling_idx < tilings_->num_tilings();
 152        ++tiling_idx) {
 153     PictureLayerTiling* tiling = tilings_->tiling_at(tiling_idx);
 154     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 155     for (size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
 156       Tile* tile = tiles[tile_idx];
 157       TilePriority priority;
 158       priority.resolution = HIGH_RESOLUTION;
 159       priority.priority_bin = TilePriority::NOW;
 160       priority.distance_to_visible = 0.f;
 161       tile->set_priority(priority);
 162     }
 163   }
 164 }
 165
 166 void FakePictureLayerImpl::ResetAllTilesPriorities() {
 167   for (size_t tiling_idx = 0; tiling_idx < tilings_->num_tilings();
 168        ++tiling_idx) {
 169     PictureLayerTiling* tiling = tilings_->tiling_at(tiling_idx);
 170     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 171     for (size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
 172       Tile* tile = tiles[tile_idx];
 173       tile->set_priority(TilePriority());
 174     }
 175   }
 176 }
 177
 178 void FakePictureLayerImpl::SetAllTilesReady() {
 179   for (size_t tiling_idx = 0; tiling_idx < tilings_->num_tilings();
 180        ++tiling_idx) {
 181     PictureLayerTiling* tiling = tilings_->tiling_at(tiling_idx);
 182     SetAllTilesReadyInTiling(tiling);
 183   }
 184 }
 185
 186 void FakePictureLayerImpl::SetAllTilesReadyInTiling(
 187     PictureLayerTiling* tiling) {
 188   std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 189   for (size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
 190     Tile* tile = tiles[tile_idx];
 191     SetTileReady(tile);
 192   }
 193 }
 194
 195 void FakePictureLayerImpl::SetTileReady(Tile* tile) {
 196   TileDrawInfo& draw_info = tile->draw_info();
 197   draw_info.SetSolidColorForTesting(true);
 198   DCHECK(tile->IsReadyToDraw());
 199 }
 200
 201 void FakePictureLayerImpl::DidBecomeActive() {
 202   PictureLayerImpl::DidBecomeActive();
 203   ++did_become_active_call_count_;
 204 }
 205
 206 bool FakePictureLayerImpl::HasValidTilePriorities() const {
 207   return use_set_valid_tile_priorities_flag_
 208              ? has_valid_tile_priorities_
 209              : PictureLayerImpl::HasValidTilePriorities();
 210 }
 211
 212 size_t FakePictureLayerImpl::CountTilesRequired(
 213     TileRequirementCheck is_tile_required_callback) const {
 214   if (!HasValidTilePriorities())
 215     return 0;
 216
 217   if (!tilings_)
 218     return 0;
 219
 220   if (visible_rect_for_tile_priority_.IsEmpty())
 221     return 0;
 222
 223   gfx::Rect rect = viewport_rect_for_tile_priority_in_content_space_;
 224   rect.Intersect(visible_rect_for_tile_priority_);
 225
 226   size_t count = 0;
 227
 228   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
 229     PictureLayerTiling* tiling = tilings_->tiling_at(i);
 230     if (tiling->resolution() != HIGH_RESOLUTION &&
 231         tiling->resolution() != LOW_RESOLUTION)
 232       continue;
 233
 234     for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f, rect); iter;
 235          ++iter) {
 236       const Tile* tile = *iter;
 237       // A null tile (i.e. missing recording) can just be skipped.
 238       // TODO(vmpstr): Verify this is true if we create tiles in raster
 239       // iterators.
 240       if (!tile)
 241         continue;
 242
 243       // We can't check tile->required_for_activation, because that value might
 244       // be out of date. It is updated in the raster/eviction iterators.
 245       // TODO(vmpstr): Remove the comment once you can't access this information
 246       // from the tile.
 247       if ((tiling->*is_tile_required_callback)(tile))
 248         ++count;
 249     }
 250   }
 251
 252   return count;
 253 }
 254
 255 size_t FakePictureLayerImpl::CountTilesRequiredForActivation() const {
 256   if (!layer_tree_impl()->IsPendingTree())
 257     return 0;
 258
 259   return CountTilesRequired(&PictureLayerTiling::IsTileRequiredForActivation);
 260 }
 261
 262 size_t FakePictureLayerImpl::CountTilesRequiredForDraw() const {
 263   if (!layer_tree_impl()->IsActiveTree())
 264     return 0;
 265
 266   return CountTilesRequired(&PictureLayerTiling::IsTileRequiredForDraw);
 267 }
 268
 269 void FakePictureLayerImpl::ReleaseResources() {
 270   PictureLayerImpl::ReleaseResources();
 271   ++release_resources_count_;
 272 }
 273
 274 }  // namespace cc