Title: [194419] trunk/Source
Revision
194419
Author
[email protected]
Date
2015-12-25 04:22:16 -0800 (Fri, 25 Dec 2015)

Log Message

ResourceError should store failingURL as URL instead of String to avoid reparsing and to address FIXME comments in ResourceErrorCF.cpp and ResourceErrorMac.mm
<http://webkit.org/b/146391>

Reviewed by Antti Koivisto.

Source/WebCore:

* loader/DocumentThreadableLoader.cpp:
(WebCore::DocumentThreadableLoader::DocumentThreadableLoader):
(WebCore::DocumentThreadableLoader::makeSimpleCrossOriginAccessRequest):
(WebCore::DocumentThreadableLoader::didReceiveResponse):
(WebCore::DocumentThreadableLoader::preflightFailure):
* loader/DocumentThreadableLoader.h:
(WebCore::DocumentThreadableLoader::preflightFailure):
- Switch type of 'url' argument of preflightFailure() from
  String to URL.
- Update for type change of 'failingURL' argument to
  ResourceError().

* loader/EmptyClients.h:
* loader/FrameLoader.cpp:
(WebCore::FrameLoader::loadResourceSynchronously):
* loader/MediaResourceLoader.cpp:
(WebCore::MediaResourceLoader::responseReceived):
* loader/ResourceLoader.cpp:
(WebCore::ResourceLoader::loadDataURL):
* loader/WorkerThreadableLoader.cpp:
(WebCore::WorkerThreadableLoader::MainThreadBridge::cancel):
* loader/cache/CachedResourceLoader.cpp:
(WebCore::CachedResourceLoader::requestResource):
- Update for type change of 'failingURL' argument to
  ResourceError().

* page/EventSource.cpp:
(WebCore::EventSource::didFailAccessControlCheck):
- Convert failingURL() to String explicitly.

* platform/efl/ErrorsEfl.cpp:
(WebCore::cancelledError):
(WebCore::blockedError):
(WebCore::blockedByContentBlockerError):
(WebCore::cannotShowURLError):
(WebCore::interruptedForPolicyChangeError):
(WebCore::cannotShowMIMETypeError):
(WebCore::fileDoesNotExistError):
(WebCore::pluginWillHandleLoadError):
(WebCore::downloadCancelledByUserError):
(WebCore::downloadDestinationError):
* platform/gtk/ErrorsGtk.cpp:
(WebCore::cancelledError):
(WebCore::blockedError):
(WebCore::blockedByContentBlockerError):
(WebCore::cannotShowURLError):
(WebCore::interruptedForPolicyChangeError):
(WebCore::cannotShowMIMETypeError):
(WebCore::fileDoesNotExistError):
(WebCore::pluginWillHandleLoadError):
(WebCore::downloadCancelledByUserError):
(WebCore::downloadDestinationError):
- Update for type change of 'failingURL' argument to
  ResourceError().

* platform/network/ResourceErrorBase.h:
(WebCore::ResourceErrorBase::failingURL):
- Change return type from String to URL.
(WebCore::ResourceErrorBase::ResourceErrorBase):
* platform/network/cf/ResourceError.h:
(WebCore::ResourceError::ResourceError):
- Change type of 'failingURL' from String to URL.

* platform/network/cf/ResourceErrorCF.cpp:
(WebCore::ResourceError::ResourceError):
- Change type of 'failingURL' from String to URL.
(WebCore::ResourceError::platformLazyInit):
- Clean up code and address FIXME by parsing CFURLRef using
  URL() constructor.
(WebCore::ResourceError::cfError):
- Clean up code and address FIXME after switching type of
  m_failingURL.

* platform/network/curl/ResourceError.h:
(WebCore::ResourceError::ResourceError):
- Change type of 'failingURL' from String to URL.

* platform/network/mac/ResourceErrorMac.mm:
(WebCore::createNSErrorFromResourceErrorBase):
(WebCore::ResourceError::platformLazyInit):
- Clean up code and address FIXME after switching type of
  m_failingURL.

* platform/network/soup/ResourceError.h:
(WebCore::ResourceError::ResourceError):
(WebCore::ResourceError::timeoutError):
* platform/network/soup/ResourceErrorSoup.cpp:
(WebCore::failingURI):
(WebCore::ResourceError::timeoutError):
* platform/network/soup/ResourceHandleSoup.cpp:
(WebCore::ResourceHandle::timeoutFired):
- Change type of 'failingURL' from String to URL.

* xml/XMLHttpRequest.cpp:
(WebCore::XMLHttpRequest::didFail):
- Convert failingURL() to String explicitly.
- Also switch to using makeString().

Source/WebKit/win:

* WebCoreSupport/WebFrameLoaderClient.cpp:
(WebFrameLoaderClient::cancelledError):
(WebFrameLoaderClient::blockedError):
(WebFrameLoaderClient::cannotShowURLError):
(WebFrameLoaderClient::interruptedForPolicyChangeError):
(WebFrameLoaderClient::cannotShowMIMETypeError):
(WebFrameLoaderClient::fileDoesNotExistError):
(WebFrameLoaderClient::pluginWillHandleLoadError):
(WebFrameLoaderClient::dispatchDidFailToStartPlugin):
(WebFrameLoaderClient::createJavaAppletWidget):
* WebDownloadCFNet.cpp:
(WebDownload::cancelAuthenticationChallenge):
* WebError.cpp:
(WebError::init):
- Update for type change of 'failingURL' argument to
  ResourceError().

Source/WebKit2:

* NetworkProcess/Downloads/efl/DownloadSoupErrorsEfl.cpp:
(WebKit::platformDownloadNetworkError):
* NetworkProcess/Downloads/gtk/DownloadSoupErrorsGtk.cpp:
(WebKit::platformDownloadNetworkError):
* NetworkProcess/Downloads/soup/DownloadSoup.cpp:
(WebKit::DownloadClient::didReceiveResponse):
* NetworkProcess/Downloads/soup/DownloadSoupErrors.h:
* Shared/soup/WebCoreArgumentCodersSoup.cpp:
(IPC::ArgumentCoder<ResourceError>::encodePlatformData):
(IPC::ArgumentCoder<ResourceError>::decodePlatformData):
* UIProcess/API/gtk/WebKitLoaderClient.cpp:
(LoaderClient::didFailProvisionalLoadWithErrorForFrame):
(LoaderClient::didFailLoadWithErrorForFrame):
* UIProcess/API/gtk/WebKitURISchemeRequest.cpp:
(webkit_uri_scheme_request_finish_error):
* WebProcess/WebCoreSupport/efl/WebErrorsEfl.cpp:
(WebKit::internalError):
* WebProcess/WebCoreSupport/gtk/WebErrorsGtk.cpp:
(WebKit::internalError):
- Update for type change of 'failingURL' argument to
  ResourceError().

Modified Paths

Diff

Modified: trunk/Source/WebCore/ChangeLog (194418 => 194419)


