src/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(LayerTreeImpl* tree_impl,
  14                                            int id,
  15                                            scoped_refptr<PicturePileImpl> pile)
  16     : PictureLayerImpl(tree_impl, id),
  17       append_quads_count_(0),
  18       did_become_active_call_count_(0),
  19       has_valid_tile_priorities_(false),
  20       use_set_valid_tile_priorities_flag_(false),
  21       release_resources_count_(0) {
  22   pile_ = pile;
  23   SetBounds(pile_->tiling_size());
  24   SetContentBounds(pile_->tiling_size());
  25 }
  26
  27 FakePictureLayerImpl::FakePictureLayerImpl(LayerTreeImpl* tree_impl,
  28                                            int id,
  29                                            scoped_refptr<PicturePileImpl> pile,
  30                                            const gfx::Size& layer_bounds)
  31     : PictureLayerImpl(tree_impl, id),
  32       append_quads_count_(0),
  33       did_become_active_call_count_(0),
  34       has_valid_tile_priorities_(false),
  35       use_set_valid_tile_priorities_flag_(false),
  36       release_resources_count_(0) {
  37   pile_ = pile;
  38   SetBounds(layer_bounds);
  39   SetContentBounds(layer_bounds);
  40 }
  41
  42 FakePictureLayerImpl::FakePictureLayerImpl(LayerTreeImpl* tree_impl, int id)
  43     : PictureLayerImpl(tree_impl, id),
  44       append_quads_count_(0),
  45       did_become_active_call_count_(0),
  46       has_valid_tile_priorities_(false),
  47       use_set_valid_tile_priorities_flag_(false),
  48       release_resources_count_(0) {
  49 }
  50
  51 scoped_ptr<LayerImpl> FakePictureLayerImpl::CreateLayerImpl(
  52     LayerTreeImpl* tree_impl) {
  53   return make_scoped_ptr(new FakePictureLayerImpl(tree_impl, id()));
  54 }
  55
  56 void FakePictureLayerImpl::AppendQuads(
  57     RenderPass* render_pass,
  58     const Occlusion& occlusion_in_content_space,
  59     AppendQuadsData* append_quads_data) {
  60   PictureLayerImpl::AppendQuads(
  61       render_pass, occlusion_in_content_space, append_quads_data);
  62   ++append_quads_count_;
  63 }
  64
  65 gfx::Size FakePictureLayerImpl::CalculateTileSize(
  66     const gfx::Size& content_bounds) const {
  67   if (fixed_tile_size_.IsEmpty()) {
  68     return PictureLayerImpl::CalculateTileSize(content_bounds);
  69   }
  70
  71   return fixed_tile_size_;
  72 }
  73
  74 PictureLayerTiling* FakePictureLayerImpl::HighResTiling() const {
  75   PictureLayerTiling* result = NULL;
  76   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
  77     PictureLayerTiling* tiling = tilings_->tiling_at(i);
  78     if (tiling->resolution() == HIGH_RESOLUTION) {
  79       // There should be only one high res tiling.
  80       CHECK(!result);
  81       result = tiling;
  82     }
  83   }
  84   return result;
  85 }
  86
  87 PictureLayerTiling* FakePictureLayerImpl::LowResTiling() const {
  88   PictureLayerTiling* result = NULL;
  89   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
  90     PictureLayerTiling* tiling = tilings_->tiling_at(i);
  91     if (tiling->resolution() == LOW_RESOLUTION) {
  92       // There should be only one low res tiling.
  93       CHECK(!result);
  94       result = tiling;
  95     }
  96   }
  97   return result;
  98 }
  99
 100 void FakePictureLayerImpl::SetPile(scoped_refptr<PicturePileImpl> pile) {
 101   pile_.swap(pile);
 102   if (tilings()) {
 103     for (size_t i = 0; i < num_tilings(); ++i) {
 104       tilings()->tiling_at(i)->UpdateTilesToCurrentPile(Region(),
 105                                                         pile_->tiling_size());
 106     }
 107   }
 108 }
 109
 110 void FakePictureLayerImpl::SetAllTilesVisible() {
 111   WhichTree tree =
 112       layer_tree_impl()->IsActiveTree() ? ACTIVE_TREE : PENDING_TREE;
 113
 114   for (size_t tiling_idx = 0; tiling_idx < tilings_->num_tilings();
 115        ++tiling_idx) {
 116     PictureLayerTiling* tiling = tilings_->tiling_at(tiling_idx);
 117     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 118     for (size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
 119       Tile* tile = tiles[tile_idx];
 120       TilePriority priority;
 121       priority.resolution = HIGH_RESOLUTION;
 122       priority.priority_bin = TilePriority::NOW;
 123       priority.distance_to_visible = 0.f;
 124       tile->SetPriority(tree, priority);
 125     }
 126   }
 127 }
 128
 129 void FakePictureLayerImpl::ResetAllTilesPriorities() {
 130   for (size_t tiling_idx = 0; tiling_idx < tilings_->num_tilings();
 131        ++tiling_idx) {
 132     PictureLayerTiling* tiling = tilings_->tiling_at(tiling_idx);
 133     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 134     for (size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
 135       Tile* tile = tiles[tile_idx];
 136       tile->SetPriority(ACTIVE_TREE, TilePriority());
 137       tile->SetPriority(PENDING_TREE, TilePriority());
 138     }
 139   }
 140 }
 141
 142 void FakePictureLayerImpl::SetAllTilesReady() {
 143   for (size_t tiling_idx = 0; tiling_idx < tilings_->num_tilings();
 144        ++tiling_idx) {
 145     PictureLayerTiling* tiling = tilings_->tiling_at(tiling_idx);
 146     SetAllTilesReadyInTiling(tiling);
 147   }
 148 }
 149
 150 void FakePictureLayerImpl::SetAllTilesReadyInTiling(
 151     PictureLayerTiling* tiling) {
 152   std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 153   for (size_t tile_idx = 0; tile_idx < tiles.size(); ++tile_idx) {
 154     Tile* tile = tiles[tile_idx];
 155     SetTileReady(tile);
 156   }
 157 }
 158
 159 void FakePictureLayerImpl::SetTileReady(Tile* tile) {
 160   ManagedTileState& state = tile->managed_state();
 161   state.draw_info.SetSolidColorForTesting(true);
 162   DCHECK(tile->IsReadyToDraw());
 163 }
 164
 165 void FakePictureLayerImpl::CreateDefaultTilingsAndTiles() {
 166   layer_tree_impl()->UpdateDrawProperties();
 167
 168   if (CanHaveTilings()) {
 169     DCHECK_EQ(tilings()->num_tilings(),
 170               layer_tree_impl()->settings().create_low_res_tiling ? 2u : 1u);
 171     DCHECK_EQ(tilings()->tiling_at(0)->resolution(), HIGH_RESOLUTION);
 172     HighResTiling()->CreateAllTilesForTesting();
 173     if (layer_tree_impl()->settings().create_low_res_tiling) {
 174       DCHECK_EQ(tilings()->tiling_at(1)->resolution(), LOW_RESOLUTION);
 175       LowResTiling()->CreateAllTilesForTesting();
 176     }
 177   } else {
 178     DCHECK_EQ(tilings()->num_tilings(), 0u);
 179   }
 180 }
 181
 182 void FakePictureLayerImpl::DidBecomeActive() {
 183   PictureLayerImpl::DidBecomeActive();
 184   ++did_become_active_call_count_;
 185 }
 186
 187 bool FakePictureLayerImpl::HasValidTilePriorities() const {
 188   return use_set_valid_tile_priorities_flag_
 189              ? has_valid_tile_priorities_
 190              : PictureLayerImpl::HasValidTilePriorities();
 191 }
 192
 193 void FakePictureLayerImpl::ReleaseResources() {
 194   PictureLayerImpl::ReleaseResources();
 195   ++release_resources_count_;
 196 }
 197
 198 }  // namespace cc