cc: Separate the priority from the tile and put in new PrioritizedTile

cc/resources/tile_manager.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 253 matching lines @@
 }
 
 TaskSetCollection TileManager::TasksThatShouldBeForcedToComplete() const {
   TaskSetCollection tasks_that_should_be_forced_to_complete;
   if (global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY)
     tasks_that_should_be_forced_to_complete[REQUIRED_FOR_ACTIVATION] = true;
   return tasks_that_should_be_forced_to_complete;
 }
 
 void TileManager::FreeResourcesForReleasedTiles() {
-  for (std::vector<Tile*>::iterator it = released_tiles_.begin();
-       it != released_tiles_.end();
-       ++it) {
-    Tile* tile = *it;
+  for (auto* tile : released_tiles_)
     FreeResourcesForTile(tile);
-  }
 }
 
 void TileManager::CleanUpReleasedTiles() {
   std::vector<Tile*> tiles_to_retain;
   for (auto* tile : released_tiles_) {
     if (tile->HasRasterTask()) {
       tiles_to_retain.push_back(tile);
       continue;
     }
 
@@ skipping 51 matching lines @@
   // We need to call CheckForCompletedTasks() once in-between each call
   // to ScheduleTasks() to prevent canceled tasks from being scheduled.
   if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
     tile_task_runner_->CheckForCompletedTasks();
     did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
   }
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
 
-  TileVector tiles_that_need_to_be_rasterized;
+  PrioritizedTileVector tiles_that_need_to_be_rasterized;
   scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
       client_->BuildRasterQueue(global_state_.tree_priority,
                                 RasterTilePriorityQueue::Type::ALL));
   AssignGpuMemoryToTiles(raster_priority_queue.get(),
                          scheduled_raster_task_limit_,
                          &tiles_that_need_to_be_rasterized);
 
   // Inform the client that will likely require a draw if the highest priority
   // tile that will be rasterized is required for draw.
   client_->SetIsLikelyToRequireADraw(
       !tiles_that_need_to_be_rasterized.empty() &&
-      (*tiles_that_need_to_be_rasterized.begin())->required_for_draw());
+      tiles_that_need_to_be_rasterized.front().tile()->required_for_draw());
 
   // Schedule tile tasks.
   ScheduleTasks(tiles_that_need_to_be_rasterized);
 
   did_notify_ready_to_activate_ = false;
   did_notify_ready_to_draw_ = false;
 
   TRACE_EVENT_INSTANT1("cc", "DidPrepareTiles", TRACE_EVENT_SCOPE_THREAD,
                        "state", BasicStateAsValue());
 