--- trunk/Source/WebCore/ChangeLog	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/ChangeLog	2015-12-25 12:22:16 UTC (rev 194419)
@@ -1,3 +1,108 @@
+2015-12-25  David Kilzer  <[email protected]>
+
+        ResourceError should store failingURL as URL instead of String to avoid reparsing and to address FIXME comments in ResourceErrorCF.cpp and ResourceErrorMac.mm
+        <http://webkit.org/b/146391>
+
+        Reviewed by Antti Koivisto.
+
+        * loader/DocumentThreadableLoader.cpp:
+        (WebCore::DocumentThreadableLoader::DocumentThreadableLoader):
+        (WebCore::DocumentThreadableLoader::makeSimpleCrossOriginAccessRequest):
+        (WebCore::DocumentThreadableLoader::didReceiveResponse):
+        (WebCore::DocumentThreadableLoader::preflightFailure):
+        * loader/DocumentThreadableLoader.h:
+        (WebCore::DocumentThreadableLoader::preflightFailure):
+        - Switch type of 'url' argument of preflightFailure() from
+          String to URL.
+        - Update for type change of 'failingURL' argument to
+          ResourceError().
+
+        * loader/EmptyClients.h:
+        * loader/FrameLoader.cpp:
+        (WebCore::FrameLoader::loadResourceSynchronously):
+        * loader/MediaResourceLoader.cpp:
+        (WebCore::MediaResourceLoader::responseReceived):
+        * loader/ResourceLoader.cpp:
+        (WebCore::ResourceLoader::loadDataURL):
+        * loader/WorkerThreadableLoader.cpp:
+        (WebCore::WorkerThreadableLoader::MainThreadBridge::cancel):
+        * loader/cache/CachedResourceLoader.cpp:
+        (WebCore::CachedResourceLoader::requestResource):
+        - Update for type change of 'failingURL' argument to
+          ResourceError().
+
+        * page/EventSource.cpp:
+        (WebCore::EventSource::didFailAccessControlCheck):
+        - Convert failingURL() to String explicitly.
+
+        * platform/efl/ErrorsEfl.cpp:
+        (WebCore::cancelledError):
+        (WebCore::blockedError):
+        (WebCore::blockedByContentBlockerError):
+        (WebCore::cannotShowURLError):
+        (WebCore::interruptedForPolicyChangeError):
+        (WebCore::cannotShowMIMETypeError):
+        (WebCore::fileDoesNotExistError):
+        (WebCore::pluginWillHandleLoadError):
+        (WebCore::downloadCancelledByUserError):
+        (WebCore::downloadDestinationError):
+        * platform/gtk/ErrorsGtk.cpp:
+        (WebCore::cancelledError):
+        (WebCore::blockedError):
+        (WebCore::blockedByContentBlockerError):
+        (WebCore::cannotShowURLError):
+        (WebCore::interruptedForPolicyChangeError):
+        (WebCore::cannotShowMIMETypeError):
+        (WebCore::fileDoesNotExistError):
+        (WebCore::pluginWillHandleLoadError):
+        (WebCore::downloadCancelledByUserError):
+        (WebCore::downloadDestinationError):
+        - Update for type change of 'failingURL' argument to
+          ResourceError().
+
+        * platform/network/ResourceErrorBase.h:
+        (WebCore::ResourceErrorBase::failingURL):
+        - Change return type from String to URL.
+        (WebCore::ResourceErrorBase::ResourceErrorBase):
+        * platform/network/cf/ResourceError.h:
+        (WebCore::ResourceError::ResourceError):
+        - Change type of 'failingURL' from String to URL.
+
+        * platform/network/cf/ResourceErrorCF.cpp:
+        (WebCore::ResourceError::ResourceError):
+        - Change type of 'failingURL' from String to URL.
+        (WebCore::ResourceError::platformLazyInit):
+        - Clean up code and address FIXME by parsing CFURLRef using
+          URL() constructor.
+        (WebCore::ResourceError::cfError):
+        - Clean up code and address FIXME after switching type of
+          m_failingURL.
+
+        * platform/network/curl/ResourceError.h:
+        (WebCore::ResourceError::ResourceError):
+        - Change type of 'failingURL' from String to URL.
+
+        * platform/network/mac/ResourceErrorMac.mm:
+        (WebCore::createNSErrorFromResourceErrorBase):
+        (WebCore::ResourceError::platformLazyInit):
+        - Clean up code and address FIXME after switching type of
+          m_failingURL.
+
+        * platform/network/soup/ResourceError.h:
+        (WebCore::ResourceError::ResourceError):
+        (WebCore::ResourceError::timeoutError):
+        * platform/network/soup/ResourceErrorSoup.cpp:
+        (WebCore::failingURI):
+        (WebCore::ResourceError::timeoutError):
+        * platform/network/soup/ResourceHandleSoup.cpp:
+        (WebCore::ResourceHandle::timeoutFired):
+        - Change type of 'failingURL' from String to URL.
+
+        * xml/XMLHttpRequest.cpp:
+        (WebCore::XMLHttpRequest::didFail):
+        - Convert failingURL() to String explicitly.
+        - Also switch to using makeString().
+
 2015-12-24  Zalan Bujtas  <[email protected]>
 
         ASSERTION FAILED: x2 >= x1 in WebCore::RenderElement::drawLineForBoxSide

Modified: trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp (194418 => 194419)


--- trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -85,7 +85,7 @@
     }
 
     if (m_options.crossOriginRequestPolicy == DenyCrossOriginRequests) {
-        m_client->didFail(ResourceError(errorDomainWebKitInternal, 0, request.url().string(), "Cross origin requests are not supported."));
+        m_client->didFail(ResourceError(errorDomainWebKitInternal, 0, request.url(), "Cross origin requests are not supported."));
         return;
     }
 
@@ -119,7 +119,7 @@
 
     // Cross-origin requests are only allowed for HTTP and registered schemes. We would catch this when checking response headers later, but there is no reason to send a request that's guaranteed to be denied.
     if (!SchemeRegistry::shouldTreatURLSchemeAsCORSEnabled(request.url().protocol())) {
-        m_client->didFailAccessControlCheck(ResourceError(errorDomainWebKitInternal, 0, request.url().string(), "Cross origin requests are only supported for HTTP."));
+        m_client->didFailAccessControlCheck(ResourceError(errorDomainWebKitInternal, 0, request.url(), "Cross origin requests are only supported for HTTP."));
         return;
     }
 
@@ -261,7 +261,7 @@
     } else {
         if (!m_sameOriginRequest && m_options.crossOriginRequestPolicy == UseAccessControl) {
             if (!passesAccessControlCheck(response, m_options.allowCredentials(), securityOrigin(), accessControlErrorDescription)) {
-                m_client->didFailAccessControlCheck(ResourceError(errorDomainWebKitInternal, 0, response.url().string(), accessControlErrorDescription));
+                m_client->didFailAccessControlCheck(ResourceError(errorDomainWebKitInternal, 0, response.url(), accessControlErrorDescription));
                 return;
             }
         }
@@ -333,7 +333,7 @@
     loadRequest(*actualRequest, SkipSecurityCheck);
 }
 
