Schedule bitmap animation timers on the compositor task runner.

third_party/WebKit/Source/core/frame/ImageBitmapTest.cpp

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 26 matching lines @@
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "core/loader/resource/ImageResourceContent.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/heap/Handle.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "platform/loader/fetch/MemoryCache.h"
 #include "platform/loader/fetch/ResourceRequest.h"
+#include "platform/scheduler/test/fake_web_task_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColorSpaceXform.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/core/SkSwizzle.h"
 
 namespace blink {
 
 class ExceptionState;
@@ skipping 13 matching lines @@
     global_memory_cache_ = ReplaceMemoryCacheForTesting(MemoryCache::Create());
 
     // Save the state of experimental canvas features and color correct
     // rendering flags to restore them on teardown.
     experimental_canvas_features =
         RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
     color_correct_rendering =
         RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
     color_correct_rendering_default_mode =
         RuntimeEnabledFeatures::colorCorrectRenderingDefaultModeEnabled();
+
+    task_runner_ = AdoptRef(new scheduler::FakeWebTaskRunner);
   }
   virtual void TearDown() {
     // Garbage collection is required prior to switching out the
     // test's memory cache; image resources are released, evicting
     // them from the cache.
     ThreadState::Current()->CollectGarbage(BlinkGC::kNoHeapPointersOnStack,
                                            BlinkGC::kGCWithSweep,
                                            BlinkGC::kForcedGC);
 
     ReplaceMemoryCacheForTesting(global_memory_cache_.Release());
     RuntimeEnabledFeatures::setExperimentalCanvasFeaturesEnabled(
         experimental_canvas_features);
     RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(
         color_correct_rendering);
     RuntimeEnabledFeatures::setColorCorrectRenderingDefaultModeEnabled(
         color_correct_rendering_default_mode);
   }
 
   sk_sp<SkImage> image_, image2_;
   Persistent<MemoryCache> global_memory_cache_;
   bool experimental_canvas_features;
   bool color_correct_rendering;
   bool color_correct_rendering_default_mode;
