Schedule bitmap animation timers on the compositor task runner.

third_party/WebKit/Source/platform/graphics/BitmapImage.cpp

Index: third_party/WebKit/Source/platform/graphics/BitmapImage.cpp
diff --git a/third_party/WebKit/Source/platform/graphics/BitmapImage.cpp b/third_party/WebKit/Source/platform/graphics/BitmapImage.cpp
index f1524ed4ee789d4e4adcd82d0fa19939b901f40e..a6a92481e1513134e2e427d185a8875df6ae3e00 100644
--- a/third_party/WebKit/Source/platform/graphics/BitmapImage.cpp
+++ b/third_party/WebKit/Source/platform/graphics/BitmapImage.cpp
@@ -56,20 +56,24 @@ ColorBehavior DefaultColorBehavior() {
 }  // namespace
 
 PassRefPtr<BitmapImage> BitmapImage::CreateWithOrientationForTesting(
+    RefPtr<WebTaskRunner> task_runner,
     const SkBitmap& bitmap,
     ImageOrientation orientation) {
   if (bitmap.isNull()) {
-    return BitmapImage::Create();
+    return BitmapImage::Create(task_runner);
   }
 
-  RefPtr<BitmapImage> result = AdoptRef(new BitmapImage(bitmap));
+  RefPtr<BitmapImage> result = AdoptRef(new BitmapImage(task_runner, bitmap));
   result->frames_[0].orientation_ = orientation;
   if (orientation.UsesWidthAsHeight())
     result->size_respecting_orientation_ = result->size_.TransposedSize();
   return result.Release();
 }
 
-BitmapImage::BitmapImage(ImageObserver* observer)
+BitmapImage::BitmapImage() : BitmapImage(TimerBase::GetTimerTaskRunner()) {}

[Dan Elphick, 2017/04/27 14:41:39]

I guess I could just inline that function here:

Platform::Current()->CurrentThread()->Scheduler()->TimerTaskRunner()

and can then remove the friend BitmapImage in Timer.h.

[Sami, 2017/04/27 17:38:17]

So this is the case where we can't tie the image to a frame/document? I hope
this is very rare, so it doesn't much matter which task runner we use here.
Getting the global one like you said seems fine.

[fs, 2017/04/27 17:42:54]

Sorry to say, but Images don't have a 1:1 relation to a frame (or a document for
that matter), so while this might work in many cases (to some degree probably
accidentally), it won't work in general. (See for instance the animation policy
irkiness for an example of this.)

[Dan Elphick, 2017/05/03 09:41:06]

I've reworked it all now to get the Compositor task runner with
Platform::Current()->CurrentThread()->Scheduler()->CompositorTaskRunner()
explicitly acknowledging that there is only one Compositor task runner per
process.

+
+BitmapImage::BitmapImage(RefPtr<WebTaskRunner> task_runner,
+                         ImageObserver* observer)
     : Image(observer),
       current_frame_(0),
       cached_frame_index_(0),
@@ -83,9 +87,12 @@ BitmapImage::BitmapImage(ImageObserver* observer)
       all_data_received_(false),
       have_size_(false),
       size_available_(false),
-      have_frame_count_(false) {}
+      have_frame_count_(false),
+      task_runner_(task_runner) {}
 
-BitmapImage::BitmapImage(const SkBitmap& bitmap, ImageObserver* observer)
+BitmapImage::BitmapImage(RefPtr<WebTaskRunner> task_runner,
+                         const SkBitmap& bitmap,
+                         ImageObserver* observer)
     : Image(observer),
       size_(bitmap.width(), bitmap.height()),
       current_frame_(0),
@@ -100,7 +107,8 @@ BitmapImage::BitmapImage(const SkBitmap& bitmap, ImageObserver* observer)
       all_data_received_(true),
       have_size_(true),
       size_available_(true),
-      have_frame_count_(true) {
+      have_frame_count_(true),
+      task_runner_(task_runner) {
   // Since we don't have a decoder, we can't figure out the image orientation.
   // Set m_sizeRespectingOrientation to be the same as m_size so it's not 0x0.
   size_respecting_orientation_ = size_;
@@ -517,8 +525,8 @@ void BitmapImage::StartAnimation(CatchUpAnimation catch_up_if_necessary) {
   if (catch_up_if_necessary == kDoNotCatchUp ||
       time < desired_frame_start_time_) {
     // Haven't yet reached time for next frame to start; delay until then.
-    frame_timer_ = WTF::WrapUnique(
-        new Timer<BitmapImage>(this, &BitmapImage::AdvanceAnimation));
+    frame_timer_ = WTF::WrapUnique(new TaskRunnerTimer<BitmapImage>(
+        task_runner_, this, &BitmapImage::AdvanceAnimation));
     frame_timer_->StartOneShot(std::max(desired_frame_start_time_ - time, 0.),
                                BLINK_FROM_HERE);
   } else {
@@ -548,8 +556,8 @@ void BitmapImage::StartAnimation(CatchUpAnimation catch_up_if_necessary) {
     // may be in the past, meaning the next time through this function we'll
     // kick off the next advancement sooner than this frame's duration would
     // suggest.
-    frame_timer_ = WTF::WrapUnique(new Timer<BitmapImage>(
-        this, &BitmapImage::AdvanceAnimationWithoutCatchUp));
+    frame_timer_ = WTF::WrapUnique(new TaskRunnerTimer<BitmapImage>(
+        task_runner_, this, &BitmapImage::AdvanceAnimationWithoutCatchUp));
     frame_timer_->StartOneShot(0, BLINK_FROM_HERE);
   }
 }
@@ -631,8 +639,9 @@ bool BitmapImage::InternalAdvanceAnimation(AnimationAdvancement advancement) {
       // last frame. Skipping frames occurs while painting so we do not
       // synchronously notify the observer which could cause a layout.
       if (advancement == kSkipFramesToCatchUp) {
-        frame_timer_ = WTF::WrapUnique(new Timer<BitmapImage>(
-            this, &BitmapImage::NotifyObserversOfAnimationAdvance));
+        frame_timer_ = WTF::WrapUnique(new TaskRunnerTimer<BitmapImage>(
+            task_runner_, this,
+            &BitmapImage::NotifyObserversOfAnimationAdvance));
         frame_timer_->StartOneShot(0, BLINK_FROM_HERE);
       }