-void DocumentThreadableLoader::preflightFailure(unsigned long identifier, const String& url, const String& errorDescription)
+void DocumentThreadableLoader::preflightFailure(unsigned long identifier, const URL& url, const String& errorDescription)
 {
     ResourceError error(errorDomainWebKitInternal, 0, url, errorDescription);
     if (m_actualRequest)

Modified: trunk/Source/WebCore/loader/DocumentThreadableLoader.h (194418 => 194419)


--- trunk/Source/WebCore/loader/DocumentThreadableLoader.h	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/loader/DocumentThreadableLoader.h	2015-12-25 12:22:16 UTC (rev 194419)
@@ -91,7 +91,7 @@
         void makeSimpleCrossOriginAccessRequest(const ResourceRequest& request);
         void makeCrossOriginAccessRequestWithPreflight(const ResourceRequest& request);
         void preflightSuccess();
-        void preflightFailure(unsigned long identifier, const String& url, const String& errorDescription);
+        void preflightFailure(unsigned long identifier, const URL&, const String& errorDescription);
 
         void loadRequest(const ResourceRequest&, SecurityCheckPolicy);
         bool isAllowedRedirect(const URL&);

Modified: trunk/Source/WebCore/loader/EmptyClients.h (194418 => 194419)


--- trunk/Source/WebCore/loader/EmptyClients.h	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/loader/EmptyClients.h	2015-12-25 12:22:16 UTC (rev 194419)
@@ -320,15 +320,15 @@
     virtual void committedLoad(DocumentLoader*, const char*, int) override { }
     virtual void finishedLoading(DocumentLoader*) override { }
 
-    virtual ResourceError cancelledError(const ResourceRequest&) override { ResourceError error("", 0, "", ""); error.setIsCancellation(true); return error; }
-    virtual ResourceError blockedError(const ResourceRequest&) override { return ResourceError("", 0, "", ""); }
-    virtual ResourceError blockedByContentBlockerError(const ResourceRequest&) override { return ResourceError("", 0, "", ""); }
-    virtual ResourceError cannotShowURLError(const ResourceRequest&) override { return ResourceError("", 0, "", ""); }
-    virtual ResourceError interruptedForPolicyChangeError(const ResourceRequest&) override { return ResourceError("", 0, "", ""); }
+    virtual ResourceError cancelledError(const ResourceRequest&) override { ResourceError error("", 0, URL(), ""); error.setIsCancellation(true); return error; }
+    virtual ResourceError blockedError(const ResourceRequest&) override { return ResourceError("", 0, URL(), ""); }
+    virtual ResourceError blockedByContentBlockerError(const ResourceRequest&) override { return ResourceError("", 0, URL(), ""); }
+    virtual ResourceError cannotShowURLError(const ResourceRequest&) override { return ResourceError("", 0, URL(), ""); }
+    virtual ResourceError interruptedForPolicyChangeError(const ResourceRequest&) override { return ResourceError("", 0, URL(), ""); }
 
-    virtual ResourceError cannotShowMIMETypeError(const ResourceResponse&) override { return ResourceError("", 0, "", ""); }
-    virtual ResourceError fileDoesNotExistError(const ResourceResponse&) override { return ResourceError("", 0, "", ""); }
-    virtual ResourceError pluginWillHandleLoadError(const ResourceResponse&) override { return ResourceError("", 0, "", ""); }
+    virtual ResourceError cannotShowMIMETypeError(const ResourceResponse&) override { return ResourceError("", 0, URL(), ""); }
+    virtual ResourceError fileDoesNotExistError(const ResourceResponse&) override { return ResourceError("", 0, URL(), ""); }
+    virtual ResourceError pluginWillHandleLoadError(const ResourceResponse&) override { return ResourceError("", 0, URL(), ""); }
 
     virtual bool shouldFallBack(const ResourceError&) override { return false; }
 

Modified: trunk/Source/WebCore/loader/FrameLoader.cpp (194418 => 194419)


--- trunk/Source/WebCore/loader/FrameLoader.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/loader/FrameLoader.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -2686,7 +2686,7 @@
             if (auto* controller = page->userContentController()) {
                 if (m_documentLoader && controller->processContentExtensionRulesForLoad(newRequest, ResourceType::Raw, *m_documentLoader) == ContentExtensions::BlockedStatus::Blocked) {
                     newRequest = { };
-                    error = ResourceError(errorDomainWebKitInternal, 0, initialRequest.url().string(), emptyString());
+                    error = ResourceError(errorDomainWebKitInternal, 0, initialRequest.url(), emptyString());
                     response = { };
                     data = ""
                 }

Modified: trunk/Source/WebCore/loader/MediaResourceLoader.cpp (194418 => 194419)


--- trunk/Source/WebCore/loader/MediaResourceLoader.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/loader/MediaResourceLoader.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -100,7 +100,7 @@
         static NeverDestroyed<const String> consoleMessage("Cross-origin media resource load denied by Cross-Origin Resource Sharing policy.");
         m_document.addConsoleMessage(MessageSource::Security, MessageLevel::Error, consoleMessage.get());
         m_didPassAccessControlCheck = false;
-        m_client->accessControlCheckFailed(ResourceError(errorDomainWebKitInternal, 0, response.url().string(), consoleMessage.get()));
+        m_client->accessControlCheckFailed(ResourceError(errorDomainWebKitInternal, 0, response.url(), consoleMessage.get()));
         stop();
         return;
     }

Modified: trunk/Source/WebCore/loader/ResourceLoader.cpp (194418 => 194419)


--- trunk/Source/WebCore/loader/ResourceLoader.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/loader/ResourceLoader.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -257,7 +257,7 @@
         if (loader->reachedTerminalState())
             return;
         if (!decodeResult) {
-            loader->didFail(ResourceError(errorDomainWebKitInternal, 0, url.string(), "Data URL decoding failed"));
+            loader->didFail(ResourceError(errorDomainWebKitInternal, 0, url, "Data URL decoding failed"));
             return;
         }
         if (loader->wasCancelled())

Modified: trunk/Source/WebCore/loader/WorkerThreadableLoader.cpp (194418 => 194419)


--- trunk/Source/WebCore/loader/WorkerThreadableLoader.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/loader/WorkerThreadableLoader.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -139,7 +139,7 @@
     if (!clientWrapper->done()) {
         // If the client hasn't reached a termination state, then transition it by sending a cancellation error.
         // Note: no more client callbacks will be done after this method -- the clearClientWrapper() call ensures that.
-        ResourceError error(String(), 0, String(), String());
+        ResourceError error(String(), 0, URL(), String());
         error.setIsCancellation(true);
         clientWrapper->didFail(error);
     }

Modified: trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp (194418 => 194419)


--- trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -544,7 +544,7 @@
                 auto resource = createResource(type, request.mutableResourceRequest(), request.charset(), sessionID());
                 ASSERT(resource);
                 resource->error(CachedResource::Status::LoadError);
-                resource->setResourceError(ResourceError(ContentExtensions::WebKitContentBlockerDomain, 0, request.resourceRequest().url().string(), WEB_UI_STRING("The URL was blocked by a content blocker", "WebKitErrorBlockedByContentBlocker description")));
+                resource->setResourceError(ResourceError(ContentExtensions::WebKitContentBlockerDomain, 0, request.resourceRequest().url(), WEB_UI_STRING("The URL was blocked by a content blocker", "WebKitErrorBlockedByContentBlocker description")));
                 return resource;
             }
             return nullptr;

Modified: trunk/Source/WebCore/page/EventSource.cpp (194418 => 194419)


