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 80 matching lines @@
 #include <public/WebVector.h>
 #include <v8.h>
 #include <wtf/StringExtras.h>
 #include <wtf/text/CString.h>
 #include <wtf/text/WTFString.h>
 
 using namespace WebCore;
 
 namespace WebKit {
 
-// Domain for internal error codes.
-static const char internalErrorDomain[] = "WebKit";
-
-// An internal error code.  Used to note a policy change error resulting from
-// dispatchDecidePolicyForMIMEType not passing the PolicyUse option.
-enum {
-    PolicyChangeError = -10000,
-};
-
 FrameLoaderClientImpl::FrameLoaderClientImpl(WebFrameImpl* frame)
     : m_webFrame(frame)
     , m_sentInitialResponseToPlugin(false)
     , m_nextNavigationPolicy(WebNavigationPolicyIgnore)
 {
 }
 
 FrameLoaderClientImpl::~FrameLoaderClientImpl()
 {
 }
@@ skipping 630 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(cancelledError(error.failingURL()), true);
+    if (error.domain() == errorDomainWebKitInternal
+        && error.errorCode() == policyChangeError) {
+        m_webFrame->didFail(ResourceError::createCancelledError(error.failingURL()), true);

[Nate Chapin, 2013/04/16 20:40:43]

This is the only usage for policy change errors, afaict.

         return;
     }
 
     OwnPtr<WebPluginLoadObserver> observer = pluginLoadObserver();
     m_webFrame->didFail(error, true);
     if (observer)
         observer->didFailLoading(error);
 }
 
 void FrameLoaderClientImpl::dispatchDidFailLoad(const ResourceError& error)
@@ skipping 181 matching lines @@
                 WrappedResourceRequest webreq(request);
                 m_webFrame->client()->loadURLExternally(m_webFrame, webreq, navigationPolicy);
             }
             policyAction = PolicyIgnore;
         }
     }
 
     (m_webFrame->frame()->loader()->policyChecker()->*function)(policyAction);
 }
 
-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 65 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(pluginWillHandleLoadError(loader->response()));
+        loader->cancelMainResourceLoad(ResourceError::createCancelledError(loader->url()));
 
     // 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