[WIP2] 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/FetchParameters.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/scheduler/child/web_scheduler.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/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 task_handle_;
+  HashSet<Persistent<Resource>> resources_with_pending_clients_;
+};
+
+StaticResourceCallback::StaticResourceCallback() {}
+StaticResourceCallback::~StaticResourceCallback() {}
+
+void StaticResourceCallback::Schedule(Resource* resource) {
+  if (!task_handle_.IsActive()) {
+    // WTF::unretained(this) is safe because a posted task is canceled when
+    // |task_handle_| is destroyed on the dtor of this ResourceCallback.
+    task_handle_ =
+        Platform::Current()
+            ->CurrentThread()
+            ->Scheduler()
+            ->LoadingTaskRunner()
+            ->PostCancellableTask(BLINK_FROM_HERE,
+                                  WTF::Bind(&StaticResourceCallback::RunTask,
+                                            WTF::Unretained(this)));
+  }
+  resources_with_pending_clients_.insert(resource);
+}
+
+void StaticResourceCallback::Cancel(Resource* resource) {
+  resources_with_pending_clients_.erase(resource);
+  if (task_handle_.IsActive() && resources_with_pending_clients_.IsEmpty())
+    task_handle_.Cancel();
+}
+
+bool StaticResourceCallback::IsScheduled(Resource* resource) const {
+  return resources_with_pending_clients_.Contains(resource);
+}
+
+void StaticResourceCallback::RunTask() {
+  HeapVector<Member<Resource>> resources;
+  for (const Member<Resource>& resource : resources_with_pending_clients_)
+    resources.push_back(resource);
+  resources_with_pending_clients_.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 kHeadersToIgnoreAfterRevalidation[] = {
     "allow",
     "connection",
     "etag",
     "expires",
     "keep-alive",
     "last-modified",
@@ skipping 168 matching lines @@
         WebSecurityOrigin(security_origin_),
         GetResponse().CacheStorageCacheName());
   } else {
     Platform::Current()->CacheMetadataInCacheStorage(
         GetResponse().Url(), GetResponse().ResponseTime(), nullptr, 0,
         WebSecurityOrigin(security_origin_),
         GetResponse().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 task_handle_;
-  HashSet<Persistent<Resource>> resources_with_pending_clients_;
-};
-
-Resource::ResourceCallback& Resource::ResourceCallback::CallbackHandler() {
-  DEFINE_STATIC_LOCAL(ResourceCallback, callback_handler, ());
-  return callback_handler;
-}
-
-Resource::ResourceCallback::ResourceCallback() {}
-
-void Resource::ResourceCallback::Schedule(Resource* resource) {
-  if (!task_handle_.IsActive()) {
-    // WTF::unretained(this) is safe because a posted task is canceled when
-    // |m_taskHandle| is destroyed on the dtor of this ResourceCallback.
-    task_handle_ =
-        Platform::Current()
-            ->CurrentThread()
-            ->Scheduler()
-            ->LoadingTaskRunner()
-            ->PostCancellableTask(
-                BLINK_FROM_HERE,
-                WTF::Bind(&ResourceCallback::RunTask, WTF::Unretained(this)));
-  }
-  resources_with_pending_clients_.insert(resource);
-}
-
-void Resource::ResourceCallback::Cancel(Resource* resource) {
-  resources_with_pending_clients_.erase(resource);
-  if (task_handle_.IsActive() && resources_with_pending_clients_.IsEmpty())
-    task_handle_.Cancel();
-}
-
-bool Resource::ResourceCallback::IsScheduled(Resource* resource) const {
-  return resources_with_pending_clients_.Contains(resource);
-}
-
-void Resource::ResourceCallback::RunTask() {
-  HeapVector<Member<Resource>> resources;
-  for (const Member<Resource>& resource : resources_with_pending_clients_)
-    resources.push_back(resource.Get());
-  resources_with_pending_clients_.clear();
-
-  for (const auto& resource : resources)
-    resource->FinishPendingClients();
-}
-
 Resource::Resource(const ResourceRequest& request,
                    Type type,
-                   const ResourceLoaderOptions& options)
+                   const ResourceLoaderOptions& options,
+                   FetchContext* fetch_context)
     : load_finish_time_(0),
       identifier_(0),
       encoded_size_(0),
       encoded_size_memory_usage_(0),
       decoded_size_(0),
       overhead_size_(CalculateOverheadSize()),
       preload_count_(0),
       preload_discovery_time_(0.0),
       cache_identifier_(MemoryCache::DefaultCacheIdentifier()),
       preload_result_(kPreloadNotReferenced),
       type_(type),
       status_(ResourceStatus::kNotStarted),
       needs_synchronous_cache_hit_(false),
       link_preload_(false),
       is_revalidating_(false),
       is_alive_(false),
       is_add_remove_client_prohibited_(false),
       integrity_disposition_(ResourceIntegrityDisposition::kNotChecked),
       options_(options),
       response_timestamp_(CurrentTime()),
