cc: Remove ScheduleOnOriginThread() and CompleteOnOriginThread().

cc/tiles/gpu_image_decode_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/gpu_image_decode_controller.h"
 
 #include "base/memory/discardable_memory_allocator.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_math.h"
 #include "base/strings/stringprintf.h"
@@ skipping 44 matching lines @@
 
 }  // namespace
 
 // Task which decodes an image and stores the result in discardable memory.
 // This task does not use GPU resources and can be run on any thread.
 class ImageDecodeTaskImpl : public TileTask {
  public:
   ImageDecodeTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
                       const ImageDecodeController::TracingInfo& tracing_info)
-      : TileTask(true),
+      : TileTask(TileTask::Type::IMAGE_DECODE, true),
         controller_(controller),
         image_(draw_image),
         tracing_info_(tracing_info) {
     DCHECK(!SkipImage(draw_image));
   }
 
   // Overridden from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageDecodeTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", tracing_info_.prepare_tiles_id);
     controller_->DecodeImage(image_);
   }
 
-  // Overridden from TileTask:
-  void ScheduleOnOriginThread(RasterBufferProvider* provider) override {}
-  void CompleteOnOriginThread(RasterBufferProvider* provider) override {
-    controller_->DecodeTaskCompleted(image_);
-  }
-
  protected:
   ~ImageDecodeTaskImpl() override {}
 
  private:
+  friend class GpuImageDecodeController;
+
   GpuImageDecodeController* controller_;
   DrawImage image_;
   const ImageDecodeController::TracingInfo tracing_info_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageDecodeTaskImpl);
 };
 
 // Task which creates an image from decoded data. Typically this involves
 // uploading data to the GPU, which requires this task be run on the non-
 // concurrent thread.
 class ImageUploadTaskImpl : public TileTask {
  public:
   ImageUploadTaskImpl(GpuImageDecodeController* controller,
                       const DrawImage& draw_image,
                       scoped_refptr<TileTask> decode_dependency,
                       const ImageDecodeController::TracingInfo& tracing_info)
-      : TileTask(false),
+      : TileTask(TileTask::Type::IMAGE_UPLOAD, false),
         controller_(controller),
         image_(draw_image),
         tracing_info_(tracing_info) {
     DCHECK(!SkipImage(draw_image));
     // If an image is already decoded and locked, we will not generate a
     // decode task.
     if (decode_dependency)
       dependencies_.push_back(std::move(decode_dependency));
   }
 
   // Override from Task:
   void RunOnWorkerThread() override {
     TRACE_EVENT2("cc", "ImageUploadTaskImpl::RunOnWorkerThread", "mode", "gpu",
                  "source_prepare_tiles_id", tracing_info_.prepare_tiles_id);
     controller_->UploadImage(image_);
   }
 
-  void ScheduleOnOriginThread(RasterBufferProvider* provider) override {}
-  void CompleteOnOriginThread(RasterBufferProvider* provider) override {
-    controller_->UploadTaskCompleted(image_);
-  }
-
  protected:
   ~ImageUploadTaskImpl() override {}
 
  private:
+  friend class GpuImageDecodeController;
+
   GpuImageDecodeController* controller_;
   DrawImage image_;
   const ImageDecodeController::TracingInfo tracing_info_;
 
   DISALLOW_COPY_AND_ASSIGN(ImageUploadTaskImpl);
 };
 
 GpuImageDecodeController::DecodedImageData::DecodedImageData()
     : ref_count(0), is_locked(false), decode_failure(false) {}
 
@@ skipping 218 matching lines @@
 
     // We are holding the context lock, so finish cleaning up deleted images
     // now.
     DeletePendingImages();
   } else {
     base::AutoLock lock(lock_);
     cached_bytes_limit_ = kMaxGpuImageBytes;
   }
 }
 
