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