-      cancel_timer_(Platform::Current()->MainThread()->GetWebTaskRunner(),
+      cancel_timer_(fetch_context && fetch_context->TimerTaskRunner()
+                        ? fetch_context->TimerTaskRunner()
+                        : Platform::Current()->MainThread()->GetWebTaskRunner(),
                     this,
                     &Resource::CancelTimerFired),
+      fetch_context_(fetch_context),
       resource_request_(request) {
   InstanceCounters::IncrementCounter(InstanceCounters::kResourceCounter);
 
   // Currently we support the metadata caching only for HTTP family.
   if (GetResourceRequest().Url().ProtocolIsInHTTPFamily())
     cache_handler_ = CachedMetadataHandlerImpl::Create(this);
-  MemoryCoordinator::Instance().RegisterClient(this);
+  if (IsMainThread())
+    MemoryCoordinator::Instance().RegisterClient(this);
 }
 
 Resource::~Resource() {
   InstanceCounters::DecrementCounter(InstanceCounters::kResourceCounter);
 }
 
 DEFINE_TRACE(Resource) {
   visitor->Trace(loader_);
+  visitor->Trace(fetch_context_);
   visitor->Trace(cache_handler_);
   visitor->Trace(clients_);
   visitor->Trace(clients_awaiting_callback_);
   visitor->Trace(finished_clients_);
   MemoryCoordinatorClient::Trace(visitor);
 }
 
 void Resource::SetLoader(ResourceLoader* loader) {
   CHECK(!loader_);
   DCHECK(StillNeedsLoad());
@@ skipping 50 matching lines @@
   options_.data_buffering_policy = data_buffering_policy;
   ClearData();
   SetEncodedSize(0);
 }
 
 void Resource::GetError(const ResourceError& error) {
   DCHECK(!error.IsNull());
   error_ = error;
   is_revalidating_ = false;
 
-  if (error_.IsCancellation() || !IsPreloaded())
+  if ((error_.IsCancellation() || !IsPreloaded()) && IsMainThread())
     GetMemoryCache()->Remove(this);
 
   if (!ErrorOccurred())
     SetStatus(ResourceStatus::kLoadError);
   DCHECK(ErrorOccurred());
   ClearData();
   loader_ = nullptr;
   CheckNotify();
 }
 
@@ skipping 208 matching lines @@
       builder.Append(' ');
     builder.Append("m_loader");
   }
   if (preload_count_) {
     if (!builder.IsEmpty())
       builder.Append(' ');
     builder.Append("m_preloadCount(");
     builder.AppendNumber(preload_count_);
     builder.Append(')');
   }
-  if (GetMemoryCache()->Contains(this)) {
+  if (IsMainThread() && GetMemoryCache()->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 54 matching lines @@
     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() || !GetResponse().IsNull()) &&
       !TypeNeedsSynchronousCacheHit(GetType()) &&
       !needs_synchronous_cache_hit_) {
     clients_awaiting_callback_.insert(client);
-    ResourceCallback::CallbackHandler().Schedule(this);
+    GetResourceCallback().Schedule(this);
     return;
   }
 
   clients_.insert(client);
   DidAddClient(client);
   return;
 }
 
 void Resource::RemoveClient(ResourceClient* client) {
   CHECK(!is_add_remove_client_prohibited_);
 
   // This code may be called in a pre-finalizer, where weak members in the
   // HashCountedSet are already swept out.
 
   if (finished_clients_.Contains(client))
     finished_clients_.erase(client);
   else if (clients_awaiting_callback_.Contains(client))
     clients_awaiting_callback_.erase(client);
   else
     clients_.erase(client);
 
   if (clients_awaiting_callback_.IsEmpty())
-    ResourceCallback::CallbackHandler().Cancel(this);
+    GetResourceCallback().Cancel(this);
 
   DidRemoveClientOrObserver();
 }
 
 void Resource::DidRemoveClientOrObserver() {
   if (!HasClientsOrObservers() && is_alive_) {
     is_alive_ = 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())
       GetMemoryCache()->Remove(this);
   }
 }
 
 void Resource::AllClientsAndObserversRemoved() {
   if (!loader_)
     return;
   if (!cancel_timer_.IsActive())
     cancel_timer_.StartOneShot(0, BLINK_FROM_HERE);
 }
 
 void Resource::CancelTimerFired(TimerBase* timer) {
   DCHECK_EQ(timer, &cancel_timer_);
   if (!HasClientsOrObservers() && loader_)
     loader_->Cancel();
 }
 
 void Resource::SetDecodedSize(size_t decoded_size) {
   if (decoded_size == decoded_size_)
     return;
   size_t old_size = size();
   decoded_size_ = decoded_size;
-  GetMemoryCache()->Update(this, old_size, size());
+  if (IsMainThread())
+    GetMemoryCache()->Update(this, old_size, size());
 }
 
 void Resource::SetEncodedSize(size_t encoded_size) {
   if (encoded_size == encoded_size_ &&
       encoded_size == encoded_size_memory_usage_)
     return;
   size_t old_size = size();
   encoded_size_ = encoded_size;
   encoded_size_memory_usage_ = encoded_size;
-  GetMemoryCache()->Update(this, old_size, size());
+  if (IsMainThread())
+    GetMemoryCache()->Update(this, old_size, 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 (!is_revalidating_)
       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 = GetResourceCallback().IsScheduled(this);
   if (scheduled && clients_awaiting_callback_.IsEmpty())
-    ResourceCallback::CallbackHandler().Cancel(this);
+    GetResourceCallback().Cancel(this);
 
   // Prevent the case when there are clients waiting but no callback scheduled.
   DCHECK(clients_awaiting_callback_.IsEmpty() || scheduled);
 }
 
 void Resource::Prune() {
   DestroyDecodedDataIfPossible();
 }
 
 void Resource::OnPurgeMemory() {
@@ skipping 276 matching lines @@
     case Resource::kTextTrack:
     case Resource::kMedia:
     case Resource::kManifest:
     case Resource::kMock:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
+Resource::ResourceCallback& Resource::GetResourceCallback() {
+  if (fetch_context_ && fetch_context_->GetResourceCallback()) {
+    DCHECK(!IsMainThread());
+    return *fetch_context_->GetResourceCallback();
+  }
+  DCHECK(IsMainThread());
+  DEFINE_STATIC_LOCAL(StaticResourceCallback, callback_handler, ());
+  return callback_handler;
+}
+
 }  // namespace blink