Create errors (especially cancellation errors) internally to WebCore, rather

Source/WebCore/loader/DocumentLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer. 
@@ skipping 258 matching lines @@
         return;
     }
 
     // We might run in to infinite recursion if we're stopping loading as the result of 
     // detaching from the frame, so break out of that recursion here.
     // See <rdar://problem/9673866> for more details.
     if (m_isStopping)
         return;
 
     m_isStopping = true;
-
-    FrameLoader* frameLoader = DocumentLoader::frameLoader();
     
     if (isLoadingMainResource())
         // Stop the main resource loader and let it send the cancelled message.
-        cancelMainResourceLoad(frameLoader->cancelledError(m_request));
+        cancelMainResourceLoad(ResourceError::createCancelledError(m_request.url()));
     else if (!m_resourceLoaders.isEmpty())
         // The main resource loader already finished loading. Set the cancelled error on the 
         // document and let the resourceLoaders send individual cancelled messages below.
-        setMainDocumentError(frameLoader->cancelledError(m_request));
+        setMainDocumentError(ResourceError::createCancelledError(m_request.url()));
     else
         // If there are no resource loaders, we need to manufacture a cancelled message.
         // (A back/forward navigation has no resource loaders because its resources are cached.)
-        mainReceivedError(frameLoader->cancelledError(m_request));
+        mainReceivedError(ResourceError::createCancelledError(m_request.url()));
     
     stopLoadingSubresources();
     
     m_isStopping = false;
 }
 
 void DocumentLoader::commitIfReady()
 {
     if (!m_committed) {
         m_committed = true;
@@ skipping 116 matching lines @@
 
 void DocumentLoader::willSendRequest(ResourceRequest& newRequest, const ResourceResponse& redirectResponse)
 {
     // Note that there are no asserts here as there are for the other callbacks. This is due to the
     // fact that this "callback" is sent when starting every load, and the state of callback
     // deferrals plays less of a part in this function in preventing the bad behavior deferring 
     // callbacks is meant to prevent.
     ASSERT(!newRequest.isNull());
 
     if (!frameLoader()->checkIfFormActionAllowedByCSP(newRequest.url())) {
-        cancelMainResourceLoad(frameLoader()->cancelledError(newRequest));
+        cancelMainResourceLoad(ResourceError::createCancelledError(newRequest.url()));
         return;
     }
 
     ASSERT(timing()->fetchStart());
     if (!redirectResponse.isNull()) {
         // If the redirecting url is not allowed to display content from the target origin,
         // then block the redirect.
         RefPtr<SecurityOrigin> redirectingOrigin = SecurityOrigin::create(redirectResponse.url());
         if (!redirectingOrigin->canDisplay(newRequest.url())) {
             FrameLoader::reportLocalLoadFailed(m_frame, newRequest.url().string());
-            cancelMainResourceLoad(frameLoader()->cancelledError(newRequest));
+            cancelMainResourceLoad(ResourceError::createCancelledError(newRequest.url()));
             return;
         }
         timing()->addRedirect(redirectResponse.url(), newRequest.url());
     }
 
     // Update cookie policy base URL as URL changes, except for subframes, which use the
     // URL of the main frame which doesn't change when we redirect.
     if (frameLoader()->isLoadingMainFrame())
         newRequest.setFirstPartyForCookies(newRequest.url());
 
     // If we're fielding a redirect in response to a POST, force a load from origin, since
     // this is a common site technique to return to a page viewing some data that the POST
     // just modified.
     // Also, POST requests always load from origin, but this does not affect subresources.
     if (newRequest.cachePolicy() == UseProtocolCachePolicy && isPostOrRedirectAfterPost(newRequest, redirectResponse))
         newRequest.setCachePolicy(ReloadIgnoringCacheData);
 
     Frame* top = m_frame->tree()->top();
     if (top != m_frame) {
         if (!frameLoader()->mixedContentChecker()->canDisplayInsecureContent(top->document()->securityOrigin(), newRequest.url())) {
-            cancelMainResourceLoad(frameLoader()->cancelledError(newRequest));
+            cancelMainResourceLoad(ResourceError::createCancelledError(newRequest.url()));
             return;
         }
     }
 
     setRequest(newRequest);
 
     if (!redirectResponse.isNull()) {
         // We checked application cache for initial URL, now we need to check it for redirected one.
         ASSERT(!m_substituteData.isValid());
         m_applicationCacheHost->maybeLoadMainResourceForRedirect(newRequest, m_substituteData);
@@ skipping 60 matching lines @@
         ASSERT(m_mainResource);
         unsigned long identifier = m_identifierForLoadWithoutResourceLoader ? m_identifierForLoadWithoutResourceLoader : m_mainResource->identifier();
         ASSERT(identifier);
         if (frameLoader()->shouldInterruptLoadForXFrameOptions(content, response.url(), identifier)) {
             InspectorInstrumentation::continueAfterXFrameOptionsDenied(m_frame, this, identifier, response);
             String message = "Refused to display '" + response.url().elidedString() + "' in a frame because it set 'X-Frame-Options' to '" + content + "'.";
             frame()->document()->addConsoleMessage(SecurityMessageSource, ErrorMessageLevel, message, identifier);
             frame()->document()->enforceSandboxFlags(SandboxOrigin);
             if (HTMLFrameOwnerElement* ownerElement = frame()->ownerElement())
                 ownerElement->dispatchEvent(Event::create(eventNames().loadEvent, false, false));
-            cancelMainResourceLoad(frameLoader()->cancelledError(m_request));
+            cancelMainResourceLoad(ResourceError::createCancelledError(m_request.url()));
             return;
         }
     }
 
     ASSERT(!mainResourceLoader() || !mainResourceLoader()->defersLoading());
 
     if (m_isLoadingMultipartContent) {
         setupForReplace();
         m_mainResource->clear();
     } else if (response.isMultipart()) {
@@ skipping 32 matching lines @@
 
     KURL url = m_request.url();
     const String& mimeType = m_response.mimeType();
     
     switch (policy) {
     case PolicyUse: {
         // Prevent remote web archives from loading because they can claim to be from any domain and thus avoid cross-domain security checks (4120255).
         bool isRemoteWebArchive = equalIgnoringCase("multipart/related", mimeType)
             && !m_substituteData.isValid() && !SchemeRegistry::shouldTreatURLSchemeAsLocal(url.protocol());
         if (!frameLoader()->client()->canShowMIMEType(mimeType) || isRemoteWebArchive) {
-            frameLoader()->policyChecker()->cannotShowMIMEType(m_response);
-            // Check reachedTerminalState since the load may have already been canceled inside of _handleUnimplementablePolicyWithErrorCode::.
+            ASSERT_NOT_REACHED();
             stopLoadingForPolicyChange();
             return;
         }
         break;
     }
 
     case PolicyDownload: {
-        // m_mainResource can be null, e.g. when loading a substitute resource from application cache.
-        if (!m_mainResource) {
-            mainReceivedError(frameLoader()->client()->cannotShowURLError(m_request));
-            return;
-        }
+        ASSERT(m_mainResource);
         InspectorInstrumentation::continueWithPolicyDownload(m_frame, this, mainResourceLoader()->identifier(), m_response);
 
         // When starting the request, we didn't know that it would result in download and not navigation. Now we know that main document URL didn't change.
         // Download may use this knowledge for purposes unrelated to cookies, notably for setting file quarantine data.
         frameLoader()->setOriginalURLForDownloadRequest(m_request);
         return;
     }
     case PolicyIgnore:
         InspectorInstrumentation::continueWithPolicyIgnore(m_frame, this, mainResourceLoader()->identifier(), m_response);
         stopLoadingForPolicyChange();
         return;
     
     default:
         ASSERT_NOT_REACHED();
     }
 
     if (m_response.isHTTP()) {
         int status = m_response.httpStatusCode();
         if (status < 200 || status >= 300) {
             bool hostedByObject = frameLoader()->isHostedByObjectElement();
 
             frameLoader()->handleFallbackContent();
             // object elements are no longer rendered after we fallback, so don't
             // keep trying to process data from their load
 
             if (hostedByObject)
-                cancelMainResourceLoad(frameLoader()->cancelledError(m_request));
+                cancelMainResourceLoad(ResourceError::createCancelledError(m_request.url()));
         }
     }
 
     if (!isStopping() && m_substituteData.isValid()) {
         if (m_substituteData.content()->size())
             dataReceived(0, m_substituteData.content()->data(), m_substituteData.content()->size());
         if (isLoadingMainResource())
             finishedLoading(0);
     }
 }
@@ skipping 12 matching lines @@
 
     commitIfReady();
     FrameLoader* frameLoader = DocumentLoader::frameLoader();
     if (!frameLoader)
         return;
     if (isArchiveMIMEType(response().mimeType()))
         return;
     frameLoader->client()->committedLoad(this, data, length);
 }
 
-ResourceError DocumentLoader::interruptedForPolicyChangeError() const
-{
-    return frameLoader()->client()->interruptedForPolicyChangeError(request());
-}
-
 void DocumentLoader::stopLoadingForPolicyChange()
 {
-    ResourceError error = interruptedForPolicyChangeError();
+    ResourceError error = ResourceError::createPolicyChangeError(m_request.url());
     error.setIsCancellation(true);
     cancelMainResourceLoad(error);
 }
 
 void DocumentLoader::commitData(const char* bytes, size_t length)
 {
     if (!m_gotFirstByte) {
         m_gotFirstByte = true;
         m_writer.begin(documentURL(), false);
         m_writer.setDocumentWasLoadedAsPartOfNavigation();
@@ skipping 233 matching lines @@
     if (m_frame->page()->defersLoading())
         return;
 
     SubstituteResourceMap copy;
     copy.swap(m_pendingSubstituteResources);
 
     SubstituteResourceMap::const_iterator end = copy.end();
     for (SubstituteResourceMap::const_iterator it = copy.begin(); it != end; ++it) {
         RefPtr<ResourceLoader> loader = it->key;
         SubstituteResource* resource = it->value.get();
+        ASSERT(resource);
         
         if (resource) {
             SharedBuffer* data = resource->data();
         
             loader->didReceiveResponse(0, resource->response());
 
             // Calling ResourceLoader::didReceiveResponse can end up cancelling the load,
             // so we need to check if the loader has reached its terminal state.
             if (loader->reachedTerminalState())
                 return;
 
             loader->didReceiveData(0, data->data(), data->size(), data->size());
 
             // Calling ResourceLoader::didReceiveData can end up cancelling the load,
             // so we need to check if the loader has reached its terminal state.
             if (loader->reachedTerminalState())
                 return;
 
             loader->didFinishLoading(0, 0);
-        } else {
-            // A null resource means that we should fail the load.
-            // FIXME: Maybe we should use another error here - something like "not in cache".
-            loader->didFail(0, loader->cannotShowURLError());
         }
     }
 }
 
 #ifndef NDEBUG
 bool DocumentLoader::isSubstituteLoadPending(ResourceLoader* loader) const
 {
     return m_pendingSubstituteResources.contains(loader);
 }
 #endif
@@ skipping 198 matching lines @@
     // If there was a fragment identifier on m_request, the cache will have stripped it. m_request should include
     // the fragment identifier, so add that back in.
     if (equalIgnoringFragmentIdentifier(m_request.url(), request.url()))
         request.setURL(m_request.url());
     setRequest(request);
 }
 
 void DocumentLoader::cancelMainResourceLoad(const ResourceError& resourceError)
 {
     RefPtr<DocumentLoader> protect(this);
-    ResourceError error = resourceError.isNull() ? frameLoader()->cancelledError(m_request) : resourceError;
+    ResourceError error = resourceError.isNull() ? ResourceError::createCancelledError(m_request.url()) : resourceError;
 
     m_dataLoadTimer.stop();
     if (m_waitingForContentPolicy) {
         frameLoader()->policyChecker()->cancelCheck();
         ASSERT(m_waitingForContentPolicy);
         m_waitingForContentPolicy = false;
     }
 
     if (mainResourceLoader())
         mainResourceLoader()->cancel(error);
@@ skipping 21 matching lines @@
     commitLoad(resourceData->data(), resourceData->size());
 }
 
 void DocumentLoader::handledOnloadEvents()
 {
     m_wasOnloadHandled = true;
     applicationCacheHost()->stopDeferringEvents();
 }
 
 } // namespace WebCore