Phase III Step 1: Make ImageResourceContent manage its own ResourceStatus

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 11 matching lines @@
     Boston, MA 02110-1301, USA.
 
     This class provides all functionality needed for loading images, style
     sheets and html pages from the web. It has a memory cache for these objects.
 */
 
 #include "platform/loader/fetch/ResourceFetcher.h"
 
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/ScriptForbiddenScope.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/instrumentation/tracing/TracedValue.h"
 #include "platform/loader/fetch/FetchContext.h"
 #include "platform/loader/fetch/FetchInitiatorTypeNames.h"
 #include "platform/loader/fetch/MemoryCache.h"
 #include "platform/loader/fetch/ResourceLoader.h"
 #include "platform/loader/fetch/ResourceLoadingLog.h"
 #include "platform/loader/fetch/ResourceTimingInfo.h"
 #include "platform/loader/fetch/UniqueIdentifier.h"
 #include "platform/mhtml/ArchiveResource.h"
@@ skipping 382 matching lines @@
     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->SetNeedsSynchronousCacheHit(substitute_data.ForceSynchronousLoad());
   // FIXME: We should provide a body stream here.
+  resource->SetStatus(ResourceStatus::kPending);
+  resource->NotifyStartLoad();
   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->SetStatus(ResourceStatus::kPending);
+  resource->NotifyStartLoad();
   resource->FinishAsError(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 862 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())) {
-    GetMemoryCache()->Remove(resource);
-    return false;
+
+  ResourceRequest request(resource->GetResourceRequest());
+  ResourceLoader* loader = nullptr;
+
+  {
+    // Forbids JavaScript/addClient/removeClient/revalidation until start()
+    // to prevent unintended state transitions.
+    Resource::ProhibitAddRemoveClientInScope
+        prohibit_add_remove_client_in_scope(resource);
+    Resource::RevalidationStartForbiddenScope
+        revalidation_start_forbidden_scope(resource);
+    ScriptForbiddenScope script_forbidden_scope;
+
+    if (!Context().ShouldLoadNewResource(resource->GetType())) {
+      GetMemoryCache()->Remove(resource);
+      return false;
+    }
+
+    ResourceResponse response;
+
+    blink::probe::PlatformSendRequest probe(&Context(), resource->Identifier(),
+                                            request, response,
+                                            resource->Options().initiator_info);
+
+    Context().DispatchWillSendRequest(resource->Identifier(), request, response,
+                                      resource->Options().initiator_info);
+
+    // TODO(shaochuan): Saving modified ResourceRequest back to |resource|,
+    // remove once dispatchWillSendRequest() takes const ResourceRequest.
+    // crbug.com/632580
+    resource->SetResourceRequest(request);
+
+    // Resource requests from suborigins should not be intercepted by the
+    // service worker of the physical origin. This has the effect that, for now,
+    // suborigins do not work with service workers. See
+    // https://w3c.github.io/webappsec-suborigins/.
+    SecurityOrigin* source_origin = Context().GetSecurityOrigin();
+    if (source_origin && source_origin->HasSuborigin())
+      request.SetServiceWorkerMode(WebURLRequest::ServiceWorkerMode::kNone);
+
+    loader = ResourceLoader::Create(this, resource);
+    if (resource->ShouldBlockLoadEvent())
+      loaders_.insert(loader);
+    else
+      non_blocking_loaders_.insert(loader);
+
+    StorePerformanceTimingInitiatorInformation(resource);
+    resource->SetFetcherSecurityOrigin(source_origin);
+
+    resource->NotifyStartLoad();
+    loader->ActivateCacheAwareLoadingIfNeeded(request);
   }
 
-  ResourceRequest request(resource->GetResourceRequest());
-  ResourceResponse response;
-
-  blink::probe::PlatformSendRequest probe(&Context(), resource->Identifier(),
-                                          request, response,
-                                          resource->Options().initiator_info);
-
-  Context().DispatchWillSendRequest(resource->Identifier(), request, response,
-                                    resource->Options().initiator_info);
-
-  // TODO(shaochuan): Saving modified ResourceRequest back to |resource|, remove
-  // once dispatchWillSendRequest() takes const ResourceRequest.
-  // crbug.com/632580
-  resource->SetResourceRequest(request);
-
-  // Resource requests from suborigins should not be intercepted by the service
-  // worker of the physical origin. This has the effect that, for now,
-  // suborigins do not work with service workers. See
-  // https://w3c.github.io/webappsec-suborigins/.
-  SecurityOrigin* source_origin = Context().GetSecurityOrigin();
-  if (source_origin && source_origin->HasSuborigin())
-    request.SetServiceWorkerMode(WebURLRequest::ServiceWorkerMode::kNone);
-
-  ResourceLoader* loader = ResourceLoader::Create(this, resource);
-  if (resource->ShouldBlockLoadEvent())
-    loaders_.insert(loader);
-  else
-    non_blocking_loaders_.insert(loader);
-
-  StorePerformanceTimingInitiatorInformation(resource);
-  resource->SetFetcherSecurityOrigin(source_origin);
-
-  loader->ActivateCacheAwareLoadingIfNeeded(request);
   loader->Start(request);
   return true;
 }
 
 void ResourceFetcher::RemoveResourceLoader(ResourceLoader* loader) {
   DCHECK(loader);
   if (loaders_.Contains(loader))
     loaders_.erase(loader);
   else if (non_blocking_loaders_.Contains(loader))
     non_blocking_loaders_.erase(loader);
@@ skipping 228 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