Reland (2): cc: Make tile manager object persist for the length of LTHI.

cc/tiles/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/tiles/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 210 matching lines @@
                     base::saturated_cast<int>(stats.completed_count));
   state->SetInteger("canceled_count",
                     base::saturated_cast<int>(stats.canceled_count));
   return state;
 }
 
 // static
 scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
     base::SequencedTaskRunner* task_runner,
-    ResourcePool* resource_pool,
-    TileTaskRunner* tile_task_runner,
     size_t scheduled_raster_task_limit) {
-  return make_scoped_ptr(new TileManager(client, task_runner, resource_pool,
-                                         tile_task_runner,
-                                         scheduled_raster_task_limit));
+  return make_scoped_ptr(
+      new TileManager(client, task_runner, scheduled_raster_task_limit));
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
-    ResourcePool* resource_pool,
-    TileTaskRunner* tile_task_runner,
     size_t scheduled_raster_task_limit)
     : client_(client),
       task_runner_(task_runner),
-      resource_pool_(resource_pool),
-      tile_task_runner_(tile_task_runner),
+      resource_pool_(nullptr),
+      tile_task_runner_(nullptr),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
       all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       did_oom_on_last_assign_(false),
       more_tiles_need_prepare_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared,
                      base::Unretained(this))),
       signals_check_notifier_(task_runner_.get(),
                               base::Bind(&TileManager::CheckAndIssueSignals,
                                          base::Unretained(this))),
       has_scheduled_tile_tasks_(false),
       prepare_tiles_count_(0u) {
-  tile_task_runner_->SetClient(this);
 }
 
 TileManager::~TileManager() {
-  // Reset global state and manage. This should cause
-  // our memory usage to drop to zero.
+}

[enne (OOO), 2015/07/06 18:07:25]

Should this call FinishTasksAndCleanUp? Or at least DCHECK that it's been done?

[vmpstr, 2015/07/06 18:41:35]

Done.

+
+void TileManager::FinishTasksAndCleanUp() {
+  if (!tile_task_runner_)
+    return;
+
   global_state_ = GlobalStateThatImpactsTilePriority();
 
   TileTaskQueue empty;
   tile_task_runner_->ScheduleTasks(&empty);
   orphan_raster_tasks_.clear();
 
   // This should finish all pending tasks and release any uninitialized
   // resources.
   tile_task_runner_->Shutdown();
   tile_task_runner_->CheckForCompletedTasks();
 
   FreeResourcesForReleasedTiles();
   CleanUpReleasedTiles();
+
+  tile_task_runner_ = nullptr;
+  resource_pool_ = nullptr;
+  more_tiles_need_prepare_check_notifier_.Cancel();
+  signals_check_notifier_.Cancel();
+}
+
+void TileManager::SetResources(ResourcePool* resource_pool,
+                               TileTaskRunner* tile_task_runner) {
+  DCHECK(!tile_task_runner_);
+  DCHECK(tile_task_runner);
+
+  resource_pool_ = resource_pool;
+  tile_task_runner_ = tile_task_runner;
+  tile_task_runner_->SetClient(this);
 }
 
 void TileManager::Release(Tile* tile) {
   released_tiles_.push_back(tile);
 }
 
 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;
@@ skipping 26 matching lines @@
     }
 
     delete tile;
   }
   released_tiles_.swap(tiles_to_retain);
 }
 
 void TileManager::DidFinishRunningTileTasks(TaskSet task_set) {
   TRACE_EVENT1("cc", "TileManager::DidFinishRunningTileTasks", "task_set",
                TaskSetName(task_set));
+  DCHECK(resource_pool_);
+  DCHECK(tile_task_runner_);
 
   switch (task_set) {
     case ALL: {
       has_scheduled_tile_tasks_ = false;
 
       bool memory_usage_above_limit =
           resource_pool_->total_memory_usage_bytes() >
           global_state_.soft_memory_limit_in_bytes;
 
       if (all_tiles_that_need_to_be_rasterized_are_scheduled_ &&
@@ skipping 16 matching lines @@
 
     case REQUIRED_FOR_DRAW:
       signals_.ready_to_draw = true;
       signals_check_notifier_.Schedule();
       return;
   }
 
   NOTREACHED();
 }
 
-void TileManager::PrepareTiles(
+bool TileManager::PrepareTiles(
     const GlobalStateThatImpactsTilePriority& state) {
   ++prepare_tiles_count_;
 
   TRACE_EVENT1("cc", "TileManager::PrepareTiles", "prepare_tiles_id",
                prepare_tiles_count_);
 
+  if (!tile_task_runner_) {
+    TRACE_EVENT_INSTANT0("cc", "PrepareTiles aborted",
+                         TRACE_EVENT_SCOPE_THREAD);
+    return false;
+  }
+
   signals_.reset();
   global_state_ = state;
 
   // 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;
   }
 
@@ skipping 16 matching lines @@
 
   // Schedule tile tasks.
   ScheduleTasks(tiles_that_need_to_be_rasterized);
 
   TRACE_EVENT_INSTANT1("cc", "DidPrepareTiles", TRACE_EVENT_SCOPE_THREAD,
                        "state", BasicStateAsValue());
 
   TRACE_COUNTER_ID1("cc", "unused_memory_bytes", this,
                     resource_pool_->total_memory_usage_bytes() -
                         resource_pool_->acquired_memory_usage_bytes());
+  return true;
 }
 
 void TileManager::Flush() {
   TRACE_EVENT0("cc", "TileManager::Flush");
 
+  if (!tile_task_runner_) {
+    TRACE_EVENT_INSTANT0("cc", "Flush aborted", TRACE_EVENT_SCOPE_THREAD);
+    return;
+  }
+
   tile_task_runner_->CheckForCompletedTasks();
 
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   TRACE_EVENT_INSTANT1("cc", "DidFlush", TRACE_EVENT_SCOPE_THREAD, "stats",
                        RasterTaskCompletionStatsAsValue(flush_stats_));
   flush_stats_ = RasterTaskCompletionStats();
 }
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
@@ skipping 76 matching lines @@
   NOTREACHED();
   return true;
 }
 
 void TileManager::AssignGpuMemoryToTiles(
     RasterTilePriorityQueue* raster_priority_queue,
     size_t scheduled_raster_task_limit,
     PrioritizedTileVector* tiles_that_need_to_be_rasterized) {
   TRACE_EVENT_BEGIN0("cc", "TileManager::AssignGpuMemoryToTiles");
 
+  DCHECK(resource_pool_);
+  DCHECK(tile_task_runner_);
+
   // 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;
@@ skipping 297 matching lines @@
 
   client_->NotifyTileStateChanged(tile);
 }
 
 ScopedTilePtr TileManager::CreateTile(const gfx::Size& desired_texture_size,
                                       const gfx::Rect& content_rect,
                                       float contents_scale,
                                       int layer_id,
                                       int source_frame_number,
                                       int flags) {
+  // We need to have a tile task worker pool to do anything meaningful with
+  // tiles.
+  DCHECK(tile_task_runner_);
   ScopedTilePtr tile(new Tile(this, desired_texture_size, content_rect,
                               contents_scale, layer_id, source_frame_number,
                               flags));
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
 
   tiles_[tile->id()] = tile.get();
   used_layer_counts_[tile->layer_id()]++;
   return tile;
 }
 
@@ skipping 223 matching lines @@
 void TileManager::Signals::reset() {
   ready_to_activate = false;
   did_notify_ready_to_activate = false;
   ready_to_draw = false;
   did_notify_ready_to_draw = false;
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 }  // namespace cc