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