[WIP] off-main-thread loading

third_party/WebKit/Source/platform/loader/fetch/ResourceFetcher.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) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
     rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
@@ skipping 402 matching lines @@
     // Fall back to the network if the archive doesn't contain the resource.
     if (!archiveResource)
       return nullptr;
     data = archiveResource->data();
     response.setURL(url);
     response.setMimeType(archiveResource->mimeType());
     response.setExpectedContentLength(data->size());
     response.setTextEncodingName(archiveResource->textEncoding());
   }
 
-  Resource* resource = factory.create(request.resourceRequest(),
-                                      request.options(), request.charset());
+  Resource* resource =
+      factory.create(request.resourceRequest(), request.options(),
+                     request.charset(), &context());
   resource->setNeedsSynchronousCacheHit(substituteData.forceSynchronousLoad());
   // FIXME: We should provide a body stream here.
   resource->responseReceived(response, nullptr);
   resource->setDataBufferingPolicy(BufferData);
   if (data->size())
     resource->setResourceBuffer(data);
   resource->setIdentifier(createUniqueIdentifier());
   resource->setCacheIdentifier(cacheIdentifier);
   resource->finish();
 
   if (!substituteData.isValid())
     memoryCache()->add(resource);
 
   return resource;
 }
 
 Resource* ResourceFetcher::resourceForBlockedRequest(
     const FetchRequest& request,
     const ResourceFactory& factory,
     ResourceRequestBlockedReason blockedReason) {
-  Resource* resource = factory.create(request.resourceRequest(),
-                                      request.options(), request.charset());
+  Resource* resource =
+      factory.create(request.resourceRequest(), request.options(),
+                     request.charset(), &context());
   resource->error(ResourceError::cancelledDueToAccessCheckError(request.url(),
                                                                 blockedReason));
   return resource;
 }
 
 void ResourceFetcher::makePreloadedResourceBlockOnloadIfNeeded(
     Resource* resource,
     const FetchRequest& request) {
   // TODO(yoav): Test that non-blocking resources (video/audio/track) continue
   // to not-block even after being preloaded and discovered.
@@ skipping 118 matching lines @@
   bool isStaticData = isDataUrl || substituteData.isValid() || m_archive;
   if (isStaticData) {
     resource = resourceForStaticData(request, factory, substituteData);
     // Abort the request if the archive doesn't contain the resource, except in
     // the case of data URLs which might have resources such as fonts that need
     // to be decoded only on demand.  These data URLs are allowed to be
     // processed using the normal ResourceFetcher machinery.
     if (!resource && !isDataUrl && m_archive)
       return nullptr;
   }
-  if (!resource) {
+  if (!resource && isMainThread()) {
     resource =
         memoryCache()->resourceForURL(request.url(), getCacheIdentifier());
   }
 
   // If we got a preloaded resource from the cache for a non-preload request,
   // we may need to make it block the onload event.
   makePreloadedResourceBlockOnloadIfNeeded(resource, request);
 
   const RevalidationPolicy policy = determineRevalidationPolicy(
       factory.type(), request, resource, isStaticData);
@@ skipping 128 matching lines @@
     revalidatingRequest.setHTTPHeaderField(HTTPNames::If_None_Match, eTag);
 
   resource->setRevalidatingRequest(revalidatingRequest);
 }
 
 Resource* ResourceFetcher::createResourceForLoading(
     FetchRequest& request,
     const String& charset,
     const ResourceFactory& factory) {
   const String cacheIdentifier = getCacheIdentifier();
-  DCHECK(!memoryCache()->resourceForURL(request.resourceRequest().url(),
+
+  DCHECK(!isMainThread() ||
+         !memoryCache()->resourceForURL(request.resourceRequest().url(),
                                         cacheIdentifier));
 
   RESOURCE_LOADING_DVLOG(1) << "Loading Resource for "
                             << request.resourceRequest().url().elidedString();
 
-  Resource* resource =
-      factory.create(request.resourceRequest(), request.options(), charset);
+  Resource* resource = factory.create(request.resourceRequest(),
+                                      request.options(), charset, &context());
   resource->setLinkPreload(request.isLinkPreload());
   if (request.isSpeculativePreload()) {
     resource->setPreloadDiscoveryTime(request.preloadDiscoveryTime());
   }
   resource->setCacheIdentifier(cacheIdentifier);
 
   // - Don't add main resource to cache to prevent reuse.
   // - Don't add the resource if its body will not be stored.
-  if (factory.type() != Resource::MainResource &&
+  if (isMainThread() && factory.type() != Resource::MainResource &&
       request.options().dataBufferingPolicy != DoNotBufferData) {
     memoryCache()->add(resource);
   }
   return resource;
 }
 
 void ResourceFetcher::storePerformanceTimingInitiatorInformation(
     Resource* resource) {
   const AtomicString& fetchInitiator = resource->options().initiatorInfo.name;
   if (fetchInitiator == FetchInitiatorTypeNames::internal)
@@ skipping 487 matching lines @@
   DCHECK(loader);
   // TODO(yoav): Convert CHECK to DCHECK if no crash reports come in.
   CHECK(m_loaders.contains(loader));
   m_nonBlockingLoaders.insert(loader);
   m_loaders.erase(loader);
 }
 
 bool ResourceFetcher::startLoad(Resource* resource) {
   DCHECK(resource);
   DCHECK(resource->stillNeedsLoad());
-  if (!context().shouldLoadNewResource(resource->getType())) {
+  if (isMainThread() && !context().shouldLoadNewResource(resource->getType())) {
     memoryCache()->remove(resource);
     return false;
   }
 
   ResourceRequest request(resource->resourceRequest());
   ResourceResponse response;
 
   blink::probe::PlatformSendRequest probe(&context(), resource->identifier(),
                                           request, response,
                                           resource->options().initiatorInfo);
@@ skipping 302 matching lines @@
   visitor->trace(m_context);
   visitor->trace(m_archive);
   visitor->trace(m_loaders);
   visitor->trace(m_nonBlockingLoaders);
   visitor->trace(m_documentResources);
   visitor->trace(m_preloads);
   visitor->trace(m_resourceTimingInfoMap);
 }
 
 }  // namespace blink