test all

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 403 matching lines @@
     // Fall back to the network if the archive doesn't contain the resource.
     if (!archive_resource)
       return nullptr;
     data = archive_resource->Data();
     response.SetURL(url);
     response.SetMimeType(archive_resource->MimeType());
     response.SetExpectedContentLength(data->size());
     response.SetTextEncodingName(archive_resource->TextEncoding());
   }
 
-  Resource* resource = factory.Create(params.GetResourceRequest(),
-                                      params.Options(), params.Charset());
+  Resource* resource =
+      factory.Create(params.GetResourceRequest(), params.Options(),
+                     params.Charset(), &Context());
   resource->SetNeedsSynchronousCacheHit(substitute_data.ForceSynchronousLoad());
   // FIXME: We should provide a body stream here.
   resource->ResponseReceived(response, nullptr);
   resource->SetDataBufferingPolicy(kBufferData);
   if (data->size())
     resource->SetResourceBuffer(data);
   resource->SetIdentifier(CreateUniqueIdentifier());
   resource->SetCacheIdentifier(cache_identifier);
   resource->Finish();
 
   if (!substitute_data.IsValid())
     GetMemoryCache()->Add(resource);
 
   return resource;
 }
 
 Resource* ResourceFetcher::ResourceForBlockedRequest(
     const FetchParameters& params,
     const ResourceFactory& factory,
     ResourceRequestBlockedReason blocked_reason) {
-  Resource* resource = factory.Create(params.GetResourceRequest(),
-                                      params.Options(), params.Charset());
+  Resource* resource =
+      factory.Create(params.GetResourceRequest(), params.Options(),
+                     params.Charset(), &Context());
   resource->GetError(ResourceError::CancelledDueToAccessCheckError(
       params.Url(), blocked_reason));
   return resource;
 }
 
 void ResourceFetcher::MakePreloadedResourceBlockOnloadIfNeeded(
     Resource* resource,
     const FetchParameters& params) {
   // TODO(yoav): Test that non-blocking resources (video/audio/track) continue
   // to not-block even after being preloaded and discovered.
@@ skipping 120 matching lines @@
   bool is_static_data = is_data_url || substitute_data.IsValid() || archive_;
   if (is_static_data) {
     resource = ResourceForStaticData(params, factory, substitute_data);
     // 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 && !is_data_url && archive_)
       return nullptr;
   }
-  if (!resource) {
+  if (!resource && IsMainThread()) {
     resource =
         GetMemoryCache()->ResourceForURL(params.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, params);
 
   const RevalidationPolicy policy = DetermineRevalidationPolicy(
       factory.GetType(), params, resource, is_static_data);
@@ skipping 128 matching lines @@
     revalidating_request.SetHTTPHeaderField(HTTPNames::If_None_Match, e_tag);
 
   resource->SetRevalidatingRequest(revalidating_request);
 }
 
 Resource* ResourceFetcher::CreateResourceForLoading(
     FetchParameters& params,
     const String& charset,
     const ResourceFactory& factory) {
   const String cache_identifier = GetCacheIdentifier();
-  DCHECK(!GetMemoryCache()->ResourceForURL(params.GetResourceRequest().Url(),
+  DCHECK(!IsMainThread() ||
+         !GetMemoryCache()->ResourceForURL(params.GetResourceRequest().Url(),
                                            cache_identifier));
 
   RESOURCE_LOADING_DVLOG(1) << "Loading Resource for "
                             << params.GetResourceRequest().Url().ElidedString();
 
-  Resource* resource =
-      factory.Create(params.GetResourceRequest(), params.Options(), charset);
+  Resource* resource = factory.Create(params.GetResourceRequest(),
+                                      params.Options(), charset, &Context());
   resource->SetLinkPreload(params.IsLinkPreload());
   if (params.IsSpeculativePreload()) {
     resource->SetPreloadDiscoveryTime(params.PreloadDiscoveryTime());
   }
   resource->SetCacheIdentifier(cache_identifier);
 
   // - Don't add main resource to cache to prevent reuse.
   // - Don't add the resource if its body will not be stored.
-  if (factory.GetType() != Resource::kMainResource &&
+  if (IsMainThread() && factory.GetType() != Resource::kMainResource &&
       params.Options().data_buffering_policy != kDoNotBufferData) {
     GetMemoryCache()->Add(resource);
   }
   return resource;
 }
 
 void ResourceFetcher::StorePerformanceTimingInitiatorInformation(
     Resource* resource) {
   const AtomicString& fetch_initiator = resource->Options().initiator_info.name;
   if (fetch_initiator == FetchInitiatorTypeNames::internal)
@@ skipping 489 matching lines @@
   DCHECK(loader);
   // TODO(yoav): Convert CHECK to DCHECK if no crash reports come in.
   CHECK(loaders_.Contains(loader));
   non_blocking_loaders_.insert(loader);
   loaders_.erase(loader);
 }
 
 bool ResourceFetcher::StartLoad(Resource* resource) {
   DCHECK(resource);
   DCHECK(resource->StillNeedsLoad());
-  if (!Context().ShouldLoadNewResource(resource->GetType())) {
+  if (IsMainThread() && !Context().ShouldLoadNewResource(resource->GetType())) {
     GetMemoryCache()->Remove(resource);
     return false;
   }
 
   ResourceRequest request(resource->GetResourceRequest());
   ResourceResponse response;
 
   blink::probe::PlatformSendRequest probe(&Context(), resource->Identifier(),
                                           request, response,
                                           resource->Options().initiator_info);
@@ skipping 303 matching lines @@
   visitor->Trace(context_);
   visitor->Trace(archive_);
   visitor->Trace(loaders_);
   visitor->Trace(non_blocking_loaders_);
   visitor->Trace(document_resources_);
   visitor->Trace(preloads_);
   visitor->Trace(resource_timing_info_map_);
 }
 
 }  // namespace blink