--- trunk/Source/WebCore/page/EventSource.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/page/EventSource.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -273,7 +273,7 @@
 
 void EventSource::didFailAccessControlCheck(const ResourceError& error)
 {
-    String message = makeString("EventSource cannot load ", error.failingURL(), ". ", error.localizedDescription());
+    String message = makeString("EventSource cannot load ", error.failingURL().string(), ". ", error.localizedDescription());
     scriptExecutionContext()->addConsoleMessage(MessageSource::JS, MessageLevel::Error, message);
 
     abortConnectionAttempt();

Modified: trunk/Source/WebCore/platform/efl/ErrorsEfl.cpp (194418 => 194419)


--- trunk/Source/WebCore/platform/efl/ErrorsEfl.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/platform/efl/ErrorsEfl.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -34,42 +34,42 @@
 
 ResourceError cancelledError(const ResourceRequest& request)
 {
-    return ResourceError(errorDomainNetwork, NetworkErrorCancelled, request.url().string(), ASCIILiteral("Load request cancelled"));
+    return ResourceError(errorDomainNetwork, NetworkErrorCancelled, request.url(), ASCIILiteral("Load request cancelled"));
 }
 
 ResourceError blockedError(const ResourceRequest& request)
 {
-    return ResourceError(errorDomainPolicy, PolicyErrorCannotUseRestrictedPort, request.url().string(), ASCIILiteral("Not allowed to use restricted network port"));
+    return ResourceError(errorDomainPolicy, PolicyErrorCannotUseRestrictedPort, request.url(), ASCIILiteral("Not allowed to use restricted network port"));
 }
 
 ResourceError blockedByContentBlockerError(const ResourceRequest& request)
 {
-    return ResourceError(errorDomainPolicy, PolicyErrorBlockedByContentBlocker, request.url().string(), ASCIILiteral("Blocked by content blocker"));
+    return ResourceError(errorDomainPolicy, PolicyErrorBlockedByContentBlocker, request.url(), ASCIILiteral("Blocked by content blocker"));
 }
 
 ResourceError cannotShowURLError(const ResourceRequest& request)
 {
-    return ResourceError(errorDomainPolicy, PolicyErrorCannotShowURL, request.url().string(), ASCIILiteral("URL cannot be shown"));
+    return ResourceError(errorDomainPolicy, PolicyErrorCannotShowURL, request.url(), ASCIILiteral("URL cannot be shown"));
 }
 
 ResourceError interruptedForPolicyChangeError(const ResourceRequest& request)
 {
-    return ResourceError(errorDomainPolicy, PolicyErrorFrameLoadInterruptedByPolicyChange, request.url().string(), ASCIILiteral("Frame load was interrupted"));
+    return ResourceError(errorDomainPolicy, PolicyErrorFrameLoadInterruptedByPolicyChange, request.url(), ASCIILiteral("Frame load was interrupted"));
 }
 
 ResourceError cannotShowMIMETypeError(const ResourceResponse& response)
 {
-    return ResourceError(errorDomainPolicy, PolicyErrorCannotShowMimeType, response.url().string(), ASCIILiteral("Content with the specified MIME type cannot be shown"));
+    return ResourceError(errorDomainPolicy, PolicyErrorCannotShowMimeType, response.url(), ASCIILiteral("Content with the specified MIME type cannot be shown"));
 }
 
 ResourceError fileDoesNotExistError(const ResourceResponse& response)
 {
-    return ResourceError(errorDomainNetwork, NetworkErrorFileDoesNotExist, response.url().string(), ASCIILiteral("File does not exist"));
+    return ResourceError(errorDomainNetwork, NetworkErrorFileDoesNotExist, response.url(), ASCIILiteral("File does not exist"));
 }
 
 ResourceError pluginWillHandleLoadError(const ResourceResponse& response)
 {
-    return ResourceError(errorDomainPlugin, PluginErrorWillHandleLoad, response.url().string(), ASCIILiteral("Plugin will handle load"));
+    return ResourceError(errorDomainPlugin, PluginErrorWillHandleLoad, response.url(), ASCIILiteral("Plugin will handle load"));
 }
 
 ResourceError downloadNetworkError(const ResourceError& networkError)
@@ -79,12 +79,12 @@
 
 ResourceError downloadCancelledByUserError(const ResourceResponse& response)
 {
-    return ResourceError(errorDomainDownload, DownloadErrorCancelledByUser, response.url().string(), ASCIILiteral("User cancelled the download"));
+    return ResourceError(errorDomainDownload, DownloadErrorCancelledByUser, response.url(), ASCIILiteral("User cancelled the download"));
 }
 
 ResourceError downloadDestinationError(const ResourceResponse& response, const String& errorMessage)
 {
-    return ResourceError(errorDomainDownload, DownloadErrorDestination, response.url().string(), errorMessage);
+    return ResourceError(errorDomainDownload, DownloadErrorDestination, response.url(), errorMessage);
 }
 
 ResourceError printError(const URL& failingURL, const String& errorMessage)

Modified: trunk/Source/WebCore/platform/gtk/ErrorsGtk.cpp (194418 => 194419)


--- trunk/Source/WebCore/platform/gtk/ErrorsGtk.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/platform/gtk/ErrorsGtk.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -29,67 +29,57 @@
 
 ResourceError cancelledError(const ResourceRequest& request)
 {
-    return ResourceError(errorDomainNetwork, NetworkErrorCancelled,
-                         request.url().string(), _("Load request cancelled"));
+    return ResourceError(errorDomainNetwork, NetworkErrorCancelled, request.url(), _("Load request cancelled"));
 }
 
 ResourceError blockedError(const ResourceRequest& request)
 {
-    return ResourceError(errorDomainPolicy, PolicyErrorCannotUseRestrictedPort,
-                         request.url().string(), _("Not allowed to use restricted network port"));
+    return ResourceError(errorDomainPolicy, PolicyErrorCannotUseRestrictedPort, request.url(), _("Not allowed to use restricted network port"));
 }
 
 ResourceError blockedByContentBlockerError(const ResourceRequest& request)
 {
-    return ResourceError(errorDomainPolicy, PolicyErrorBlockedByContentBlocker, request.url().string(), _("Blocked by content blocker"));
+    return ResourceError(errorDomainPolicy, PolicyErrorBlockedByContentBlocker, request.url(), _("Blocked by content blocker"));
 }
 
 ResourceError cannotShowURLError(const ResourceRequest& request)
 {
-    return ResourceError(errorDomainPolicy, PolicyErrorCannotShowURL,
-                         request.url().string(), _("URL cannot be shown"));
+    return ResourceError(errorDomainPolicy, PolicyErrorCannotShowURL, request.url(), _("URL cannot be shown"));
 }
 
 ResourceError interruptedForPolicyChangeError(const ResourceRequest& request)
 {
-    return ResourceError(errorDomainPolicy, PolicyErrorFrameLoadInterruptedByPolicyChange,
-                         request.url().string(), _("Frame load was interrupted"));
+    return ResourceError(errorDomainPolicy, PolicyErrorFrameLoadInterruptedByPolicyChange, request.url(), _("Frame load was interrupted"));
 }
 
 ResourceError cannotShowMIMETypeError(const ResourceResponse& response)
 {
-    return ResourceError(errorDomainPolicy, PolicyErrorCannotShowMimeType,
-                         response.url().string(), _("Content with the specified MIME type cannot be shown"));
+    return ResourceError(errorDomainPolicy, PolicyErrorCannotShowMimeType, response.url(), _("Content with the specified MIME type cannot be shown"));
 }
 
 ResourceError fileDoesNotExistError(const ResourceResponse& response)
 {
-    return ResourceError(errorDomainNetwork, NetworkErrorFileDoesNotExist,
-                         response.url().string(), _("File does not exist"));
+    return ResourceError(errorDomainNetwork, NetworkErrorFileDoesNotExist, response.url(), _("File does not exist"));
 }
 
 ResourceError pluginWillHandleLoadError(const ResourceResponse& response)
 {
-    return ResourceError(errorDomainPlugin, PluginErrorWillHandleLoad,
-                         response.url().string(), _("Plugin will handle load"));
+    return ResourceError(errorDomainPlugin, PluginErrorWillHandleLoad, response.url(), _("Plugin will handle load"));
 }
 
 ResourceError downloadNetworkError(const ResourceError& networkError)
 {
-    return ResourceError(errorDomainDownload, DownloadErrorNetwork,
-                         networkError.failingURL(), networkError.localizedDescription());
+    return ResourceError(errorDomainDownload, DownloadErrorNetwork, networkError.failingURL(), networkError.localizedDescription());
 }
 
 ResourceError downloadCancelledByUserError(const ResourceResponse& response)
 {
-    return ResourceError(errorDomainDownload, DownloadErrorCancelledByUser,
-                         response.url().string(), _("User cancelled the download"));
+    return ResourceError(errorDomainDownload, DownloadErrorCancelledByUser, response.url(), _("User cancelled the download"));
 }
 
 ResourceError downloadDestinationError(const ResourceResponse& response, const String& errorMessage)
 {
-    return ResourceError(errorDomainDownload, DownloadErrorDestination,
-                         response.url().string(), errorMessage);
+    return ResourceError(errorDomainDownload, DownloadErrorDestination, response.url(), errorMessage);
 }
 
 ResourceError printError(const URL& failingURL, const String& errorMessage)

Modified: trunk/Source/WebCore/platform/network/ResourceErrorBase.h (194418 => 194419)


--- trunk/Source/WebCore/platform/network/ResourceErrorBase.h	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/platform/network/ResourceErrorBase.h	2015-12-25 12:22:16 UTC (rev 194419)
@@ -26,6 +26,7 @@
 #ifndef ResourceErrorBase_h
 #define ResourceErrorBase_h
 
+#include "URL.h"
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
@@ -43,7 +44,7 @@
 
     const String& domain() const { lazyInit(); return m_domain; }
     int errorCode() const { lazyInit(); return m_errorCode; }
-    const String& failingURL() const { lazyInit(); return m_failingURL; }
+    const URL& failingURL() const { lazyInit(); return m_failingURL; }
     const String& localizedDescription() const { lazyInit(); return m_localizedDescription; }
 
     void setIsCancellation(bool isCancellation) { m_isCancellation = isCancellation; }
@@ -63,7 +64,7 @@
     {
     }
 
-    ResourceErrorBase(const String& domain, int errorCode, const String& failingURL, const String& localizedDescription)
+    ResourceErrorBase(const String& domain, int errorCode, const URL& failingURL, const String& localizedDescription)
         : m_domain(domain)
         , m_failingURL(failingURL)
         , m_localizedDescription(localizedDescription)
@@ -86,7 +87,7 @@
     static bool platformCompare(const ResourceError&, const ResourceError&) { return true; }
 
     String m_domain;
-    String m_failingURL;
+    URL m_failingURL;
     String m_localizedDescription;
     int m_errorCode;
     bool m_isNull : 1;

Modified: trunk/Source/WebCore/platform/network/cf/ResourceError.h (194418 => 194419)


--- trunk/Source/WebCore/platform/network/cf/ResourceError.h	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/platform/network/cf/ResourceError.h	2015-12-25 12:22:16 UTC (rev 194419)
@@ -50,7 +50,7 @@
     {
     }
 
-    ResourceError(const String& domain, int errorCode, const String& failingURL, const String& localizedDescription)
+    ResourceError(const String& domain, int errorCode, const URL& failingURL, const String& localizedDescription)
         : ResourceErrorBase(domain, errorCode, failingURL, localizedDescription)
         , m_dataIsUpToDate(true)
     {
@@ -63,7 +63,7 @@
 
 #if USE(CFNETWORK)
 #if PLATFORM(WIN)
-    ResourceError(const String& domain, int errorCode, const String& failingURL, const String& localizedDescription, CFDataRef certificate);
+    ResourceError(const String& domain, int errorCode, const URL& failingURL, const String& localizedDescription, CFDataRef certificate);
     PCCERT_CONTEXT certificate() const;
     void setCertificate(CFDataRef);
 #endif

Modified: trunk/Source/WebCore/platform/network/cf/ResourceErrorCF.cpp (194418 => 194419)


--- trunk/Source/WebCore/platform/network/cf/ResourceErrorCF.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/platform/network/cf/ResourceErrorCF.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -49,7 +49,7 @@
 }
 
 #if PLATFORM(WIN)
-ResourceError::ResourceError(const String& domain, int errorCode, const String& failingURL, const String& localizedDescription, CFDataRef certificate)
+ResourceError::ResourceError(const String& domain, int errorCode, const URL& failingURL, const String& localizedDescription, CFDataRef certificate)
     : ResourceErrorBase(domain, errorCode, failingURL, localizedDescription)
     , m_dataIsUpToDate(true)
     , m_certificate(certificate)
@@ -101,17 +101,12 @@
     if (userInfo.get()) {
         CFStringRef failingURLString = (CFStringRef) CFDictionaryGetValue(userInfo.get(), failingURLStringKey);
         if (failingURLString)
-            m_failingURL = String(failingURLString);
+            m_failingURL = URL(URL(), failingURLString);
         else {
             CFURLRef failingURL = (CFURLRef) CFDictionaryGetValue(userInfo.get(), failingURLKey);
             if (failingURL) {
-                RetainPtr<CFURLRef> absoluteURLRef = adoptCF(CFURLCopyAbsoluteURL(failingURL));
-                if (absoluteURLRef.get()) {
-                    // FIXME: CFURLGetString returns a normalized URL which is different from what is actually used by CFNetwork.
-                    // We should use CFURLGetBytes instead.
-                    failingURLString = CFURLGetString(absoluteURLRef.get());
-                    m_failingURL = String(failingURLString);
-                }
+                if (RetainPtr<CFURLRef> absoluteURLRef = adoptCF(CFURLCopyAbsoluteURL(failingURL)))
+                    m_failingURL = URL(absoluteURLRef.get());
             }
         }
         m_localizedDescription = (CFStringRef) CFDictionaryGetValue(userInfo.get(), kCFErrorLocalizedDescriptionKey);
@@ -152,12 +147,9 @@
             CFDictionarySetValue(userInfo.get(), kCFErrorLocalizedDescriptionKey, m_localizedDescription.createCFString().get());
 
         if (!m_failingURL.isEmpty()) {
-            RetainPtr<CFStringRef> failingURLString = m_failingURL.createCFString();
+            RetainPtr<CFStringRef> failingURLString = m_failingURL.string().createCFString();
             CFDictionarySetValue(userInfo.get(), failingURLStringKey, failingURLString.get());
-            // FIXEME: We normally create a CFURL from a string by using URL::createCFURL, which handles
-            // cases correctly that CFURLCreateWithString handles incorrectly.
-            RetainPtr<CFURLRef> url = "" failingURLString.get(), 0));
-            if (url)
+            if (RetainPtr<CFURLRef> url = ""
                 CFDictionarySetValue(userInfo.get(), failingURLKey, url.get());
         }
 

Modified: trunk/Source/WebCore/platform/network/curl/ResourceError.h (194418 => 194419)


--- trunk/Source/WebCore/platform/network/curl/ResourceError.h	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/platform/network/curl/ResourceError.h	2015-12-25 12:22:16 UTC (rev 194419)
@@ -44,7 +44,7 @@
     {
     }
 
-    ResourceError(const String& domain, int errorCode, const String& failingURL, const String& localizedDescription)
+    ResourceError(const String& domain, int errorCode, const URL& failingURL, const String& localizedDescription)
         : ResourceErrorBase(domain, errorCode, failingURL, localizedDescription), m_sslErrors(0)
     {
     }

Modified: trunk/Source/WebCore/platform/network/mac/ResourceErrorMac.mm (194418 => 194419)


--- trunk/Source/WebCore/platform/network/mac/ResourceErrorMac.mm	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/platform/network/mac/ResourceErrorMac.mm	2015-12-25 12:22:16 UTC (rev 194419)
@@ -182,12 +182,9 @@
         [userInfo.get() setValue:resourceError.localizedDescription() forKey:NSLocalizedDescriptionKey];
 
     if (!resourceError.failingURL().isEmpty()) {
-        // FIXEME: We normally create an NSURL from a string by using URL::createNSURL, which handles
-        // cases correctly that initWithString: handles incorrectly.
-        RetainPtr<NSURL> cocoaURL = adoptNS([[NSURL alloc] initWithString:resourceError.failingURL()]);
-        [userInfo.get() setValue:resourceError.failingURL() forKey:@"NSErrorFailingURLStringKey"];
-        if (cocoaURL)
-            [userInfo.get() setValue:cocoaURL.get() forKey:@"NSErrorFailingURLKey"];
+        [userInfo.get() setValue:(NSString *)resourceError.failingURL().string() forKey:@"NSErrorFailingURLStringKey"];
+        if (NSURL *cocoaURL = (NSURL *)resourceError.failingURL())
+            [userInfo.get() setValue:cocoaURL forKey:@"NSErrorFailingURLKey"];
     }
 
     return adoptNS([[NSError alloc] initWithDomain:resourceError.domain() code:resourceError.errorCode() userInfo:userInfo.get()]);
@@ -266,10 +263,10 @@
     m_domain = [m_platformError.get() domain];
     m_errorCode = [m_platformError.get() code];
 
-    NSString* failingURLString = [[m_platformError.get() userInfo] valueForKey:@"NSErrorFailingURLStringKey"];
-    if (!failingURLString)
-        failingURLString = [[[m_platformError.get() userInfo] valueForKey:@"NSErrorFailingURLKey"] absoluteString];
-    m_failingURL = failingURLString; 
+    if (NSString* failingURLString = [[m_platformError.get() userInfo] valueForKey:@"NSErrorFailingURLStringKey"])
+        m_failingURL = URL(URL(), failingURLString);
+    else
+        m_failingURL = URL((NSURL *)[[m_platformError.get() userInfo] valueForKey:@"NSErrorFailingURLKey"]);
     // Workaround for <rdar://problem/6554067>
     m_localizedDescription = m_failingURL;
     BEGIN_BLOCK_OBJC_EXCEPTIONS;

Modified: trunk/Source/WebCore/platform/network/soup/ResourceError.h (194418 => 194419)


--- trunk/Source/WebCore/platform/network/soup/ResourceError.h	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/platform/network/soup/ResourceError.h	2015-12-25 12:22:16 UTC (rev 194419)
@@ -41,7 +41,7 @@
 class ResourceError : public ResourceErrorBase
 {
 public:
-    ResourceError(const String& domain, int errorCode, const String& failingURL, const String& localizedDescription)
+    ResourceError(const String& domain, int errorCode, const URL& failingURL, const String& localizedDescription)
         : ResourceErrorBase(domain, errorCode, failingURL, localizedDescription)
         , m_tlsErrors(0)
     {
@@ -56,7 +56,7 @@
     static ResourceError transportError(SoupRequest*, int statusCode, const String& reasonPhrase);
     static ResourceError genericGError(GError*, SoupRequest*);
     static ResourceError tlsError(SoupRequest*, unsigned tlsErrors, GTlsCertificate*);
-    static ResourceError timeoutError(const String& failingURL);
+    static ResourceError timeoutError(const URL& failingURL);
     static ResourceError authenticationError(SoupMessage*);
 
     unsigned tlsErrors() const { return m_tlsErrors; }

Modified: trunk/Source/WebCore/platform/network/soup/ResourceErrorSoup.cpp (194418 => 194419)


--- trunk/Source/WebCore/platform/network/soup/ResourceErrorSoup.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/platform/network/soup/ResourceErrorSoup.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -35,14 +35,13 @@
 
 namespace WebCore {
 
-static String failingURI(SoupURI* soupURI)
+static URL failingURI(SoupURI* soupURI)
 {
     ASSERT(soupURI);
-    GUniquePtr<char> uri(soup_uri_to_string(soupURI, FALSE));
-    return uri.get();
+    return URL(soupURI);
 }
 
-static String failingURI(SoupRequest* request)
+static URL failingURI(SoupRequest* request)
 {
     ASSERT(request);
     return failingURI(soup_request_get_uri(request));
@@ -85,7 +84,7 @@
     return resourceError;
 }
 
-ResourceError ResourceError::timeoutError(const String& failingURL)
+ResourceError ResourceError::timeoutError(const URL& failingURL)
 {
     // FIXME: This should probably either be integrated into Errors(Gtk/EFL).h or the
     // networking errors from those files should be moved here.

Modified: trunk/Source/WebCore/platform/network/soup/ResourceHandleSoup.cpp (194418 => 194419)


--- trunk/Source/WebCore/platform/network/soup/ResourceHandleSoup.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/platform/network/soup/ResourceHandleSoup.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -1051,7 +1051,7 @@
 
 void ResourceHandle::timeoutFired()
 {
-    client()->didFail(this, ResourceError::timeoutError(firstRequest().url().string()));
+    client()->didFail(this, ResourceError::timeoutError(firstRequest().url()));
     cancel();
 }
 

Modified: trunk/Source/WebCore/xml/XMLHttpRequest.cpp (194418 => 194419)


--- trunk/Source/WebCore/xml/XMLHttpRequest.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebCore/xml/XMLHttpRequest.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -1077,8 +1077,10 @@
     }
 
     // Network failures are already reported to Web Inspector by ResourceLoader.
-    if (error.domain() == errorDomainWebKitInternal)
-        logConsoleError(scriptExecutionContext(), "XMLHttpRequest cannot load " + error.failingURL() + ". " + error.localizedDescription());
+    if (error.domain() == errorDomainWebKitInternal) {
+        String message = makeString("XMLHttpRequest cannot load ", error.failingURL().string(), ". ", error.localizedDescription());
+        logConsoleError(scriptExecutionContext(), message);
+    }
 
     m_exceptionCode = XMLHttpRequestException::NETWORK_ERR;
     networkError();

Modified: trunk/Source/WebKit/win/ChangeLog (194418 => 194419)


--- trunk/Source/WebKit/win/ChangeLog	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit/win/ChangeLog	2015-12-25 12:22:16 UTC (rev 194419)
@@ -1,3 +1,27 @@
+2015-12-25  David Kilzer  <[email protected]>
+
+        ResourceError should store failingURL as URL instead of String to avoid reparsing and to address FIXME comments in ResourceErrorCF.cpp and ResourceErrorMac.mm
+        <http://webkit.org/b/146391>
+
+        Reviewed by Antti Koivisto.
+
+        * WebCoreSupport/WebFrameLoaderClient.cpp:
+        (WebFrameLoaderClient::cancelledError):
+        (WebFrameLoaderClient::blockedError):
+        (WebFrameLoaderClient::cannotShowURLError):
+        (WebFrameLoaderClient::interruptedForPolicyChangeError):
+        (WebFrameLoaderClient::cannotShowMIMETypeError):
+        (WebFrameLoaderClient::fileDoesNotExistError):
+        (WebFrameLoaderClient::pluginWillHandleLoadError):
+        (WebFrameLoaderClient::dispatchDidFailToStartPlugin):
+        (WebFrameLoaderClient::createJavaAppletWidget):
+        * WebDownloadCFNet.cpp:
+        (WebDownload::cancelAuthenticationChallenge):
+        * WebError.cpp:
+        (WebError::init):
+        - Update for type change of 'failingURL' argument to
+          ResourceError().
+
 2015-12-23  Brent Fulgham  <[email protected]>
 
         Web Inspector: add support for running protocol-test.js tests on Windows

Modified: trunk/Source/WebKit/win/WebCoreSupport/WebFrameLoaderClient.cpp (194418 => 194419)


--- trunk/Source/WebKit/win/WebCoreSupport/WebFrameLoaderClient.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit/win/WebCoreSupport/WebFrameLoaderClient.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -851,12 +851,12 @@
 {
     // FIXME: Need ChickenCat to include CFNetwork/CFURLError.h to get these values
     // Alternatively, we could create our own error domain/codes.
-    return ResourceError(String(WebURLErrorDomain), -999, request.url().string(), String("Cancelled"));
+    return ResourceError(String(WebURLErrorDomain), -999, request.url(), String("Cancelled"));
 }
 
 ResourceError WebFrameLoaderClient::blockedError(const ResourceRequest& request)
 {
-    return ResourceError(String(WebKitErrorDomain), WebKitErrorCannotUseRestrictedPort, request.url().string(), WEB_UI_STRING("Not allowed to use restricted network port", "WebKitErrorCannotUseRestrictedPort description"));
+    return ResourceError(String(WebKitErrorDomain), WebKitErrorCannotUseRestrictedPort, request.url(), WEB_UI_STRING("Not allowed to use restricted network port", "WebKitErrorCannotUseRestrictedPort description"));
 }
 
 ResourceError WebFrameLoaderClient::blockedByContentBlockerError(const ResourceRequest& request)
@@ -866,27 +866,27 @@
 
 ResourceError WebFrameLoaderClient::cannotShowURLError(const ResourceRequest& request)
 {
-    return ResourceError(String(WebKitErrorDomain), WebKitErrorCannotShowURL, request.url().string(), WEB_UI_STRING("The URL can\xE2\x80\x99t be shown", "WebKitErrorCannotShowURL description"));
+    return ResourceError(String(WebKitErrorDomain), WebKitErrorCannotShowURL, request.url(), WEB_UI_STRING("The URL can\xE2\x80\x99t be shown", "WebKitErrorCannotShowURL description"));
 }
 
 ResourceError WebFrameLoaderClient::interruptedForPolicyChangeError(const ResourceRequest& request)
 {
-    return ResourceError(String(WebKitErrorDomain), WebKitErrorFrameLoadInterruptedByPolicyChange, request.url().string(), WEB_UI_STRING("Frame load interrupted", "WebKitErrorFrameLoadInterruptedByPolicyChange description"));
+    return ResourceError(String(WebKitErrorDomain), WebKitErrorFrameLoadInterruptedByPolicyChange, request.url(), WEB_UI_STRING("Frame load interrupted", "WebKitErrorFrameLoadInterruptedByPolicyChange description"));
 }
 
 ResourceError WebFrameLoaderClient::cannotShowMIMETypeError(const ResourceResponse& response)
 {
-    return ResourceError(String(), WebKitErrorCannotShowMIMEType, response.url().string(), WEB_UI_STRING("Content with specified MIME type can\xE2\x80\x99t be shown", "WebKitErrorCannotShowMIMEType description"));
+    return ResourceError(String(), WebKitErrorCannotShowMIMEType, response.url(), WEB_UI_STRING("Content with specified MIME type can\xE2\x80\x99t be shown", "WebKitErrorCannotShowMIMEType description"));
 }
 
 ResourceError WebFrameLoaderClient::fileDoesNotExistError(const ResourceResponse& response)
 {
-    return ResourceError(String(WebURLErrorDomain), -1100, response.url().string(), String("File does not exist."));
+    return ResourceError(String(WebURLErrorDomain), -1100, response.url(), String("File does not exist."));
 }
 
 ResourceError WebFrameLoaderClient::pluginWillHandleLoadError(const ResourceResponse& response)
 {
-    return ResourceError(String(WebKitErrorDomain), WebKitErrorPlugInWillHandleLoad, response.url().string(), WEB_UI_STRING("Plug-in handled load", "WebKitErrorPlugInWillHandleLoad description"));
+    return ResourceError(String(WebKitErrorDomain), WebKitErrorPlugInWillHandleLoad, response.url(), WEB_UI_STRING("Plug-in handled load", "WebKitErrorPlugInWillHandleLoad description"));
 }
 
 bool WebFrameLoaderClient::shouldFallBack(const ResourceError& error)
@@ -1166,7 +1166,7 @@
             ASSERT_NOT_REACHED();
     }
 
-    ResourceError resourceError(String(WebKitErrorDomain), errorCode, pluginView->url().string(), String());
+    ResourceError resourceError(String(WebKitErrorDomain), errorCode, pluginView->url(), String());
     COMPtr<IWebError> error(AdoptCOM, WebError::createInstance(resourceError, userInfoBag.get()));
      
     resourceLoadDelegate->plugInFailedWithError(webView, error.get(), getWebDataSource(frame->loader().documentLoader()));
@@ -1244,7 +1244,7 @@
 
     COMPtr<CFDictionaryPropertyBag> userInfoBag = CFDictionaryPropertyBag::createInstance();
 
-    ResourceError resourceError(String(WebKitErrorDomain), WebKitErrorJavaUnavailable, String(), WEB_UI_STRING("Java is unavailable", "WebKitErrorJavaUnavailable description"));
+    ResourceError resourceError(String(WebKitErrorDomain), WebKitErrorJavaUnavailable, URL(), WEB_UI_STRING("Java is unavailable", "WebKitErrorJavaUnavailable description"));
     COMPtr<IWebError> error(AdoptCOM, WebError::createInstance(resourceError, userInfoBag.get()));
 
     Frame* coreFrame = core(m_webFrame);

Modified: trunk/Source/WebKit/win/WebDownloadCFNet.cpp (194418 => 194419)


--- trunk/Source/WebKit/win/WebDownloadCFNet.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit/win/WebDownloadCFNet.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -307,7 +307,7 @@
     }
 
     // FIXME: Do we need a URL or description for this error code?
-    ResourceError error(String(WebURLErrorDomain), WebURLErrorUserCancelledAuthentication, "", "");
+    ResourceError error(String(WebURLErrorDomain), WebURLErrorUserCancelledAuthentication, URL(), "");
     COMPtr<WebError> webError(AdoptCOM, WebError::createInstance(error));
     m_delegate->didFailWithError(this, webError.get());
 

Modified: trunk/Source/WebKit/win/WebError.cpp (194418 => 194419)


--- trunk/Source/WebKit/win/WebError.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit/win/WebError.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -107,7 +107,7 @@
 
 HRESULT WebError::init(_In_ BSTR domain, int code, _In_ BSTR url)
 {
-    m_error = ResourceError(String(domain, SysStringLen(domain)), code, String(url, SysStringLen(url)), String());
+    m_error = ResourceError(String(domain, SysStringLen(domain)), code, URL(URL(), String(url, SysStringLen(url))), String());
     return S_OK;
 }
   

Modified: trunk/Source/WebKit2/ChangeLog (194418 => 194419)


--- trunk/Source/WebKit2/ChangeLog	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit2/ChangeLog	2015-12-25 12:22:16 UTC (rev 194419)
@@ -1,3 +1,32 @@
+2015-12-25  David Kilzer  <[email protected]>
+
+        ResourceError should store failingURL as URL instead of String to avoid reparsing and to address FIXME comments in ResourceErrorCF.cpp and ResourceErrorMac.mm
+        <http://webkit.org/b/146391>
+
+        Reviewed by Antti Koivisto.
+
+        * NetworkProcess/Downloads/efl/DownloadSoupErrorsEfl.cpp:
+        (WebKit::platformDownloadNetworkError):
+        * NetworkProcess/Downloads/gtk/DownloadSoupErrorsGtk.cpp:
+        (WebKit::platformDownloadNetworkError):
+        * NetworkProcess/Downloads/soup/DownloadSoup.cpp:
+        (WebKit::DownloadClient::didReceiveResponse):
+        * NetworkProcess/Downloads/soup/DownloadSoupErrors.h:
+        * Shared/soup/WebCoreArgumentCodersSoup.cpp:
+        (IPC::ArgumentCoder<ResourceError>::encodePlatformData):
+        (IPC::ArgumentCoder<ResourceError>::decodePlatformData):
+        * UIProcess/API/gtk/WebKitLoaderClient.cpp:
+        (LoaderClient::didFailProvisionalLoadWithErrorForFrame):
+        (LoaderClient::didFailLoadWithErrorForFrame):
+        * UIProcess/API/gtk/WebKitURISchemeRequest.cpp:
+        (webkit_uri_scheme_request_finish_error):
+        * WebProcess/WebCoreSupport/efl/WebErrorsEfl.cpp:
+        (WebKit::internalError):
+        * WebProcess/WebCoreSupport/gtk/WebErrorsGtk.cpp:
+        (WebKit::internalError):
+        - Update for type change of 'failingURL' argument to
+          ResourceError().
+
 2015-12-23  Simon Fraser  <[email protected]>
 
         Use "constrainedBetween" in more places

Modified: trunk/Source/WebKit2/NetworkProcess/Downloads/efl/DownloadSoupErrorsEfl.cpp (194418 => 194419)


--- trunk/Source/WebKit2/NetworkProcess/Downloads/efl/DownloadSoupErrorsEfl.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit2/NetworkProcess/Downloads/efl/DownloadSoupErrorsEfl.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -33,7 +33,7 @@
 
 namespace WebKit {
 
-ResourceError platformDownloadNetworkError(int errorCode, const String& failingURL, const String& localizedDescription)
+ResourceError platformDownloadNetworkError(int errorCode, const URL& failingURL, const String& localizedDescription)
 {
     return downloadNetworkError(ResourceError(errorDomainDownload, errorCode, failingURL, localizedDescription));
 }

Modified: trunk/Source/WebKit2/NetworkProcess/Downloads/gtk/DownloadSoupErrorsGtk.cpp (194418 => 194419)


--- trunk/Source/WebKit2/NetworkProcess/Downloads/gtk/DownloadSoupErrorsGtk.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit2/NetworkProcess/Downloads/gtk/DownloadSoupErrorsGtk.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -33,7 +33,7 @@
 
 namespace WebKit {
 
-ResourceError platformDownloadNetworkError(int errorCode, const String& failingURL, const String& localizedDescription)
+ResourceError platformDownloadNetworkError(int errorCode, const URL& failingURL, const String& localizedDescription)
 {
     return downloadNetworkError(ResourceError(errorDomainDownload, errorCode, failingURL, localizedDescription));
 }

Modified: trunk/Source/WebKit2/NetworkProcess/Downloads/soup/DownloadSoup.cpp (194418 => 194419)


--- trunk/Source/WebKit2/NetworkProcess/Downloads/soup/DownloadSoup.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit2/NetworkProcess/Downloads/soup/DownloadSoup.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -82,7 +82,7 @@
         m_download->didReceiveResponse(response);
 
         if (response.httpStatusCode() >= 400) {
-            downloadFailed(platformDownloadNetworkError(response.httpStatusCode(), response.url().string(), response.httpStatusText()));
+            downloadFailed(platformDownloadNetworkError(response.httpStatusCode(), response.url(), response.httpStatusText()));
             return;
         }
 

Modified: trunk/Source/WebKit2/NetworkProcess/Downloads/soup/DownloadSoupErrors.h (194418 => 194419)


--- trunk/Source/WebKit2/NetworkProcess/Downloads/soup/DownloadSoupErrors.h	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit2/NetworkProcess/Downloads/soup/DownloadSoupErrors.h	2015-12-25 12:22:16 UTC (rev 194419)
@@ -27,11 +27,12 @@
 #define DownloadSoupErrors_h
 
 #include <WebCore/ResourceHandle.h>
+#include <WebCore/URL.h>
 #include <wtf/text/WTFString.h>
 
 namespace WebKit {
 
-WebCore::ResourceError platformDownloadNetworkError(int errorCode, const String& failingURL, const String& localizedDescription);
+WebCore::ResourceError platformDownloadNetworkError(int errorCode, const WebCore::URL& failingURL, const String& localizedDescription);
 WebCore::ResourceError platformDownloadDestinationError(const WebCore::ResourceResponse&, const String& message);
 
 } // namespace WebKit

Modified: trunk/Source/WebKit2/Shared/soup/WebCoreArgumentCodersSoup.cpp (194418 => 194419)


--- trunk/Source/WebKit2/Shared/soup/WebCoreArgumentCodersSoup.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit2/Shared/soup/WebCoreArgumentCodersSoup.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -193,7 +193,7 @@
 
     encoder << resourceError.domain();
     encoder << resourceError.errorCode();
-    encoder << resourceError.failingURL();
+    encoder << resourceError.failingURL().string();
     encoder << resourceError.localizedDescription();
     encoder << resourceError.isCancellation();
     encoder << resourceError.isTimeout();
@@ -235,7 +235,7 @@
     if (!decoder.decode(isTimeout))
         return false;
 
-    resourceError = ResourceError(domain, errorCode, failingURL, localizedDescription);
+    resourceError = ResourceError(domain, errorCode, URL(URL(), failingURL), localizedDescription);
     resourceError.setIsCancellation(isCancellation);
     resourceError.setIsTimeout(isTimeout);
 

Modified: trunk/Source/WebKit2/UIProcess/API/gtk/WebKitLoaderClient.cpp (194418 => 194419)


--- trunk/Source/WebKit2/UIProcess/API/gtk/WebKitLoaderClient.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit2/UIProcess/API/gtk/WebKitLoaderClient.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -62,10 +62,10 @@
         GUniquePtr<GError> error(g_error_new_literal(g_quark_from_string(resourceError.domain().utf8().data()),
             toWebKitError(resourceError.errorCode()), resourceError.localizedDescription().utf8().data()));
         if (resourceError.tlsErrors()) {
-            webkitWebViewLoadFailedWithTLSErrors(m_webView, resourceError.failingURL().utf8().data(), error.get(),
+            webkitWebViewLoadFailedWithTLSErrors(m_webView, resourceError.failingURL().string().utf8().data(), error.get(),
                 static_cast<GTlsCertificateFlags>(resourceError.tlsErrors()), resourceError.certificate());
         } else
-            webkitWebViewLoadFailed(m_webView, WEBKIT_LOAD_STARTED, resourceError.failingURL().utf8().data(), error.get());
+            webkitWebViewLoadFailed(m_webView, WEBKIT_LOAD_STARTED, resourceError.failingURL().string().utf8().data(), error.get());
     }
 
     void didCommitLoadForFrame(WebPageProxy&, WebFrameProxy& frame, API::Navigation*, API::Object* /* userData */) override
@@ -88,7 +88,7 @@
             return;
         GUniquePtr<GError> error(g_error_new_literal(g_quark_from_string(resourceError.domain().utf8().data()),
             toWebKitError(resourceError.errorCode()), resourceError.localizedDescription().utf8().data()));
-        webkitWebViewLoadFailed(m_webView, WEBKIT_LOAD_COMMITTED, resourceError.failingURL().utf8().data(), error.get());
+        webkitWebViewLoadFailed(m_webView, WEBKIT_LOAD_COMMITTED, resourceError.failingURL().string().utf8().data(), error.get());
     }
 
     void didDisplayInsecureContentForFrame(WebPageProxy&, WebFrameProxy&, API::Object* /* userData */) override

Modified: trunk/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequest.cpp (194418 => 194419)


--- trunk/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequest.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit2/UIProcess/API/gtk/WebKitURISchemeRequest.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -239,7 +239,7 @@
         return;
 
     priv->stream = nullptr;
-    WebCore::ResourceError resourceError(g_quark_to_string(error->domain), toWebCoreError(error->code), priv->uri.data(), String::fromUTF8(error->message));
+    WebCore::ResourceError resourceError(g_quark_to_string(error->domain), toWebCoreError(error->code), WebCore::URL(priv->soupURI.get()), String::fromUTF8(error->message));
     priv->webRequestManager->didFailWithError(priv->requestID, resourceError);
     webkitWebContextDidFinishLoadingCustomProtocol(priv->webContext, priv->requestID);
 }

Modified: trunk/Source/WebKit2/WebProcess/WebCoreSupport/efl/WebErrorsEfl.cpp (194418 => 194419)


--- trunk/Source/WebKit2/WebProcess/WebCoreSupport/efl/WebErrorsEfl.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit2/WebProcess/WebCoreSupport/efl/WebErrorsEfl.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -79,7 +79,7 @@
 
 WebCore::ResourceError internalError(const WebCore::URL& url)
 {
-    return ResourceError(API::Error::webKitErrorDomain(), kWKErrorInternal, url.string(), ASCIILiteral("Internal error"));
+    return ResourceError(API::Error::webKitErrorDomain(), kWKErrorInternal, url, ASCIILiteral("Internal error"));
 }
 
 } // namespace WebKit

Modified: trunk/Source/WebKit2/WebProcess/WebCoreSupport/gtk/WebErrorsGtk.cpp (194418 => 194419)


--- trunk/Source/WebKit2/WebProcess/WebCoreSupport/gtk/WebErrorsGtk.cpp	2015-12-25 07:25:29 UTC (rev 194418)
+++ trunk/Source/WebKit2/WebProcess/WebCoreSupport/gtk/WebErrorsGtk.cpp	2015-12-25 12:22:16 UTC (rev 194419)
@@ -82,7 +82,7 @@
 
 WebCore::ResourceError internalError(const WebCore::URL& url)
 {
-    return ResourceError(API::Error::webKitErrorDomain(), kWKErrorInternal, url.string(), _("Internal error"));
+    return ResourceError(API::Error::webKitErrorDomain(), kWKErrorInternal, url, _("Internal error"));
 }
 
 } // namespace WebKit
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to