Refactoring for merging ManagedTileState into Tile.

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 263 matching lines @@
 void TileManager::CleanUpReleasedTiles() {
   std::vector<Tile*>::iterator it = released_tiles_.begin();
   while (it != released_tiles_.end()) {
     Tile* tile = *it;
 
     if (tile->HasRasterTask()) {
       ++it;
       continue;
     }
 
-    DCHECK(!tile->HasResources());
+    DCHECK(!tile->HasResource());
     DCHECK(tiles_.find(tile->id()) != tiles_.end());
     tiles_.erase(tile->id());
 
     LayerCountMap::iterator layer_it =
         used_layer_counts_.find(tile->layer_id());
     DCHECK_GT(layer_it->second, 0);
     if (--layer_it->second == 0) {
       used_layer_counts_.erase(layer_it);
       image_decode_tasks_.erase(tile->layer_id());
     }
@@ skipping 51 matching lines @@
       // been been assigned memory after reaching a steady memory state. This
       // ensures that we activate even when OOM. Note that we have to rebuilt
       // the
       // queue in case the last AssignGpuMemoryToTiles evicted some tiles that
       // would otherwise not be picked up by the old raster queue.
       client_->BuildRasterQueue(&raster_priority_queue_,
                                 global_state_.tree_priority);
       bool ready_to_activate = true;
       while (!raster_priority_queue_.IsEmpty()) {
         Tile* tile = raster_priority_queue_.Top();
-        ManagedTileState& mts = tile->managed_state();
+        TileDrawInfo& draw_info = tile->draw_info();
 
-        if (tile->required_for_activation() && !mts.draw_info.IsReadyToDraw()) {
+        if (tile->required_for_activation() && !draw_info.IsReadyToDraw()) {
           // If we can't raster on demand, give up early (and don't activate).
           if (!allow_rasterize_on_demand) {
             ready_to_activate = false;
             break;
           }
 
-          mts.draw_info.set_rasterize_on_demand();
+          draw_info.set_rasterize_on_demand();
           client_->NotifyTileStateChanged(tile);
         }
         raster_priority_queue_.Pop();
       }
 
       if (ready_to_activate) {
         DCHECK(IsReadyToActivate());
         ready_to_activate_check_notifier_.Schedule();
       }
       raster_priority_queue_.Reset();
@@ skipping 183 matching lines @@
       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;
     }
 
-    ManagedTileState& mts = tile->managed_state();
-    mts.scheduled_priority = schedule_priority++;
-    mts.resolution = priority.resolution;
+    TileDrawInfo& draw_info = tile->draw_info();
+    tile->scheduled_priority = schedule_priority++;
 
-    DCHECK(mts.draw_info.mode() ==
-               ManagedTileState::DrawInfo::PICTURE_PILE_MODE ||
-           !mts.draw_info.IsReadyToDraw());
+    DCHECK(draw_info.mode() == TileDrawInfo::PICTURE_PILE_MODE ||
+           !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 (!mts.raster_task.get()) {
+    if (!tile->raster_task.get()) {
       memory_required_by_tile_to_be_scheduled = MemoryUsage::FromConfig(
           tile->size(), resource_pool_->resource_format());
     }
 
     bool tile_is_needed_now = priority.priority_bin == TilePriority::NOW;
 
     // This is the memory limit that will be used by this tile. Depending on
     // the tile priority, it will be one of hard_memory_limit or
     // soft_memory_limit.
     MemoryUsage& tile_memory_limit =
@@ skipping 38 matching lines @@
 
   TRACE_EVENT_END2("cc",
                    "TileManager::AssignGpuMemoryToTiles",
                    "all_tiles_that_need_to_be_rasterized_are_scheduled",
                    all_tiles_that_need_to_be_rasterized_are_scheduled_,
                    "had_enough_memory_to_schedule_tiles_needed_now",
                    had_enough_memory_to_schedule_tiles_needed_now);
 }
 
 void TileManager::FreeResourcesForTile(Tile* tile) {
-  ManagedTileState& mts = tile->managed_state();
-  if (mts.draw_info.resource_)
-    resource_pool_->ReleaseResource(mts.draw_info.resource_.Pass());
+  TileDrawInfo& draw_info = tile->draw_info();
+  if (draw_info.resource_)
+    resource_pool_->ReleaseResource(draw_info.resource_.Pass());
 }
 
 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) {
   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;
-    ManagedTileState& mts = tile->managed_state();
+    TileDrawInfo& draw_info = tile->draw_info();
 
-    DCHECK(mts.draw_info.requires_resource());
-    DCHECK(!mts.draw_info.resource_);
+    DCHECK(draw_info.requires_resource());
+    DCHECK(!draw_info.resource_);
 
-    if (!mts.raster_task.get())
-      mts.raster_task = CreateRasterTask(tile);
+    if (!tile->raster_task.get())
+      tile->raster_task = CreateRasterTask(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(mts.raster_task.get(), task_sets));
+        TileTaskQueue::Item(tile->raster_task.get(), task_sets));
   }
 
   // We must reduce the amount of unused resoruces before calling
   // ScheduleTasks to prevent usage from rising above limits.
   resource_pool_->ReduceResourceUsage();
 
   // Schedule running of |raster_queue_|. This replaces any previously
   // scheduled tasks and effectively cancels all tasks not present
   // in |raster_queue_|.
   tile_task_runner_->ScheduleTasks(&raster_queue_);
@@ skipping 12 matching lines @@
   return make_scoped_refptr(new ImageDecodeTaskImpl(
       pixel_ref,
       tile->layer_id(),
       base::Bind(&TileManager::OnImageDecodeTaskCompleted,
                  base::Unretained(this),
                  tile->layer_id(),
                  base::Unretained(pixel_ref))));
 }
 
 scoped_refptr<RasterTask> TileManager::CreateRasterTask(Tile* tile) {
-  ManagedTileState& mts = tile->managed_state();
-
   scoped_ptr<ScopedResource> resource =
       resource_pool_->AcquireResource(tile->size());
   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(
       tile->content_rect(), tile->contents_scale(), &pixel_refs);
   for (SkPixelRef* pixel_ref : pixel_refs) {
     uint32_t id = pixel_ref->getGenerationID();
 
     // Append existing image decode task if available.
     PixelRefTaskMap::iterator decode_task_it = existing_pixel_refs.find(id);
     if (decode_task_it != existing_pixel_refs.end()) {
       decode_tasks.push_back(decode_task_it->second);
       continue;
     }
 
     // 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(),
-                         mts.resolution,
-                         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));
+  return make_scoped_refptr(new RasterTaskImpl(
+      const_resource, tile->raster_source(), tile->content_rect(),
+      tile->contents_scale(), tile->combined_priority().resolution,
+      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_|.
   if (!was_canceled)
     return;
 
@@ skipping 10 matching lines @@
 }
 
 void TileManager::OnRasterTaskCompleted(
     Tile::Id tile_id,
     scoped_ptr<ScopedResource> resource,
     const RasterSource::SolidColorAnalysis& analysis,
     bool was_canceled) {
   DCHECK(tiles_.find(tile_id) != tiles_.end());
 
   Tile* tile = tiles_[tile_id];
-  ManagedTileState& mts = tile->managed_state();
-  DCHECK(mts.raster_task.get());
-  orphan_raster_tasks_.push_back(mts.raster_task);
-  mts.raster_task = NULL;
+  TileDrawInfo& draw_info = tile->draw_info();
+  DCHECK(tile->raster_task.get());
+  orphan_raster_tasks_.push_back(tile->raster_task);
+  tile->raster_task = NULL;
 
   if (was_canceled) {
     ++update_visible_tiles_stats_.canceled_count;
     resource_pool_->ReleaseResource(resource.Pass());
     return;
   }
 
   ++update_visible_tiles_stats_.completed_count;
 
   if (analysis.is_solid_color) {
-    mts.draw_info.set_solid_color(analysis.solid_color);
+    draw_info.set_solid_color(analysis.solid_color);
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
-    mts.draw_info.set_use_resource();
-    mts.draw_info.resource_ = resource.Pass();
+    draw_info.set_use_resource();
+    draw_info.resource_ = resource.Pass();
   }
 
   client_->NotifyTileStateChanged(tile);
 }
 
 scoped_refptr<Tile> TileManager::CreateTile(RasterSource* raster_source,
                                             const gfx::Size& tile_size,
                                             const gfx::Rect& content_rect,
                                             float contents_scale,
                                             int layer_id,
@@ skipping 82 matching lines @@
 
 // static
 TileManager::MemoryUsage TileManager::MemoryUsage::FromConfig(
     const gfx::Size& size,
     ResourceFormat format) {
   return MemoryUsage(Resource::MemorySizeBytes(size, format), 1);
 }
 
 // static
 TileManager::MemoryUsage TileManager::MemoryUsage::FromTile(const Tile* tile) {
-  const ManagedTileState& mts = tile->managed_state();
-  if (mts.draw_info.resource_) {
-    return MemoryUsage::FromConfig(tile->size(),
-                                   mts.draw_info.resource_->format());
+  const TileDrawInfo& draw_info = tile->draw_info();
+  if (draw_info.resource_) {
+    return MemoryUsage::FromConfig(tile->size(), draw_info.resource_->format());
   }
   return MemoryUsage();
 }
 
 TileManager::MemoryUsage& TileManager::MemoryUsage::operator+=(
     const MemoryUsage& other) {
   memory_bytes_ += other.memory_bytes_;
   resource_count_ += other.resource_count_;
   return *this;
 }
@@ skipping 11 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