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

cc/tiles/image_controller_unittest.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 <utility>
 
 #include "base/bind.h"
 #include "base/optional.h"
@@ skipping 94 matching lines @@
         image.image()->width() * image.image()->height() >= 1000 * 1000) {
       return false;
     }
 
     *task = task_to_use_;
     ++number_of_refs_;
     return true;
   }
   bool GetOutOfRasterDecodeTaskForImageAndRef(
       const DrawImage& image,
+      ImageDecodeType type,
       scoped_refptr<TileTask>* task) override {
     return GetTaskForImageAndRef(image, TracingInfo(), task);
   }
 
   void UnrefImage(const DrawImage& image) override {
     ASSERT_GT(number_of_refs_, 0);
     --number_of_refs_;
   }
   DecodedDrawImage GetDecodedImageForDraw(const DrawImage& image) override {
     return DecodedDrawImage(nullptr, kNone_SkFilterQuality);
@@ skipping 175 matching lines @@
 }
 
 TEST_F(ImageControllerTest, QueueImageDecode) {
   base::RunLoop run_loop;
   DecodeClient decode_client;
   EXPECT_EQ(image()->bounds().width(), 1);
   ImageController::ImageDecodeRequestId expected_id =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client),
-                     run_loop.QuitClosure()));
+                     run_loop.QuitClosure()),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   RunOrTimeout(&run_loop);
   EXPECT_EQ(expected_id, decode_client.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
             decode_client.result());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeNonLazy) {
   base::RunLoop run_loop;
   DecodeClient decode_client;
 
   SkBitmap bitmap;
   bitmap.allocN32Pixels(1, 1);
   sk_sp<const SkImage> image = SkImage::MakeFromBitmap(bitmap);
 
   ImageController::ImageDecodeRequestId expected_id =
       controller()->QueueImageDecode(
           image,
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client),
-                     run_loop.QuitClosure()));
+                     run_loop.QuitClosure()),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   RunOrTimeout(&run_loop);
   EXPECT_EQ(expected_id, decode_client.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::DECODE_NOT_REQUIRED,
             decode_client.result());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeTooLarge) {
   base::RunLoop run_loop;
   DecodeClient decode_client;
 
   sk_sp<const SkImage> image = CreateDiscardableImage(gfx::Size(2000, 2000));
   ImageController::ImageDecodeRequestId expected_id =
       controller()->QueueImageDecode(
           image,
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client),
-                     run_loop.QuitClosure()));
+                     run_loop.QuitClosure()),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   RunOrTimeout(&run_loop);
   EXPECT_EQ(expected_id, decode_client.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::FAILURE,
             decode_client.result());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeMultipleImages) {
   base::RunLoop run_loop;
   DecodeClient decode_client1;
   ImageController::ImageDecodeRequestId expected_id1 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client1),
-                     base::Bind([] {})));
+                     base::Bind([] {})),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   DecodeClient decode_client2;
   ImageController::ImageDecodeRequestId expected_id2 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client2),
-                     base::Bind([] {})));
+                     base::Bind([] {})),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   DecodeClient decode_client3;
   ImageController::ImageDecodeRequestId expected_id3 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client3),
-                     run_loop.QuitClosure()));
+                     run_loop.QuitClosure()),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   RunOrTimeout(&run_loop);
   EXPECT_EQ(expected_id1, decode_client1.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
             decode_client1.result());
   EXPECT_EQ(expected_id2, decode_client2.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
             decode_client2.result());
   EXPECT_EQ(expected_id3, decode_client3.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
             decode_client3.result());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeWithTask) {
   scoped_refptr<SimpleTask> task(new SimpleTask);
   cache()->SetTaskToUse(task);
 
   base::RunLoop run_loop;
   DecodeClient decode_client;
   ImageController::ImageDecodeRequestId expected_id =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client),
-                     run_loop.QuitClosure()));
+                     run_loop.QuitClosure()),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   RunOrTimeout(&run_loop);
   EXPECT_EQ(expected_id, decode_client.id());
   EXPECT_TRUE(task->has_run());
   EXPECT_TRUE(task->HasCompleted());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeMultipleImagesSameTask) {
   scoped_refptr<SimpleTask> task(new SimpleTask);
   cache()->SetTaskToUse(task);
 
   base::RunLoop run_loop;
   DecodeClient decode_client1;
   ImageController::ImageDecodeRequestId expected_id1 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client1),
-                     base::Bind([] {})));
+                     base::Bind([] {})),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   DecodeClient decode_client2;
   ImageController::ImageDecodeRequestId expected_id2 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client2),
-                     base::Bind([] {})));
+                     base::Bind([] {})),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   DecodeClient decode_client3;
   ImageController::ImageDecodeRequestId expected_id3 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client3),
-                     run_loop.QuitClosure()));
+                     run_loop.QuitClosure()),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   RunOrTimeout(&run_loop);
   EXPECT_EQ(expected_id1, decode_client1.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
             decode_client1.result());
   EXPECT_EQ(expected_id2, decode_client2.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
             decode_client2.result());
   EXPECT_EQ(expected_id3, decode_client3.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
             decode_client3.result());
   EXPECT_TRUE(task->has_run());
   EXPECT_TRUE(task->HasCompleted());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeChangeControllerWithTaskQueued) {
   scoped_refptr<BlockingTask> task_one(new BlockingTask);
   cache()->SetTaskToUse(task_one);
 
   DecodeClient decode_client1;
   ImageController::ImageDecodeRequestId expected_id1 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client1),
-                     base::Bind([] {})));
+                     base::Bind([] {})),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
 
   scoped_refptr<BlockingTask> task_two(new BlockingTask);
   cache()->SetTaskToUse(task_two);
 
   base::RunLoop run_loop;
   DecodeClient decode_client2;
   ImageController::ImageDecodeRequestId expected_id2 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client2),
