cc: Add UMA for tracking decode duration for out of raster decodes.

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"
@@ skipping 161 matching lines @@
     const ImageDecodeCache::TracingInfo& tracing_info) {
   std::vector<scoped_refptr<TileTask>> new_tasks;
   GetTasksForImagesAndRef(&images, &new_tasks, tracing_info);
   UnrefImages(predecode_locked_images_);
   predecode_locked_images_ = std::move(images);
   return new_tasks;
 }
 
 ImageController::ImageDecodeRequestId ImageController::QueueImageDecode(
     sk_sp<const SkImage> image,
-    const ImageDecodedCallback& callback) {
+    const ImageDecodedCallback& callback,
+    ImageDecodeCache::ImageDecodeType type) {
   // We must not receive any image requests if we have no worker.
   CHECK(worker_task_runner_);
 
   // Generate the next id.
   ImageDecodeRequestId id = s_next_image_decode_queue_id_++;
 
   // TODO(ccameron): The target color space specified here should match the
   // target color space that will be used at rasterization time. Leave this
   // unspecified now, since that will match the rasterization-time color
   // space while color correct rendering is disabled.
   gfx::ColorSpace target_color_space;
 
   DCHECK(image);
   bool is_image_lazy = image->isLazyGenerated();
   auto image_bounds = image->bounds();
   // TODO(khushalsagar): Eliminate the use of an incorrect id here and have all
   // call-sites provide PaintImage to the ImageController.
   DrawImage draw_image(
       PaintImage(PaintImage::kUnknownStableId,
                  sk_sp<SkImage>(const_cast<SkImage*>(image.release()))),
       image_bounds, kNone_SkFilterQuality, SkMatrix::I(), target_color_space);
 
   // Get the tasks for this decode.
   scoped_refptr<TileTask> task;
   bool need_unref = false;
   if (is_image_lazy) {
     need_unref =
-        cache_->GetOutOfRasterDecodeTaskForImageAndRef(draw_image, &task);
+        cache_->GetOutOfRasterDecodeTaskForImageAndRef(draw_image, type, &task);
   }
   // If we don't need to unref this, we don't actually have a task.
   DCHECK(need_unref || !task);
 
   // Schedule the task and signal that there is more work.
   base::AutoLock hold(lock_);
-  image_decode_queue_[id] =
-      ImageDecodeRequest(id, draw_image, callback, std::move(task), need_unref);
+  image_decode_queue_[id] = ImageDecodeRequest(
+      id, draw_image, callback, std::move(task), need_unref, type);
 
   // If this is the only image decode request, schedule a task to run.
   // Otherwise, the task will be scheduled in the previou task's completion.
   if (image_decode_queue_.size() == 1) {
     // Post a worker task.
     worker_task_runner_->PostTask(
         FROM_HERE,
         base::BindOnce(&ImageController::ProcessNextImageDecodeOnWorkerThread,
                        base::Unretained(this)));
   }
@@ skipping 110 matching lines @@
   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);
+          request.draw_image, request.decode_type, &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::BindOnce(&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)
+    bool need_unref,
+    ImageDecodeCache::ImageDecodeType decode_type)
     : id(id),
       draw_image(draw_image),
       callback(callback),
       task(std::move(task)),
-      need_unref(need_unref) {}
+      need_unref(need_unref),
+      decode_type(decode_type) {}
 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