Schedule bitmap animation timers on the compositor task runner.

third_party/WebKit/Source/core/loader/resource/ImageResource.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 111 matching lines @@
                                             initiator_name);
   }
 
   const Member<ImageResource> resource_;
 };
 
 class ImageResource::ImageResourceFactory : public ResourceFactory {
   STACK_ALLOCATED();
 
  public:
-  ImageResourceFactory(const FetchParameters& fetch_params)
-      : ResourceFactory(Resource::kImage), fetch_params_(&fetch_params) {}
+  ImageResourceFactory(const FetchParameters& fetch_params,
+                       RefPtr<WebTaskRunner> task_runner)
+      : ResourceFactory(Resource::kImage),
+        fetch_params_(&fetch_params),
+        task_runner_(task_runner) {}
 
   Resource* Create(const ResourceRequest& request,
                    const ResourceLoaderOptions& options,
                    const String&) const override {
-    return new ImageResource(request, options, ImageResourceContent::Create(),
+    return new ImageResource(task_runner_, request, options,
+                             ImageResourceContent::Create(task_runner_),
                              fetch_params_->GetPlaceholderImageRequestType() ==
                                  FetchParameters::kAllowPlaceholder);
   }
 
  private:
   // Weak, unowned pointer. Must outlive |this|.
   const FetchParameters* fetch_params_;
+  RefPtr<WebTaskRunner> task_runner_;
 };
 
-ImageResource* ImageResource::Fetch(FetchParameters& params,
+ImageResource* ImageResource::Fetch(RefPtr<WebTaskRunner> task_runner,
+                                    FetchParameters& params,
                                     ResourceFetcher* fetcher) {
   if (params.GetResourceRequest().GetRequestContext() ==
       WebURLRequest::kRequestContextUnspecified) {
     params.SetRequestContext(WebURLRequest::kRequestContextImage);
   }
   if (fetcher->Context().PageDismissalEventBeingDispatched()) {
     KURL request_url = params.GetResourceRequest().Url();
     if (request_url.IsValid()) {
       ResourceRequestBlockedReason block_reason = fetcher->Context().CanRequest(
           Resource::kImage, params.GetResourceRequest(), request_url,
           params.Options(),
           /* Don't send security violation reports for speculative preloads */
           params.IsSpeculativePreload()
               ? SecurityViolationReportingPolicy::kSuppressReporting
               : SecurityViolationReportingPolicy::kReport,
           params.GetOriginRestriction());
       if (block_reason == ResourceRequestBlockedReason::kNone)
         fetcher->Context().SendImagePing(request_url);
     }
     return nullptr;
   }
 
-  return ToImageResource(
-      fetcher->RequestResource(params, ImageResourceFactory(params)));
+  return ToImageResource(fetcher->RequestResource(
+      params, ImageResourceFactory(params, task_runner)));
 }
 
 bool ImageResource::CanReuse(const FetchParameters& params) const {
   // If the image is a placeholder, but this fetch doesn't allow a
   // placeholder, then do not reuse this resource.
   if (params.GetPlaceholderImageRequestType() !=
           FetchParameters::kAllowPlaceholder &&
       placeholder_option_ != PlaceholderOption::kDoNotReloadPlaceholder)
     return false;
   return true;
 }
 
-ImageResource* ImageResource::Create(const ResourceRequest& request) {
-  return new ImageResource(request, ResourceLoaderOptions(),
-                           ImageResourceContent::Create(), false);
+ImageResource* ImageResource::Create(RefPtr<WebTaskRunner> task_runner,
+                                     const ResourceRequest& request) {
+  return new ImageResource(task_runner, request, ResourceLoaderOptions(),
+                           ImageResourceContent::Create(task_runner), false);
 }
 
-ImageResource::ImageResource(const ResourceRequest& resource_request,
+ImageResource::ImageResource(RefPtr<WebTaskRunner> task_runner,
+                             const ResourceRequest& resource_request,
                              const ResourceLoaderOptions& options,
                              ImageResourceContent* content,
                              bool is_placeholder)
     : Resource(resource_request, kImage, options),
       content_(content),
       device_pixel_ratio_header_value_(1.0),
       has_device_pixel_ratio_header_value_(false),
       is_scheduling_reload_(false),
       placeholder_option_(
           is_placeholder ? PlaceholderOption::kShowAndReloadPlaceholderAlways
                          : PlaceholderOption::kDoNotReloadPlaceholder),
-      flush_timer_(this, &ImageResource::FlushImageIfNeeded) {
+      flush_timer_(this, &ImageResource::FlushImageIfNeeded),
+      task_runner_(task_runner) {
   DCHECK(GetContent());
   RESOURCE_LOADING_DVLOG(1) << "new ImageResource(ResourceRequest) " << this;
   GetContent()->SetImageResourceInfo(new ImageResourceInfoImpl(this));
 }
 
 ImageResource::~ImageResource() {
   RESOURCE_LOADING_DVLOG(1) << "~ImageResource " << this;
 }
 
 DEFINE_TRACE(ImageResource) {
@@ skipping 381 matching lines @@
     //    reloading in Step 3 due to notifyObservers()'s
     //    schedulingReloadOrShouldReloadBrokenPlaceholder() check.
     // 3. reloadIfLoFiOrPlaceholderImage() is called via ResourceFetcher
     //    (a) via didFinishLoading() called in decodeError(), or
     //    (b) after returning ImageResource::updateImage().
     DecodeError(all_data_received);
   }
 }
 
 }  // namespace blink