cc: Add image decode queue functionality to image manager.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 324 matching lines @@
 RasterTaskCompletionStatsAsValue(const RasterTaskCompletionStats& stats) {
   std::unique_ptr<base::trace_event::TracedValue> state(
       new base::trace_event::TracedValue());
   state->SetInteger("completed_count",
                     base::saturated_cast<int>(stats.completed_count));
   state->SetInteger("canceled_count",
                     base::saturated_cast<int>(stats.canceled_count));
   return std::move(state);
 }
 
-TileManager::TileManager(TileManagerClient* client,
-                         base::SequencedTaskRunner* task_runner,
-                         size_t scheduled_raster_task_limit,
-                         bool use_partial_raster,
-                         bool check_tile_priority_inversion)
+TileManager::TileManager(
+    TileManagerClient* client,
+    base::SequencedTaskRunner* origin_task_runner,
+    scoped_refptr<base::SequencedTaskRunner> image_worker_task_runner,
+    size_t scheduled_raster_task_limit,
+    bool use_partial_raster,
+    bool check_tile_priority_inversion)
     : client_(client),
-      task_runner_(task_runner),
+      task_runner_(origin_task_runner),
       resource_pool_(nullptr),
       tile_task_manager_(nullptr),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
       use_partial_raster_(use_partial_raster),
       use_gpu_rasterization_(false),
       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),
+      image_controller_(origin_task_runner,
+                        std::move(image_worker_task_runner)),
       more_tiles_need_prepare_check_notifier_(
           task_runner_,
           base::Bind(&TileManager::CheckIfMoreTilesNeedToBePrepared,
                      base::Unretained(this))),
       signals_check_notifier_(task_runner_,
                               base::Bind(&TileManager::CheckAndIssueSignals,
                                          base::Unretained(this))),
       has_scheduled_tile_tasks_(false),
       prepare_tiles_count_(0u),
       next_tile_id_(0u),
@@ skipping 687 matching lines @@
   TileDrawInfo& draw_info = tile->draw_info();
   draw_info.set_use_resource();
   draw_info.resource_ = resource;
   draw_info.contents_swizzled_ = DetermineResourceRequiresSwizzle(tile);
 
   DCHECK(draw_info.IsReadyToDraw());
   draw_info.set_was_ever_ready_to_draw();
   client_->NotifyTileStateChanged(tile);
 }
 
+void TileManager::SetDecodedImageTracker(
+    DecodedImageTracker* decoded_image_tracker) {
+  // TODO(vmpstr): If the tile manager needs to request out-of-raster decodes,
+  // it should retain and use |decoded_image_tracker| here.
+  decoded_image_tracker->set_image_controller(&image_controller_);
+}
+
 std::unique_ptr<Tile> TileManager::CreateTile(const Tile::CreateInfo& info,
                                               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_manager_);
   std::unique_ptr<Tile> tile(
       new Tile(this, info, layer_id, source_frame_number, flags));
   DCHECK(tiles_.find(tile->id()) == tiles_.end());
@@ skipping 283 matching lines @@
   all_tile_tasks_completed = false;
   did_notify_all_tile_tasks_completed = false;
 }
 
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule() = default;
 TileManager::PrioritizedWorkToSchedule::PrioritizedWorkToSchedule(
     PrioritizedWorkToSchedule&& other) = default;
 TileManager::PrioritizedWorkToSchedule::~PrioritizedWorkToSchedule() = default;
 
 }  // namespace cc