[WIP2] off-main-thread loading

third_party/WebKit/Source/platform/loader/fetch/Resource.h

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller <mueller@kde.org>
     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 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 30 matching lines @@
 #include "platform/wtf/Allocator.h"
 #include "platform/wtf/AutoReset.h"
 #include "platform/wtf/HashCountedSet.h"
 #include "platform/wtf/HashSet.h"
 #include "platform/wtf/text/AtomicString.h"
 #include "platform/wtf/text/WTFString.h"
 #include "public/platform/WebDataConsumerHandle.h"
 
 namespace blink {
 
+class FetchContext;
 class FetchParameters;
 class ResourceClient;
 class ResourceFetcher;
 class ResourceTimingInfo;
 class ResourceLoader;
 class SecurityOrigin;
 
 // A resource that is held in the cache. Classes who want to use this object
 // should derive from ResourceClient, to get the function calls in case the
 // requested data has arrived. This class also does the actual communication
@@ skipping 31 matching lines @@
     kMarkAsReferenced,
     kDontMarkAsReferenced,
   };
 
   // Used by reloadIfLoFiOrPlaceholderImage().
   enum ReloadLoFiOrPlaceholderPolicy {
     kReloadIfNeeded,
     kReloadAlways,
   };
 
+  class ResourceCallback {
+   public:
+    virtual ~ResourceCallback() {}
+    virtual void Schedule(Resource*) = 0;
+    virtual void Cancel(Resource*) = 0;
+    virtual bool IsScheduled(Resource*) const = 0;
+  };
+
   virtual ~Resource();
 
   DECLARE_VIRTUAL_TRACE();
 
   virtual void SetEncoding(const String&) {}
   virtual String Encoding() const { return String(); }
   virtual void AppendData(const char*, size_t);
   virtual void GetError(const ResourceError&);
   virtual void SetCORSFailed() {}
 
@@ skipping 217 matching lines @@
   // If this Resource is ImageResource and has the Lo-Fi response headers or is
   // a placeholder, reload the full original image with the Lo-Fi state set to
   // off and optionally bypassing the cache.
   virtual void ReloadIfLoFiOrPlaceholderImage(ResourceFetcher*,
                                               ReloadLoFiOrPlaceholderPolicy) {}
 
   static const char* ResourceTypeToString(
       Type,
       const AtomicString& fetch_initiator_name);
 
+  void FinishPendingClients();
+
  protected:
-  Resource(const ResourceRequest&, Type, const ResourceLoaderOptions&);
+  Resource(const ResourceRequest&,
+           Type,
+           const ResourceLoaderOptions&,
+           FetchContext* = nullptr);
 
   virtual void CheckNotify();
 
   void MarkClientFinished(ResourceClient*);
 
   virtual bool HasClientsOrObservers() const {
     return !clients_.IsEmpty() || !clients_awaiting_callback_.IsEmpty() ||
            !finished_clients_.IsEmpty();
   }
   virtual void DestroyDecodedDataForFailedRevalidation() {}
 
   void SetEncodedSize(size_t);
   void SetDecodedSize(size_t);
 
-  void FinishPendingClients();
-
   virtual void DidAddClient(ResourceClient*);
   void WillAddClientOrObserver(PreloadReferencePolicy);
 
   void DidRemoveClientOrObserver();
   virtual void AllClientsAndObserversRemoved();
 
   bool HasClient(ResourceClient* client) const {
     return clients_.Contains(client) ||
            clients_awaiting_callback_.Contains(client) ||
            finished_clients_.Contains(client);
@@ skipping 34 matching lines @@
         : AutoReset(&resource->is_add_remove_client_prohibited_, true) {}
   };
 
   class RevalidationStartForbiddenScope : public AutoReset<bool> {
    public:
     RevalidationStartForbiddenScope(Resource* resource)
         : AutoReset(&resource->is_revalidation_start_forbidden_, true) {}
   };
 
  private:
-  class ResourceCallback;
   class CachedMetadataHandlerImpl;
   class ServiceWorkerResponseCachedMetadataHandler;
 
   void CancelTimerFired(TimerBase*);
 
   void RevalidationSucceeded(const ResourceResponse&);
   void RevalidationFailed();
 
   size_t CalculateOverheadSize() const;
 
   String ReasonNotDeletable() const;
 
+  ResourceCallback& GetResourceCallback();
+
   // MemoryCoordinatorClient overrides:
   void OnPurgeMemory() override;
 
   Member<CachedMetadataHandlerImpl> cache_handler_;
   RefPtr<SecurityOrigin> fetcher_security_origin_;
 
   ResourceError error_;
 
   double load_finish_time_;
 
@@ skipping 34 matching lines @@
 
   HeapHashCountedSet<WeakMember<ResourceClient>> clients_;
   HeapHashCountedSet<WeakMember<ResourceClient>> clients_awaiting_callback_;
   HeapHashCountedSet<WeakMember<ResourceClient>> finished_clients_;
 
   ResourceLoaderOptions options_;
 
   double response_timestamp_;
 
   TaskRunnerTimer<Resource> cancel_timer_;
+  Member<FetchContext> fetch_context_;
 
   ResourceRequest resource_request_;
   Member<ResourceLoader> loader_;
   ResourceResponse response_;
 
   RefPtr<SharedBuffer> data_;
 };
 
 class ResourceFactory {
   STACK_ALLOCATED();
 
  public:
   virtual Resource* Create(const ResourceRequest&,
                            const ResourceLoaderOptions&,
-                           const String&) const = 0;
+                           const String&,
+                           FetchContext*) const = 0;
   Resource::Type GetType() const { return type_; }
 
  protected:
   explicit ResourceFactory(Resource::Type type) : type_(type) {}
 
   Resource::Type type_;
 };
 
 #define DEFINE_RESOURCE_TYPE_CASTS(typeName)                      \
   DEFINE_TYPE_CASTS(typeName##Resource, Resource, resource,       \
                     resource->GetType() == Resource::k##typeName, \
                     resource.GetType() == Resource::k##typeName);
 
 }  // namespace blink
 
 #endif