cc: Simplify Task and its derived classes.

cc/tiles/software_image_decode_controller.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_controller.h"
 
 #include <stdint.h>
 
 #include <functional>
 
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/memory/discardable_memory.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "cc/debug/devtools_instrumentation.h"
-#include "cc/raster/tile_task_runner.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "ui/gfx/skia_util.h"
 
 namespace cc {
 namespace {
 
 // The amount of memory we can lock ahead of time (128MB). This limit is only
 // used to inform the caller of the amount of space available in the cache. The
 // caller can still request tasks which can cause this limit to be breached.
 const size_t kLockedMemoryLimitBytes = 128 * 1024 * 1024;
 
 // The largest single high quality image to try and process. Images above this
 // size will drop down to medium quality.
 const size_t kMaxHighQualityImageSizeBytes = 64 * 1024 * 1024;
 
 // The number of entries to keep around in the cache. This limit can be breached
 // if more items are locked. That is, locked items ignore this limit.
 const size_t kMaxItemsInCache = 1000;
 
 class AutoRemoveKeyFromTaskMap {
  public:
   AutoRemoveKeyFromTaskMap(
       std::unordered_map<SoftwareImageDecodeController::ImageKey,
-                         scoped_refptr<ImageDecodeTask>,
+                         scoped_refptr<Task>,
                          SoftwareImageDecodeController::ImageKeyHash>* task_map,
       const SoftwareImageDecodeController::ImageKey& key)
       : task_map_(task_map), key_(key) {}
   ~AutoRemoveKeyFromTaskMap() { task_map_->erase(key_); }
 
  private:
   std::unordered_map<SoftwareImageDecodeController::ImageKey,
-                     scoped_refptr<ImageDecodeTask>,
+                     scoped_refptr<Task>,
                      SoftwareImageDecodeController::ImageKeyHash>* task_map_;
   SoftwareImageDecodeController::ImageKey key_;
 };
 
-class ImageDecodeTaskImpl : public ImageDecodeTask {
+class ImageDecodeTaskImpl : public Task {
  public:
   ImageDecodeTaskImpl(SoftwareImageDecodeController* controller,
                       const SoftwareImageDecodeController::ImageKey& image_key,
                       const DrawImage& image,
                       uint64_t source_prepare_tiles_id)
       : controller_(controller),
         image_key_(image_key),
         image_(image),
         image_ref_(skia::SharePtr(image.image())),
         source_prepare_tiles_id_(source_prepare_tiles_id) {
-    SetTaskTypeId(TASK_TYPE_IMAGE_DECODE);
+    SetTaskType(TASK_TYPE_IMAGE_DECODE);
   }
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageDecodeTaskImpl::RunOnWorkerThread", "mode",
                  "software", "source_prepare_tiles_id",
                  source_prepare_tiles_id_);
     devtools_instrumentation::ScopedImageDecodeTask image_decode_task(
         image_ref_.get());
     controller_->DecodeImage(image_key_, image_);
@@ skipping 63 matching lines @@
   DCHECK_EQ(0u, at_raster_decoded_images_ref_counts_.size());
 
   // It is safe to unregister, even if we didn't register in the constructor.
   base::trace_event::MemoryDumpManager::GetInstance()->UnregisterDumpProvider(
       this);
 }
 
 bool SoftwareImageDecodeController::GetTaskForImageAndRef(
     const DrawImage& image,
     uint64_t prepare_tiles_id,
-    scoped_refptr<ImageDecodeTask>* task) {
+    scoped_refptr<Task>* 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("disabled-by-default-cc.debug",
                "SoftwareImageDecodeController::GetTaskForImageAndRef", "key",
                key.ToString());
 
   // If the target size is empty, we can skip this image during draw (and thus
   // we don't need to decode it or ref it).
   if (key.target_size().IsEmpty()) {
     *task = nullptr;
     return false;
   }
 
   // If we're not going to do a scale, we will just create a task to preroll the
   // image the first time we see it. This doesn't need to account for memory.
   // TODO(vmpstr): We can also lock the original sized image, in which case it
   // does require memory bookkeeping.
   if (!CanHandleImage(key)) {
     base::AutoLock lock(lock_);
     if (prerolled_images_.count(key.image_id()) == 0) {
-      scoped_refptr<ImageDecodeTask>& existing_task = pending_image_tasks_[key];
+      scoped_refptr<Task>& existing_task = pending_image_tasks_[key];
       if (!existing_task) {
         existing_task = make_scoped_refptr(
             new ImageDecodeTaskImpl(this, key, image, prepare_tiles_id));
       }
       *task = existing_task;
     } else {
       *task = nullptr;
     }
     return false;
   }
@@ skipping 12 matching lines @@
       SanityCheckState(__LINE__, true);
       return true;
     }
     // 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)
       decoded_images_.Erase(decoded_it);
   }
 
   // If the task exists, return it.
-  scoped_refptr<ImageDecodeTask>& existing_task = pending_image_tasks_[key];
+  scoped_refptr<Task>& existing_task = pending_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
@@ skipping 706 matching lines @@
 void SoftwareImageDecodeController::MemoryBudget::ResetUsage() {
   current_usage_bytes_ = 0;
 }
 
 size_t SoftwareImageDecodeController::MemoryBudget::GetCurrentUsageSafe()
     const {
   return current_usage_bytes_.ValueOrDie();
 }
 
 }  // namespace cc