[ServiceWorker] Provide more descriptive error messages when fetch API fails.

Source/modules/serviceworkers/FetchManager.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "FetchManager.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 22 matching lines @@
     virtual void didFail(const ResourceError&);
     virtual void didFailAccessControlCheck(const ResourceError&);
     virtual void didFailRedirectCheck();
     virtual void didDownloadData(int);
 
     void start();
     void cleanup();
 
 private:
     void performBasicFetch();
-    void performNetworkError();
+    void performNetworkError(const String& message);
     void performHTTPFetch();
-    void failed();
+    void failed(const String& message);
     void notifyFinished();
 
     ExecutionContext* m_executionContext;
     FetchManager* m_fetchManager;
     RefPtr<ScriptPromiseResolver> m_resolver;
     Persistent<FetchRequestData> m_request;
     RefPtr<ThreadableLoader> m_loader;
     ResourceResponse m_response;
     long long m_downloadedBlobLength;
     bool m_corsFlag;
@@ skipping 57 matching lines @@
     case FetchRequestData::OpaqueTainting:
         response = response->createOpaqueFilteredResponse();
         break;
     }
     m_resolver->resolve(Response::create(m_resolver->executionContext(), response));
     notifyFinished();
 }
 
 void FetchManager::Loader::didFail(const ResourceError& error)
 {
-    failed();
+    failed("Fetch API cannot load " + error.failingURL() + ". " + error.localizedDescription());
 }
 
 void FetchManager::Loader::didFailAccessControlCheck(const ResourceError& error)
 {
-    failed();
+    failed("Fetch API cannot load " + error.failingURL() + ". " + error.localizedDescription());
 }
 
 void FetchManager::Loader::didFailRedirectCheck()
 {
-    failed();
+    failed("Fetch API cannot load " + m_request->url().string() + ". Unsupported redirection.");

[falken, 2014/11/17 02:14:46]

This message suggests there is a class of unsupported redirects. Are redirects
not supported at all? Then "Redirects are not yet supported" is better.
Otherwise, we should explain which class is supported/not supported.

[horo, 2014/11/17 03:25:35]

Done.

 }
 
 void FetchManager::Loader::didDownloadData(int dataLength)
 {
     m_downloadedBlobLength += dataLength;
 }
 
 void FetchManager::Loader::start()
 {
     // "1. If |request|'s url contains a Known HSTS Host, modify it per the
@@ skipping 28 matching lines @@
         || (m_request->url().protocolIsData() && m_request->sameOriginDataURLFlag())
         || (m_request->url().protocolIsAbout())) {
         // "The result of performing a basic fetch using request."
         performBasicFetch();
         return;
     }
 
     // "- |request|'s mode is |same-origin|"
     if (m_request->mode() == WebURLRequest::FetchRequestModeSameOrigin) {
         // "A network error."
-        performNetworkError();
+        performNetworkError("Fetch API cannot load " + m_request->url().string() + ". Request mode is \"same-origin\" but the URL is not same origin.");

[falken, 2014/11/17 02:14:46]

not the same origin as what?

[horo, 2014/11/17 03:25:35]

Done.

         return;
     }
 
     // "- |request|'s mode is |no CORS|"
     if (m_request->mode() == WebURLRequest::FetchRequestModeNoCORS) {
         // "Set |request|'s response tainting to |opaque|."
         m_request->setResponseTainting(FetchRequestData::OpaqueTainting);
         // "The result of performing a basic fetch using |request|."
         performBasicFetch();
         return;
     }
 
     // "- |request|'s url's scheme is not one of 'http' and 'https'"
     if (!m_request->url().protocolIsInHTTPFamily()) {
         // "A network error."
-        performNetworkError();
+        performNetworkError("Fetch API cannot load " + m_request->url().string() + ". URL scheme must be \"http\" or \"https\" for CORS request.");
         return;
     }
 
     // "- |request|'s mode is |CORS-with-forced-preflight|.
     // "- |request|'s unsafe request flag is set and either |request|'s method
     // is not a simple method or a header in |request|'s header list is not a
     // simple header"
     if (m_request->mode() == WebURLRequest::FetchRequestModeCORSWithForcedPreflight
         || (m_request->unsafeRequestFlag()
             && (!FetchUtils::isSimpleMethod(m_request->method())
@@ skipping 33 matching lines @@
 {
     // "To perform a basic fetch using |request|, switch on |request|'s url's
     // scheme, and run the associated steps:"
     if (m_request->url().protocolIsInHTTPFamily()) {
         // "Return the result of performing an HTTP fetch using |request|."
         m_corsFlag = false;
         m_corsPreflightFlag = false;
         performHTTPFetch();
     } else {
         // FIXME: implement other protocols.
-        performNetworkError();
+        performNetworkError("Fetch API cannot load " + m_request->url().string() + ". URL scheme \"" + m_request->url().protocol() + "\" is not supported.");
     }
 }
 
-void FetchManager::Loader::performNetworkError()
+void FetchManager::Loader::performNetworkError(const String& message)
 {
-    failed();
+    failed(message);
 }
 
 void FetchManager::Loader::performHTTPFetch()
 {
     ASSERT(m_request->url().protocolIsInHTTPFamily());
     // CORS preflight fetch procedure is implemented inside DocumentThreadableLoader.
 
     // "1. Let |HTTPRequest| be a copy of |request|, except that |HTTPRequest|'s
     //  body is a tee of |request|'s body."
     // We use ResourceRequest class for HTTPRequest.
@@ skipping 46 matching lines @@
         threadableLoaderOptions.preflightPolicy = ForcePreflight;
     if (m_corsFlag)
         threadableLoaderOptions.crossOriginRequestPolicy = UseAccessControl;
     else
         threadableLoaderOptions.crossOriginRequestPolicy = AllowCrossOriginRequests;
 
 
     m_loader = ThreadableLoader::create(*m_executionContext, this, request, threadableLoaderOptions, resourceLoaderOptions);
 }
 
-void FetchManager::Loader::failed()
+void FetchManager::Loader::failed(const String& message)
 {
     if (m_failed)
         return;
     if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
         return;
     m_failed = true;
     ScriptState* state = m_resolver->scriptState();
     ScriptState::Scope scope(state);
-    m_resolver->reject(V8ThrowException::createTypeError(state->isolate(), "Failed to fetch"));
+    m_resolver->reject(V8ThrowException::createTypeError(state->isolate(), message));
     notifyFinished();
 }
 
 void FetchManager::Loader::notifyFinished()
 {
     if (m_fetchManager)
         m_fetchManager->onLoaderFinished(this);
 }
 
 FetchManager::FetchManager(ExecutionContext* executionContext)
@@ skipping 18 matching lines @@
     loader->start();
     return promise;
 }
 
 void FetchManager::onLoaderFinished(Loader* loader)
 {
     m_loaders.remove(loader);
 }
 
 } // namespace blink