+void GpuImageDecodeController::OnImageDecodeTaskCompleted(TileTask* task) {
+  base::AutoLock lock(lock_);
+  ImageDecodeTaskImpl* decode_task = static_cast<ImageDecodeTaskImpl*>(task);
+  DCHECK(decode_task);
+  // Decode task is complete, remove it from our list of pending tasks.
+  pending_image_decode_tasks_.erase(decode_task->image_.image()->uniqueID());
+
+  // While the decode task is active, we keep a ref on the decoded data.
+  // Release that ref now.
+  UnrefImageDecode(decode_task->image_);
+}
+
+void GpuImageDecodeController::OnImageUploadTaskCompleted(TileTask* task) {
+  base::AutoLock lock(lock_);
+  ImageUploadTaskImpl* upload_task = static_cast<ImageUploadTaskImpl*>(task);
+  DCHECK(upload_task);
+  // Upload task is complete, remove it from our list of pending tasks.
+  pending_image_upload_tasks_.erase(upload_task->image_.image()->uniqueID());
+
+  // While the upload task is active, we keep a ref on both the image it will be
+  // populating, as well as the decode it needs to populate it. Release these
+  // refs now.
+  UnrefImageDecode(upload_task->image_);
+  UnrefImageInternal(upload_task->image_);
+}
+
 bool GpuImageDecodeController::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   for (const auto& image_pair : image_data_) {
     const ImageData* image_data = image_pair.second.get();
     const uint32_t image_id = image_pair.first;
 
     // If we have discardable decoded data, dump this here.
     if (image_data->decode.data) {
       std::string discardable_dump_name = base::StringPrintf(
@@ skipping 55 matching lines @@
 
 void GpuImageDecodeController::UploadImage(const DrawImage& draw_image) {
   ContextProvider::ScopedContextLock context_lock(context_);
   base::AutoLock lock(lock_);
   auto found = image_data_.Peek(draw_image.image()->uniqueID());
   DCHECK(found != image_data_.end());
   DCHECK(!found->second->is_at_raster);
   UploadImageIfNecessary(draw_image, found->second.get());
 }
 
-void GpuImageDecodeController::DecodeTaskCompleted(
-    const DrawImage& draw_image) {
-  base::AutoLock lock(lock_);
-  // Decode task is complete, remove it from our list of pending tasks.
-  pending_image_decode_tasks_.erase(draw_image.image()->uniqueID());
-
-  // While the decode task is active, we keep a ref on the decoded data.
-  // Release that ref now.
-  UnrefImageDecode(draw_image);
-}
-
-void GpuImageDecodeController::UploadTaskCompleted(
-    const DrawImage& draw_image) {
-  base::AutoLock lock(lock_);
-  // Upload task is complete, remove it from our list of pending tasks.
-  pending_image_upload_tasks_.erase(draw_image.image()->uniqueID());
-
-  // While the upload task is active, we keep a ref on both the image it will be
-  // populating, as well as the decode it needs to populate it. Release these
-  // refs now.
-  UnrefImageDecode(draw_image);
-  UnrefImageInternal(draw_image);
-}
-
 // Checks if an existing image decode exists. If not, returns a task to produce
 // the requested decode.
 scoped_refptr<TileTask> GpuImageDecodeController::GetImageDecodeTaskAndRef(
     const DrawImage& draw_image,
     const TracingInfo& tracing_info) {
   lock_.AssertAcquired();
 
   const uint32_t image_id = draw_image.image()->uniqueID();
 
   // This ref is kept alive while an upload task may need this decode. We
@@ skipping 345 matching lines @@
 void GpuImageDecodeController::SetImageDecodingFailedForTesting(
     const DrawImage& image) {
   base::AutoLock lock(lock_);
   auto found = image_data_.Peek(image.image()->uniqueID());
   DCHECK(found != image_data_.end());
   ImageData* image_data = found->second.get();
   image_data->decode.decode_failure = true;
 }
 
 }  // namespace cc