@@ skipping 42 matching lines @@
     const MemoryUsage& limit,
     MemoryUsage* usage) {
   while (usage->Exceeds(limit)) {
     if (!eviction_priority_queue) {
       eviction_priority_queue =
           client_->BuildEvictionQueue(global_state_.tree_priority);
     }
     if (eviction_priority_queue->IsEmpty())
       break;
 
-    Tile* tile = eviction_priority_queue->Top();
+    Tile* tile = eviction_priority_queue->Top().tile();
     *usage -= MemoryUsage::FromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
     eviction_priority_queue->Pop();
   }
   return eviction_priority_queue;
 }
 
 scoped_ptr<EvictionTilePriorityQueue>
 TileManager::FreeTileResourcesWithLowerPriorityUntilUsageIsWithinLimit(
     scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
     const MemoryUsage& limit,
     const TilePriority& other_priority,
     MemoryUsage* usage) {
   while (usage->Exceeds(limit)) {
     if (!eviction_priority_queue) {
       eviction_priority_queue =
           client_->BuildEvictionQueue(global_state_.tree_priority);
     }
     if (eviction_priority_queue->IsEmpty())
       break;
 
-    Tile* tile = eviction_priority_queue->Top();
-    if (!other_priority.IsHigherPriorityThan(tile->priority()))
+    const PrioritizedTile& prioritized_tile = eviction_priority_queue->Top();
+    if (!other_priority.IsHigherPriorityThan(prioritized_tile.priority()))
       break;
 
+    Tile* tile = prioritized_tile.tile();
     *usage -= MemoryUsage::FromTile(tile);
     FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(tile);
     eviction_priority_queue->Pop();
   }
   return eviction_priority_queue;
 }
 
 bool TileManager::TilePriorityViolatesMemoryPolicy(
     const TilePriority& priority) {
   switch (global_state_.memory_limit_policy) {
     case ALLOW_NOTHING:
       return true;
     case ALLOW_ABSOLUTE_MINIMUM:
       return priority.priority_bin > TilePriority::NOW;
     case ALLOW_PREPAINT_ONLY:
       return priority.priority_bin > TilePriority::SOON;
     case ALLOW_ANYTHING:
       return priority.distance_to_visible ==
              std::numeric_limits<float>::infinity();
   }
   NOTREACHED();
   return true;
 }
 
 void TileManager::AssignGpuMemoryToTiles(
     RasterTilePriorityQueue* raster_priority_queue,
     size_t scheduled_raster_task_limit,
-    TileVector* tiles_that_need_to_be_rasterized) {
+    PrioritizedTileVector* tiles_that_need_to_be_rasterized) {
   TRACE_EVENT_BEGIN0("cc", "TileManager::AssignGpuMemoryToTiles");
 
   // Maintain the list of released resources that can potentially be re-used
   // or deleted. If this operation becomes expensive too, only do this after
   // some resource(s) was returned. Note that in that case, one also need to
   // invalidate when releasing some resource from the pool.
   resource_pool_->CheckBusyResources(false);
 
   // Now give memory out to the tiles until we're out, and build
   // the needs-to-be-rasterized queue.
   unsigned schedule_priority = 1u;
   all_tiles_that_need_to_be_rasterized_are_scheduled_ = true;
   bool had_enough_memory_to_schedule_tiles_needed_now = true;
 
   MemoryUsage hard_memory_limit(global_state_.hard_memory_limit_in_bytes,
                                 global_state_.num_resources_limit);
   MemoryUsage soft_memory_limit(global_state_.soft_memory_limit_in_bytes,
                                 global_state_.num_resources_limit);
   MemoryUsage memory_usage(resource_pool_->acquired_memory_usage_bytes(),
                            resource_pool_->acquired_resource_count());
 
   scoped_ptr<EvictionTilePriorityQueue> eviction_priority_queue;
   for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
-    Tile* tile = raster_priority_queue->Top();
-    TilePriority priority = tile->priority();
+    const PrioritizedTile& prioritized_tile = raster_priority_queue->Top();
+    Tile* tile = prioritized_tile.tile();
+    TilePriority priority = prioritized_tile.priority();
 
     if (TilePriorityViolatesMemoryPolicy(priority)) {
       TRACE_EVENT_INSTANT0(
           "cc", "TileManager::AssignGpuMemory tile violates memory policy",
           TRACE_EVENT_SCOPE_THREAD);
       break;
     }
 
     // We won't be able to schedule this tile, so break out early.
     if (tiles_that_need_to_be_rasterized->size() >=
         scheduled_raster_task_limit) {
       all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
       break;
     }
 
-    TileDrawInfo& draw_info = tile->draw_info();
     tile->scheduled_priority_ = schedule_priority++;
 
-    DCHECK_IMPLIES(draw_info.mode() != TileDrawInfo::OOM_MODE,
-                   !draw_info.IsReadyToDraw());
+    DCHECK_IMPLIES(tile->draw_info().mode() != TileDrawInfo::OOM_MODE,
+                   !tile->draw_info().IsReadyToDraw());
 
     // If the tile already has a raster_task, then the memory used by it is
     // already accounted for in memory_usage. Otherwise, we'll have to acquire
     // more memory to create a raster task.
     MemoryUsage memory_required_by_tile_to_be_scheduled;
     if (!tile->raster_task_.get()) {
       memory_required_by_tile_to_be_scheduled = MemoryUsage::FromConfig(
           tile->desired_texture_size(), tile_task_runner_->GetResourceFormat());
     }
 
@@ skipping 17 matching lines @@
     // If we couldn't fit the tile into our current memory limit, then we're
     // done.
     if (!memory_usage_is_within_limit) {
       if (tile_is_needed_now)
         had_enough_memory_to_schedule_tiles_needed_now = false;
       all_tiles_that_need_to_be_rasterized_are_scheduled_ = false;
       break;
     }
 
     memory_usage += memory_required_by_tile_to_be_scheduled;
-    tiles_that_need_to_be_rasterized->push_back(tile);
+    tiles_that_need_to_be_rasterized->push_back(prioritized_tile);
   }
 
   // Note that we should try and further reduce memory in case the above loop
   // didn't reduce memory. This ensures that we always release as many resources
   // as possible to stay within the memory limit.
   eviction_priority_queue = FreeTileResourcesUntilUsageIsWithinLimit(
       eviction_priority_queue.Pass(), hard_memory_limit, &memory_usage);
 
   UMA_HISTOGRAM_BOOLEAN("TileManager.ExceededMemoryBudget",
                         !had_enough_memory_to_schedule_tiles_needed_now);
