cc: Regenerate image decode requests tasks when cache switches.

cc/tiles/image_controller.cc

 // Copyright 2016 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/image_controller.h"
 
 #include "base/bind.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/completion_event.h"
 #include "cc/tiles/tile_task_manager.h"
 
 namespace cc {
 
 ImageController::ImageDecodeRequestId
     ImageController::s_next_image_decode_queue_id_ = 1;
 
 ImageController::ImageController(
     base::SequencedTaskRunner* origin_task_runner,
     scoped_refptr<base::SequencedTaskRunner> worker_task_runner)
     : worker_task_runner_(std::move(worker_task_runner)),
       origin_task_runner_(origin_task_runner),
       weak_ptr_factory_(this) {}
 
 ImageController::~ImageController() {
   StopWorkerTasks();
+  for (auto& request : orphaned_decode_requests_)
+    request.callback.Run(request.id, ImageDecodeResult::FAILURE);
 }
 
 void ImageController::StopWorkerTasks() {
   // We can't have worker threads without a cache_ or a worker_task_runner_, so
   // terminate early.
   if (!cache_ || !worker_task_runner_)
     return;
 
   // Abort all tasks that are currently scheduled to run (we'll wait for them to
   // finish next).
@@ skipping 28 matching lines @@
   // Unlock all of the locked images (note that this vector would only be
   // populated if we actually need to unref the image.
   for (auto image_pair : requested_locked_images_)
     cache_->UnrefImage(image_pair.second);
   requested_locked_images_.clear();
 
   // Now, complete the tasks that already ran but haven't completed. These would
   // be posted in the run loop, but since we invalidated the weak ptrs, we need
   // to run everything manually.
   for (auto& request_to_complete : requests_needing_completion_) {
-    ImageDecodeRequestId id = request_to_complete.first;
     ImageDecodeRequest& request = request_to_complete.second;
 
     // The task (if one exists) would have run already, we just need to make
     // sure it was completed. Multiple requests for the same image use the same
     // task so it could have already been completed.
     if (request.task && !request.task->HasCompleted())
       request.task->DidComplete();
 
-    // Issue the callback, and unref the image immediately. This is so that any
-    // code waiting on the callback can proceed, although we're breaking the
-    // promise of having this image decoded. This is unfortunate, but it seems
-    // like the least complexity to process an image decode controller becoming
-    // nullptr.
-    // TODO(vmpstr): We can move these back to |image_decode_queue_| instead
-    // and defer completion until we get a new cache and process the request
-    // again. crbug.com/693692.
-    request.callback.Run(id, ImageDecodeResult::FAILURE);
     if (request.need_unref)
       cache_->UnrefImage(request.draw_image);
+
+    // Orphan the request so that we can still run it when a new cache is set.
+    request.task = nullptr;
+    request.need_unref = false;
+    orphaned_decode_requests_.push_back(std::move(request));
   }
   requests_needing_completion_.clear();
 
   // Finally, complete all of the tasks that never started running. This is
   // similar to the |requests_needing_completion_|, but happens at a different
   // stage in the pipeline.
   for (auto& request_pair : image_decode_queue_) {
-    ImageDecodeRequestId id = request_pair.first;
     ImageDecodeRequest& request = request_pair.second;
 
     if (request.task) {
       // This task may have run via a different request, so only cancel it if
       // it's "new". That is, the same task could have been referenced by
       // several different image deque requests for the same image.
       if (request.task->state().IsNew())
         request.task->state().DidCancel();
 
       if (!request.task->HasCompleted())
         request.task->DidComplete();
     }
-    // Run the callback and unref the image.
-    // TODO(vmpstr): We can regenerate the tasks for the new cache if we get
-    // one. crbug.com/693692.
-    request.callback.Run(id, ImageDecodeResult::FAILURE);
     cache_->UnrefImage(request.draw_image);
+
+    // Orphan the request so that we can still run it when a new cache is set.
+    request.task = nullptr;
+    request.need_unref = false;
+    orphaned_decode_requests_.push_back(std::move(request));
   }
   image_decode_queue_.clear();
 }
 
 void ImageController::SetImageDecodeCache(ImageDecodeCache* cache) {
   DCHECK(!cache_ || !cache);
 
   if (!cache) {
     SetPredecodeImages(std::vector<DrawImage>(),
                        ImageDecodeCache::TracingInfo());
     StopWorkerTasks();
   }
 
   cache_ = cache;
+
+  if (cache_)
+    GenerateTasksForOrphanedRequests();
 }
 
 void ImageController::GetTasksForImagesAndRef(
     std::vector<DrawImage>* images,
     std::vector<scoped_refptr<TileTask>>* tasks,
     const ImageDecodeCache::TracingInfo& tracing_info) {
   DCHECK(cache_);
   for (auto it = images->begin(); it != images->end();) {
     scoped_refptr<TileTask> task;
     bool need_to_unref_when_finished =
@@ skipping 168 matching lines @@
   // Post another task to run.
   worker_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ImageController::ProcessNextImageDecodeOnWorkerThread,
                  base::Unretained(this)));
 
   // Finally run the requested callback.
   callback.Run(id, result);
 }
 
+void ImageController::GenerateTasksForOrphanedRequests() {
+  base::AutoLock hold(lock_);
+  DCHECK_EQ(0u, image_decode_queue_.size());
+  DCHECK_EQ(0u, requests_needing_completion_.size());
+  DCHECK(cache_);
+
+  for (auto& request : orphaned_decode_requests_) {
+    DCHECK(!request.task);
+    DCHECK(!request.need_unref);
+    if (request.draw_image.image()->isLazyGenerated()) {
+      // Get the task for this decode.
+      request.need_unref = cache_->GetOutOfRasterDecodeTaskForImageAndRef(
+          request.draw_image, &request.task);
+    }
+    image_decode_queue_[request.id] = std::move(request);
+  }
+
+  orphaned_decode_requests_.clear();
+  if (!image_decode_queue_.empty()) {
+    // Post a worker task.
+    worker_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&ImageController::ProcessNextImageDecodeOnWorkerThread,
+                   base::Unretained(this)));
+  }
+}
+
 ImageController::ImageDecodeRequest::ImageDecodeRequest() = default;
 ImageController::ImageDecodeRequest::ImageDecodeRequest(
     ImageDecodeRequestId id,
     const DrawImage& draw_image,
     const ImageDecodedCallback& callback,
     scoped_refptr<TileTask> task,
     bool need_unref)
     : id(id),
       draw_image(draw_image),
       callback(callback),
       task(std::move(task)),
       need_unref(need_unref) {}
 ImageController::ImageDecodeRequest::ImageDecodeRequest(
     ImageDecodeRequest&& other) = default;
 ImageController::ImageDecodeRequest::ImageDecodeRequest(
     const ImageDecodeRequest& other) = default;
 ImageController::ImageDecodeRequest::~ImageDecodeRequest() = default;
 
 ImageController::ImageDecodeRequest& ImageController::ImageDecodeRequest::
 operator=(ImageDecodeRequest&& other) = default;
 ImageController::ImageDecodeRequest& ImageController::ImageDecodeRequest::
 operator=(const ImageDecodeRequest& other) = default;
 
 }  // namespace cc