[ImageLoader 2d] Set DecodeError by calling ResourceLoader::cancel()

third_party/WebKit/Source/core/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 421 matching lines @@
     memoryCache()->add(resource);
 
   return resource;
 }
 
 Resource* ResourceFetcher::resourceForBlockedRequest(
     const FetchRequest& request,
     const ResourceFactory& factory) {
   Resource* resource = factory.create(request.resourceRequest(),
                                       request.options(), request.charset());
-  resource->error(ResourceError::cancelledDueToAccessCheckError(request.url()));
+  resource->error(ResourceError::cancelledDueToAccessCheckError(request.url()),
+                  Resource::LoadError);
   return resource;
 }
 
 void ResourceFetcher::moveCachedNonBlockingResourceToBlocking(
     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.
   if (resource && resource->loader() &&
       resource->isLoadEventBlockingResourceType() &&
@@ skipping 709 matching lines @@
     resource->finish(finishTime);
   context().didLoadResource(resource);
 
   if (resource->isImage() &&
       toImageResource(resource)->shouldReloadBrokenPlaceholder()) {
     toImageResource(resource)->reloadIfLoFiOrPlaceholder(this);
   }
 }
 
 void ResourceFetcher::didFailLoading(Resource* resource,
-                                     const ResourceError& error) {
+                                     const ResourceError& error,
+                                     Resource::Status errorStatus) {
   TRACE_EVENT_ASYNC_END0("blink.net", "Resource", resource->identifier());
   removeResourceLoader(resource->loader());
   m_resourceTimingInfoMap.take(const_cast<Resource*>(resource));
   bool isInternalRequest = resource->options().initiatorInfo.name ==
                            FetchInitiatorTypeNames::internal;
-  context().dispatchDidFail(resource->identifier(), error, isInternalRequest);
-  resource->error(error);
+  context().dispatchDidFail(resource->identifier(), error, isInternalRequest,
+                            errorStatus == Resource::DecodeError);
+  resource->error(error, errorStatus);
   context().didLoadResource(resource);
 
   if (resource->isImage() &&
       toImageResource(resource)->shouldReloadBrokenPlaceholder()) {
     toImageResource(resource)->reloadIfLoFiOrPlaceholder(this);
   }
 }
 
 void ResourceFetcher::didReceiveResponse(Resource* resource,
                                          const ResourceResponse& response,
@@ skipping 24 matching lines @@
     // If the response is fetched via ServiceWorker, the original URL of the
     // response could be different from the URL of the request. We check the URL
     // not to load the resources which are forbidden by the page CSP.
     // https://w3c.github.io/webappsec-csp/#should-block-response
     const KURL& originalURL = response.originalURLViaServiceWorker();
     if (!originalURL.isEmpty() &&
         !context().allowResponse(resource->getType(),
                                  resource->resourceRequest(), originalURL,
                                  resource->options())) {
       resource->loader()->didFail(
-          ResourceError::cancelledDueToAccessCheckError(originalURL));
+          ResourceError::cancelledDueToAccessCheckError(originalURL),
+          Resource::LoadError);
       return;
     }
   } else if (resource->options().corsEnabled == IsCORSEnabled &&
              !canAccessResponse(resource, response)) {
     resource->loader()->didFail(
-        ResourceError::cancelledDueToAccessCheckError(response.url()));
+        ResourceError::cancelledDueToAccessCheckError(response.url()),
+        Resource::LoadError);
     return;
   }
 
   context().dispatchDidReceiveResponse(
       resource->identifier(), response, resource->resourceRequest().frameType(),
       resource->resourceRequest().requestContext(), resource);
   resource->responseReceived(response, std::move(handle));
   if (resource->loader() && response.httpStatusCode() >= 400 &&
       !resource->shouldIgnoreHTTPStatusCodeErrors()) {
-    resource->loader()->didFail(ResourceError::cancelledError(response.url()));
+    resource->loader()->didFail(ResourceError::cancelledError(response.url()),
+                                Resource::LoadError);
   }
 }
 
 void ResourceFetcher::didReceiveData(const Resource* resource,
                                      const char* data,
                                      int dataLength,
                                      int encodedDataLength) {
   context().dispatchDidReceiveData(resource->identifier(), data, dataLength,
                                    encodedDataLength);
 }
@@ skipping 374 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