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

Source/WebKit/chromium/src/FrameLoaderClientImpl.cpp

 /*
  * Copyright (C) 2009, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2011 Apple 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 725 matching lines @@
 void FrameLoaderClientImpl::dispatchDidFailProvisionalLoad(
     const ResourceError& error)
 {
 
     // If a policy change occured, then we do not want to inform the plugin
     // delegate.  See http://b/907789 for details.  FIXME: This means the
     // plugin won't receive NPP_URLNotify, which seems like it could result in
     // a memory leak in the plugin!!
     if (error.domain() == internalErrorDomain
         && error.errorCode() == PolicyChangeError) {
-        m_webFrame->didFail(ResourceError::cancelledError(error.failingURL()), true);
+        m_webFrame->didFail(cancelledError(error.failingURL()), true);
         return;
     }
 
     OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver();
     m_webFrame->didFail(error, true);
     if (observer)
         observer->didFailLoading(error);
 }
 
 void FrameLoaderClientImpl::dispatchDidFailLoad(const ResourceError& error)
@@ skipping 129 matching lines @@
             return PolicyDownload;
         else if (navigationPolicy != WebNavigationPolicyIgnore) {
                 WrappedResourceRequest webreq(request);
                 m_webFrame->client()->loadURLExternally(m_webFrame, webreq, navigationPolicy);
         }
     }
 
     return PolicyIgnore;
 }
 
+void FrameLoaderClientImpl::dispatchUnableToImplementPolicy(const ResourceError& error)
+{
+    m_webFrame->client()->unableToImplementPolicyWithError(m_webFrame, error);
+}
+
 void FrameLoaderClientImpl::dispatchWillRequestResource(CachedResourceRequest* request)
 {
     if (m_webFrame->client()) {
         WebCachedURLRequest urlRequest(request);
         m_webFrame->client()->willRequestResource(m_webFrame, urlRequest);
     }
 }
 
 void FrameLoaderClientImpl::dispatchWillSendSubmitEvent(PassRefPtr<FormState> prpFormState)
 {
@@ skipping 63 matching lines @@
             bool preventDefault = false;
             m_webFrame->client()->didReceiveDocumentData(m_webFrame, data, length, preventDefault);
             if (!preventDefault)
                 m_webFrame->commitDocumentData(data, length);
         }
     }
 
     // If we are sending data to MediaDocument, we should stop here
     // and cancel the request.
     if (m_webFrame->frame()->document()->isMediaDocument())
-        loader->cancelMainResourceLoad(ResourceError::cancelledError(loader->response().url()));
+        loader->cancelMainResourceLoad(pluginWillHandleLoadError(loader->response()));
 
     // The plugin widget could have been created in the m_webFrame->DidReceiveData
     // function.
     if (m_pluginWidget) {
         if (!m_sentInitialResponseToPlugin) {
             m_sentInitialResponseToPlugin = true;
             m_pluginWidget->didReceiveResponse(
                 m_webFrame->frame()->loader()->activeDocumentLoader()->response());
         }
 
@@ skipping 68 matching lines @@
     if (m_webFrame->client())
         m_webFrame->client()->didRunInsecureContent(m_webFrame, WebSecurityOrigin(origin), insecureURL);
 }
 
 void FrameLoaderClientImpl::didDetectXSS(const KURL& insecureURL, bool didBlockEntirePage)
 {
     if (m_webFrame->client())
         m_webFrame->client()->didDetectXSS(m_webFrame, insecureURL, didBlockEntirePage);
 }
 
+ResourceError FrameLoaderClientImpl::cancelledError(const ResourceRequest& request)
+{
+    if (!m_webFrame->client())
+        return ResourceError();
+
+    return m_webFrame->client()->cancelledError(
+        m_webFrame, WrappedResourceRequest(request));
+}
+
+ResourceError FrameLoaderClientImpl::cannotShowURLError(const ResourceRequest& request)
+{
+    if (!m_webFrame->client())
+        return ResourceError();
+
+    return m_webFrame->client()->cannotHandleRequestError(
+        m_webFrame, WrappedResourceRequest(request));
+}
+
 ResourceError FrameLoaderClientImpl::interruptedForPolicyChangeError(
     const ResourceRequest& request)
 {
     return ResourceError(internalErrorDomain, PolicyChangeError,
                          request.url().string(), String());
 }
 
+ResourceError FrameLoaderClientImpl::cannotShowMIMETypeError(const ResourceResponse&)
+{
+    // FIXME
+    return ResourceError();
+}
+
+ResourceError FrameLoaderClientImpl::fileDoesNotExistError(const ResourceResponse&)
+{
+    // FIXME
+    return ResourceError();
+}
+
+ResourceError FrameLoaderClientImpl::pluginWillHandleLoadError(const ResourceResponse&)
+{
+    // FIXME
+    return ResourceError();
+}
+
+bool FrameLoaderClientImpl::shouldFallBack(const ResourceError& error)
+{
+    // This method is called when we fail to load the URL for an <object> tag
+    // that has fallback content (child elements) and is being loaded as a frame.
+    // The error parameter indicates the reason for the load failure.
+    // We should let the fallback content load only if this wasn't a cancelled
+    // request.
+    // Note: The mac version also has a case for "WebKitErrorPluginWillHandleLoad"
+    ResourceError c = cancelledError(ResourceRequest());
+    return error.errorCode() != c.errorCode() || error.domain() != c.domain();
+}
+
+bool FrameLoaderClientImpl::canHandleRequest(const ResourceRequest& request) const
+{
+    return m_webFrame->client()->canHandleRequest(
+        m_webFrame, WrappedResourceRequest(request));
+}
+
 bool FrameLoaderClientImpl::canShowMIMEType(const String& mimeType) const
 {
     // This method is called to determine if the media type can be shown
     // "internally" (i.e. inside the browser) regardless of whether or not the
     // browser or a plugin is doing the rendering.
 
     // mimeType strings are supposed to be ASCII, but if they are not for some
     // reason, then it just means that the mime type will fail all of these "is
     // supported" checks and go down the path of an unhandled mime type.
     if (WebKit::Platform::current()->mimeRegistry()->supportsMIMEType(mimeType) == WebMimeRegistry::IsSupported)
@@ skipping 266 matching lines @@
         m_webFrame->client()->didLoseWebGLContext(m_webFrame, arbRobustnessContextLostReason);
 }
 
 void FrameLoaderClientImpl::dispatchWillInsertBody()
 {
     if (m_webFrame->client())
         m_webFrame->client()->willInsertBody(m_webFrame);
 }
 
 } // namespace WebKit