Schedule bitmap animation timers on the compositor task runner.

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

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.  All rights reserved.
  * Copyright (C) 2008-2009 Torch Mobile, Inc.
  *
  * 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.
@@ skipping 33 matching lines @@
 namespace blink {
 
 class PLATFORM_EXPORT BitmapImage final : public Image {
   friend class BitmapImageTest;
   friend class CrossfadeGeneratedImage;
   friend class GeneratedImage;
   friend class GradientGeneratedImage;
   friend class GraphicsContext;
 
  public:
-  static PassRefPtr<BitmapImage> Create(ImageObserver* observer = 0) {
-    return AdoptRef(new BitmapImage(observer));
+  static PassRefPtr<BitmapImage> CreateGlobal() {
+    return AdoptRef(new BitmapImage());
+  }
+
+  static PassRefPtr<BitmapImage> Create(RefPtr<WebTaskRunner> task_runner,
+                                        ImageObserver* observer = 0) {
+    return AdoptRef(new BitmapImage(task_runner, observer));
   }
 
   ~BitmapImage() override;
 
   bool IsBitmapImage() const override { return true; }
 
   bool CurrentFrameHasSingleSecurityOrigin() const override;
 
   IntSize Size() const override;
   IntSize SizeRespectingOrientation() const;
@@ skipping 20 matching lines @@
   PassRefPtr<Image> ImageForDefaultFrame() override;
 
   bool CurrentFrameKnownToBeOpaque(MetadataMode = kUseCurrentMetadata) override;
   bool CurrentFrameIsComplete() override;
   bool CurrentFrameIsLazyDecoded() override;
 
   ImageOrientation CurrentFrameOrientation();
 
   // Construct a BitmapImage with the given orientation.
   static PassRefPtr<BitmapImage> CreateWithOrientationForTesting(
+      RefPtr<WebTaskRunner>,
       const SkBitmap&,
       ImageOrientation);
   // Advance the image animation by one frame.
   void AdvanceAnimationForTesting() override { InternalAdvanceAnimation(); }
 
  private:
   enum RepetitionCountStatus {
     kUnknown,    // We haven't checked the source's repetition count.
     kUncertain,  // We have a repetition count, but it might be wrong (some GIFs
                  // have a count after the image data, and will report "loop
                  // once" until all data has been decoded).
     kCertain     // The repetition count is known to be correct.
   };
 
-  BitmapImage(const SkBitmap&, ImageObserver* = 0);
-  BitmapImage(ImageObserver* = 0);
+  BitmapImage();
+
+  BitmapImage(RefPtr<WebTaskRunner>, const SkBitmap&, ImageObserver* = 0);

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

Should we make these two explicit?

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

no longer required

+  BitmapImage(RefPtr<WebTaskRunner>, ImageObserver* = 0);
 
   void Draw(PaintCanvas*,
             const PaintFlags&,
             const FloatRect& dst_rect,
             const FloatRect& src_rect,
             RespectImageOrientationEnum,
             ImageClampingMode) override;
 
   size_t CurrentFrame() const { return current_frame_; }
   size_t FrameCount();
@@ skipping 63 matching lines @@
 
   size_t current_frame_;         // The index of the current frame of animation.
   Vector<FrameData, 1> frames_;  // An array of the cached frames of the
                                  // animation. We have to ref frames to pin
                                  // them in the cache.
 
   sk_sp<SkImage>
       cached_frame_;  // A cached copy of the most recently-accessed frame.
   size_t cached_frame_index_;  // Index of the frame that is cached.
 
-  std::unique_ptr<Timer<BitmapImage>> frame_timer_;
+  std::unique_ptr<TaskRunnerTimer<BitmapImage>> frame_timer_;
   int repetition_count_;  // How many total animation loops we should do.  This
                           // will be cAnimationNone if this image type is
                           // incapable of animation.
   RepetitionCountStatus repetition_count_status_;
   int repetitions_complete_;         // How many repetitions we've finished.
   double desired_frame_start_time_;  // The system time at which we hope to see
                                      // the next call to startAnimation().
 
   size_t frame_count_;
 
   ImageAnimationPolicy
       animation_policy_;  // Whether or not we can play animation.
 
   bool animation_finished_ : 1;  // Whether we've completed the entire
                                  // animation.
 
   bool all_data_received_ : 1;  // Whether we've received all our data.
   mutable bool have_size_ : 1;  // Whether our |m_size| member variable has the
                                 // final overall image size yet.
   bool size_available_ : 1;     // Whether we can obtain the size of the first
                                 // image frame from ImageIO yet.
   mutable bool have_frame_count_ : 1;
+
+  RefPtr<WebTaskRunner> task_runner_;
 };
 
 DEFINE_IMAGE_TYPE_CASTS(BitmapImage);
 
 }  // namespace blink
 
 #endif