[WIP] off-main-thread loading

third_party/WebKit/Source/platform/loader/fetch/Resource.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, 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
@@ skipping 18 matching lines @@
 #include <cassert>
 #include <memory>
 #include "platform/Histogram.h"
 #include "platform/InstanceCounters.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
 #include "platform/WebTaskRunner.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/loader/fetch/CachedMetadata.h"
 #include "platform/loader/fetch/CrossOriginAccessControl.h"
+#include "platform/loader/fetch/FetchContext.h"
 #include "platform/loader/fetch/FetchInitiatorTypeNames.h"
 #include "platform/loader/fetch/FetchRequest.h"
 #include "platform/loader/fetch/IntegrityMetadata.h"
 #include "platform/loader/fetch/MemoryCache.h"
 #include "platform/loader/fetch/ResourceClient.h"
 #include "platform/loader/fetch/ResourceClientWalker.h"
 #include "platform/loader/fetch/ResourceLoader.h"
 #include "platform/network/HTTPParsers.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/wtf/CurrentTime.h"
 #include "platform/wtf/MathExtras.h"
 #include "platform/wtf/StdLibExtras.h"
 #include "platform/wtf/Vector.h"
 #include "platform/wtf/text/CString.h"
 #include "platform/wtf/text/StringBuilder.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebSecurityOrigin.h"
 
 namespace blink {
 
+namespace {
+
+class StaticResourceCallback final : public Resource::ResourceCallback {
+ public:
+  StaticResourceCallback();
+  ~StaticResourceCallback() override;
+  void schedule(Resource*) override;
+  void cancel(Resource*) override;
+  bool isScheduled(Resource*) const override;
+
+ private:
+  void runTask();
+
+  TaskHandle m_taskHandle;
+  HashSet<Persistent<Resource>> m_resourcesWithPendingClients;
+};
+
+StaticResourceCallback::StaticResourceCallback() {}
+StaticResourceCallback::~StaticResourceCallback() {}
+
+void StaticResourceCallback::schedule(Resource* resource) {
+  if (!m_taskHandle.isActive()) {
+    // WTF::unretained(this) is safe because a posted task is canceled when
+    // |m_taskHandle| is destroyed on the dtor of this ResourceCallback.
+    m_taskHandle =
+        Platform::current()
+            ->currentThread()
+            ->scheduler()
+            ->loadingTaskRunner()
+            ->postCancellableTask(BLINK_FROM_HERE,
+                                  WTF::bind(&StaticResourceCallback::runTask,
+                                            WTF::unretained(this)));
+  }
+  m_resourcesWithPendingClients.insert(resource);
+}
+
+void StaticResourceCallback::cancel(Resource* resource) {
+  m_resourcesWithPendingClients.erase(resource);
+  if (m_taskHandle.isActive() && m_resourcesWithPendingClients.isEmpty())
+    m_taskHandle.cancel();
+}
+
+bool StaticResourceCallback::isScheduled(Resource* resource) const {
+  return m_resourcesWithPendingClients.contains(resource);
+}
+
+void StaticResourceCallback::runTask() {
+  HeapVector<Member<Resource>> resources;
+  for (const Member<Resource>& resource : m_resourcesWithPendingClients)
+    resources.push_back(resource.get());
+  m_resourcesWithPendingClients.clear();
+
+  for (const auto& resource : resources)
+    resource->finishPendingClients();
+}
+
+}  // namespace
+
 // These response headers are not copied from a revalidated response to the
 // cached response headers. For compatibility, this list is based on Chromium's
 // net/http/http_response_headers.cc.
 const char* const headersToIgnoreAfterRevalidation[] = {
     "allow",
     "connection",
     "etag",
     "expires",
     "keep-alive",
     "last-modified",
@@ skipping 163 matching lines @@
         serializedData.size(), WebSecurityOrigin(m_securityOrigin),
         response().cacheStorageCacheName());
   } else {
     Platform::current()->cacheMetadataInCacheStorage(
         response().url(), response().responseTime(), nullptr, 0,
         WebSecurityOrigin(m_securityOrigin),
         response().cacheStorageCacheName());
   }
 }
 
