blob: 5b40945e559a13f670d38bf0e6b11785db55a72c (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "cc/resources/prioritized_tile_set.h"
#include <algorithm>
#include "cc/resources/managed_tile_state.h"
#include "cc/resources/tile.h"
namespace cc {
class BinComparator {
public:
bool operator()(const scoped_refptr<Tile>& a,
const scoped_refptr<Tile>& b) const {
const ManagedTileState& ams = a->managed_state();
const ManagedTileState& bms = b->managed_state();
if (ams.bin[LOW_PRIORITY_BIN] != bms.bin[LOW_PRIORITY_BIN])
return ams.bin[LOW_PRIORITY_BIN] < bms.bin[LOW_PRIORITY_BIN];
if (ams.required_for_activation != bms.required_for_activation)
return ams.required_for_activation;
if (ams.resolution != bms.resolution)
return ams.resolution < bms.resolution;
if (ams.time_to_needed_in_seconds != bms.time_to_needed_in_seconds)
return ams.time_to_needed_in_seconds < bms.time_to_needed_in_seconds;
if (ams.distance_to_visible_in_pixels !=
bms.distance_to_visible_in_pixels) {
return ams.distance_to_visible_in_pixels <
bms.distance_to_visible_in_pixels;
}
gfx::Rect a_rect = a->content_rect();
gfx::Rect b_rect = b->content_rect();
if (a_rect.y() != b_rect.y())
return a_rect.y() < b_rect.y();
return a_rect.x() < b_rect.x();
}
};
namespace {
typedef std::vector<scoped_refptr<Tile> > TileVector;
void SortBinTiles(ManagedTileBin bin, TileVector* tiles) {
switch (bin) {
case NOW_AND_READY_TO_DRAW_BIN:
break;
case NOW_BIN:
case SOON_BIN:
case EVENTUALLY_AND_ACTIVE_BIN:
case EVENTUALLY_BIN:
case NEVER_AND_ACTIVE_BIN:
case NEVER_BIN:
std::sort(tiles->begin(), tiles->end(), BinComparator());
break;
default:
NOTREACHED();
}
}
} // namespace
PrioritizedTileSet::PrioritizedTileSet() {}
PrioritizedTileSet::~PrioritizedTileSet() {}
void PrioritizedTileSet::InsertTile(Tile* tile, ManagedTileBin bin) {
tiles_[bin].push_back(make_scoped_refptr(tile));
}
void PrioritizedTileSet::Clear() {
for (int bin = 0; bin < NUM_BINS; ++bin)
tiles_[bin].clear();
}
void PrioritizedTileSet::Sort() {
for (int bin = 0; bin < NUM_BINS; ++bin)
SortBinTiles(static_cast<ManagedTileBin>(bin), &tiles_[bin]);
}
PrioritizedTileSet::PriorityIterator::PriorityIterator(
PrioritizedTileSet* tile_set)
: tile_set_(tile_set),
current_bin_(NOW_AND_READY_TO_DRAW_BIN),
iterator_(tile_set->tiles_[current_bin_].begin()) {
if (iterator_ == tile_set_->tiles_[current_bin_].end())
AdvanceList();
}
PrioritizedTileSet::PriorityIterator::~PriorityIterator() {}
PrioritizedTileSet::PriorityIterator&
PrioritizedTileSet::PriorityIterator::operator++() {
// We can't increment past the end of the tiles.
DCHECK(iterator_ != tile_set_->tiles_[current_bin_].end());
++iterator_;
if (iterator_ == tile_set_->tiles_[current_bin_].end())
AdvanceList();
return *this;
}
Tile* PrioritizedTileSet::PriorityIterator::operator*() {
DCHECK(iterator_ != tile_set_->tiles_[current_bin_].end());
return iterator_->get();
}
void PrioritizedTileSet::PriorityIterator::AdvanceList() {
DCHECK(iterator_ == tile_set_->tiles_[current_bin_].end());
while (current_bin_ != NEVER_BIN) {
current_bin_ = static_cast<ManagedTileBin>(current_bin_ + 1);
iterator_ = tile_set_->tiles_[current_bin_].begin();
if (iterator_ != tile_set_->tiles_[current_bin_].end())
break;
}
}
} // namespace cc
|