-                     run_loop.QuitClosure()));
+                     run_loop.QuitClosure()),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
 
   task_one->AllowToRun();
   task_two->AllowToRun();
   controller()->SetImageDecodeCache(nullptr);
   ResetController();
 
   RunOrTimeout(&run_loop);
 
   EXPECT_TRUE(task_one->state().IsCanceled() || task_one->HasCompleted());
   EXPECT_TRUE(task_two->state().IsCanceled() || task_two->HasCompleted());
   EXPECT_EQ(expected_id1, decode_client1.id());
   EXPECT_EQ(expected_id2, decode_client2.id());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeImageAlreadyLocked) {
   scoped_refptr<SimpleTask> task(new SimpleTask);
   cache()->SetTaskToUse(task);
 
   base::RunLoop run_loop1;
   DecodeClient decode_client1;
   ImageController::ImageDecodeRequestId expected_id1 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client1),
-                     run_loop1.QuitClosure()));
+                     run_loop1.QuitClosure()),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   RunOrTimeout(&run_loop1);
   EXPECT_EQ(expected_id1, decode_client1.id());
   EXPECT_TRUE(task->has_run());
 
   cache()->SetTaskToUse(nullptr);
   base::RunLoop run_loop2;
   DecodeClient decode_client2;
   ImageController::ImageDecodeRequestId expected_id2 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client2),
-                     run_loop2.QuitClosure()));
+                     run_loop2.QuitClosure()),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   RunOrTimeout(&run_loop2);
   EXPECT_EQ(expected_id2, decode_client2.id());
   EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
             decode_client2.result());
 }
 
 TEST_F(ImageControllerTest, QueueImageDecodeLockedImageControllerChange) {
   scoped_refptr<SimpleTask> task(new SimpleTask);
   cache()->SetTaskToUse(task);
 
   base::RunLoop run_loop1;
   DecodeClient decode_client1;
   ImageController::ImageDecodeRequestId expected_id1 =
       controller()->QueueImageDecode(
           image(),
           base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client1),
-                     run_loop1.QuitClosure()));
+                     run_loop1.QuitClosure()),
+          ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   RunOrTimeout(&run_loop1);
   EXPECT_EQ(expected_id1, decode_client1.id());
   EXPECT_TRUE(task->has_run());
   EXPECT_EQ(1, cache()->number_of_refs());
 
   controller()->SetImageDecodeCache(nullptr);
   EXPECT_EQ(0, cache()->number_of_refs());
 }
 
 TEST_F(ImageControllerTest, DispatchesDecodeCallbacksAfterCacheReset) {
   scoped_refptr<SimpleTask> task(new SimpleTask);
   cache()->SetTaskToUse(task);
 
   base::RunLoop run_loop1;
   DecodeClient decode_client1;
   base::RunLoop run_loop2;
   DecodeClient decode_client2;
 
   controller()->QueueImageDecode(
       image(),
       base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client1),
-                 run_loop1.QuitClosure()));
+                 run_loop1.QuitClosure()),
+      ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   controller()->QueueImageDecode(
       image(),
       base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client2),
-                 run_loop2.QuitClosure()));
+                 run_loop2.QuitClosure()),
+      ImageDecodeCache::ImageDecodeType::kCheckerImaging);
 
   // Now reset the image cache before decode completed callbacks are posted to
   // the compositor thread. Ensure that the completion callbacks for the decode
   // is still run.
   controller()->SetImageDecodeCache(nullptr);
   ResetController();
 
   RunOrTimeout(&run_loop1);
   RunOrTimeout(&run_loop2);
 
   EXPECT_EQ(ImageController::ImageDecodeResult::FAILURE,
             decode_client1.result());
   EXPECT_EQ(ImageController::ImageDecodeResult::FAILURE,
             decode_client2.result());
 }
 
 TEST_F(ImageControllerTest, DispatchesDecodeCallbacksAfterCacheChanged) {
   scoped_refptr<SimpleTask> task(new SimpleTask);
   cache()->SetTaskToUse(task);
 
   base::RunLoop run_loop1;
   DecodeClient decode_client1;
   base::RunLoop run_loop2;
   DecodeClient decode_client2;
 
   controller()->QueueImageDecode(
       image(),
       base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client1),
-                 run_loop1.QuitClosure()));
+                 run_loop1.QuitClosure()),
+      ImageDecodeCache::ImageDecodeType::kCheckerImaging);
   controller()->QueueImageDecode(
       image(),
       base::Bind(&DecodeClient::Callback, base::Unretained(&decode_client2),
-                 run_loop2.QuitClosure()));
+                 run_loop2.QuitClosure()),
+      ImageDecodeCache::ImageDecodeType::kCheckerImaging);
 
   // Now reset the image cache before decode completed callbacks are posted to
   // the compositor thread. This should orphan the requests.
   controller()->SetImageDecodeCache(nullptr);
 
   EXPECT_EQ(0, cache()->number_of_refs());
 
   TestableCache other_cache;
   other_cache.SetTaskToUse(task);
 
   controller()->SetImageDecodeCache(&other_cache);
 
   RunOrTimeout(&run_loop1);
   RunOrTimeout(&run_loop2);
 
   EXPECT_EQ(2, other_cache.number_of_refs());
   EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
             decode_client1.result());
   EXPECT_EQ(ImageController::ImageDecodeResult::SUCCESS,
             decode_client2.result());
 
   // Reset the controller since the order of destruction is wrong in this test
   // (|other_cache| should outlive the controller. This is normally done via
   // SetImageDecodeCache(nullptr) or it can be done in the dtor of the cache.)
   ResetController();
 }
 
 }  // namespace
 }  // namespace cc