@@ skipping 20 matching lines @@
 
 void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(
     Tile* tile) {
   bool was_ready_to_draw = tile->IsReadyToDraw();
   FreeResourcesForTile(tile);
   if (was_ready_to_draw)
     client_->NotifyTileStateChanged(tile);
 }
 
 void TileManager::ScheduleTasks(
-    const TileVector& tiles_that_need_to_be_rasterized) {
+    const PrioritizedTileVector& tiles_that_need_to_be_rasterized) {
   TRACE_EVENT1("cc",
                "TileManager::ScheduleTasks",
                "count",
                tiles_that_need_to_be_rasterized.size());
 
   DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
 
   raster_queue_.Reset();
 
   // Build a new task queue containing all task currently needed. Tasks
   // are added in order of priority, highest priority task first.
-  for (TileVector::const_iterator it = tiles_that_need_to_be_rasterized.begin();
-       it != tiles_that_need_to_be_rasterized.end();
-       ++it) {
-    Tile* tile = *it;
-    TileDrawInfo& draw_info = tile->draw_info();
+  for (auto& prioritized_tile : tiles_that_need_to_be_rasterized) {
+    Tile* tile = prioritized_tile.tile();
 
-    DCHECK(draw_info.requires_resource());
-    DCHECK(!draw_info.resource_);
+    DCHECK(tile->draw_info().requires_resource());
+    DCHECK(!tile->draw_info().resource_);
 
     if (!tile->raster_task_.get())
-      tile->raster_task_ = CreateRasterTask(tile);
+      tile->raster_task_ = CreateRasterTask(prioritized_tile);
 
     TaskSetCollection task_sets;
     if (tile->required_for_activation())
       task_sets.set(REQUIRED_FOR_ACTIVATION);
     if (tile->required_for_draw())
       task_sets.set(REQUIRED_FOR_DRAW);
     task_sets.set(ALL);
     raster_queue_.items.push_back(
         TileTaskQueue::Item(tile->raster_task_.get(), task_sets));
   }
@@ skipping 19 matching lines @@
     Tile* tile,
     SkPixelRef* pixel_ref) {
   return make_scoped_refptr(new ImageDecodeTaskImpl(
       pixel_ref,
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
                  tile->layer_id(),
                  base::Unretained(pixel_ref))));
 }
 
-scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
+scoped_refptr<RasterTask> TileManager::CreateRasterTask(
+    const PrioritizedTile& prioritized_tile) {
+  Tile* tile = prioritized_tile.tile();
   scoped_ptr<ScopedResource> resource =
       resource_pool_->AcquireResource(tile->desired_texture_size(),
                                       tile_task_runner_->GetResourceFormat());
   const ScopedResource* const_resource = resource.get();
 
   // Create and queue all image decode tasks that this tile depends on.
   ImageDecodeTask::Vector decode_tasks;
   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
   std::vector<SkPixelRef*> pixel_refs;
   tile->raster_source()->GatherPixelRefs(
@@ skipping 10 matching lines @@
 
     // Create and append new image decode task for this pixel ref.
     scoped_refptr<ImageDecodeTask> decode_task =
         CreateImageDecodeTask(tile, pixel_ref);
     decode_tasks.push_back(decode_task);
     existing_pixel_refs[id] = decode_task;
   }
 
   return make_scoped_refptr(new RasterTaskImpl(
       const_resource, tile->raster_source(), tile->content_rect(),
-      tile->contents_scale(), tile->priority().resolution, tile->layer_id(),
-      static_cast<const void*>(tile), tile->source_frame_number(),
-      tile->use_picture_analysis(),
+      tile->contents_scale(), prioritized_tile.priority().resolution,

[vmpstr, 2015/05/11 16:44:44]

Can you see what the resolution is used for? Or whether it is used? I was hoping
to just pass Tile* to CreateRasterTask

[hendrikw, 2015/05/11 17:38:30]

it's passed to Analyze and Raster, which passes it to ScopedAnalyzeTask and
ScopedRasterTask, when pass it to a trace event.

It can be removed, but you'll lose it from the trace (which currently reports
the tile id, resolution, source frame number and layer it.

+      tile->layer_id(), static_cast<const void*>(tile),
+      tile->source_frame_number(), tile->use_picture_analysis(),
       base::Bind(&TileManager::OnRasterTaskCompleted, base::Unretained(this),
                  tile->id(), base::Passed(&resource)),
       &decode_tasks));
 }
 
 void TileManager::OnImageDecodeTaskCompleted(int layer_id,
                                              SkPixelRef* pixel_ref,
                                              bool was_canceled) {
   // If the task was canceled, we need to clean it up
   // from |image_decode_tasks_|.
@@ skipping 81 matching lines @@
 bool TileManager::AreRequiredTilesReadyToDraw(
     RasterTilePriorityQueue::Type type) const {
   scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
       client_->BuildRasterQueue(global_state_.tree_priority, type));
   // It is insufficient to check whether the raster queue we constructed is
   // empty. The reason for this is that there are situations (rasterize on
   // demand) when the tile both needs raster and it's ready to draw. Hence, we
   // have to iterate the queue to check whether the required tiles are ready to
   // draw.
   for (; !raster_priority_queue->IsEmpty(); raster_priority_queue->Pop()) {
-    if (!raster_priority_queue->Top()->IsReadyToDraw())
+    if (!raster_priority_queue->Top().tile()->IsReadyToDraw())
       return false;
   }
 
 #if DCHECK_IS_ON()
   scoped_ptr<RasterTilePriorityQueue> all_queue(
       client_->BuildRasterQueue(global_state_.tree_priority, type));
   for (; !all_queue->IsEmpty(); all_queue->Pop()) {
-    auto* tile = all_queue->Top();
+    Tile* tile = all_queue->Top().tile();
     DCHECK_IMPLIES(tile->required_for_activation(), tile->IsReadyToDraw());
   }
 #endif
   return true;
 }
 bool TileManager::IsReadyToActivate() const {
   TRACE_EVENT0("cc", "TileManager::IsReadyToActivate");
   return AreRequiredTilesReadyToDraw(
       RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION);
 }
