src/cc/resources/tile_manager.cc

   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.
   4
   5 #include "cc/resources/tile_manager.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9 #include <string>
  10
  11 #include "base/bind.h"
  12 #include "base/debug/trace_event_argument.h"
  13 #include "base/json/json_writer.h"
  14 #include "base/logging.h"
  15 #include "base/metrics/histogram.h"
  16 #include "cc/debug/devtools_instrumentation.h"
  17 #include "cc/debug/frame_viewer_instrumentation.h"
  18 #include "cc/debug/traced_value.h"
  19 #include "cc/layers/picture_layer_impl.h"
  20 #include "cc/resources/raster_worker_pool.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"
  26
  27 namespace cc {
  28 namespace {
  29
  30 // Flag to indicate whether we should try and detect that
  31 // a tile is of solid color.
  32 const bool kUseColorEstimator = true;
  33
  34 class RasterTaskImpl : public RasterTask {
  35  public:
  36   RasterTaskImpl(
  37       const Resource* resource,
  38       PicturePileImpl* picture_pile,
  39       const gfx::Rect& content_rect,
  40       float contents_scale,
  41       RasterMode raster_mode,
  42       TileResolution tile_resolution,
  43       int layer_id,
  44       const void* tile_id,
  45       int source_frame_number,
  46       bool analyze_picture,
  47       RenderingStatsInstrumentation* rendering_stats,
  48       const base::Callback<void(const PicturePileImpl::Analysis&, bool)>& reply,
  49       ImageDecodeTask::Vector* dependencies)
  50       : RasterTask(resource, dependencies),
  51         picture_pile_(picture_pile),
  52         content_rect_(content_rect),
  53         contents_scale_(contents_scale),
  54         raster_mode_(raster_mode),
  55         tile_resolution_(tile_resolution),
  56         layer_id_(layer_id),
  57         tile_id_(tile_id),
  58         source_frame_number_(source_frame_number),
  59         analyze_picture_(analyze_picture),
  60         rendering_stats_(rendering_stats),
  61         reply_(reply),
  62         canvas_(NULL) {}
  63
  64   // Overridden from Task:
  65   virtual void RunOnWorkerThread() OVERRIDE {
  66     TRACE_EVENT0("cc", "RasterizerTaskImpl::RunOnWorkerThread");
  67
  68     DCHECK(picture_pile_);
  69     if (canvas_) {
  70       AnalyzeAndRaster(picture_pile_->GetCloneForDrawingOnThread(
  71           RasterWorkerPool::GetPictureCloneIndexForCurrentThread()));
  72     }
  73   }
  74
  75   // Overridden from RasterizerTask:
  76   virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
  77     DCHECK(!canvas_);
  78     canvas_ = client->AcquireCanvasForRaster(this);
  79   }
  80   virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {
  81     canvas_ = NULL;
  82     client->ReleaseCanvasForRaster(this);
  83   }
  84   virtual void RunReplyOnOriginThread() OVERRIDE {
  85     DCHECK(!canvas_);
  86     reply_.Run(analysis_, !HasFinishedRunning());
  87   }
  88
  89  protected:
  90   virtual ~RasterTaskImpl() { DCHECK(!canvas_); }
  91
  92  private:
  93   void AnalyzeAndRaster(PicturePileImpl* picture_pile) {
  94     DCHECK(picture_pile);
  95     DCHECK(canvas_);
  96
  97     if (analyze_picture_) {
  98       Analyze(picture_pile);
  99       if (analysis_.is_solid_color)
 100         return;
 101     }
 102
 103     Raster(picture_pile);
 104   }
 105
 106   void Analyze(PicturePileImpl* picture_pile) {
 107     frame_viewer_instrumentation::ScopedAnalyzeTask analyze_task(
 108         tile_id_, tile_resolution_, source_frame_number_, layer_id_);
 109
 110     DCHECK(picture_pile);
 111
 112     picture_pile->AnalyzeInRect(
 113         content_rect_, contents_scale_, &analysis_, rendering_stats_);
 114
 115     // Record the solid color prediction.
 116     UMA_HISTOGRAM_BOOLEAN("Renderer4.SolidColorTilesAnalyzed",
 117                           analysis_.is_solid_color);
 118
 119     // Clear the flag if we're not using the estimator.
 120     analysis_.is_solid_color &= kUseColorEstimator;
 121   }
 122
 123   void Raster(PicturePileImpl* picture_pile) {
 124     frame_viewer_instrumentation::ScopedRasterTask raster_task(
 125         tile_id_,
 126         tile_resolution_,
 127         source_frame_number_,
 128         layer_id_,
 129         raster_mode_);
 130     devtools_instrumentation::ScopedLayerTask layer_task(
 131         devtools_instrumentation::kRasterTask, layer_id_);
 132
 133     skia::RefPtr<SkDrawFilter> draw_filter;
 134     switch (raster_mode_) {
 135       case LOW_QUALITY_RASTER_MODE:
 136         draw_filter = skia::AdoptRef(new skia::PaintSimplifier);
 137         break;
 138       case HIGH_QUALITY_RASTER_MODE:
 139         break;
 140       case NUM_RASTER_MODES:
 141       default:
 142         NOTREACHED();
 143     }
 144     canvas_->setDrawFilter(draw_filter.get());
 145
 146     base::TimeDelta prev_rasterize_time =
 147         rendering_stats_->impl_thread_rendering_stats().rasterize_time;
 148
 149     // Only record rasterization time for highres tiles, because
 150     // lowres tiles are not required for activation and therefore
 151     // introduce noise in the measurement (sometimes they get rasterized
 152     // before we draw and sometimes they aren't)
 153     RenderingStatsInstrumentation* stats =
 154         tile_resolution_ == HIGH_RESOLUTION ? rendering_stats_ : NULL;
 155     DCHECK(picture_pile);
 156     picture_pile->RasterToBitmap(
 157         canvas_, content_rect_, contents_scale_, stats);
 158
 159     if (rendering_stats_->record_rendering_stats()) {
 160       base::TimeDelta current_rasterize_time =
 161           rendering_stats_->impl_thread_rendering_stats().rasterize_time;
 162       HISTOGRAM_CUSTOM_COUNTS(
 163           "Renderer4.PictureRasterTimeUS",
 164           (current_rasterize_time - prev_rasterize_time).InMicroseconds(),
 165           0,
 166           100000,
 167           100);
 168     }
 169   }
 170
 171   PicturePileImpl::Analysis analysis_;
 172   scoped_refptr<PicturePileImpl> picture_pile_;
 173   gfx::Rect content_rect_;
 174   float contents_scale_;
 175   RasterMode raster_mode_;
 176   TileResolution tile_resolution_;
 177   int layer_id_;
 178   const void* tile_id_;
 179   int source_frame_number_;
 180   bool analyze_picture_;
 181   RenderingStatsInstrumentation* rendering_stats_;
 182   const base::Callback<void(const PicturePileImpl::Analysis&, bool)> reply_;
 183   SkCanvas* canvas_;
 184
 185   DISALLOW_COPY_AND_ASSIGN(RasterTaskImpl);
 186 };
 187
 188 class ImageDecodeTaskImpl : public ImageDecodeTask {
 189  public:
 190   ImageDecodeTaskImpl(SkPixelRef* pixel_ref,
 191                       int layer_id,
 192                       RenderingStatsInstrumentation* rendering_stats,
 193                       const base::Callback<void(bool was_canceled)>& reply)
 194       : pixel_ref_(skia::SharePtr(pixel_ref)),
 195         layer_id_(layer_id),
 196         rendering_stats_(rendering_stats),
 197         reply_(reply) {}
 198
 199   // Overridden from Task:
 200   virtual void RunOnWorkerThread() OVERRIDE {
 201     TRACE_EVENT0("cc", "ImageDecodeTaskImpl::RunOnWorkerThread");
 202
 203     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
 204         pixel_ref_.get());
 205     // This will cause the image referred to by pixel ref to be decoded.
 206     pixel_ref_->lockPixels();
 207     pixel_ref_->unlockPixels();
 208   }
 209
 210   // Overridden from RasterizerTask:
 211   virtual void ScheduleOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
 212   virtual void CompleteOnOriginThread(RasterizerTaskClient* client) OVERRIDE {}
 213   virtual void RunReplyOnOriginThread() OVERRIDE {
 214     reply_.Run(!HasFinishedRunning());
 215   }
 216
 217  protected:
 218   virtual ~ImageDecodeTaskImpl() {}
 219
 220  private:
 221   skia::RefPtr<SkPixelRef> pixel_ref_;
 222   int layer_id_;
 223   RenderingStatsInstrumentation* rendering_stats_;
 224   const base::Callback<void(bool was_canceled)> reply_;
 225
 226   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 227 };
 228
 229 const size_t kScheduledRasterTasksLimit = 32u;
 230
 231 // Memory limit policy works by mapping some bin states to the NEVER bin.
 232 const ManagedTileBin kBinPolicyMap[NUM_TILE_MEMORY_LIMIT_POLICIES][NUM_BINS] = {
 233     // [ALLOW_NOTHING]
 234     {NEVER_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
 235      NEVER_BIN,  // [NOW_BIN]
 236      NEVER_BIN,  // [SOON_BIN]
 237      NEVER_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
 238      NEVER_BIN,  // [EVENTUALLY_BIN]
 239      NEVER_BIN,  // [AT_LAST_AND_ACTIVE_BIN]
 240      NEVER_BIN,  // [AT_LAST_BIN]
 241      NEVER_BIN   // [NEVER_BIN]
 242     },
 243     // [ALLOW_ABSOLUTE_MINIMUM]
 244     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
 245      NOW_BIN,                    // [NOW_BIN]
 246      NEVER_BIN,                  // [SOON_BIN]
 247      NEVER_BIN,                  // [EVENTUALLY_AND_ACTIVE_BIN]
 248      NEVER_BIN,                  // [EVENTUALLY_BIN]
 249      NEVER_BIN,                  // [AT_LAST_AND_ACTIVE_BIN]
 250      NEVER_BIN,                  // [AT_LAST_BIN]
 251      NEVER_BIN                   // [NEVER_BIN]
 252     },
 253     // [ALLOW_PREPAINT_ONLY]
 254     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
 255      NOW_BIN,                    // [NOW_BIN]
 256      SOON_BIN,                   // [SOON_BIN]
 257      NEVER_BIN,                  // [EVENTUALLY_AND_ACTIVE_BIN]
 258      NEVER_BIN,                  // [EVENTUALLY_BIN]
 259      NEVER_BIN,                  // [AT_LAST_AND_ACTIVE_BIN]
 260      NEVER_BIN,                  // [AT_LAST_BIN]
 261      NEVER_BIN                   // [NEVER_BIN]
 262     },
 263     // [ALLOW_ANYTHING]
 264     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
 265      NOW_BIN,                    // [NOW_BIN]
 266      SOON_BIN,                   // [SOON_BIN]
 267      EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
 268      EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
 269      AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
 270      AT_LAST_BIN,                // [AT_LAST_BIN]
 271      NEVER_BIN                   // [NEVER_BIN]
 272     }};
 273
 274 // Ready to draw works by mapping NOW_BIN to NOW_AND_READY_TO_DRAW_BIN.
 275 const ManagedTileBin kBinReadyToDrawMap[2][NUM_BINS] = {
 276     // Not ready
 277     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
 278      NOW_BIN,                    // [NOW_BIN]
 279      SOON_BIN,                   // [SOON_BIN]
 280      EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
 281      EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
 282      AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
 283      AT_LAST_BIN,                // [AT_LAST_BIN]
 284      NEVER_BIN                   // [NEVER_BIN]
 285     },
 286     // Ready
 287     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
 288      NOW_AND_READY_TO_DRAW_BIN,  // [NOW_BIN]
 289      SOON_BIN,                   // [SOON_BIN]
 290      EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
 291      EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
 292      AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
 293      AT_LAST_BIN,                // [AT_LAST_BIN]
 294      NEVER_BIN                   // [NEVER_BIN]
 295     }};
 296
 297 // Active works by mapping some bin stats to equivalent _ACTIVE_BIN state.
 298 const ManagedTileBin kBinIsActiveMap[2][NUM_BINS] = {
 299     // Inactive
 300     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
 301      NOW_BIN,                    // [NOW_BIN]
 302      SOON_BIN,                   // [SOON_BIN]
 303      EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
 304      EVENTUALLY_BIN,             // [EVENTUALLY_BIN]
 305      AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
 306      AT_LAST_BIN,                // [AT_LAST_BIN]
 307      NEVER_BIN                   // [NEVER_BIN]
 308     },
 309     // Active
 310     {NOW_AND_READY_TO_DRAW_BIN,  // [NOW_AND_READY_TO_DRAW_BIN]
 311      NOW_BIN,                    // [NOW_BIN]
 312      SOON_BIN,                   // [SOON_BIN]
 313      EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_AND_ACTIVE_BIN]
 314      EVENTUALLY_AND_ACTIVE_BIN,  // [EVENTUALLY_BIN]
 315      AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_AND_ACTIVE_BIN]
 316      AT_LAST_AND_ACTIVE_BIN,     // [AT_LAST_BIN]
 317      NEVER_BIN                   // [NEVER_BIN]
 318     }};
 319
 320 // Determine bin based on three categories of tiles: things we need now,
 321 // things we need soon, and eventually.
 322 inline ManagedTileBin BinFromTilePriority(const TilePriority& prio) {
 323   if (prio.priority_bin == TilePriority::NOW)
 324     return NOW_BIN;
 325
 326   if (prio.priority_bin == TilePriority::SOON)
 327     return SOON_BIN;
 328
 329   if (prio.distance_to_visible == std::numeric_limits<float>::infinity())
 330     return NEVER_BIN;
 331
 332   return EVENTUALLY_BIN;
 333 }
 334
 335 }  // namespace
 336
 337 RasterTaskCompletionStats::RasterTaskCompletionStats()
 338     : completed_count(0u), canceled_count(0u) {}
 339
 340 scoped_refptr<base::debug::ConvertableToTraceFormat>
 341 RasterTaskCompletionStatsAsValue(const RasterTaskCompletionStats& stats) {
 342   scoped_refptr<base::debug::TracedValue> state =
 343       new base::debug::TracedValue();
 344   state->SetInteger("completed_count", stats.completed_count);
 345   state->SetInteger("canceled_count", stats.canceled_count);
 346   return state;
 347 }
 348
 349 // static
 350 scoped_ptr<TileManager> TileManager::Create(
 351     TileManagerClient* client,
 352     base::SequencedTaskRunner* task_runner,
 353     ResourcePool* resource_pool,
 354     Rasterizer* rasterizer,
 355     RenderingStatsInstrumentation* rendering_stats_instrumentation) {
 356   return make_scoped_ptr(new TileManager(client,
 357                                          task_runner,
 358                                          resource_pool,
 359                                          rasterizer,
 360                                          rendering_stats_instrumentation));
 361 }
 362
 363 TileManager::TileManager(
 364     TileManagerClient* client,
 365     base::SequencedTaskRunner* task_runner,
 366     ResourcePool* resource_pool,
 367     Rasterizer* rasterizer,
 368     RenderingStatsInstrumentation* rendering_stats_instrumentation)
 369     : client_(client),
 370       task_runner_(task_runner),
 371       resource_pool_(resource_pool),
 372       rasterizer_(rasterizer),
 373       prioritized_tiles_dirty_(false),
 374       all_tiles_that_need_to_be_rasterized_have_memory_(true),
 375       all_tiles_required_for_activation_have_memory_(true),
 376       bytes_releasable_(0),
 377       resources_releasable_(0),
 378       ever_exceeded_memory_budget_(false),
 379       rendering_stats_instrumentation_(rendering_stats_instrumentation),
 380       did_initialize_visible_tile_(false),
 381       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
 382       ready_to_activate_check_notifier_(
 383           task_runner_,
 384           base::Bind(&TileManager::CheckIfReadyToActivate,
 385                      base::Unretained(this))) {
 386   rasterizer_->SetClient(this);
 387 }
 388
 389 TileManager::~TileManager() {
 390   // Reset global state and manage. This should cause
 391   // our memory usage to drop to zero.
 392   global_state_ = GlobalStateThatImpactsTilePriority();
 393
 394   RasterTaskQueue empty;
 395   rasterizer_->ScheduleTasks(&empty);
 396   orphan_raster_tasks_.clear();
 397
 398   // This should finish all pending tasks and release any uninitialized
 399   // resources.
 400   rasterizer_->Shutdown();
 401   rasterizer_->CheckForCompletedTasks();
 402
 403   prioritized_tiles_.Clear();
 404
 405   FreeResourcesForReleasedTiles();
 406   CleanUpReleasedTiles();
 407
 408   DCHECK_EQ(0u, bytes_releasable_);
 409   DCHECK_EQ(0u, resources_releasable_);
 410 }
 411
 412 void TileManager::Release(Tile* tile) {
 413   DCHECK(TilePriority() == tile->combined_priority());
 414
 415   prioritized_tiles_dirty_ = true;
 416   released_tiles_.push_back(tile);
 417 }
 418
 419 void TileManager::DidChangeTilePriority(Tile* tile) {
 420   prioritized_tiles_dirty_ = true;
 421 }
 422
 423 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
 424   return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 425 }
 426
 427 void TileManager::FreeResourcesForReleasedTiles() {
 428   for (std::vector<Tile*>::iterator it = released_tiles_.begin();
 429        it != released_tiles_.end();
 430        ++it) {
 431     Tile* tile = *it;
 432     FreeResourcesForTile(tile);
 433   }
 434 }
 435
 436 void TileManager::CleanUpReleasedTiles() {
 437   // Make sure |prioritized_tiles_| doesn't contain any of the tiles
 438   // we're about to delete.
 439   DCHECK(prioritized_tiles_.IsEmpty());
 440
 441   std::vector<Tile*>::iterator it = released_tiles_.begin();
 442   while (it != released_tiles_.end()) {
 443     Tile* tile = *it;
 444
 445     if (tile->HasRasterTask()) {
 446       ++it;
 447       continue;
 448     }
 449
 450     DCHECK(!tile->HasResources());
 451     DCHECK(tiles_.find(tile->id()) != tiles_.end());
 452     tiles_.erase(tile->id());
 453
 454     LayerCountMap::iterator layer_it =
 455         used_layer_counts_.find(tile->layer_id());
 456     DCHECK_GT(layer_it->second, 0);
 457     if (--layer_it->second == 0) {
 458       used_layer_counts_.erase(layer_it);
 459       image_decode_tasks_.erase(tile->layer_id());
 460     }
 461
 462     delete tile;
 463     it = released_tiles_.erase(it);
 464   }
 465 }
 466
 467 void TileManager::UpdatePrioritizedTileSetIfNeeded() {
 468   if (!prioritized_tiles_dirty_)
 469     return;
 470
 471   prioritized_tiles_.Clear();
 472
 473   FreeResourcesForReleasedTiles();
 474   CleanUpReleasedTiles();
 475
 476   GetTilesWithAssignedBins(&prioritized_tiles_);
 477   prioritized_tiles_dirty_ = false;
 478 }
 479
 480 void TileManager::DidFinishRunningTasks() {
 481   TRACE_EVENT0("cc", "TileManager::DidFinishRunningTasks");
 482
 483   bool memory_usage_above_limit = resource_pool_->total_memory_usage_bytes() >
 484                                   global_state_.soft_memory_limit_in_bytes;
 485
 486   // When OOM, keep re-assigning memory until we reach a steady state
 487   // where top-priority tiles are initialized.
 488   if (all_tiles_that_need_to_be_rasterized_have_memory_ &&
 489       !memory_usage_above_limit)
 490     return;
 491
 492   rasterizer_->CheckForCompletedTasks();
 493   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 494
 495   TileVector tiles_that_need_to_be_rasterized;
 496   AssignGpuMemoryToTiles(&prioritized_tiles_,
 497                          &tiles_that_need_to_be_rasterized);
 498
 499   // |tiles_that_need_to_be_rasterized| will be empty when we reach a
 500   // steady memory state. Keep scheduling tasks until we reach this state.
 501   if (!tiles_that_need_to_be_rasterized.empty()) {
 502     ScheduleTasks(tiles_that_need_to_be_rasterized);
 503     return;
 504   }
 505
 506   FreeResourcesForReleasedTiles();
 507
 508   resource_pool_->ReduceResourceUsage();
 509
 510   // We don't reserve memory for required-for-activation tiles during
 511   // accelerated gestures, so we just postpone activation when we don't
 512   // have these tiles, and activate after the accelerated gesture.
 513   bool allow_rasterize_on_demand =
 514       global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 515
 516   // Use on-demand raster for any required-for-activation tiles that have not
 517   // been been assigned memory after reaching a steady memory state. This
 518   // ensures that we activate even when OOM.
 519   for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
 520     Tile* tile = it->second;
 521     ManagedTileState& mts = tile->managed_state();
 522     ManagedTileState::TileVersion& tile_version =
 523         mts.tile_versions[mts.raster_mode];
 524
 525     if (tile->required_for_activation() && !tile_version.IsReadyToDraw()) {
 526       // If we can't raster on demand, give up early (and don't activate).
 527       if (!allow_rasterize_on_demand)
 528         return;
 529
 530       tile_version.set_rasterize_on_demand();
 531       client_->NotifyTileStateChanged(tile);
 532     }
 533   }
 534
 535   DCHECK(IsReadyToActivate());
 536   ready_to_activate_check_notifier_.Schedule();
 537 }
 538
 539 void TileManager::DidFinishRunningTasksRequiredForActivation() {
 540   // This is only a true indication that all tiles required for
 541   // activation are initialized when no tiles are OOM. We need to
 542   // wait for DidFinishRunningTasks() to be called, try to re-assign
 543   // memory and in worst case use on-demand raster when tiles
 544   // required for activation are OOM.
 545   if (!all_tiles_required_for_activation_have_memory_)
 546     return;
 547
 548   ready_to_activate_check_notifier_.Schedule();
 549 }
 550
 551 void TileManager::GetTilesWithAssignedBins(PrioritizedTileSet* tiles) {
 552   TRACE_EVENT0("cc", "TileManager::GetTilesWithAssignedBins");
 553
 554   const TileMemoryLimitPolicy memory_policy = global_state_.memory_limit_policy;
 555   const TreePriority tree_priority = global_state_.tree_priority;
 556
 557   // For each tree, bin into different categories of tiles.
 558   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
 559     Tile* tile = it->second;
 560     ManagedTileState& mts = tile->managed_state();
 561
 562     const ManagedTileState::TileVersion& tile_version =
 563         tile->GetTileVersionForDrawing();
 564     bool tile_is_ready_to_draw = tile_version.IsReadyToDraw();
 565     bool tile_is_active = tile_is_ready_to_draw ||
 566                           mts.tile_versions[mts.raster_mode].raster_task_;
 567
 568     // Get the active priority and bin.
 569     TilePriority active_priority = tile->priority(ACTIVE_TREE);
 570     ManagedTileBin active_bin = BinFromTilePriority(active_priority);
 571
 572     // Get the pending priority and bin.
 573     TilePriority pending_priority = tile->priority(PENDING_TREE);
 574     ManagedTileBin pending_bin = BinFromTilePriority(pending_priority);
 575
 576     bool pending_is_low_res = pending_priority.resolution == LOW_RESOLUTION;
 577     bool pending_is_non_ideal =
 578         pending_priority.resolution == NON_IDEAL_RESOLUTION;
 579     bool active_is_non_ideal =
 580         active_priority.resolution == NON_IDEAL_RESOLUTION;
 581
 582     // Adjust bin state based on if ready to draw.
 583     active_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][active_bin];
 584     pending_bin = kBinReadyToDrawMap[tile_is_ready_to_draw][pending_bin];
 585
 586     // Adjust bin state based on if active.
 587     active_bin = kBinIsActiveMap[tile_is_active][active_bin];
 588     pending_bin = kBinIsActiveMap[tile_is_active][pending_bin];
 589
 590     // We never want to paint new non-ideal tiles, as we always have
 591     // a high-res tile covering that content (paint that instead).
 592     if (!tile_is_ready_to_draw && active_is_non_ideal)
 593       active_bin = NEVER_BIN;
 594     if (!tile_is_ready_to_draw && pending_is_non_ideal)
 595       pending_bin = NEVER_BIN;
 596
 597     ManagedTileBin tree_bin[NUM_TREES];
 598     tree_bin[ACTIVE_TREE] = kBinPolicyMap[memory_policy][active_bin];
 599     tree_bin[PENDING_TREE] = kBinPolicyMap[memory_policy][pending_bin];
 600
 601     // Adjust pending bin state for low res tiles. This prevents pending tree
 602     // low-res tiles from being initialized before high-res tiles.
 603     if (pending_is_low_res)
 604       tree_bin[PENDING_TREE] = std::max(tree_bin[PENDING_TREE], EVENTUALLY_BIN);
 605
 606     TilePriority tile_priority;
 607     switch (tree_priority) {
 608       case SAME_PRIORITY_FOR_BOTH_TREES:
 609         mts.bin = std::min(tree_bin[ACTIVE_TREE], tree_bin[PENDING_TREE]);
 610         tile_priority = tile->combined_priority();
 611         break;
 612       case SMOOTHNESS_TAKES_PRIORITY:
 613         mts.bin = tree_bin[ACTIVE_TREE];
 614         tile_priority = active_priority;
 615         break;
 616       case NEW_CONTENT_TAKES_PRIORITY:
 617         mts.bin = tree_bin[PENDING_TREE];
 618         tile_priority = pending_priority;
 619         break;
 620       default:
 621         NOTREACHED();
 622     }
 623
 624     // Bump up the priority if we determined it's NEVER_BIN on one tree,
 625     // but is still required on the other tree.
 626     bool is_in_never_bin_on_both_trees = tree_bin[ACTIVE_TREE] == NEVER_BIN &&
 627                                          tree_bin[PENDING_TREE] == NEVER_BIN;
 628
 629     if (mts.bin == NEVER_BIN && !is_in_never_bin_on_both_trees)
 630       mts.bin = tile_is_active ? AT_LAST_AND_ACTIVE_BIN : AT_LAST_BIN;
 631
 632     mts.resolution = tile_priority.resolution;
 633     mts.priority_bin = tile_priority.priority_bin;
 634     mts.distance_to_visible = tile_priority.distance_to_visible;
 635     mts.required_for_activation = tile_priority.required_for_activation;
 636
 637     mts.visible_and_ready_to_draw =
 638         tree_bin[ACTIVE_TREE] == NOW_AND_READY_TO_DRAW_BIN;
 639
 640     // Tiles that are required for activation shouldn't be in NEVER_BIN unless
 641     // smoothness takes priority or memory policy allows nothing to be
 642     // initialized.
 643     DCHECK(!mts.required_for_activation || mts.bin != NEVER_BIN ||
 644            tree_priority == SMOOTHNESS_TAKES_PRIORITY ||
 645            memory_policy == ALLOW_NOTHING);
 646
 647     // If the tile is in NEVER_BIN and it does not have an active task, then we
 648     // can release the resources early. If it does have the task however, we
 649     // should keep it in the prioritized tile set to ensure that AssignGpuMemory
 650     // can visit it.
 651     if (mts.bin == NEVER_BIN &&
 652         !mts.tile_versions[mts.raster_mode].raster_task_) {
 653       FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
 654       continue;
 655     }
 656
 657     // Insert the tile into a priority set.
 658     tiles->InsertTile(tile, mts.bin);
 659   }
 660 }
 661
 662 void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
 663   TRACE_EVENT0("cc", "TileManager::ManageTiles");
 664
 665   // Update internal state.
 666   if (state != global_state_) {
 667     global_state_ = state;
 668     prioritized_tiles_dirty_ = true;
 669   }
 670
 671   // We need to call CheckForCompletedTasks() once in-between each call
 672   // to ScheduleTasks() to prevent canceled tasks from being scheduled.
 673   if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
 674     rasterizer_->CheckForCompletedTasks();
 675     did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 676   }
 677
 678   UpdatePrioritizedTileSetIfNeeded();
 679
 680   TileVector tiles_that_need_to_be_rasterized;
 681   AssignGpuMemoryToTiles(&prioritized_tiles_,
 682                          &tiles_that_need_to_be_rasterized);
 683
 684   // Finally, schedule rasterizer tasks.
 685   ScheduleTasks(tiles_that_need_to_be_rasterized);
 686
 687   TRACE_EVENT_INSTANT1("cc",
 688                        "DidManage",
 689                        TRACE_EVENT_SCOPE_THREAD,
 690                        "state",
 691                        BasicStateAsValue());
 692
 693   TRACE_COUNTER_ID1("cc",
 694                     "unused_memory_bytes",
 695                     this,
 696                     resource_pool_->total_memory_usage_bytes() -
 697                         resource_pool_->acquired_memory_usage_bytes());
 698 }
 699
 700 bool TileManager::UpdateVisibleTiles() {
 701   TRACE_EVENT0("cc", "TileManager::UpdateVisibleTiles");
 702
 703   rasterizer_->CheckForCompletedTasks();
 704   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 705
 706   TRACE_EVENT_INSTANT1(
 707       "cc",
 708       "DidUpdateVisibleTiles",
 709       TRACE_EVENT_SCOPE_THREAD,
 710       "stats",
 711       RasterTaskCompletionStatsAsValue(update_visible_tiles_stats_));
 712   update_visible_tiles_stats_ = RasterTaskCompletionStats();
 713
 714   bool did_initialize_visible_tile = did_initialize_visible_tile_;
 715   did_initialize_visible_tile_ = false;
 716   return did_initialize_visible_tile;
 717 }
 718
 719 scoped_refptr<base::debug::ConvertableToTraceFormat>
 720 TileManager::BasicStateAsValue() const {
 721   scoped_refptr<base::debug::TracedValue> value =
 722       new base::debug::TracedValue();
 723   BasicStateAsValueInto(value.get());
 724   return value;
 725 }
 726
 727 void TileManager::BasicStateAsValueInto(base::debug::TracedValue* state) const {
 728   state->SetInteger("tile_count", tiles_.size());
 729   state->BeginDictionary("global_state");
 730   global_state_.AsValueInto(state);
 731   state->EndDictionary();
 732 }
 733
 734 void TileManager::AllTilesAsValueInto(base::debug::TracedValue* state) const {
 735   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
 736     state->BeginDictionary();
 737     it->second->AsValueInto(state);
 738     state->EndDictionary();
 739   }
 740 }
 741
 742 void TileManager::AssignGpuMemoryToTiles(
 743     PrioritizedTileSet* tiles,
 744     TileVector* tiles_that_need_to_be_rasterized) {
 745   TRACE_EVENT0("cc", "TileManager::AssignGpuMemoryToTiles");
 746
 747   // Maintain the list of released resources that can potentially be re-used
 748   // or deleted.
 749   // If this operation becomes expensive too, only do this after some
 750   // resource(s) was returned. Note that in that case, one also need to
 751   // invalidate when releasing some resource from the pool.
 752   resource_pool_->CheckBusyResources();
 753
 754   // Now give memory out to the tiles until we're out, and build
 755   // the needs-to-be-rasterized queue.
 756   all_tiles_that_need_to_be_rasterized_have_memory_ = true;
 757   all_tiles_required_for_activation_have_memory_ = true;
 758
 759   // Cast to prevent overflow.
 760   int64 soft_bytes_available =
 761       static_cast<int64>(bytes_releasable_) +
 762       static_cast<int64>(global_state_.soft_memory_limit_in_bytes) -
 763       static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
 764   int64 hard_bytes_available =
 765       static_cast<int64>(bytes_releasable_) +
 766       static_cast<int64>(global_state_.hard_memory_limit_in_bytes) -
 767       static_cast<int64>(resource_pool_->acquired_memory_usage_bytes());
 768   int resources_available = resources_releasable_ +
 769                             global_state_.num_resources_limit -
 770                             resource_pool_->acquired_resource_count();
 771   size_t soft_bytes_allocatable =
 772       std::max(static_cast<int64>(0), soft_bytes_available);
 773   size_t hard_bytes_allocatable =
 774       std::max(static_cast<int64>(0), hard_bytes_available);
 775   size_t resources_allocatable = std::max(0, resources_available);
 776
 777   size_t bytes_that_exceeded_memory_budget = 0;
 778   size_t soft_bytes_left = soft_bytes_allocatable;
 779   size_t hard_bytes_left = hard_bytes_allocatable;
 780
 781   size_t resources_left = resources_allocatable;
 782   bool oomed_soft = false;
 783   bool oomed_hard = false;
 784   bool have_hit_soft_memory = false;  // Soft memory comes after hard.
 785
 786   unsigned schedule_priority = 1u;
 787   for (PrioritizedTileSet::Iterator it(tiles, true); it; ++it) {
 788     Tile* tile = *it;
 789     ManagedTileState& mts = tile->managed_state();
 790
 791     mts.scheduled_priority = schedule_priority++;
 792
 793     mts.raster_mode = tile->DetermineOverallRasterMode();
 794
 795     ManagedTileState::TileVersion& tile_version =
 796         mts.tile_versions[mts.raster_mode];
 797
 798     // If this tile doesn't need a resource, then nothing to do.
 799     if (!tile_version.requires_resource())
 800       continue;
 801
 802     // If the tile is not needed, free it up.
 803     if (mts.bin == NEVER_BIN) {
 804       FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
 805       continue;
 806     }
 807
 808     const bool tile_uses_hard_limit = mts.bin <= NOW_BIN;
 809     const size_t bytes_if_allocated = BytesConsumedIfAllocated(tile);
 810     const size_t tile_bytes_left =
 811         (tile_uses_hard_limit) ? hard_bytes_left : soft_bytes_left;
 812
 813     // Hard-limit is reserved for tiles that would cause a calamity
 814     // if they were to go away, so by definition they are the highest
 815     // priority memory, and must be at the front of the list.
 816     DCHECK(!(have_hit_soft_memory && tile_uses_hard_limit));
 817     have_hit_soft_memory |= !tile_uses_hard_limit;
 818
 819     size_t tile_bytes = 0;
 820     size_t tile_resources = 0;
 821
 822     // It costs to maintain a resource.
 823     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
 824       if (mts.tile_versions[mode].resource_) {
 825         tile_bytes += bytes_if_allocated;
 826         tile_resources++;
 827       }
 828     }
 829
 830     // Allow lower priority tiles with initialized resources to keep
 831     // their memory by only assigning memory to new raster tasks if
 832     // they can be scheduled.
 833     bool reached_scheduled_raster_tasks_limit =
 834         tiles_that_need_to_be_rasterized->size() >= kScheduledRasterTasksLimit;
 835     if (!reached_scheduled_raster_tasks_limit) {
 836       // If we don't have the required version, and it's not in flight
 837       // then we'll have to pay to create a new task.
 838       if (!tile_version.resource_ && !tile_version.raster_task_) {
 839         tile_bytes += bytes_if_allocated;
 840         tile_resources++;
 841       }
 842     }
 843
 844     // Tile is OOM.
 845     if (tile_bytes > tile_bytes_left || tile_resources > resources_left) {
 846       FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
 847
 848       // This tile was already on screen and now its resources have been
 849       // released. In order to prevent checkerboarding, set this tile as
 850       // rasterize on demand immediately.
 851       if (mts.visible_and_ready_to_draw)
 852         tile_version.set_rasterize_on_demand();
 853
 854       oomed_soft = true;
 855       if (tile_uses_hard_limit) {
 856         oomed_hard = true;
 857         bytes_that_exceeded_memory_budget += tile_bytes;
 858       }
 859     } else {
 860       resources_left -= tile_resources;
 861       hard_bytes_left -= tile_bytes;
 862       soft_bytes_left =
 863           (soft_bytes_left > tile_bytes) ? soft_bytes_left - tile_bytes : 0;
 864       if (tile_version.resource_)
 865         continue;
 866     }
 867
 868     DCHECK(!tile_version.resource_);
 869
 870     // Tile shouldn't be rasterized if |tiles_that_need_to_be_rasterized|
 871     // has reached it's limit or we've failed to assign gpu memory to this
 872     // or any higher priority tile. Preventing tiles that fit into memory
 873     // budget to be rasterized when higher priority tile is oom is
 874     // important for two reasons:
 875     // 1. Tile size should not impact raster priority.
 876     // 2. Tiles with existing raster task could otherwise incorrectly
 877     //    be added as they are not affected by |bytes_allocatable|.
 878     bool can_schedule_tile =
 879         !oomed_soft && !reached_scheduled_raster_tasks_limit;
 880
 881     if (!can_schedule_tile) {
 882       all_tiles_that_need_to_be_rasterized_have_memory_ = false;
 883       if (tile->required_for_activation())
 884         all_tiles_required_for_activation_have_memory_ = false;
 885       it.DisablePriorityOrdering();
 886       continue;
 887     }
 888
 889     tiles_that_need_to_be_rasterized->push_back(tile);
 890   }
 891
 892   // OOM reporting uses hard-limit, soft-OOM is normal depending on limit.
 893   ever_exceeded_memory_budget_ |= oomed_hard;
 894   if (ever_exceeded_memory_budget_) {
 895     TRACE_COUNTER_ID2("cc",
 896                       "over_memory_budget",
 897                       this,
 898                       "budget",
 899                       global_state_.hard_memory_limit_in_bytes,
 900                       "over",
 901                       bytes_that_exceeded_memory_budget);
 902   }
 903   UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget", oomed_hard);
 904   memory_stats_from_last_assign_.total_budget_in_bytes =
 905       global_state_.hard_memory_limit_in_bytes;
 906   memory_stats_from_last_assign_.bytes_allocated =
 907       hard_bytes_allocatable - hard_bytes_left;
 908   memory_stats_from_last_assign_.bytes_unreleasable =
 909       resource_pool_->acquired_memory_usage_bytes() - bytes_releasable_;
 910   memory_stats_from_last_assign_.bytes_over = bytes_that_exceeded_memory_budget;
 911 }
 912
 913 void TileManager::FreeResourceForTile(Tile* tile, RasterMode mode) {
 914   ManagedTileState& mts = tile->managed_state();
 915   if (mts.tile_versions[mode].resource_) {
 916     resource_pool_->ReleaseResource(mts.tile_versions[mode].resource_.Pass());
 917
 918     DCHECK_GE(bytes_releasable_, BytesConsumedIfAllocated(tile));
 919     DCHECK_GE(resources_releasable_, 1u);
 920
 921     bytes_releasable_ -= BytesConsumedIfAllocated(tile);
 922     --resources_releasable_;
 923   }
 924 }
 925
 926 void TileManager::FreeResourcesForTile(Tile* tile) {
 927   for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
 928     FreeResourceForTile(tile, static_cast<RasterMode>(mode));
 929   }
 930 }
 931
 932 void TileManager::FreeUnusedResourcesForTile(Tile* tile) {
 933   DCHECK(tile->IsReadyToDraw());
 934   ManagedTileState& mts = tile->managed_state();
 935   RasterMode used_mode = LOW_QUALITY_RASTER_MODE;
 936   for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
 937     if (mts.tile_versions[mode].IsReadyToDraw()) {
 938       used_mode = static_cast<RasterMode>(mode);
 939       break;
 940     }
 941   }
 942
 943   for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
 944     if (mode != used_mode)
 945       FreeResourceForTile(tile, static_cast<RasterMode>(mode));
 946   }
 947 }
 948
 949 void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(
 950     Tile* tile) {
 951   bool was_ready_to_draw = tile->IsReadyToDraw();
 952   FreeResourcesForTile(tile);
 953   if (was_ready_to_draw)
 954     client_->NotifyTileStateChanged(tile);
 955 }
 956
 957 void TileManager::ScheduleTasks(
 958     const TileVector& tiles_that_need_to_be_rasterized) {
 959   TRACE_EVENT1("cc",
 960                "TileManager::ScheduleTasks",
 961                "count",
 962                tiles_that_need_to_be_rasterized.size());
 963
 964   DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
 965
 966   raster_queue_.Reset();
 967
 968   // Build a new task queue containing all task currently needed. Tasks
 969   // are added in order of priority, highest priority task first.
 970   for (TileVector::const_iterator it = tiles_that_need_to_be_rasterized.begin();
 971        it != tiles_that_need_to_be_rasterized.end();
 972        ++it) {
 973     Tile* tile = *it;
 974     ManagedTileState& mts = tile->managed_state();
 975     ManagedTileState::TileVersion& tile_version =
 976         mts.tile_versions[mts.raster_mode];
 977
 978     DCHECK(tile_version.requires_resource());
 979     DCHECK(!tile_version.resource_);
 980
 981     if (!tile_version.raster_task_)
 982       tile_version.raster_task_ = CreateRasterTask(tile);
 983
 984     raster_queue_.items.push_back(RasterTaskQueue::Item(
 985         tile_version.raster_task_.get(), tile->required_for_activation()));
 986     raster_queue_.required_for_activation_count +=
 987         tile->required_for_activation();
 988   }
 989
 990   // We must reduce the amount of unused resoruces before calling
 991   // ScheduleTasks to prevent usage from rising above limits.
 992   resource_pool_->ReduceResourceUsage();
 993
 994   // Schedule running of |raster_tasks_|. This replaces any previously
 995   // scheduled tasks and effectively cancels all tasks not present
 996   // in |raster_tasks_|.
 997   rasterizer_->ScheduleTasks(&raster_queue_);
 998
 999   // It's now safe to clean up orphan tasks as raster worker pool is not
1000   // allowed to keep around unreferenced raster tasks after ScheduleTasks() has
1001   // been called.
1002   orphan_raster_tasks_.clear();
1003
1004   did_check_for_completed_tasks_since_last_schedule_tasks_ = false;
1005 }
1006
1007 scoped_refptr<ImageDecodeTask> TileManager::CreateImageDecodeTask(
1008     Tile* tile,
1009     SkPixelRef* pixel_ref) {
1010   return make_scoped_refptr(new ImageDecodeTaskImpl(
1011       pixel_ref,
1012       tile->layer_id(),
1013       rendering_stats_instrumentation_,
1014       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
1015                  base::Unretained(this),
1016                  tile->layer_id(),
1017                  base::Unretained(pixel_ref))));
1018 }
1019
1020 scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
1021   ManagedTileState& mts = tile->managed_state();
1022
1023   scoped_ptr<ScopedResource> resource =
1024       resource_pool_->AcquireResource(tile->size());
1025   const ScopedResource* const_resource = resource.get();
1026
1027   // Create and queue all image decode tasks that this tile depends on.
1028   ImageDecodeTask::Vector decode_tasks;
1029   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
1030   for (PicturePileImpl::PixelRefIterator iter(
1031            tile->content_rect(), tile->contents_scale(), tile->picture_pile());
1032        iter;
1033        ++iter) {
1034     SkPixelRef* pixel_ref = *iter;
1035     uint32_t id = pixel_ref->getGenerationID();
1036
1037     // Append existing image decode task if available.
1038     PixelRefTaskMap::iterator decode_task_it = existing_pixel_refs.find(id);
1039     if (decode_task_it != existing_pixel_refs.end()) {
1040       decode_tasks.push_back(decode_task_it->second);
1041       continue;
1042     }
1043
1044     // Create and append new image decode task for this pixel ref.
1045     scoped_refptr<ImageDecodeTask> decode_task =
1046         CreateImageDecodeTask(tile, pixel_ref);
1047     decode_tasks.push_back(decode_task);
1048     existing_pixel_refs[id] = decode_task;
1049   }
1050
1051   return make_scoped_refptr(
1052       new RasterTaskImpl(const_resource,
1053                          tile->picture_pile(),
1054                          tile->content_rect(),
1055                          tile->contents_scale(),
1056                          mts.raster_mode,
1057                          mts.resolution,
1058                          tile->layer_id(),
1059                          static_cast<const void*>(tile),
1060                          tile->source_frame_number(),
1061                          tile->use_picture_analysis(),
1062                          rendering_stats_instrumentation_,
1063                          base::Bind(&TileManager::OnRasterTaskCompleted,
1064                                     base::Unretained(this),
1065                                     tile->id(),
1066                                     base::Passed(&resource),
1067                                     mts.raster_mode),
1068                          &decode_tasks));
1069 }
1070
1071 void TileManager::OnImageDecodeTaskCompleted(int layer_id,
1072                                              SkPixelRef* pixel_ref,
1073                                              bool was_canceled) {
1074   // If the task was canceled, we need to clean it up
1075   // from |image_decode_tasks_|.
1076   if (!was_canceled)
1077     return;
1078
1079   LayerPixelRefTaskMap::iterator layer_it = image_decode_tasks_.find(layer_id);
1080   if (layer_it == image_decode_tasks_.end())
1081     return;
1082
1083   PixelRefTaskMap& pixel_ref_tasks = layer_it->second;
1084   PixelRefTaskMap::iterator task_it =
1085       pixel_ref_tasks.find(pixel_ref->getGenerationID());
1086
1087   if (task_it != pixel_ref_tasks.end())
1088     pixel_ref_tasks.erase(task_it);
1089 }
1090
1091 void TileManager::OnRasterTaskCompleted(
1092     Tile::Id tile_id,
1093     scoped_ptr<ScopedResource> resource,
1094     RasterMode raster_mode,
1095     const PicturePileImpl::Analysis& analysis,
1096     bool was_canceled) {
1097   DCHECK(tiles_.find(tile_id) != tiles_.end());
1098
1099   Tile* tile = tiles_[tile_id];
1100   ManagedTileState& mts = tile->managed_state();
1101   ManagedTileState::TileVersion& tile_version = mts.tile_versions[raster_mode];
1102   DCHECK(tile_version.raster_task_);
1103   orphan_raster_tasks_.push_back(tile_version.raster_task_);
1104   tile_version.raster_task_ = NULL;
1105
1106   if (was_canceled) {
1107     ++update_visible_tiles_stats_.canceled_count;
1108     resource_pool_->ReleaseResource(resource.Pass());
1109     return;
1110   }
1111
1112   ++update_visible_tiles_stats_.completed_count;
1113
1114   if (analysis.is_solid_color) {
1115     tile_version.set_solid_color(analysis.solid_color);
1116     resource_pool_->ReleaseResource(resource.Pass());
1117   } else {
1118     tile_version.set_use_resource();
1119     tile_version.resource_ = resource.Pass();
1120
1121     bytes_releasable_ += BytesConsumedIfAllocated(tile);
1122     ++resources_releasable_;
1123   }
1124
1125   FreeUnusedResourcesForTile(tile);
1126   if (tile->priority(ACTIVE_TREE).distance_to_visible == 0.f)
1127     did_initialize_visible_tile_ = true;
1128
1129   client_->NotifyTileStateChanged(tile);
1130 }
1131
1132 scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
1133                                             const gfx::Size& tile_size,
1134                                             const gfx::Rect& content_rect,
1135                                             const gfx::Rect& opaque_rect,
1136                                             float contents_scale,
1137                                             int layer_id,
1138                                             int source_frame_number,
1139                                             int flags) {
1140   scoped_refptr<Tile> tile = make_scoped_refptr(new Tile(this,
1141                                                          picture_pile,
1142                                                          tile_size,
1143                                                          content_rect,
1144                                                          opaque_rect,
1145                                                          contents_scale,
1146                                                          layer_id,
1147                                                          source_frame_number,
1148                                                          flags));
1149   DCHECK(tiles_.find(tile->id()) == tiles_.end());
1150
1151   tiles_[tile->id()] = tile;
1152   used_layer_counts_[tile->layer_id()]++;
1153   prioritized_tiles_dirty_ = true;
1154   return tile;
1155 }
1156
1157 void TileManager::SetRasterizerForTesting(Rasterizer* rasterizer) {
1158   rasterizer_ = rasterizer;
1159   rasterizer_->SetClient(this);
1160 }
1161
1162 bool TileManager::IsReadyToActivate() const {
1163   const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
1164
1165   for (std::vector<PictureLayerImpl*>::const_iterator it = layers.begin();
1166        it != layers.end();
1167        ++it) {
1168     if (!(*it)->AllTilesRequiredForActivationAreReadyToDraw())
1169       return false;
1170   }
1171
1172   return true;
1173 }
1174
1175 void TileManager::CheckIfReadyToActivate() {
1176   TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate");
1177
1178   rasterizer_->CheckForCompletedTasks();
1179   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
1180
1181   if (IsReadyToActivate())
1182     client_->NotifyReadyToActivate();
1183 }
1184
1185 }  // namespace cc