cc: Add image decode queue functionality to image manager.

cc/tiles/software_image_decode_cache.cc

 // Copyright 2015 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/software_image_decode_cache.h"
 
 #include <inttypes.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 76 matching lines @@
   SoftwareImageDecodeCache* cache_;
   const DrawImage& draw_image_;
   const DecodedDrawImage& decoded_draw_image_;
 };
 
 class ImageDecodeTaskImpl : public TileTask {
  public:
   ImageDecodeTaskImpl(SoftwareImageDecodeCache* cache,
                       const SoftwareImageDecodeCache::ImageKey& image_key,
                       const DrawImage& image,
+                      const SoftwareImageDecodeCache::DecodeTaskType task_type,
                       const ImageDecodeCache::TracingInfo& tracing_info)
       : TileTask(true),
         cache_(cache),
         image_key_(image_key),
         image_(image),
+        task_type_(task_type),
         tracing_info_(tracing_info) {}
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageDecodeTaskImpl::RunOnWorkerThread", "mode",
                  "software", "source_prepare_tiles_id",
                  tracing_info_.prepare_tiles_id);
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
         image_.image().get(),
         devtools_instrumentation::ScopedImageDecodeTask::SOFTWARE);
-    cache_->DecodeImage(image_key_, image_);
+    cache_->DecodeImage(image_key_, image_, task_type_);
   }
 
   // Overridden from TileTask:
-  void OnTaskCompleted() override { cache_->RemovePendingTask(image_key_); }
+  void OnTaskCompleted() override {
+    cache_->RemovePendingTask(image_key_, task_type_);
+  }
 
  protected:
   ~ImageDecodeTaskImpl() override {}
 
  private:
   SoftwareImageDecodeCache* cache_;
   SoftwareImageDecodeCache::ImageKey image_key_;
   DrawImage image_;
+  SoftwareImageDecodeCache::DecodeTaskType task_type_;
   const ImageDecodeCache::TracingInfo tracing_info_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
 SkSize GetScaleAdjustment(const ImageDecodeCacheKey& key) {
   // If the requested filter quality did not require scale, then the adjustment
   // is identity.
   if (key.can_use_original_decode() || key.should_use_subrect()) {
     return SkSize::Make(1.f, 1.f);
@@ skipping 65 matching lines @@
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
   // Unregister this component with memory_coordinator::ClientRegistry.
   base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(this);
 }
 
 bool SoftwareImageDecodeCache::GetTaskForImageAndRef(
     const DrawImage& image,
     const TracingInfo& tracing_info,
     scoped_refptr<TileTask>* task) {
+  return GetTaskForImageAndRefInternal(image, tracing_info, USE_IN_RASTER_TASKS,
+                                       task);
+}
+
+bool SoftwareImageDecodeCache::GetOutOfRasterDecodeTaskForImageAndRef(
+    const DrawImage& image,
+    scoped_refptr<TileTask>* task) {
+  return GetTaskForImageAndRefInternal(image, TracingInfo(),
+                                       USE_OUT_OF_RASTER_TASKS, task);
+}
+
+bool SoftwareImageDecodeCache::GetTaskForImageAndRefInternal(
+    const DrawImage& image,
+    const TracingInfo& tracing_info,
+    DecodeTaskType task_type,
+    scoped_refptr<TileTask>* task) {
   // If the image already exists or if we're going to create a task for it, then
   // we'll likely need to ref this image (the exception is if we're prerolling
   // the image only). That means the image is or will be in the cache. When the
   // ref goes to 0, it will be unpinned but will remain in the cache. If the
   // image does not fit into the budget, then we don't ref this image, since it
   // will be decoded at raster time which is when it will be temporarily put in
   // the cache.
   ImageKey key = ImageKey::FromDrawImage(image);
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "SoftwareImageDecodeCache::GetTaskForImageAndRef", "key",
@@ skipping 30 matching lines @@
 
     // If the image fits in memory, then we at least tried to lock it and
     // failed. This means that it's not valid anymore.
     if (new_image_fits_in_memory) {
       RecordLockExistingCachedImageHistogram(tracing_info.requesting_tile_bin,
                                              false);
       decoded_images_.Erase(decoded_it);
     }
   }
 
-  // If the task exists, return it.
-  scoped_refptr<TileTask>& existing_task = pending_image_tasks_[key];
+  DCHECK(task_type == USE_IN_RASTER_TASKS ||
+         task_type == USE_OUT_OF_RASTER_TASKS);
+  // If the task exists, return it. Note that if we always need to create a new
+  // task, then just set |existing_task| to reference the passed in task (which
+  // is set to nullptr above).
+  scoped_refptr<TileTask>& existing_task =
+      (task_type == USE_IN_RASTER_TASKS)
+          ? pending_in_raster_image_tasks_[key]
+          : pending_out_of_raster_image_tasks_[key];
   if (existing_task) {
     RefImage(key);
     *task = existing_task;
     SanityCheckState(__LINE__, true);
     return true;
   }
 
   // At this point, we have to create a new image/task, so we need to abort if
   // it doesn't fit into memory and there are currently no raster tasks that
   // would have already accounted for memory. The latter part is possible if
   // there's a running raster task that could not be canceled, and still has a
   // ref to the image that is now being reffed for the new schedule.
   if (!new_image_fits_in_memory && (decoded_images_ref_counts_.find(key) ==
                                     decoded_images_ref_counts_.end())) {
     *task = nullptr;
     SanityCheckState(__LINE__, true);
     return false;
   }
 
   // Actually create the task. RefImage will account for memory on the first
   // ref.
   RefImage(key);
   existing_task = make_scoped_refptr(
-      new ImageDecodeTaskImpl(this, key, image, tracing_info));
+      new ImageDecodeTaskImpl(this, key, image, task_type, tracing_info));
   *task = existing_task;
   SanityCheckState(__LINE__, true);
   return true;
 }
 
 void SoftwareImageDecodeCache::RefImage(const ImageKey& key) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "SoftwareImageDecodeCache::RefImage", "key", key.ToString());
   lock_.AssertAcquired();
   int ref = ++decoded_images_ref_counts_[key];
