[WIP] 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 FetchRequest;
 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 @@
     MarkAsReferenced,
     DontMarkAsReferenced,
   };
 
   // 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 error(const ResourceError&);
   virtual void setCORSFailed() {}
 
@@ skipping 218 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& fetchInitiatorName);
 
+  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 !m_clients.isEmpty() || !m_clientsAwaitingCallback.isEmpty() ||
            !m_finishedClients.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 m_clients.contains(client) ||
            m_clientsAwaitingCallback.contains(client) ||
            m_finishedClients.contains(client);
@@ skipping 34 matching lines @@
         : AutoReset(&resource->m_isAddRemoveClientProhibited, true) {}
   };
 
   class RevalidationStartForbiddenScope : public AutoReset<bool> {
    public:
     RevalidationStartForbiddenScope(Resource* resource)
         : AutoReset(&resource->m_isRevalidationStartForbidden, 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& resourceCallback();
+
   // MemoryCoordinatorClient overrides:
   void onPurgeMemory() override;
 
   Member<CachedMetadataHandlerImpl> m_cacheHandler;
   RefPtr<SecurityOrigin> m_fetcherSecurityOrigin;
 
   ResourceError m_error;
 
   double m_loadFinishTime;
 
@@ skipping 34 matching lines @@
 
   HeapHashCountedSet<WeakMember<ResourceClient>> m_clients;
   HeapHashCountedSet<WeakMember<ResourceClient>> m_clientsAwaitingCallback;
   HeapHashCountedSet<WeakMember<ResourceClient>> m_finishedClients;
 
   ResourceLoaderOptions m_options;
 
   double m_responseTimestamp;
 
   TaskRunnerTimer<Resource> m_cancelTimer;
+  Member<FetchContext> m_fetchContext;
 
   ResourceRequest m_resourceRequest;
   Member<ResourceLoader> m_loader;
   ResourceResponse m_response;
 
   RefPtr<SharedBuffer> m_data;
 };
 
 class ResourceFactory {
   STACK_ALLOCATED();
 
  public:
   virtual Resource* create(const ResourceRequest&,
                            const ResourceLoaderOptions&,
-                           const String&) const = 0;
+                           const String&,
+                           FetchContext*) const = 0;
   Resource::Type type() const { return m_type; }
 
  protected:
   explicit ResourceFactory(Resource::Type type) : m_type(type) {}
 
   Resource::Type m_type;
 };
 
 #define DEFINE_RESOURCE_TYPE_CASTS(typeName)                   \
   DEFINE_TYPE_CASTS(typeName##Resource, Resource, resource,    \
                     resource->getType() == Resource::typeName, \
                     resource.getType() == Resource::typeName);
 
 }  // namespace blink
 
 #endif