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