-// This class cannot be on-heap because the first callbackHandler() call
-// instantiates the singleton object while we can call it in the
-// pre-finalization step.
-class Resource::ResourceCallback final {
- public:
-  static ResourceCallback& callbackHandler();
-  void schedule(Resource*);
-  void cancel(Resource*);
-  bool isScheduled(Resource*) const;
-
- private:
-  ResourceCallback();
-
-  void runTask();
-  TaskHandle m_taskHandle;
-  HashSet<Persistent<Resource>> m_resourcesWithPendingClients;
-};
-
-Resource::ResourceCallback& Resource::ResourceCallback::callbackHandler() {
-  DEFINE_STATIC_LOCAL(ResourceCallback, callbackHandler, ());
-  return callbackHandler;
-}
-
-Resource::ResourceCallback::ResourceCallback() {}
-
-void Resource::ResourceCallback::schedule(Resource* resource) {
-  if (!m_taskHandle.isActive()) {
-    // WTF::unretained(this) is safe because a posted task is canceled when
-    // |m_taskHandle| is destroyed on the dtor of this ResourceCallback.
-    m_taskHandle =
-        Platform::current()
-            ->currentThread()
-            ->scheduler()
-            ->loadingTaskRunner()
-            ->postCancellableTask(
-                BLINK_FROM_HERE,
-                WTF::bind(&ResourceCallback::runTask, WTF::unretained(this)));
-  }
-  m_resourcesWithPendingClients.insert(resource);
-}
-
-void Resource::ResourceCallback::cancel(Resource* resource) {
-  m_resourcesWithPendingClients.erase(resource);
-  if (m_taskHandle.isActive() && m_resourcesWithPendingClients.isEmpty())
-    m_taskHandle.cancel();
-}
-
-bool Resource::ResourceCallback::isScheduled(Resource* resource) const {
-  return m_resourcesWithPendingClients.contains(resource);
-}
-
-void Resource::ResourceCallback::runTask() {
-  HeapVector<Member<Resource>> resources;
-  for (const Member<Resource>& resource : m_resourcesWithPendingClients)
-    resources.push_back(resource.get());
-  m_resourcesWithPendingClients.clear();
-
-  for (const auto& resource : resources)
-    resource->finishPendingClients();
-}
-
 Resource::Resource(const ResourceRequest& request,
                    Type type,
-                   const ResourceLoaderOptions& options)
+                   const ResourceLoaderOptions& options,
+                   FetchContext* fetchContext)
     : m_loadFinishTime(0),
       m_identifier(0),
       m_encodedSize(0),
       m_encodedSizeMemoryUsage(0),
       m_decodedSize(0),
       m_overheadSize(calculateOverheadSize()),
       m_preloadCount(0),
       m_preloadDiscoveryTime(0.0),
       m_cacheIdentifier(MemoryCache::defaultCacheIdentifier()),
       m_preloadResult(PreloadNotReferenced),
       m_type(type),
       m_status(ResourceStatus::NotStarted),
       m_needsSynchronousCacheHit(false),
       m_linkPreload(false),
       m_isRevalidating(false),
       m_isAlive(false),
       m_isAddRemoveClientProhibited(false),
       m_integrityDisposition(ResourceIntegrityDisposition::NotChecked),
       m_options(options),
       m_responseTimestamp(currentTime()),
