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 21 matching lines @@
 #include "platform/graphics/BitmapImageMetrics.h"
 #include "platform/graphics/DeferredImageDecoder.h"
 #include "platform/graphics/ImageObserver.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/paint/PaintCanvas.h"
 #include "platform/graphics/paint/PaintFlags.h"
 #include "platform/graphics/paint/PaintImage.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/instrumentation/PlatformInstrumentation.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
+#include "platform/scheduler/child/web_scheduler.h"
 #include "platform/wtf/PassRefPtr.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/text/WTFString.h"
 
 namespace blink {
 
 namespace {
 
 ColorBehavior DefaultColorBehavior() {
   if (RuntimeEnabledFeatures::colorCorrectRenderingEnabled())
@@ skipping 24 matching lines @@
       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_(Platform::Current()
+                       ->CurrentThread()
+                       ->Scheduler()
+                       ->CompositorTaskRunner()) {}
 
 BitmapImage::BitmapImage(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_(Platform::Current()
+                       ->CurrentThread()
+                       ->Scheduler()
+                       ->CompositorTaskRunner()) {
   // 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