Schedule bitmap animation timers on the compositor task runner.

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

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 38 matching lines @@
 
 ColorBehavior DefaultColorBehavior() {
   if (RuntimeEnabledFeatures::colorCorrectRenderingEnabled())
     return ColorBehavior::Tag();
   return ColorBehavior::TransformToGlobalTarget();
 }
 
 }  // 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),
       repetition_count_(kCAnimationNone),
       repetition_count_status_(kUnknown),
       repetitions_complete_(0),
       desired_frame_start_time_(0),
       frame_count_(0),
       animation_policy_(kImageAnimationPolicyAllowed),
       animation_finished_(false),
       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),
       cached_frame_(SkImage::MakeFromBitmap(bitmap)),
       cached_frame_index_(0),
       repetition_count_(kCAnimationNone),
       repetition_count_status_(kUnknown),
       repetitions_complete_(0),
       frame_count_(1),
       animation_policy_(kImageAnimationPolicyAllowed),
       animation_finished_(true),
       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_;
 
   frames_.Grow(1);
   frames_[0].has_alpha_ = !bitmap.isOpaque();
   frames_[0].have_metadata_ = true;
 }
 
 BitmapImage::~BitmapImage() {
@@ skipping 396 matching lines @@
   // sync an image and some other resource (e.g. audio), especially if users
   // switch tabs (and thus stop drawing the animation, which will pause it)
   // during that initial loop, then switch back later.
   if (next_frame == 0 && repetitions_complete_ == 0 &&
       desired_frame_start_time_ < time)
     desired_frame_start_time_ = time;
 
   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 {
     // We've already reached or passed the time for the next frame to start.
     // See if we've also passed the time for frames after that to start, in
     // case we need to skip some frames entirely.  Remember not to advance
     // to an incomplete frame.
     for (size_t frame_after_next = (next_frame + 1) % FrameCount();
          FrameIsCompleteAtIndex(frame_after_next);
          frame_after_next = (next_frame + 1) % FrameCount()) {
       // Should we skip the next frame?
       double frame_after_next_start_time =
           desired_frame_start_time_ + FrameDurationAtIndex(next_frame);
       if (time < frame_after_next_start_time)
         break;
 
       // Skip the next frame by advancing the animation forward one frame.
       if (!InternalAdvanceAnimation(kSkipFramesToCatchUp)) {
         DCHECK(animation_finished_);
         return;
       }
       desired_frame_start_time_ = frame_after_next_start_time;
       next_frame = frame_after_next;
     }
 
     // Post a task to advance the frame immediately. m_desiredFrameStartTime
     // 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);
   }
 }
 
 void BitmapImage::StopAnimation() {
   // This timer is used to animate all occurrences of this image.  Don't
   // invalidate the timer unless all renderers have stopped drawing.
   frame_timer_.reset();
 }
 
@@ skipping 61 matching lines @@
         animation_policy_ == kImageAnimationPolicyAnimateOnce) {
       animation_finished_ = true;
       desired_frame_start_time_ = 0;
 
       // We skipped to the last frame and cannot advance further. The
       // observer will not receive animationAdvanced notifications while
       // skipping but we still need to notify the observer to draw the
       // 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);
       }
 
       return false;
     }
 
     // Loop the animation back to the first frame.
     current_frame_ = 0;
   }
 
   // We need to draw this frame if we advanced to it while not skipping.
   if (advancement != kSkipFramesToCatchUp)
     GetImageObserver()->AnimationAdvanced(this);
 
   return true;
 }
 
 void BitmapImage::NotifyObserversOfAnimationAdvance(TimerBase*) {
   GetImageObserver()->AnimationAdvanced(this);
 }
 
 }  // namespace blink