-      m_cancelTimer(Platform::current()->mainThread()->getWebTaskRunner(),
+      m_cancelTimer(fetchContext && fetchContext->timerTaskRunner()
+                        ? fetchContext->timerTaskRunner()
+                        : Platform::current()->mainThread()->getWebTaskRunner(),
                     this,
                     &Resource::cancelTimerFired),
+      m_fetchContext(fetchContext),
       m_resourceRequest(request) {
   InstanceCounters::incrementCounter(InstanceCounters::ResourceCounter);
 
   // Currently we support the metadata caching only for HTTP family.
   if (resourceRequest().url().protocolIsInHTTPFamily())
     m_cacheHandler = CachedMetadataHandlerImpl::create(this);
-  MemoryCoordinator::instance().registerClient(this);
+  if (isMainThread())
+    MemoryCoordinator::instance().registerClient(this);
 }
 
 Resource::~Resource() {
   InstanceCounters::decrementCounter(InstanceCounters::ResourceCounter);
 }
 
 DEFINE_TRACE(Resource) {
   visitor->trace(m_loader);
+  visitor->trace(m_fetchContext);
   visitor->trace(m_cacheHandler);
   visitor->trace(m_clients);
   visitor->trace(m_clientsAwaitingCallback);
   visitor->trace(m_finishedClients);
   MemoryCoordinatorClient::trace(visitor);
 }
 
 void Resource::setLoader(ResourceLoader* loader) {
   CHECK(!m_loader);
   DCHECK(stillNeedsLoad());
@@ skipping 49 matching lines @@
   m_options.dataBufferingPolicy = dataBufferingPolicy;
   clearData();
   setEncodedSize(0);
 }
 
 void Resource::error(const ResourceError& error) {
   DCHECK(!error.isNull());
   m_error = error;
   m_isRevalidating = false;
 
-  if (m_error.isCancellation() || !isPreloaded())
+  if ((m_error.isCancellation() || !isPreloaded()) && isMainThread())
     memoryCache()->remove(this);
 
   if (!errorOccurred())
     setStatus(ResourceStatus::LoadError);
   DCHECK(errorOccurred());
   clearData();
   m_loader = nullptr;
   checkNotify();
 }
 
@@ skipping 215 matching lines @@
       builder.append(' ');
     builder.append("m_loader");
   }
   if (m_preloadCount) {
     if (!builder.isEmpty())
       builder.append(' ');
     builder.append("m_preloadCount(");
     builder.appendNumber(m_preloadCount);
     builder.append(')');
   }