@@ skipping 47 matching lines @@
 
   NotifyReadyToDraw();
 }
 
 void TileManager::CheckIfMoreTilesNeedToBePrepared() {
   tile_task_runner_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   // When OOM, keep re-assigning memory until we reach a steady state
   // where top-priority tiles are initialized.
-  TileVector tiles_that_need_to_be_rasterized;
+  PrioritizedTileVector tiles_that_need_to_be_rasterized;
   scoped_ptr<RasterTilePriorityQueue> raster_priority_queue(
       client_->BuildRasterQueue(global_state_.tree_priority,
                                 RasterTilePriorityQueue::Type::ALL));
   AssignGpuMemoryToTiles(raster_priority_queue.get(),
                          scheduled_raster_task_limit_,
                          &tiles_that_need_to_be_rasterized);
 
   // Inform the client that will likely require a draw if the highest priority
   // tile that will be rasterized is required for draw.
   client_->SetIsLikelyToRequireADraw(
       !tiles_that_need_to_be_rasterized.empty() &&
-      (*tiles_that_need_to_be_rasterized.begin())->required_for_draw());
+      tiles_that_need_to_be_rasterized.front().tile()->required_for_draw());
 
   // |tiles_that_need_to_be_rasterized| will be empty when we reach a
   // steady memory state. Keep scheduling tasks until we reach this state.
   if (!tiles_that_need_to_be_rasterized.empty()) {
     ScheduleTasks(tiles_that_need_to_be_rasterized);
     return;
   }
 
   FreeResourcesForReleasedTiles();
 
@@ skipping 20 matching lines @@
           RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION));
 
   // If we have tiles left to raster for activation, and we don't allow
   // activating without them, then skip activation and return early.
   if (!required_for_activation_queue->IsEmpty() && wait_for_all_required_tiles)
     return;
 
   // Mark required tiles as OOM so that we can activate without them.
   for (; !required_for_activation_queue->IsEmpty();
        required_for_activation_queue->Pop()) {
-    Tile* tile = required_for_activation_queue->Top();
+    Tile* tile = required_for_activation_queue->Top().tile();
     tile->draw_info().set_oom();
     client_->NotifyTileStateChanged(tile);
   }
 
   DCHECK(IsReadyToActivate());
   ready_to_activate_check_notifier_.Schedule();
 }
 
 TileManager::MemoryUsage::MemoryUsage() : memory_bytes_(0), resource_count_(0) {
 }
@@ skipping 39 matching lines @@
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
   return memory_bytes_ > limit.memory_bytes_ ||
          resource_count_ > limit.resource_count_;
 }
 
 }  // namespace cc