@@ skipping 30 matching lines @@
       SanityCheckState(__LINE__, true);
       return;
     }
     DCHECK(decoded_image_it->second->is_locked());
     decoded_image_it->second->Unlock();
   }
   SanityCheckState(__LINE__, true);
 }
 
 void SoftwareImageDecodeCache::DecodeImage(const ImageKey& key,
-                                           const DrawImage& image) {
+                                           const DrawImage& image,
+                                           DecodeTaskType task_type) {
   TRACE_EVENT1("cc", "SoftwareImageDecodeCache::DecodeImage", "key",
                key.ToString());
   base::AutoLock lock(lock_);
-  AutoRemoveKeyFromTaskMap remove_key_from_task_map(&pending_image_tasks_, key);
+  AutoRemoveKeyFromTaskMap remove_key_from_task_map(
+      (task_type == USE_IN_RASTER_TASKS) ? &pending_in_raster_image_tasks_
+                                         : &pending_out_of_raster_image_tasks_,
+      key);
 
   // We could have finished all of the raster tasks (cancelled) while the task
   // was just starting to run. Since this task already started running, it
   // wasn't cancelled. So, if the ref count for the image is 0 then we can just
   // abort.
   if (decoded_images_ref_counts_.find(key) ==
       decoded_images_ref_counts_.end()) {
     return;
   }
 
@@ skipping 409 matching lines @@
     if (it->second->is_locked()) {
       ++it;
       continue;
     }
 
     it = decoded_images_.Erase(it);
     --num_to_remove;
   }
 }
 
-void SoftwareImageDecodeCache::RemovePendingTask(const ImageKey& key) {
+void SoftwareImageDecodeCache::RemovePendingTask(const ImageKey& key,
+                                                 DecodeTaskType task_type) {
   base::AutoLock lock(lock_);
-  pending_image_tasks_.erase(key);
+  switch (task_type) {
+    case USE_IN_RASTER_TASKS:
+      pending_in_raster_image_tasks_.erase(key);
+      break;
+    case USE_OUT_OF_RASTER_TASKS:
+      pending_out_of_raster_image_tasks_.erase(key);
+      break;
+  }
 }
 
 bool SoftwareImageDecodeCache::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   base::AutoLock lock(lock_);
 
   if (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND) {
     std::string dump_name = base::StringPrintf(
         "cc/image_memory/cache_0x%" PRIXPTR, reinterpret_cast<uintptr_t>(this));
@@ skipping 46 matching lines @@
   for (const auto& image_pair : decoded_images_) {
     const auto& key = image_pair.first;
     const auto& image = image_pair.second;
 
     auto ref_it = decoded_images_ref_counts_.find(key);
     if (image->is_locked()) {
       budget.AddUsage(key.locked_bytes());
       DCHECK(ref_it != decoded_images_ref_counts_.end()) << line;
     } else {
       DCHECK(ref_it == decoded_images_ref_counts_.end() ||
-             pending_image_tasks_.find(key) != pending_image_tasks_.end())
+             pending_in_raster_image_tasks_.find(key) !=
+                 pending_in_raster_image_tasks_.end() ||
+             pending_out_of_raster_image_tasks_.find(key) !=
+                 pending_out_of_raster_image_tasks_.end())
           << line;
     }
   }
   DCHECK_GE(budget.AvailableMemoryBytes(),
             locked_images_budget_.AvailableMemoryBytes())
       << line;
 #endif  // DCHECK_IS_ON()
 }
 
 // SoftwareImageDecodeCacheKey
@@ skipping 262 matching lines @@
         break;
       case base::MemoryState::UNKNOWN:
         NOTREACHED();
         return;
     }
   }
   ReduceCacheUsage();
 }
 
 }  // namespace cc