1 // Copyright 2012 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.
5 #include "cc/resources/tile_manager.h"
11 #include "base/bind.h"
12 #include "base/json/json_writer.h"
13 #include "base/logging.h"
14 #include "base/metrics/histogram.h"
15 #include "cc/debug/devtools_instrumentation.h"
16 #include "cc/debug/frame_viewer_instrumentation.h"
17 #include "cc/debug/traced_value.h"
18 #include "cc/layers/picture_layer_impl.h"
19 #include "cc/resources/raster_worker_pool.h"
20 #include "cc/resources/rasterizer_delegate.h"
21 #include "cc/resources/tile.h"
22 #include "skia/ext/paint_simplifier.h"
23 #include "third_party/skia/include/core/SkBitmap.h"
24 #include "third_party/skia/include/core/SkPixelRef.h"
25 #include "ui/gfx/rect_conversions.h"
30 // Flag to indicate whether we should try and detect that
31 // a tile is of solid color.
32 const bool kUseColorEstimator
= true;
34 // Minimum width/height of a pile that would require analysis for tiles.
35 const int kMinDimensionsForAnalysis
= 256;
37 class DisableLCDTextFilter
: public SkDrawFilter
{
39 // SkDrawFilter interface.
40 virtual bool filter(SkPaint
* paint
, SkDrawFilter::Type type
) OVERRIDE
{
41 if (type
!= SkDrawFilter::kText_Type
)
44 paint
->setLCDRenderText(false);
49 class RasterTaskImpl
: public RasterTask
{
52 const Resource
* resource
,
53 PicturePileImpl
* picture_pile
,
54 const gfx::Rect
& content_rect
,
56 RasterMode raster_mode
,
57 TileResolution tile_resolution
,
60 int source_frame_number
,
62 RenderingStatsInstrumentation
* rendering_stats
,
63 const base::Callback
<void(const PicturePileImpl::Analysis
&, bool)>& reply
,
64 ImageDecodeTask::Vector
* dependencies
)
65 : RasterTask(resource
, dependencies
),
66 picture_pile_(picture_pile
),
67 content_rect_(content_rect
),
68 contents_scale_(contents_scale
),
69 raster_mode_(raster_mode
),
70 tile_resolution_(tile_resolution
),
73 source_frame_number_(source_frame_number
),
74 analyze_picture_(analyze_picture
),
75 rendering_stats_(rendering_stats
),
79 // Overridden from Task:
80 virtual void RunOnWorkerThread() OVERRIDE
{
81 TRACE_EVENT0("cc", "RasterizerTaskImpl::RunOnWorkerThread");
83 DCHECK(picture_pile_
);
85 AnalyzeAndRaster(picture_pile_
->GetCloneForDrawingOnThread(
86 RasterWorkerPool::GetPictureCloneIndexForCurrentThread()));
90 // Overridden from RasterizerTask:
91 virtual void ScheduleOnOriginThread(RasterizerTaskClient
* client
) OVERRIDE
{
93 canvas_
= client
->AcquireCanvasForRaster(this);
95 virtual void CompleteOnOriginThread(RasterizerTaskClient
* client
) OVERRIDE
{
97 client
->ReleaseCanvasForRaster(this);
99 virtual void RunReplyOnOriginThread() OVERRIDE
{
101 reply_
.Run(analysis_
, !HasFinishedRunning());
105 virtual ~RasterTaskImpl() { DCHECK(!canvas_
); }
108 void AnalyzeAndRaster(PicturePileImpl
* picture_pile
) {
109 DCHECK(picture_pile
);
112 if (analyze_picture_
) {
113 Analyze(picture_pile
);
114 if (analysis_
.is_solid_color
)
118 Raster(picture_pile
);
121 void Analyze(PicturePileImpl
* picture_pile
) {
122 frame_viewer_instrumentation::ScopedAnalyzeTask
analyze_task(
123 tile_id_
, tile_resolution_
, source_frame_number_
, layer_id_
);
125 DCHECK(picture_pile
);
127 picture_pile
->AnalyzeInRect(
128 content_rect_
, contents_scale_
, &analysis_
, rendering_stats_
);
130 // Record the solid color prediction.
131 UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
132 analysis_
.is_solid_color
);
134 // Clear the flag if we're not using the estimator.
135 analysis_
.is_solid_color
&= kUseColorEstimator
;
138 void Raster(PicturePileImpl
* picture_pile
) {
139 frame_viewer_instrumentation::ScopedRasterTask
raster_task(
142 source_frame_number_
,
145 devtools_instrumentation::ScopedLayerTask
layer_task(
146 devtools_instrumentation::kRasterTask
, layer_id_
);
148 skia::RefPtr
<SkDrawFilter
> draw_filter
;
149 switch (raster_mode_
) {
150 case LOW_QUALITY_RASTER_MODE
:
151 draw_filter
= skia::AdoptRef(new skia::PaintSimplifier
);
153 case HIGH_QUALITY_NO_LCD_RASTER_MODE
:
154 draw_filter
= skia::AdoptRef(new DisableLCDTextFilter
);
156 case HIGH_QUALITY_RASTER_MODE
:
158 case NUM_RASTER_MODES
:
162 canvas_
->setDrawFilter(draw_filter
.get());
164 base::TimeDelta prev_rasterize_time
=
165 rendering_stats_
->impl_thread_rendering_stats().rasterize_time
;
167 // Only record rasterization time for highres tiles, because
168 // lowres tiles are not required for activation and therefore
169 // introduce noise in the measurement (sometimes they get rasterized
170 // before we draw and sometimes they aren't)
171 RenderingStatsInstrumentation
* stats
=
172 tile_resolution_
== HIGH_RESOLUTION
? rendering_stats_
: NULL
;
173 DCHECK(picture_pile
);
174 picture_pile
->RasterToBitmap(
175 canvas_
, content_rect_
, contents_scale_
, stats
);
177 if (rendering_stats_
->record_rendering_stats()) {
178 base::TimeDelta current_rasterize_time
=
179 rendering_stats_
->impl_thread_rendering_stats().rasterize_time
;
180 HISTOGRAM_CUSTOM_COUNTS(
181 "Renderer4.PictureRasterTimeUS",
182 (current_rasterize_time
- prev_rasterize_time
).InMicroseconds(),
189 PicturePileImpl::Analysis analysis_
;
190 scoped_refptr
<PicturePileImpl
> picture_pile_
;
191 gfx::Rect content_rect_
;
192 float contents_scale_
;
193 RasterMode raster_mode_
;
194 TileResolution tile_resolution_
;
196 const void* tile_id_
;
197 int source_frame_number_
;
198 bool analyze_picture_
;
199 RenderingStatsInstrumentation
* rendering_stats_
;
200 const base::Callback
<void(const PicturePileImpl::Analysis
&, bool)> reply_
;
203 DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl
);
206 class ImageDecodeTaskImpl
: public ImageDecodeTask
{
208 ImageDecodeTaskImpl(SkPixelRef
* pixel_ref
,
210 RenderingStatsInstrumentation
* rendering_stats
,
211 const base::Callback
<void(bool was_canceled
)>& reply
)
212 : pixel_ref_(skia::SharePtr(pixel_ref
)),
214 rendering_stats_(rendering_stats
),
217 // Overridden from Task:
218 virtual void RunOnWorkerThread() OVERRIDE
{
219 TRACE_EVENT0("cc", "ImageDecodeTaskImpl::RunOnWorkerThread");
221 devtools_instrumentation::ScopedImageDecodeTask
image_decode_task(
223 // This will cause the image referred to by pixel ref to be decoded.
224 pixel_ref_
->lockPixels();
225 pixel_ref_
->unlockPixels();
228 // Overridden from RasterizerTask:
229 virtual void ScheduleOnOriginThread(RasterizerTaskClient
* client
) OVERRIDE
{}
230 virtual void CompleteOnOriginThread(RasterizerTaskClient
* client
) OVERRIDE
{}
231 virtual void RunReplyOnOriginThread() OVERRIDE
{
232 reply_
.Run(!HasFinishedRunning());
236 virtual ~ImageDecodeTaskImpl() {}
239 skia::RefPtr
<SkPixelRef
> pixel_ref_
;
241 RenderingStatsInstrumentation
* rendering_stats_
;
242 const base::Callback
<void(bool was_canceled
)> reply_
;
244 DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl
);
247 const size_t kScheduledRasterTasksLimit
= 32u;
249 // Memory limit policy works by mapping some bin states to the NEVER bin.
250 const ManagedTileBin kBinPolicyMap
[NUM_TILE_MEMORY_LIMIT_POLICIES
][NUM_BINS
] = {
252 {NEVER_BIN
, // [NOW_AND_READY_TO_DRAW_BIN]
253 NEVER_BIN
, // [NOW_BIN]
254 NEVER_BIN
, // [SOON_BIN]
255 NEVER_BIN
, // [EVENTUALLY_AND_ACTIVE_BIN]
256 NEVER_BIN
, // [EVENTUALLY_BIN]
257 NEVER_BIN
, // [AT_LAST_AND_ACTIVE_BIN]
258 NEVER_BIN
, // [AT_LAST_BIN]
259 NEVER_BIN
// [NEVER_BIN]
261 // [ALLOW_ABSOLUTE_MINIMUM]
262 {NOW_AND_READY_TO_DRAW_BIN
, // [NOW_AND_READY_TO_DRAW_BIN]
263 NOW_BIN
, // [NOW_BIN]
264 NEVER_BIN
, // [SOON_BIN]
265 NEVER_BIN
, // [EVENTUALLY_AND_ACTIVE_BIN]
266 NEVER_BIN
, // [EVENTUALLY_BIN]
267 NEVER_BIN
, // [AT_LAST_AND_ACTIVE_BIN]
268 NEVER_BIN
, // [AT_LAST_BIN]
269 NEVER_BIN
// [NEVER_BIN]
271 // [ALLOW_PREPAINT_ONLY]
272 {NOW_AND_READY_TO_DRAW_BIN
, // [NOW_AND_READY_TO_DRAW_BIN]
273 NOW_BIN
, // [NOW_BIN]
274 SOON_BIN
, // [SOON_BIN]
275 NEVER_BIN
, // [EVENTUALLY_AND_ACTIVE_BIN]
276 NEVER_BIN
, // [EVENTUALLY_BIN]
277 NEVER_BIN
, // [AT_LAST_AND_ACTIVE_BIN]
278 NEVER_BIN
, // [AT_LAST_BIN]
279 NEVER_BIN
// [NEVER_BIN]
282 {NOW_AND_READY_TO_DRAW_BIN
, // [NOW_AND_READY_TO_DRAW_BIN]
283 NOW_BIN
, // [NOW_BIN]
284 SOON_BIN
, // [SOON_BIN]
285 EVENTUALLY_AND_ACTIVE_BIN
, // [EVENTUALLY_AND_ACTIVE_BIN]
286 EVENTUALLY_BIN
, // [EVENTUALLY_BIN]
287 AT_LAST_AND_ACTIVE_BIN
, // [AT_LAST_AND_ACTIVE_BIN]
288 AT_LAST_BIN
, // [AT_LAST_BIN]
289 NEVER_BIN
// [NEVER_BIN]
292 // Ready to draw works by mapping NOW_BIN to NOW_AND_READY_TO_DRAW_BIN.
293 const ManagedTileBin kBinReadyToDrawMap
[2][NUM_BINS
] = {
295 {NOW_AND_READY_TO_DRAW_BIN
, // [NOW_AND_READY_TO_DRAW_BIN]
296 NOW_BIN
, // [NOW_BIN]
297 SOON_BIN
, // [SOON_BIN]
298 EVENTUALLY_AND_ACTIVE_BIN
, // [EVENTUALLY_AND_ACTIVE_BIN]
299 EVENTUALLY_BIN
, // [EVENTUALLY_BIN]
300 AT_LAST_AND_ACTIVE_BIN
, // [AT_LAST_AND_ACTIVE_BIN]
301 AT_LAST_BIN
, // [AT_LAST_BIN]
302 NEVER_BIN
// [NEVER_BIN]
305 {NOW_AND_READY_TO_DRAW_BIN
, // [NOW_AND_READY_TO_DRAW_BIN]
306 NOW_AND_READY_TO_DRAW_BIN
, // [NOW_BIN]
307 SOON_BIN
, // [SOON_BIN]
308 EVENTUALLY_AND_ACTIVE_BIN
, // [EVENTUALLY_AND_ACTIVE_BIN]
309 EVENTUALLY_BIN
, // [EVENTUALLY_BIN]
310 AT_LAST_AND_ACTIVE_BIN
, // [AT_LAST_AND_ACTIVE_BIN]
311 AT_LAST_BIN
, // [AT_LAST_BIN]
312 NEVER_BIN
// [NEVER_BIN]
315 // Active works by mapping some bin stats to equivalent _ACTIVE_BIN state.
316 const ManagedTileBin kBinIsActiveMap
[2][NUM_BINS
] = {
318 {NOW_AND_READY_TO_DRAW_BIN
, // [NOW_AND_READY_TO_DRAW_BIN]
319 NOW_BIN
, // [NOW_BIN]
320 SOON_BIN
, // [SOON_BIN]
321 EVENTUALLY_AND_ACTIVE_BIN
, // [EVENTUALLY_AND_ACTIVE_BIN]
322 EVENTUALLY_BIN
, // [EVENTUALLY_BIN]
323 AT_LAST_AND_ACTIVE_BIN
, // [AT_LAST_AND_ACTIVE_BIN]
324 AT_LAST_BIN
, // [AT_LAST_BIN]
325 NEVER_BIN
// [NEVER_BIN]
328 {NOW_AND_READY_TO_DRAW_BIN
, // [NOW_AND_READY_TO_DRAW_BIN]
329 NOW_BIN
, // [NOW_BIN]
330 SOON_BIN
, // [SOON_BIN]
331 EVENTUALLY_AND_ACTIVE_BIN
, // [EVENTUALLY_AND_ACTIVE_BIN]
332 EVENTUALLY_AND_ACTIVE_BIN
, // [EVENTUALLY_BIN]
333 AT_LAST_AND_ACTIVE_BIN
, // [AT_LAST_AND_ACTIVE_BIN]
334 AT_LAST_AND_ACTIVE_BIN
, // [AT_LAST_BIN]
335 NEVER_BIN
// [NEVER_BIN]
338 // Determine bin based on three categories of tiles: things we need now,
339 // things we need soon, and eventually.
340 inline ManagedTileBin
BinFromTilePriority(const TilePriority
& prio
) {
341 if (prio
.priority_bin
== TilePriority::NOW
)
344 if (prio
.priority_bin
== TilePriority::SOON
)
347 if (prio
.distance_to_visible
== std::numeric_limits
<float>::infinity())
350 return EVENTUALLY_BIN
;
355 RasterTaskCompletionStats::RasterTaskCompletionStats()
356 : completed_count(0u), canceled_count(0u) {}
358 scoped_ptr
<base::Value
> RasterTaskCompletionStatsAsValue(
359 const RasterTaskCompletionStats
& stats
) {
360 scoped_ptr
<base::DictionaryValue
> state(new base::DictionaryValue());
361 state
->SetInteger("completed_count", stats
.completed_count
);
362 state
->SetInteger("canceled_count", stats
.canceled_count
);
363 return state
.PassAs
<base::Value
>();
367 scoped_ptr
<TileManager
> TileManager::Create(
368 TileManagerClient
* client
,
369 ResourcePool
* resource_pool
,
370 Rasterizer
* rasterizer
,
371 Rasterizer
* gpu_rasterizer
,
372 bool use_rasterize_on_demand
,
373 RenderingStatsInstrumentation
* rendering_stats_instrumentation
) {
374 return make_scoped_ptr(new TileManager(client
,
378 use_rasterize_on_demand
,
379 rendering_stats_instrumentation
));
382 TileManager::TileManager(
383 TileManagerClient
* client
,
384 ResourcePool
* resource_pool
,
385 Rasterizer
* rasterizer
,
386 Rasterizer
* gpu_rasterizer
,
387 bool use_rasterize_on_demand
,
388 RenderingStatsInstrumentation
* rendering_stats_instrumentation
)
390 resource_pool_(resource_pool
),
391 prioritized_tiles_dirty_(false),
392 all_tiles_that_need_to_be_rasterized_have_memory_(true),
393 all_tiles_required_for_activation_have_memory_(true),
394 memory_required_bytes_(0),
395 memory_nice_to_have_bytes_(0),
396 bytes_releasable_(0),
397 resources_releasable_(0),
398 ever_exceeded_memory_budget_(false),
399 rendering_stats_instrumentation_(rendering_stats_instrumentation
),
400 did_initialize_visible_tile_(false),
401 did_check_for_completed_tasks_since_last_schedule_tasks_(true),
402 use_rasterize_on_demand_(use_rasterize_on_demand
) {
403 Rasterizer
* rasterizers
[NUM_RASTERIZER_TYPES
] = {
404 rasterizer
, // RASTERIZER_TYPE_DEFAULT
405 gpu_rasterizer
, // RASTERIZER_TYPE_GPU
407 rasterizer_delegate_
=
408 RasterizerDelegate::Create(this, rasterizers
, arraysize(rasterizers
));
411 TileManager::~TileManager() {
412 // Reset global state and manage. This should cause
413 // our memory usage to drop to zero.
414 global_state_
= GlobalStateThatImpactsTilePriority();
416 CleanUpReleasedTiles();
417 DCHECK_EQ(0u, tiles_
.size());
419 RasterTaskQueue empty
[NUM_RASTERIZER_TYPES
];
420 rasterizer_delegate_
->ScheduleTasks(empty
);
421 orphan_raster_tasks_
.clear();
423 // This should finish all pending tasks and release any uninitialized
425 rasterizer_delegate_
->Shutdown();
426 rasterizer_delegate_
->CheckForCompletedTasks();
428 DCHECK_EQ(0u, bytes_releasable_
);
429 DCHECK_EQ(0u, resources_releasable_
);
431 for (std::vector
<PictureLayerImpl
*>::iterator it
= layers_
.begin();
434 (*it
)->DidUnregisterLayer();
439 void TileManager::Release(Tile
* tile
) {
440 prioritized_tiles_dirty_
= true;
441 released_tiles_
.push_back(tile
);
444 void TileManager::DidChangeTilePriority(Tile
* tile
) {
445 prioritized_tiles_dirty_
= true;
448 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
449 return global_state_
.tree_priority
!= SMOOTHNESS_TAKES_PRIORITY
;
452 void TileManager::CleanUpReleasedTiles() {
453 for (std::vector
<Tile
*>::iterator it
= released_tiles_
.begin();
454 it
!= released_tiles_
.end();
457 ManagedTileState
& mts
= tile
->managed_state();
459 for (int mode
= 0; mode
< NUM_RASTER_MODES
; ++mode
) {
460 FreeResourceForTile(tile
, static_cast<RasterMode
>(mode
));
461 orphan_raster_tasks_
.push_back(mts
.tile_versions
[mode
].raster_task_
);
464 DCHECK(tiles_
.find(tile
->id()) != tiles_
.end());
465 tiles_
.erase(tile
->id());
467 LayerCountMap::iterator layer_it
=
468 used_layer_counts_
.find(tile
->layer_id());
469 DCHECK_GT(layer_it
->second
, 0);
470 if (--layer_it
->second
== 0) {
471 used_layer_counts_
.erase(layer_it
);
472 image_decode_tasks_
.erase(tile
->layer_id());
478 released_tiles_
.clear();
481 void TileManager::UpdatePrioritizedTileSetIfNeeded() {
482 if (!prioritized_tiles_dirty_
)
485 CleanUpReleasedTiles();
487 prioritized_tiles_
.Clear();
488 GetTilesWithAssignedBins(&prioritized_tiles_
);
489 prioritized_tiles_dirty_
= false;
492 void TileManager::DidFinishRunningTasks() {
493 TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks");
495 bool memory_usage_above_limit
= resource_pool_
->total_memory_usage_bytes() >
496 global_state_
.soft_memory_limit_in_bytes
;
498 // When OOM, keep re-assigning memory until we reach a steady state
499 // where top-priority tiles are initialized.
500 if (all_tiles_that_need_to_be_rasterized_have_memory_
&&
501 !memory_usage_above_limit
)
504 rasterizer_delegate_
->CheckForCompletedTasks();
505 did_check_for_completed_tasks_since_last_schedule_tasks_
= true;
507 TileVector tiles_that_need_to_be_rasterized
;
508 AssignGpuMemoryToTiles(&prioritized_tiles_
,
509 &tiles_that_need_to_be_rasterized
);
511 // |tiles_that_need_to_be_rasterized| will be empty when we reach a
512 // steady memory state. Keep scheduling tasks until we reach this state.
513 if (!tiles_that_need_to_be_rasterized
.empty()) {
514 ScheduleTasks(tiles_that_need_to_be_rasterized
);
518 resource_pool_
->ReduceResourceUsage();
520 // We don't reserve memory for required-for-activation tiles during
521 // accelerated gestures, so we just postpone activation when we don't
522 // have these tiles, and activate after the accelerated gesture.
523 bool allow_rasterize_on_demand
=
524 global_state_
.tree_priority
!= SMOOTHNESS_TAKES_PRIORITY
;
526 // Use on-demand raster for any required-for-activation tiles that have not
527 // been been assigned memory after reaching a steady memory state. This
528 // ensures that we activate even when OOM.
529 for (TileMap::iterator it
= tiles_
.begin(); it
!= tiles_
.end(); ++it
) {
530 Tile
* tile
= it
->second
;
531 ManagedTileState
& mts
= tile
->managed_state();
532 ManagedTileState::TileVersion
& tile_version
=
533 mts
.tile_versions
[mts
.raster_mode
];
535 if (tile
->required_for_activation() && !tile_version
.IsReadyToDraw()) {
536 // If we can't raster on demand, give up early (and don't activate).
537 if (!allow_rasterize_on_demand
)
539 if (use_rasterize_on_demand_
)
540 tile_version
.set_rasterize_on_demand();
544 client_
->NotifyReadyToActivate();
547 void TileManager::DidFinishRunningTasksRequiredForActivation() {
548 // This is only a true indication that all tiles required for
549 // activation are initialized when no tiles are OOM. We need to
550 // wait for DidFinishRunningTasks() to be called, try to re-assign
551 // memory and in worst case use on-demand raster when tiles
552 // required for activation are OOM.
553 if (!all_tiles_required_for_activation_have_memory_
)
556 client_
->NotifyReadyToActivate();
559 void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet
* tiles
) {
560 TRACE_EVENT0("cc", "TileManager::GetTilesWithAssignedBins");
562 // Compute new stats to be return by GetMemoryStats().
563 memory_required_bytes_
= 0;
564 memory_nice_to_have_bytes_
= 0;
566 const TileMemoryLimitPolicy memory_policy
= global_state_
.memory_limit_policy
;
567 const TreePriority tree_priority
= global_state_
.tree_priority
;
569 // For each tree, bin into different categories of tiles.
570 for (TileMap::const_iterator it
= tiles_
.begin(); it
!= tiles_
.end(); ++it
) {
571 Tile
* tile
= it
->second
;
572 ManagedTileState
& mts
= tile
->managed_state();
574 const ManagedTileState::TileVersion
& tile_version
=
575 tile
->GetTileVersionForDrawing();
576 bool tile_is_ready_to_draw
= tile_version
.IsReadyToDraw();
577 bool tile_is_active
= tile_is_ready_to_draw
||
578 mts
.tile_versions
[mts
.raster_mode
].raster_task_
;
580 // Get the active priority and bin.
581 TilePriority active_priority
= tile
->priority(ACTIVE_TREE
);
582 ManagedTileBin active_bin
= BinFromTilePriority(active_priority
);
584 // Get the pending priority and bin.
585 TilePriority pending_priority
= tile
->priority(PENDING_TREE
);
586 ManagedTileBin pending_bin
= BinFromTilePriority(pending_priority
);
588 bool pending_is_low_res
= pending_priority
.resolution
== LOW_RESOLUTION
;
589 bool pending_is_non_ideal
=
590 pending_priority
.resolution
== NON_IDEAL_RESOLUTION
;
591 bool active_is_non_ideal
=
592 active_priority
.resolution
== NON_IDEAL_RESOLUTION
;
594 // Adjust pending bin state for low res tiles. This prevents
595 // pending tree low-res tiles from being initialized before
597 if (pending_is_low_res
)
598 pending_bin
= std::max(pending_bin
, EVENTUALLY_BIN
);
600 // Adjust bin state based on if ready to draw.
601 active_bin
= kBinReadyToDrawMap
[tile_is_ready_to_draw
][active_bin
];
602 pending_bin
= kBinReadyToDrawMap
[tile_is_ready_to_draw
][pending_bin
];
604 // Adjust bin state based on if active.
605 active_bin
= kBinIsActiveMap
[tile_is_active
][active_bin
];
606 pending_bin
= kBinIsActiveMap
[tile_is_active
][pending_bin
];
608 // We never want to paint new non-ideal tiles, as we always have
609 // a high-res tile covering that content (paint that instead).
610 if (!tile_is_ready_to_draw
&& active_is_non_ideal
)
611 active_bin
= NEVER_BIN
;
612 if (!tile_is_ready_to_draw
&& pending_is_non_ideal
)
613 pending_bin
= NEVER_BIN
;
615 // Compute combined bin.
616 ManagedTileBin combined_bin
= std::min(active_bin
, pending_bin
);
618 if (!tile_is_ready_to_draw
|| tile_version
.requires_resource()) {
619 // The bin that the tile would have if the GPU memory manager had
620 // a maximally permissive policy, send to the GPU memory manager
621 // to determine policy.
622 ManagedTileBin gpu_memmgr_stats_bin
= combined_bin
;
623 if ((gpu_memmgr_stats_bin
== NOW_BIN
) ||
624 (gpu_memmgr_stats_bin
== NOW_AND_READY_TO_DRAW_BIN
))
625 memory_required_bytes_
+= BytesConsumedIfAllocated(tile
);
626 if (gpu_memmgr_stats_bin
!= NEVER_BIN
)
627 memory_nice_to_have_bytes_
+= BytesConsumedIfAllocated(tile
);
630 ManagedTileBin tree_bin
[NUM_TREES
];
631 tree_bin
[ACTIVE_TREE
] = kBinPolicyMap
[memory_policy
][active_bin
];
632 tree_bin
[PENDING_TREE
] = kBinPolicyMap
[memory_policy
][pending_bin
];
634 TilePriority tile_priority
;
635 switch (tree_priority
) {
636 case SAME_PRIORITY_FOR_BOTH_TREES
:
637 mts
.bin
= kBinPolicyMap
[memory_policy
][combined_bin
];
638 tile_priority
= tile
->combined_priority();
640 case SMOOTHNESS_TAKES_PRIORITY
:
641 mts
.bin
= tree_bin
[ACTIVE_TREE
];
642 tile_priority
= active_priority
;
644 case NEW_CONTENT_TAKES_PRIORITY
:
645 mts
.bin
= tree_bin
[PENDING_TREE
];
646 tile_priority
= pending_priority
;
650 // Bump up the priority if we determined it's NEVER_BIN on one tree,
651 // but is still required on the other tree.
652 bool is_in_never_bin_on_both_trees
= tree_bin
[ACTIVE_TREE
] == NEVER_BIN
&&
653 tree_bin
[PENDING_TREE
] == NEVER_BIN
;
655 if (mts
.bin
== NEVER_BIN
&& !is_in_never_bin_on_both_trees
)
656 mts
.bin
= tile_is_active
? AT_LAST_AND_ACTIVE_BIN
: AT_LAST_BIN
;
658 mts
.resolution
= tile_priority
.resolution
;
659 mts
.priority_bin
= tile_priority
.priority_bin
;
660 mts
.distance_to_visible
= tile_priority
.distance_to_visible
;
661 mts
.required_for_activation
= tile_priority
.required_for_activation
;
663 mts
.visible_and_ready_to_draw
=
664 tree_bin
[ACTIVE_TREE
] == NOW_AND_READY_TO_DRAW_BIN
;
666 // If the tile is in NEVER_BIN and it does not have an active task, then we
667 // can release the resources early. If it does have the task however, we
668 // should keep it in the prioritized tile set to ensure that AssignGpuMemory
670 if (mts
.bin
== NEVER_BIN
&&
671 !mts
.tile_versions
[mts
.raster_mode
].raster_task_
) {
672 FreeResourcesForTile(tile
);
676 // Insert the tile into a priority set.
677 tiles
->InsertTile(tile
, mts
.bin
);
681 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority
& state
) {
682 TRACE_EVENT0("cc", "TileManager::ManageTiles");
684 // Update internal state.
685 if (state
!= global_state_
) {
686 global_state_
= state
;
687 prioritized_tiles_dirty_
= true;
690 // We need to call CheckForCompletedTasks() once in-between each call
691 // to ScheduleTasks() to prevent canceled tasks from being scheduled.
692 if (!did_check_for_completed_tasks_since_last_schedule_tasks_
) {
693 rasterizer_delegate_
->CheckForCompletedTasks();
694 did_check_for_completed_tasks_since_last_schedule_tasks_
= true;
697 UpdatePrioritizedTileSetIfNeeded();
699 TileVector tiles_that_need_to_be_rasterized
;
700 AssignGpuMemoryToTiles(&prioritized_tiles_
,
701 &tiles_that_need_to_be_rasterized
);
703 // Finally, schedule rasterizer tasks.
704 ScheduleTasks(tiles_that_need_to_be_rasterized
);
706 TRACE_EVENT_INSTANT1("cc",
708 TRACE_EVENT_SCOPE_THREAD
,
710 TracedValue::FromValue(BasicStateAsValue().release()));
712 TRACE_COUNTER_ID1("cc",
713 "unused_memory_bytes",
715 resource_pool_
->total_memory_usage_bytes() -
716 resource_pool_
->acquired_memory_usage_bytes());
719 bool TileManager::UpdateVisibleTiles() {
720 TRACE_EVENT0("cc", "TileManager::UpdateVisibleTiles");
722 rasterizer_delegate_
->CheckForCompletedTasks();
723 did_check_for_completed_tasks_since_last_schedule_tasks_
= true;
725 TRACE_EVENT_INSTANT1(
727 "DidUpdateVisibleTiles",
728 TRACE_EVENT_SCOPE_THREAD
,
730 TracedValue::FromValue(RasterTaskCompletionStatsAsValue(
731 update_visible_tiles_stats_
).release()));
732 update_visible_tiles_stats_
= RasterTaskCompletionStats();
734 bool did_initialize_visible_tile
= did_initialize_visible_tile_
;
735 did_initialize_visible_tile_
= false;
736 return did_initialize_visible_tile
;
739 void TileManager::GetMemoryStats(size_t* memory_required_bytes
,
740 size_t* memory_nice_to_have_bytes
,
741 size_t* memory_allocated_bytes
,
742 size_t* memory_used_bytes
) const {
743 *memory_required_bytes
= memory_required_bytes_
;
744 *memory_nice_to_have_bytes
= memory_nice_to_have_bytes_
;
745 *memory_allocated_bytes
= resource_pool_
->total_memory_usage_bytes();
746 *memory_used_bytes
= resource_pool_
->acquired_memory_usage_bytes();
749 scoped_ptr
<base::Value
> TileManager::BasicStateAsValue() const {
750 scoped_ptr
<base::DictionaryValue
> state(new base::DictionaryValue());
751 state
->SetInteger("tile_count", tiles_
.size());
752 state
->Set("global_state", global_state_
.AsValue().release());
753 state
->Set("memory_requirements", GetMemoryRequirementsAsValue().release());
754 return state
.PassAs
<base::Value
>();
757 scoped_ptr
<base::Value
> TileManager::AllTilesAsValue() const {
758 scoped_ptr
<base::ListValue
> state(new base::ListValue());
759 for (TileMap::const_iterator it
= tiles_
.begin(); it
!= tiles_
.end(); ++it
)
760 state
->Append(it
->second
->AsValue().release());
762 return state
.PassAs
<base::Value
>();
765 scoped_ptr
<base::Value
> TileManager::GetMemoryRequirementsAsValue() const {
766 scoped_ptr
<base::DictionaryValue
> requirements(new base::DictionaryValue());
768 size_t memory_required_bytes
;
769 size_t memory_nice_to_have_bytes
;
770 size_t memory_allocated_bytes
;
771 size_t memory_used_bytes
;
772 GetMemoryStats(&memory_required_bytes
,
773 &memory_nice_to_have_bytes
,
774 &memory_allocated_bytes
,
776 requirements
->SetInteger("memory_required_bytes", memory_required_bytes
);
777 requirements
->SetInteger("memory_nice_to_have_bytes",
778 memory_nice_to_have_bytes
);
779 requirements
->SetInteger("memory_allocated_bytes", memory_allocated_bytes
);
780 requirements
->SetInteger("memory_used_bytes", memory_used_bytes
);
781 return requirements
.PassAs
<base::Value
>();
784 void TileManager::AssignGpuMemoryToTiles(
785 PrioritizedTileSet
* tiles
,
786 TileVector
* tiles_that_need_to_be_rasterized
) {
787 TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
789 // Maintain the list of released resources that can potentially be re-used
791 // If this operation becomes expensive too, only do this after some
792 // resource(s) was returned. Note that in that case, one also need to
793 // invalidate when releasing some resource from the pool.
794 resource_pool_
->CheckBusyResources();
796 // Now give memory out to the tiles until we're out, and build
797 // the needs-to-be-rasterized queue.
798 all_tiles_that_need_to_be_rasterized_have_memory_
= true;
799 all_tiles_required_for_activation_have_memory_
= true;
801 // Cast to prevent overflow.
802 int64 soft_bytes_available
=
803 static_cast<int64
>(bytes_releasable_
) +
804 static_cast<int64
>(global_state_
.soft_memory_limit_in_bytes
) -
805 static_cast<int64
>(resource_pool_
->acquired_memory_usage_bytes());
806 int64 hard_bytes_available
=
807 static_cast<int64
>(bytes_releasable_
) +
808 static_cast<int64
>(global_state_
.hard_memory_limit_in_bytes
) -
809 static_cast<int64
>(resource_pool_
->acquired_memory_usage_bytes());
810 int resources_available
= resources_releasable_
+
811 global_state_
.num_resources_limit
-
812 resource_pool_
->acquired_resource_count();
813 size_t soft_bytes_allocatable
=
814 std::max(static_cast<int64
>(0), soft_bytes_available
);
815 size_t hard_bytes_allocatable
=
816 std::max(static_cast<int64
>(0), hard_bytes_available
);
817 size_t resources_allocatable
= std::max(0, resources_available
);
819 size_t bytes_that_exceeded_memory_budget
= 0;
820 size_t soft_bytes_left
= soft_bytes_allocatable
;
821 size_t hard_bytes_left
= hard_bytes_allocatable
;
823 size_t resources_left
= resources_allocatable
;
824 bool oomed_soft
= false;
825 bool oomed_hard
= false;
826 bool have_hit_soft_memory
= false; // Soft memory comes after hard.
828 unsigned schedule_priority
= 1u;
829 for (PrioritizedTileSet::Iterator
it(tiles
, true); it
; ++it
) {
831 ManagedTileState
& mts
= tile
->managed_state();
833 mts
.scheduled_priority
= schedule_priority
++;
835 mts
.raster_mode
= tile
->DetermineOverallRasterMode();
837 ManagedTileState::TileVersion
& tile_version
=
838 mts
.tile_versions
[mts
.raster_mode
];
840 // If this tile doesn't need a resource, then nothing to do.
841 if (!tile_version
.requires_resource())
844 // If the tile is not needed, free it up.
845 if (mts
.bin
== NEVER_BIN
) {
846 FreeResourcesForTile(tile
);
850 const bool tile_uses_hard_limit
= mts
.bin
<= NOW_BIN
;
851 const size_t bytes_if_allocated
= BytesConsumedIfAllocated(tile
);
852 const size_t tile_bytes_left
=
853 (tile_uses_hard_limit
) ? hard_bytes_left
: soft_bytes_left
;
855 // Hard-limit is reserved for tiles that would cause a calamity
856 // if they were to go away, so by definition they are the highest
857 // priority memory, and must be at the front of the list.
858 DCHECK(!(have_hit_soft_memory
&& tile_uses_hard_limit
));
859 have_hit_soft_memory
|= !tile_uses_hard_limit
;
861 size_t tile_bytes
= 0;
862 size_t tile_resources
= 0;
864 // It costs to maintain a resource.
865 for (int mode
= 0; mode
< NUM_RASTER_MODES
; ++mode
) {
866 if (mts
.tile_versions
[mode
].resource_
) {
867 tile_bytes
+= bytes_if_allocated
;
872 // Allow lower priority tiles with initialized resources to keep
873 // their memory by only assigning memory to new raster tasks if
874 // they can be scheduled.
875 bool reached_scheduled_raster_tasks_limit
=
876 tiles_that_need_to_be_rasterized
->size() >= kScheduledRasterTasksLimit
;
877 if (!reached_scheduled_raster_tasks_limit
) {
878 // If we don't have the required version, and it's not in flight
879 // then we'll have to pay to create a new task.
880 if (!tile_version
.resource_
&& !tile_version
.raster_task_
) {
881 tile_bytes
+= bytes_if_allocated
;
887 if (tile_bytes
> tile_bytes_left
|| tile_resources
> resources_left
) {
888 FreeResourcesForTile(tile
);
890 // This tile was already on screen and now its resources have been
891 // released. In order to prevent checkerboarding, set this tile as
892 // rasterize on demand immediately.
893 if (mts
.visible_and_ready_to_draw
&& use_rasterize_on_demand_
)
894 tile_version
.set_rasterize_on_demand();
897 if (tile_uses_hard_limit
) {
899 bytes_that_exceeded_memory_budget
+= tile_bytes
;
902 resources_left
-= tile_resources
;
903 hard_bytes_left
-= tile_bytes
;
905 (soft_bytes_left
> tile_bytes
) ? soft_bytes_left
- tile_bytes
: 0;
906 if (tile_version
.resource_
)
910 DCHECK(!tile_version
.resource_
);
912 // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized|
913 // has reached it's limit or we've failed to assign gpu memory to this
914 // or any higher priority tile. Preventing tiles that fit into memory
915 // budget to be rasterized when higher priority tile is oom is
916 // important for two reasons:
917 // 1. Tile size should not impact raster priority.
918 // 2. Tiles with existing raster task could otherwise incorrectly
919 // be added as they are not affected by |bytes_allocatable|.
920 bool can_schedule_tile
=
921 !oomed_soft
&& !reached_scheduled_raster_tasks_limit
;
923 if (!can_schedule_tile
) {
924 all_tiles_that_need_to_be_rasterized_have_memory_
= false;
925 if (tile
->required_for_activation())
926 all_tiles_required_for_activation_have_memory_
= false;
927 it
.DisablePriorityOrdering();
931 tiles_that_need_to_be_rasterized
->push_back(tile
);
934 // OOM reporting uses hard-limit, soft-OOM is normal depending on limit.
935 ever_exceeded_memory_budget_
|= oomed_hard
;
936 if (ever_exceeded_memory_budget_
) {
937 TRACE_COUNTER_ID2("cc",
938 "over_memory_budget",
941 global_state_
.hard_memory_limit_in_bytes
,
943 bytes_that_exceeded_memory_budget
);
945 memory_stats_from_last_assign_
.total_budget_in_bytes
=
946 global_state_
.hard_memory_limit_in_bytes
;
947 memory_stats_from_last_assign_
.bytes_allocated
=
948 hard_bytes_allocatable
- hard_bytes_left
;
949 memory_stats_from_last_assign_
.bytes_unreleasable
=
950 resource_pool_
->acquired_memory_usage_bytes() - bytes_releasable_
;
951 memory_stats_from_last_assign_
.bytes_over
= bytes_that_exceeded_memory_budget
;
954 void TileManager::FreeResourceForTile(Tile
* tile
, RasterMode mode
) {
955 ManagedTileState
& mts
= tile
->managed_state();
956 if (mts
.tile_versions
[mode
].resource_
) {
957 resource_pool_
->ReleaseResource(mts
.tile_versions
[mode
].resource_
.Pass());
959 DCHECK_GE(bytes_releasable_
, BytesConsumedIfAllocated(tile
));
960 DCHECK_GE(resources_releasable_
, 1u);
962 bytes_releasable_
-= BytesConsumedIfAllocated(tile
);
963 --resources_releasable_
;
967 void TileManager::FreeResourcesForTile(Tile
* tile
) {
968 for (int mode
= 0; mode
< NUM_RASTER_MODES
; ++mode
) {
969 FreeResourceForTile(tile
, static_cast<RasterMode
>(mode
));
973 void TileManager::FreeUnusedResourcesForTile(Tile
* tile
) {
974 DCHECK(tile
->IsReadyToDraw());
975 ManagedTileState
& mts
= tile
->managed_state();
976 RasterMode used_mode
= HIGH_QUALITY_NO_LCD_RASTER_MODE
;
977 for (int mode
= 0; mode
< NUM_RASTER_MODES
; ++mode
) {
978 if (mts
.tile_versions
[mode
].IsReadyToDraw()) {
979 used_mode
= static_cast<RasterMode
>(mode
);
984 for (int mode
= 0; mode
< NUM_RASTER_MODES
; ++mode
) {
985 if (mode
!= used_mode
)
986 FreeResourceForTile(tile
, static_cast<RasterMode
>(mode
));
990 void TileManager::ScheduleTasks(
991 const TileVector
& tiles_that_need_to_be_rasterized
) {
993 "TileManager::ScheduleTasks",
995 tiles_that_need_to_be_rasterized
.size());
997 DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_
);
999 for (size_t i
= 0; i
< NUM_RASTERIZER_TYPES
; ++i
)
1000 raster_queue_
[i
].Reset();
1002 // Build a new task queue containing all task currently needed. Tasks
1003 // are added in order of priority, highest priority task first.
1004 for (TileVector::const_iterator it
= tiles_that_need_to_be_rasterized
.begin();
1005 it
!= tiles_that_need_to_be_rasterized
.end();
1008 ManagedTileState
& mts
= tile
->managed_state();
1009 ManagedTileState::TileVersion
& tile_version
=
1010 mts
.tile_versions
[mts
.raster_mode
];
1012 DCHECK(tile_version
.requires_resource());
1013 DCHECK(!tile_version
.resource_
);
1015 if (!tile_version
.raster_task_
)
1016 tile_version
.raster_task_
= CreateRasterTask(tile
);
1018 size_t pool_type
= tile
->use_gpu_rasterization() ? RASTERIZER_TYPE_GPU
1019 : RASTERIZER_TYPE_DEFAULT
;
1021 raster_queue_
[pool_type
].items
.push_back(RasterTaskQueue::Item(
1022 tile_version
.raster_task_
.get(), tile
->required_for_activation()));
1023 raster_queue_
[pool_type
].required_for_activation_count
+=
1024 tile
->required_for_activation();
1027 // We must reduce the amount of unused resoruces before calling
1028 // ScheduleTasks to prevent usage from rising above limits.
1029 resource_pool_
->ReduceResourceUsage();
1031 // Schedule running of |raster_tasks_|. This replaces any previously
1032 // scheduled tasks and effectively cancels all tasks not present
1033 // in |raster_tasks_|.
1034 rasterizer_delegate_
->ScheduleTasks(raster_queue_
);
1036 // It's now safe to clean up orphan tasks as raster worker pool is not
1037 // allowed to keep around unreferenced raster tasks after ScheduleTasks() has
1039 orphan_raster_tasks_
.clear();
1041 did_check_for_completed_tasks_since_last_schedule_tasks_
= false;
1044 scoped_refptr
<ImageDecodeTask
> TileManager::CreateImageDecodeTask(
1046 SkPixelRef
* pixel_ref
) {
1047 return make_scoped_refptr(new ImageDecodeTaskImpl(
1050 rendering_stats_instrumentation_
,
1051 base::Bind(&TileManager::OnImageDecodeTaskCompleted
,
1052 base::Unretained(this),
1054 base::Unretained(pixel_ref
))));
1057 scoped_refptr
<RasterTask
> TileManager::CreateRasterTask(Tile
* tile
) {
1058 ManagedTileState
& mts
= tile
->managed_state();
1060 scoped_ptr
<ScopedResource
> resource
=
1061 resource_pool_
->AcquireResource(tile
->tile_size_
.size());
1062 const ScopedResource
* const_resource
= resource
.get();
1064 // Create and queue all image decode tasks that this tile depends on.
1065 ImageDecodeTask::Vector decode_tasks
;
1066 PixelRefTaskMap
& existing_pixel_refs
= image_decode_tasks_
[tile
->layer_id()];
1067 for (PicturePileImpl::PixelRefIterator
iter(
1068 tile
->content_rect(), tile
->contents_scale(), tile
->picture_pile());
1071 SkPixelRef
* pixel_ref
= *iter
;
1072 uint32_t id
= pixel_ref
->getGenerationID();
1074 // Append existing image decode task if available.
1075 PixelRefTaskMap::iterator decode_task_it
= existing_pixel_refs
.find(id
);
1076 if (decode_task_it
!= existing_pixel_refs
.end()) {
1077 decode_tasks
.push_back(decode_task_it
->second
);
1081 // Create and append new image decode task for this pixel ref.
1082 scoped_refptr
<ImageDecodeTask
> decode_task
=
1083 CreateImageDecodeTask(tile
, pixel_ref
);
1084 decode_tasks
.push_back(decode_task
);
1085 existing_pixel_refs
[id
] = decode_task
;
1088 // We analyze picture before rasterization to detect solid-color tiles.
1089 // If the tile is detected as such there is no need to raster or upload.
1090 // It is drawn directly as a solid-color quad saving raster and upload cost.
1091 // The analysis step is however expensive and is not justified when doing
1092 // gpu rasterization where there is no upload.
1094 // Additionally, we do not want to do the analysis if the layer that produced
1095 // this tile is narrow, since more likely than not the tile would not be
1096 // solid. We use the picture pile size as a proxy for layer size, since it
1097 // represents the recorded (and thus rasterizable) content.
1098 // Note that this last optimization is a heuristic that ensures that we don't
1099 // spend too much time analyzing tiles on a multitude of small layers, as it
1100 // is likely that these layers have some non-solid content.
1101 gfx::Size pile_size
= tile
->picture_pile()->tiling_rect().size();
1102 bool analyze_picture
= !tile
->use_gpu_rasterization() &&
1103 std::min(pile_size
.width(), pile_size
.height()) >=
1104 kMinDimensionsForAnalysis
;
1106 return make_scoped_refptr(
1107 new RasterTaskImpl(const_resource
,
1108 tile
->picture_pile(),
1109 tile
->content_rect(),
1110 tile
->contents_scale(),
1114 static_cast<const void*>(tile
),
1115 tile
->source_frame_number(),
1117 rendering_stats_instrumentation_
,
1118 base::Bind(&TileManager::OnRasterTaskCompleted
,
1119 base::Unretained(this),
1121 base::Passed(&resource
),
1126 void TileManager::OnImageDecodeTaskCompleted(int layer_id
,
1127 SkPixelRef
* pixel_ref
,
1128 bool was_canceled
) {
1129 // If the task was canceled, we need to clean it up
1130 // from |image_decode_tasks_|.
1134 LayerPixelRefTaskMap::iterator layer_it
= image_decode_tasks_
.find(layer_id
);
1135 if (layer_it
== image_decode_tasks_
.end())
1138 PixelRefTaskMap
& pixel_ref_tasks
= layer_it
->second
;
1139 PixelRefTaskMap::iterator task_it
=
1140 pixel_ref_tasks
.find(pixel_ref
->getGenerationID());
1142 if (task_it
!= pixel_ref_tasks
.end())
1143 pixel_ref_tasks
.erase(task_it
);
1146 void TileManager::OnRasterTaskCompleted(
1148 scoped_ptr
<ScopedResource
> resource
,
1149 RasterMode raster_mode
,
1150 const PicturePileImpl::Analysis
& analysis
,
1151 bool was_canceled
) {
1152 TileMap::iterator it
= tiles_
.find(tile_id
);
1153 if (it
== tiles_
.end()) {
1154 ++update_visible_tiles_stats_
.canceled_count
;
1155 resource_pool_
->ReleaseResource(resource
.Pass());
1159 Tile
* tile
= it
->second
;
1160 ManagedTileState
& mts
= tile
->managed_state();
1161 ManagedTileState::TileVersion
& tile_version
= mts
.tile_versions
[raster_mode
];
1162 DCHECK(tile_version
.raster_task_
);
1163 orphan_raster_tasks_
.push_back(tile_version
.raster_task_
);
1164 tile_version
.raster_task_
= NULL
;
1167 ++update_visible_tiles_stats_
.canceled_count
;
1168 resource_pool_
->ReleaseResource(resource
.Pass());
1172 ++update_visible_tiles_stats_
.completed_count
;
1174 tile_version
.set_has_text(analysis
.has_text
);
1175 if (analysis
.is_solid_color
) {
1176 tile_version
.set_solid_color(analysis
.solid_color
);
1177 resource_pool_
->ReleaseResource(resource
.Pass());
1179 tile_version
.set_use_resource();
1180 tile_version
.resource_
= resource
.Pass();
1182 bytes_releasable_
+= BytesConsumedIfAllocated(tile
);
1183 ++resources_releasable_
;
1186 client_
->NotifyTileInitialized(tile
);
1188 FreeUnusedResourcesForTile(tile
);
1189 if (tile
->priority(ACTIVE_TREE
).distance_to_visible
== 0.f
)
1190 did_initialize_visible_tile_
= true;
1193 scoped_refptr
<Tile
> TileManager::CreateTile(PicturePileImpl
* picture_pile
,
1194 const gfx::Size
& tile_size
,
1195 const gfx::Rect
& content_rect
,
1196 const gfx::Rect
& opaque_rect
,
1197 float contents_scale
,
1199 int source_frame_number
,
1201 scoped_refptr
<Tile
> tile
= make_scoped_refptr(new Tile(this,
1208 source_frame_number
,
1210 DCHECK(tiles_
.find(tile
->id()) == tiles_
.end());
1212 tiles_
[tile
->id()] = tile
;
1213 used_layer_counts_
[tile
->layer_id()]++;
1214 prioritized_tiles_dirty_
= true;
1218 void TileManager::RegisterPictureLayerImpl(PictureLayerImpl
* layer
) {
1219 DCHECK(std::find(layers_
.begin(), layers_
.end(), layer
) == layers_
.end());
1220 layers_
.push_back(layer
);
1223 void TileManager::UnregisterPictureLayerImpl(PictureLayerImpl
* layer
) {
1224 std::vector
<PictureLayerImpl
*>::iterator it
=
1225 std::find(layers_
.begin(), layers_
.end(), layer
);
1226 DCHECK(it
!= layers_
.end());
1230 void TileManager::GetPairedPictureLayers(
1231 std::vector
<PairedPictureLayer
>* paired_layers
) const {
1232 paired_layers
->clear();
1233 // Reserve a maximum possible paired layers.
1234 paired_layers
->reserve(layers_
.size());
1236 for (std::vector
<PictureLayerImpl
*>::const_iterator it
= layers_
.begin();
1237 it
!= layers_
.end();
1239 PictureLayerImpl
* layer
= *it
;
1241 // This is a recycle tree layer, we can safely skip since the tiles on this
1242 // layer have to be accessible via the active tree.
1243 if (!layer
->IsOnActiveOrPendingTree())
1246 PictureLayerImpl
* twin_layer
= layer
->GetTwinLayer();
1248 // If the twin layer is recycled, it is not a valid twin.
1249 if (twin_layer
&& !twin_layer
->IsOnActiveOrPendingTree())
1252 PairedPictureLayer paired_layer
;
1253 WhichTree tree
= layer
->GetTree();
1255 // If the current tree is ACTIVE_TREE, then always generate a paired_layer.
1256 // If current tree is PENDING_TREE, then only generate a paired_layer if
1257 // there is no twin layer.
1258 if (tree
== ACTIVE_TREE
) {
1259 DCHECK(!twin_layer
|| twin_layer
->GetTree() == PENDING_TREE
);
1260 paired_layer
.active_layer
= layer
;
1261 paired_layer
.pending_layer
= twin_layer
;
1262 paired_layers
->push_back(paired_layer
);
1263 } else if (!twin_layer
) {
1264 paired_layer
.active_layer
= NULL
;
1265 paired_layer
.pending_layer
= layer
;
1266 paired_layers
->push_back(paired_layer
);
1271 TileManager::PairedPictureLayer::PairedPictureLayer()
1272 : active_layer(NULL
), pending_layer(NULL
) {}
1274 TileManager::PairedPictureLayer::~PairedPictureLayer() {}
1276 TileManager::RasterTileIterator::RasterTileIterator(TileManager
* tile_manager
,
1277 TreePriority tree_priority
)
1278 : tree_priority_(tree_priority
), comparator_(tree_priority
) {
1279 std::vector
<TileManager::PairedPictureLayer
> paired_layers
;
1280 tile_manager
->GetPairedPictureLayers(&paired_layers
);
1281 bool prioritize_low_res
= tree_priority_
== SMOOTHNESS_TAKES_PRIORITY
;
1283 paired_iterators_
.reserve(paired_layers
.size());
1284 iterator_heap_
.reserve(paired_layers
.size());
1285 for (std::vector
<TileManager::PairedPictureLayer
>::iterator it
=
1286 paired_layers
.begin();
1287 it
!= paired_layers
.end();
1289 PairedPictureLayerIterator paired_iterator
;
1290 if (it
->active_layer
) {
1291 paired_iterator
.active_iterator
=
1292 PictureLayerImpl::LayerRasterTileIterator(it
->active_layer
,
1293 prioritize_low_res
);
1296 if (it
->pending_layer
) {
1297 paired_iterator
.pending_iterator
=
1298 PictureLayerImpl::LayerRasterTileIterator(it
->pending_layer
,
1299 prioritize_low_res
);
1302 if (paired_iterator
.PeekTile(tree_priority_
) != NULL
) {
1303 paired_iterators_
.push_back(paired_iterator
);
1304 iterator_heap_
.push_back(&paired_iterators_
.back());
1308 std::make_heap(iterator_heap_
.begin(), iterator_heap_
.end(), comparator_
);
1311 TileManager::RasterTileIterator::~RasterTileIterator() {}
1313 TileManager::RasterTileIterator
& TileManager::RasterTileIterator::operator++() {
1316 std::pop_heap(iterator_heap_
.begin(), iterator_heap_
.end(), comparator_
);
1317 PairedPictureLayerIterator
* paired_iterator
= iterator_heap_
.back();
1318 iterator_heap_
.pop_back();
1320 paired_iterator
->PopTile(tree_priority_
);
1321 if (paired_iterator
->PeekTile(tree_priority_
) != NULL
) {
1322 iterator_heap_
.push_back(paired_iterator
);
1323 std::push_heap(iterator_heap_
.begin(), iterator_heap_
.end(), comparator_
);
1328 TileManager::RasterTileIterator::operator bool() const {
1329 return !iterator_heap_
.empty();
1332 Tile
* TileManager::RasterTileIterator::operator*() {
1334 return iterator_heap_
.front()->PeekTile(tree_priority_
);
1337 TileManager::RasterTileIterator::PairedPictureLayerIterator::
1338 PairedPictureLayerIterator() {}
1340 TileManager::RasterTileIterator::PairedPictureLayerIterator::
1341 ~PairedPictureLayerIterator() {}
1343 Tile
* TileManager::RasterTileIterator::PairedPictureLayerIterator::PeekTile(
1344 TreePriority tree_priority
) {
1345 PictureLayerImpl::LayerRasterTileIterator
* next_iterator
=
1346 NextTileIterator(tree_priority
).first
;
1350 DCHECK(*next_iterator
);
1351 DCHECK(std::find(returned_shared_tiles
.begin(),
1352 returned_shared_tiles
.end(),
1353 **next_iterator
) == returned_shared_tiles
.end());
1354 return **next_iterator
;
1357 void TileManager::RasterTileIterator::PairedPictureLayerIterator::PopTile(
1358 TreePriority tree_priority
) {
1359 PictureLayerImpl::LayerRasterTileIterator
* next_iterator
=
1360 NextTileIterator(tree_priority
).first
;
1361 DCHECK(next_iterator
);
1362 DCHECK(*next_iterator
);
1363 returned_shared_tiles
.push_back(**next_iterator
);
1366 next_iterator
= NextTileIterator(tree_priority
).first
;
1367 while (next_iterator
&&
1368 std::find(returned_shared_tiles
.begin(),
1369 returned_shared_tiles
.end(),
1370 **next_iterator
) != returned_shared_tiles
.end()) {
1372 next_iterator
= NextTileIterator(tree_priority
).first
;
1376 std::pair
<PictureLayerImpl::LayerRasterTileIterator
*, WhichTree
>
1377 TileManager::RasterTileIterator::PairedPictureLayerIterator::NextTileIterator(
1378 TreePriority tree_priority
) {
1379 // If both iterators are out of tiles, return NULL.
1380 if (!active_iterator
&& !pending_iterator
) {
1381 return std::pair
<PictureLayerImpl::LayerRasterTileIterator
*, WhichTree
>(
1385 // If we only have one iterator with tiles, return it.
1386 if (!active_iterator
)
1387 return std::make_pair(&pending_iterator
, PENDING_TREE
);
1388 if (!pending_iterator
)
1389 return std::make_pair(&active_iterator
, ACTIVE_TREE
);
1391 // Now both iterators have tiles, so we have to decide based on tree priority.
1392 switch (tree_priority
) {
1393 case SMOOTHNESS_TAKES_PRIORITY
:
1394 return std::make_pair(&active_iterator
, ACTIVE_TREE
);
1395 case NEW_CONTENT_TAKES_PRIORITY
:
1396 return std::make_pair(&pending_iterator
, ACTIVE_TREE
);
1397 case SAME_PRIORITY_FOR_BOTH_TREES
: {
1398 Tile
* active_tile
= *active_iterator
;
1399 Tile
* pending_tile
= *pending_iterator
;
1400 if (active_tile
== pending_tile
)
1401 return std::make_pair(&active_iterator
, ACTIVE_TREE
);
1403 const TilePriority
& active_priority
= active_tile
->priority(ACTIVE_TREE
);
1404 const TilePriority
& pending_priority
=
1405 pending_tile
->priority(PENDING_TREE
);
1407 if (active_priority
.IsHigherPriorityThan(pending_priority
))
1408 return std::make_pair(&active_iterator
, ACTIVE_TREE
);
1409 return std::make_pair(&pending_iterator
, PENDING_TREE
);
1414 // Keep the compiler happy.
1415 return std::pair
<PictureLayerImpl::LayerRasterTileIterator
*, WhichTree
>(
1419 TileManager::RasterTileIterator::RasterOrderComparator::RasterOrderComparator(
1420 TreePriority tree_priority
)
1421 : tree_priority_(tree_priority
) {}
1423 bool TileManager::RasterTileIterator::RasterOrderComparator::operator()(
1424 PairedPictureLayerIterator
* a
,
1425 PairedPictureLayerIterator
* b
) const {
1426 std::pair
<PictureLayerImpl::LayerRasterTileIterator
*, WhichTree
> a_pair
=
1427 a
->NextTileIterator(tree_priority_
);
1428 DCHECK(a_pair
.first
);
1429 DCHECK(*a_pair
.first
);
1431 std::pair
<PictureLayerImpl::LayerRasterTileIterator
*, WhichTree
> b_pair
=
1432 b
->NextTileIterator(tree_priority_
);
1433 DCHECK(b_pair
.first
);
1434 DCHECK(*b_pair
.first
);
1436 Tile
* a_tile
= **a_pair
.first
;
1437 Tile
* b_tile
= **b_pair
.first
;
1439 const TilePriority
& a_priority
=
1440 a_tile
->priority_for_tree_priority(tree_priority_
);
1441 const TilePriority
& b_priority
=
1442 b_tile
->priority_for_tree_priority(tree_priority_
);
1443 bool prioritize_low_res
= tree_priority_
== SMOOTHNESS_TAKES_PRIORITY
;
1445 if (b_priority
.resolution
!= a_priority
.resolution
) {
1446 return (prioritize_low_res
&& b_priority
.resolution
== LOW_RESOLUTION
) ||
1447 (!prioritize_low_res
&& b_priority
.resolution
== HIGH_RESOLUTION
) ||
1448 (a_priority
.resolution
== NON_IDEAL_RESOLUTION
);
1451 return b_priority
.IsHigherPriorityThan(a_priority
);
1454 TileManager::EvictionTileIterator::EvictionTileIterator()
1455 : comparator_(SAME_PRIORITY_FOR_BOTH_TREES
) {}
1457 TileManager::EvictionTileIterator::EvictionTileIterator(
1458 TileManager
* tile_manager
,
1459 TreePriority tree_priority
)
1460 : tree_priority_(tree_priority
), comparator_(tree_priority
) {
1461 std::vector
<TileManager::PairedPictureLayer
> paired_layers
;
1463 tile_manager
->GetPairedPictureLayers(&paired_layers
);
1465 paired_iterators_
.reserve(paired_layers
.size());
1466 iterator_heap_
.reserve(paired_layers
.size());
1467 for (std::vector
<TileManager::PairedPictureLayer
>::iterator it
=
1468 paired_layers
.begin();
1469 it
!= paired_layers
.end();
1471 PairedPictureLayerIterator paired_iterator
;
1472 if (it
->active_layer
) {
1473 paired_iterator
.active_iterator
=
1474 PictureLayerImpl::LayerEvictionTileIterator(it
->active_layer
,
1478 if (it
->pending_layer
) {
1479 paired_iterator
.pending_iterator
=
1480 PictureLayerImpl::LayerEvictionTileIterator(it
->pending_layer
,
1484 if (paired_iterator
.PeekTile(tree_priority_
) != NULL
) {
1485 paired_iterators_
.push_back(paired_iterator
);
1486 iterator_heap_
.push_back(&paired_iterators_
.back());
1490 std::make_heap(iterator_heap_
.begin(), iterator_heap_
.end(), comparator_
);
1493 TileManager::EvictionTileIterator::~EvictionTileIterator() {}
1495 TileManager::EvictionTileIterator
& TileManager::EvictionTileIterator::
1497 std::pop_heap(iterator_heap_
.begin(), iterator_heap_
.end(), comparator_
);
1498 PairedPictureLayerIterator
* paired_iterator
= iterator_heap_
.back();
1499 iterator_heap_
.pop_back();
1501 paired_iterator
->PopTile(tree_priority_
);
1502 if (paired_iterator
->PeekTile(tree_priority_
) != NULL
) {
1503 iterator_heap_
.push_back(paired_iterator
);
1504 std::push_heap(iterator_heap_
.begin(), iterator_heap_
.end(), comparator_
);
1509 TileManager::EvictionTileIterator::operator bool() const {
1510 return !iterator_heap_
.empty();
1513 Tile
* TileManager::EvictionTileIterator::operator*() {
1515 return iterator_heap_
.front()->PeekTile(tree_priority_
);
1518 TileManager::EvictionTileIterator::PairedPictureLayerIterator::
1519 PairedPictureLayerIterator() {}
1521 TileManager::EvictionTileIterator::PairedPictureLayerIterator::
1522 ~PairedPictureLayerIterator() {}
1524 Tile
* TileManager::EvictionTileIterator::PairedPictureLayerIterator::PeekTile(
1525 TreePriority tree_priority
) {
1526 PictureLayerImpl::LayerEvictionTileIterator
* next_iterator
=
1527 NextTileIterator(tree_priority
);
1531 DCHECK(*next_iterator
);
1532 DCHECK(std::find(returned_shared_tiles
.begin(),
1533 returned_shared_tiles
.end(),
1534 **next_iterator
) == returned_shared_tiles
.end());
1535 return **next_iterator
;
1538 void TileManager::EvictionTileIterator::PairedPictureLayerIterator::PopTile(
1539 TreePriority tree_priority
) {
1540 PictureLayerImpl::LayerEvictionTileIterator
* next_iterator
=
1541 NextTileIterator(tree_priority
);
1542 DCHECK(next_iterator
);
1543 DCHECK(*next_iterator
);
1544 returned_shared_tiles
.push_back(**next_iterator
);
1547 next_iterator
= NextTileIterator(tree_priority
);
1548 while (next_iterator
&&
1549 std::find(returned_shared_tiles
.begin(),
1550 returned_shared_tiles
.end(),
1551 **next_iterator
) != returned_shared_tiles
.end()) {
1553 next_iterator
= NextTileIterator(tree_priority
);
1557 PictureLayerImpl::LayerEvictionTileIterator
*
1558 TileManager::EvictionTileIterator::PairedPictureLayerIterator::NextTileIterator(
1559 TreePriority tree_priority
) {
1560 // If both iterators are out of tiles, return NULL.
1561 if (!active_iterator
&& !pending_iterator
)
1564 // If we only have one iterator with tiles, return it.
1565 if (!active_iterator
)
1566 return &pending_iterator
;
1567 if (!pending_iterator
)
1568 return &active_iterator
;
1570 Tile
* active_tile
= *active_iterator
;
1571 Tile
* pending_tile
= *pending_iterator
;
1572 if (active_tile
== pending_tile
)
1573 return &active_iterator
;
1575 const TilePriority
& active_priority
=
1576 active_tile
->priority_for_tree_priority(tree_priority
);
1577 const TilePriority
& pending_priority
=
1578 pending_tile
->priority_for_tree_priority(tree_priority
);
1580 if (pending_priority
.IsHigherPriorityThan(active_priority
))
1581 return &active_iterator
;
1582 return &pending_iterator
;
1585 TileManager::EvictionTileIterator::EvictionOrderComparator::
1586 EvictionOrderComparator(TreePriority tree_priority
)
1587 : tree_priority_(tree_priority
) {}
1589 bool TileManager::EvictionTileIterator::EvictionOrderComparator::operator()(
1590 PairedPictureLayerIterator
* a
,
1591 PairedPictureLayerIterator
* b
) const {
1592 PictureLayerImpl::LayerEvictionTileIterator
* a_iterator
=
1593 a
->NextTileIterator(tree_priority_
);
1595 DCHECK(*a_iterator
);
1597 PictureLayerImpl::LayerEvictionTileIterator
* b_iterator
=
1598 b
->NextTileIterator(tree_priority_
);
1600 DCHECK(*b_iterator
);
1602 Tile
* a_tile
= **a_iterator
;
1603 Tile
* b_tile
= **b_iterator
;
1605 const TilePriority
& a_priority
=
1606 a_tile
->priority_for_tree_priority(tree_priority_
);
1607 const TilePriority
& b_priority
=
1608 b_tile
->priority_for_tree_priority(tree_priority_
);
1609 bool prioritize_low_res
= tree_priority_
!= SMOOTHNESS_TAKES_PRIORITY
;
1611 if (b_priority
.resolution
!= a_priority
.resolution
) {
1612 return (prioritize_low_res
&& b_priority
.resolution
== LOW_RESOLUTION
) ||
1613 (!prioritize_low_res
&& b_priority
.resolution
== HIGH_RESOLUTION
) ||
1614 (a_priority
.resolution
== NON_IDEAL_RESOLUTION
);
1616 return a_priority
.IsHigherPriorityThan(b_priority
);