+  RefPtr<scheduler::FakeWebTaskRunner> task_runner_;
 };
 
 TEST_F(ImageBitmapTest, ImageResourceConsistency) {
   const ImageBitmapOptions default_options;
   HTMLImageElement* image_element =
       HTMLImageElement::Create(*Document::Create());
-  ImageResourceContent* image =
-      ImageResourceContent::Create(StaticBitmapImage::Create(image_).Get());
+  ImageResourceContent* image = ImageResourceContent::Create(
+      task_runner_, StaticBitmapImage::Create(image_).Get());
   image_element->SetImageResource(image);
 
   Optional<IntRect> crop_rect =
       IntRect(0, 0, image_->width(), image_->height());
   ImageBitmap* image_bitmap_no_crop =
       ImageBitmap::Create(image_element, crop_rect,
                           &(image_element->GetDocument()), default_options);
   crop_rect = IntRect(image_->width() / 2, image_->height() / 2,
                       image_->width() / 2, image_->height() / 2);
   ImageBitmap* image_bitmap_interior_crop =
@@ skipping 20 matching lines @@
   RefPtr<StaticBitmapImage> empty_image =
       image_bitmap_outside_crop->BitmapImage();
   ASSERT_NE(empty_image->ImageForCurrentFrame(),
             image_element->CachedImage()->GetImage()->ImageForCurrentFrame());
 }
 
 // Verifies that ImageBitmaps constructed from HTMLImageElements hold a
 // reference to the original Image if the HTMLImageElement src is changed.
 TEST_F(ImageBitmapTest, ImageBitmapSourceChanged) {
   HTMLImageElement* image = HTMLImageElement::Create(*Document::Create());
-  ImageResourceContent* original_image_resource =
-      ImageResourceContent::Create(StaticBitmapImage::Create(image_).Get());
+  ImageResourceContent* original_image_resource = ImageResourceContent::Create(
+      task_runner_, StaticBitmapImage::Create(image_).Get());
   image->SetImageResource(original_image_resource);
 
   const ImageBitmapOptions default_options;
   Optional<IntRect> crop_rect =
       IntRect(0, 0, image_->width(), image_->height());
   ImageBitmap* image_bitmap = ImageBitmap::Create(
       image, crop_rect, &(image->GetDocument()), default_options);
   // As we are applying color space conversion for the "default" mode,
   // this verifies that the color corrected image is not the same as the
   // source.
   ASSERT_NE(image_bitmap->BitmapImage()->ImageForCurrentFrame(),
             original_image_resource->GetImage()->ImageForCurrentFrame());
 
-  ImageResourceContent* new_image_resource =
-      ImageResourceContent::Create(StaticBitmapImage::Create(image2_).Get());
+  ImageResourceContent* new_image_resource = ImageResourceContent::Create(
+      task_runner_, StaticBitmapImage::Create(image2_).Get());
   image->SetImageResource(new_image_resource);
 
   {
     ASSERT_NE(image_bitmap->BitmapImage()->ImageForCurrentFrame(),
               original_image_resource->GetImage()->ImageForCurrentFrame());
     SkImage* image1 = image_bitmap->BitmapImage()->ImageForCurrentFrame().get();
     ASSERT_NE(image1, nullptr);
     SkImage* image2 =
         original_image_resource->GetImage()->ImageForCurrentFrame().get();
     ASSERT_NE(image2, nullptr);
@@ skipping 53 matching lines @@
       SkImageInfo::MakeN32Premul(10, 10, src_rgb_color_space);
   sk_sp<SkSurface> surface(SkSurface::MakeRaster(raster_image_info));
   surface->getCanvas()->drawCircle(5, 5, 5, p);
   sk_sp<SkImage> image = surface->makeImageSnapshot();
 
   std::unique_ptr<uint8_t[]> src_pixel(
       new uint8_t[raster_image_info.bytesPerPixel()]());
   image->readPixels(raster_image_info.makeWH(1, 1), src_pixel.get(),
                     image->width() * raster_image_info.bytesPerPixel(), 5, 5);
 
-  ImageResourceContent* original_image_resource =
-      ImageResourceContent::Create(StaticBitmapImage::Create(image).Get());
+  ImageResourceContent* original_image_resource = ImageResourceContent::Create(
+      task_runner_, StaticBitmapImage::Create(image).Get());
   image_element->SetImageResource(original_image_resource);
 
   Optional<IntRect> crop_rect = IntRect(0, 0, image->width(), image->height());
 
   // Create and test the ImageBitmap objects.
   // We don't check "none" color space conversion as it requires the encoded
   // data in a format readable by ImageDecoder. Furthermore, the code path for
   // "none" color space conversion is not affected by this CL.
 
   sk_sp<SkColorSpace> color_space = nullptr;
@@ skipping 75 matching lines @@
       SkImageInfo::MakeN32Premul(10, 10, src_rgb_color_space);
   sk_sp<SkSurface> surface(SkSurface::MakeRaster(raster_image_info));
   surface->getCanvas()->drawCircle(5, 5, 5, p);
   sk_sp<SkImage> image = surface->makeImageSnapshot();
 
   std::unique_ptr<uint8_t[]> src_pixel(
       new uint8_t[raster_image_info.bytesPerPixel()]());
   image->readPixels(raster_image_info.makeWH(1, 1), src_pixel.get(),
                     image->width() * raster_image_info.bytesPerPixel(), 5, 5);
 
-  ImageResourceContent* source_image_resource =
-      ImageResourceContent::Create(StaticBitmapImage::Create(image).Get());
+  ImageResourceContent* source_image_resource = ImageResourceContent::Create(
+      task_runner_, StaticBitmapImage::Create(image).Get());
   image_element->SetImageResource(source_image_resource);
 
   Optional<IntRect> crop_rect = IntRect(0, 0, image->width(), image->height());
   ImageBitmapOptions options =
       PrepareBitmapOptionsAndSetRuntimeFlags(ColorSpaceConversion::SRGB);
   ImageBitmap* source_image_bitmap = ImageBitmap::Create(
       image_element, crop_rect, &(image_element->GetDocument()), options);
 
   sk_sp<SkColorSpace> color_space = nullptr;
   SkColorType color_type = SkColorType::kN32_SkColorType;
@@ skipping 211 matching lines @@
     color_space_xform->apply(color_format, transformed_pixel.get(),
                              color_format32, src_pixel.get(), 1,
                              SkAlphaType::kUnpremul_SkAlphaType);
     int compare = std::memcmp(converted_pixel.get(), transformed_pixel.get(),
                               image_info.bytesPerPixel());
     ASSERT_EQ(compare, 0);
   }
 }
 
 }  // namespace blink