cc/resources/prioritized_tile_set.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/resources/prioritized_tile_set.h"
   6
   7 #include <algorithm>
   8
   9 #include "cc/resources/managed_tile_state.h"
  10 #include "cc/resources/tile.h"
  11
  12 namespace cc {
  13
  14 class BinComparator {
  15  public:
  16   bool operator()(const Tile* a,
  17                   const Tile* b) const {
  18     const ManagedTileState& ams = a->managed_state();
  19     const ManagedTileState& bms = b->managed_state();
  20
  21     if (ams.priority_bin != bms.priority_bin)
  22       return ams.priority_bin < bms.priority_bin;
  23
  24     if (ams.required_for_activation != bms.required_for_activation)
  25       return ams.required_for_activation;
  26
  27     if (ams.resolution != bms.resolution)
  28       return ams.resolution < bms.resolution;
  29
  30     if (ams.distance_to_visible != bms.distance_to_visible)
  31       return ams.distance_to_visible < bms.distance_to_visible;
  32
  33     gfx::Rect a_rect = a->content_rect();
  34     gfx::Rect b_rect = b->content_rect();
  35     if (a_rect.y() != b_rect.y())
  36       return a_rect.y() < b_rect.y();
  37     return a_rect.x() < b_rect.x();
  38   }
  39 };
  40
  41 namespace {
  42
  43 typedef std::vector<Tile*> TileVector;
  44
  45 void SortBinTiles(ManagedTileBin bin, TileVector* tiles) {
  46   switch (bin) {
  47     case NOW_AND_READY_TO_DRAW_BIN:
  48     case NEVER_BIN:
  49       break;
  50     case NOW_BIN:
  51     case SOON_BIN:
  52     case EVENTUALLY_AND_ACTIVE_BIN:
  53     case EVENTUALLY_BIN:
  54     case AT_LAST_AND_ACTIVE_BIN:
  55     case AT_LAST_BIN:
  56       std::sort(tiles->begin(), tiles->end(), BinComparator());
  57       break;
  58     default:
  59       NOTREACHED();
  60   }
  61 }
  62
  63 }  // namespace
  64
  65 PrioritizedTileSet::PrioritizedTileSet() {
  66   for (int bin = 0; bin < NUM_BINS; ++bin)
  67     bin_sorted_[bin] = true;
  68 }
  69
  70 PrioritizedTileSet::~PrioritizedTileSet() {}
  71
  72 void PrioritizedTileSet::InsertTile(Tile* tile, ManagedTileBin bin) {
  73   tiles_[bin].push_back(tile);
  74   bin_sorted_[bin] = false;
  75 }
  76
  77 void PrioritizedTileSet::Clear() {
  78   for (int bin = 0; bin < NUM_BINS; ++bin) {
  79     tiles_[bin].clear();
  80     bin_sorted_[bin] = true;
  81   }
  82 }
  83
  84 void PrioritizedTileSet::SortBinIfNeeded(ManagedTileBin bin) {
  85   if (!bin_sorted_[bin]) {
  86     SortBinTiles(bin, &tiles_[bin]);
  87     bin_sorted_[bin] = true;
  88   }
  89 }
  90
  91 PrioritizedTileSet::Iterator::Iterator(
  92     PrioritizedTileSet* tile_set, bool use_priority_ordering)
  93     : tile_set_(tile_set),
  94       current_bin_(NOW_AND_READY_TO_DRAW_BIN),
  95       use_priority_ordering_(use_priority_ordering) {
  96   if (use_priority_ordering_)
  97     tile_set_->SortBinIfNeeded(current_bin_);
  98   iterator_ = tile_set->tiles_[current_bin_].begin();
  99   if (iterator_ == tile_set_->tiles_[current_bin_].end())
 100     AdvanceList();
 101 }
 102
 103 PrioritizedTileSet::Iterator::~Iterator() {}
 104
 105 void PrioritizedTileSet::Iterator::DisablePriorityOrdering() {
 106   use_priority_ordering_ = false;
 107 }
 108
 109 PrioritizedTileSet::Iterator&
 110 PrioritizedTileSet::Iterator::operator++() {
 111   // We can't increment past the end of the tiles.
 112   DCHECK(iterator_ != tile_set_->tiles_[current_bin_].end());
 113
 114   ++iterator_;
 115   if (iterator_ == tile_set_->tiles_[current_bin_].end())
 116     AdvanceList();
 117   return *this;
 118 }
 119
 120 Tile* PrioritizedTileSet::Iterator::operator*() {
 121   DCHECK(iterator_ != tile_set_->tiles_[current_bin_].end());
 122   return *iterator_;
 123 }
 124
 125 void PrioritizedTileSet::Iterator::AdvanceList() {
 126   DCHECK(iterator_ == tile_set_->tiles_[current_bin_].end());
 127
 128   while (current_bin_ != NEVER_BIN) {
 129     current_bin_ = static_cast<ManagedTileBin>(current_bin_ + 1);
 130
 131     if (use_priority_ordering_)
 132       tile_set_->SortBinIfNeeded(current_bin_);
 133
 134     iterator_ = tile_set_->tiles_[current_bin_].begin();
 135     if (iterator_ != tile_set_->tiles_[current_bin_].end())
 136       break;
 137   }
 138 }
 139
 140 }  // namespace cc