-  if (memoryCache()->contains(this)) {
+  if (isMainThread() && memoryCache()->contains(this)) {
     if (!builder.isEmpty())
       builder.append(' ');
     builder.append("in_memory_cache");
   }
   return builder.toString();
 }
 
 void Resource::didAddClient(ResourceClient* c) {
   if (isLoaded()) {
     c->notifyFinished(this);
@@ skipping 53 matching lines @@
   if (m_isRevalidating) {
     m_clients.insert(client);
     return;
   }
 
   // If an error has occurred or we have existing data to send to the new client
   // and the resource type supprts it, send it asynchronously.
   if ((errorOccurred() || !response().isNull()) &&
       !typeNeedsSynchronousCacheHit(getType()) && !m_needsSynchronousCacheHit) {
     m_clientsAwaitingCallback.insert(client);
-    ResourceCallback::callbackHandler().schedule(this);
+    resourceCallback().schedule(this);
     return;
   }
 
   m_clients.insert(client);
   didAddClient(client);
   return;
 }
 
 void Resource::removeClient(ResourceClient* client) {
   CHECK(!m_isAddRemoveClientProhibited);
 
   // This code may be called in a pre-finalizer, where weak members in the
   // HashCountedSet are already swept out.
 
   if (m_finishedClients.contains(client))
     m_finishedClients.erase(client);
   else if (m_clientsAwaitingCallback.contains(client))
     m_clientsAwaitingCallback.erase(client);
   else
     m_clients.erase(client);
 
   if (m_clientsAwaitingCallback.isEmpty())
-    ResourceCallback::callbackHandler().cancel(this);
+    resourceCallback().cancel(this);
 
   didRemoveClientOrObserver();
 }
 
 void Resource::didRemoveClientOrObserver() {
   if (!hasClientsOrObservers() && m_isAlive) {
     m_isAlive = false;
     allClientsAndObserversRemoved();
 
     // RFC2616 14.9.2:
     // "no-store: ... MUST make a best-effort attempt to remove the information
     // from volatile storage as promptly as possible"
     // "... History buffers MAY store such responses as part of their normal
     // operation."
     // We allow non-secure content to be reused in history, but we do not allow
     // secure content to be reused.
-    if (hasCacheControlNoStoreHeader() && url().protocolIs("https"))
+    if (hasCacheControlNoStoreHeader() && url().protocolIs("https") &&
+        isMainThread()) {
       memoryCache()->remove(this);
+    }
   }
 }
 
 void Resource::allClientsAndObserversRemoved() {
   if (!m_loader)
     return;
   if (!m_cancelTimer.isActive())
     m_cancelTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void Resource::cancelTimerFired(TimerBase* timer) {
   DCHECK_EQ(timer, &m_cancelTimer);
   if (!hasClientsOrObservers() && m_loader)
     m_loader->cancel();
 }
 
 void Resource::setDecodedSize(size_t decodedSize) {
   if (decodedSize == m_decodedSize)
     return;
   size_t oldSize = size();
   m_decodedSize = decodedSize;
-  memoryCache()->update(this, oldSize, size());
+  if (isMainThread())
+    memoryCache()->update(this, oldSize, size());
 }
 
 void Resource::setEncodedSize(size_t encodedSize) {
   if (encodedSize == m_encodedSize && encodedSize == m_encodedSizeMemoryUsage)
     return;
   size_t oldSize = size();
   m_encodedSize = encodedSize;
   m_encodedSizeMemoryUsage = encodedSize;
-  memoryCache()->update(this, oldSize, size());
+  if (isMainThread())
+    memoryCache()->update(this, oldSize, size());
 }
 
 void Resource::finishPendingClients() {
   // We're going to notify clients one by one. It is simple if the client does
   // nothing. However there are a couple other things that can happen.
   //
   // 1. Clients can be added during the loop. Make sure they are not processed.
   // 2. Clients can be removed during the loop. Make sure they are always
   //    available to be removed. Also don't call removed clients or add them
   //    back.
@@ skipping 11 matching lines @@
 
     // When revalidation starts after waiting clients are scheduled and
     // before they are added here. In such cases, we just add the clients
     // to |m_clients| without didAddClient(), as in Resource::addClient().
     if (!m_isRevalidating)
       didAddClient(client);
   }
 
   // It is still possible for the above loop to finish a new client
   // synchronously. If there's no client waiting we should deschedule.
-  bool scheduled = ResourceCallback::callbackHandler().isScheduled(this);
+  bool scheduled = resourceCallback().isScheduled(this);
   if (scheduled && m_clientsAwaitingCallback.isEmpty())
-    ResourceCallback::callbackHandler().cancel(this);
+    resourceCallback().cancel(this);
 
   // Prevent the case when there are clients waiting but no callback scheduled.
   DCHECK(m_clientsAwaitingCallback.isEmpty() || scheduled);
 }
 
 void Resource::prune() {
   destroyDecodedDataIfPossible();
 }
 
 void Resource::onPurgeMemory() {
@@ skipping 276 matching lines @@
     case Resource::TextTrack:
     case Resource::Media:
     case Resource::Manifest:
     case Resource::Mock:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
+Resource::ResourceCallback& Resource::resourceCallback() {
+  if (m_fetchContext && m_fetchContext->resourceCallback()) {
+    DCHECK(!isMainThread());
+    return *m_fetchContext->resourceCallback();
+  }
+  DCHECK(isMainThread());
+  DEFINE_STATIC_LOCAL(StaticResourceCallback, callbackHandler, ());
+  return callbackHandler;
+}
+
 }  // namespace blink