Implementing timeout support for XHR

Source/core/loader/DocumentThreadableLoader.cpp

 /*
  * Copyright (C) 2011, 2012 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 60 matching lines @@
     return loader.release();
 }
 
 DocumentThreadableLoader::DocumentThreadableLoader(Document* document, ThreadableLoaderClient* client, BlockingBehavior blockingBehavior, const ResourceRequest& request, const ThreadableLoaderOptions& options)
     : m_client(client)
     , m_document(document)
     , m_options(options)
     , m_sameOriginRequest(securityOrigin()->canRequest(request.url()))
     , m_simpleRequest(true)
     , m_async(blockingBehavior == LoadAsynchronously)
+    , m_timeoutTimer(this, &DocumentThreadableLoader::timedOut)
 {
     ASSERT(document);
     ASSERT(client);
     // Setting an outgoing referer is only supported in the async code path.
     ASSERT(m_async || request.httpReferrer().isEmpty());
 
     if (m_sameOriginRequest || m_options.crossOriginRequestPolicy == AllowCrossOriginRequests) {
         loadRequest(request, DoSecurityCheck);
         return;
     }
@@ skipping 47 matching lines @@
 }
 
 DocumentThreadableLoader::~DocumentThreadableLoader()
 {
     if (m_resource)
         m_resource->removeClient(this);
 }
 
 void DocumentThreadableLoader::cancel()
 {
+    cancel(ResourceError());
+}
+
+void DocumentThreadableLoader::cancel(const ResourceError& error)
+{
     RefPtr<DocumentThreadableLoader> protect(this);
 
     // Cancel can re-enter and m_resource might be null here as a result.
     if (m_client && m_resource) {
-        // FIXME: This error is sent to the client in didFail(), so it should not be an internal one. Use FrameLoaderClient::cancelledError() instead.
-        ResourceError error(errorDomainWebKitInternal, 0, m_resource->url().string(), "Load cancelled");
-        error.setIsCancellation(true);
-        didFail(m_resource->identifier(), error);
+        ResourceError errorForCallback = error;
+        if (error.isNull()) {

[abarth-chromium, 2013/05/17 05:10:40]

I probably would have written errorForCallback.isNull since that's the object
we're working with in this stanza.

+            // FIXME: This error is sent to the client in didFail(), so it should not be an internal one. Use FrameLoaderClient::cancelledError() instead.
+            errorForCallback = ResourceError(errorDomainWebKitInternal, 0, m_resource->url().string(), "Load cancelled");
+            errorForCallback.setIsCancellation(true);
+        }
+        didFail(m_resource->identifier(), errorForCallback);
     }
     clearResource();
     m_client = 0;
 }
 
 void DocumentThreadableLoader::setDefersLoading(bool value)
 {
     if (m_resource)
         m_resource->setDefersLoading(value);
 }
@@ skipping 150 matching lines @@
         return;
     }
 
     m_client->didReceiveData(data, dataLength);
 }
 
 void DocumentThreadableLoader::notifyFinished(CachedResource* resource)
 {
     ASSERT(m_client);
     ASSERT_UNUSED(resource, resource == m_resource);
+
+    m_timeoutTimer.stop();
         
     if (m_resource->errorOccurred())
         didFail(m_resource->identifier(), m_resource->resourceError());
     else
         didFinishLoading(m_resource->identifier(), m_resource->loadFinishTime());
 }
 
 void DocumentThreadableLoader::didFinishLoading(unsigned long identifier, double finishTime)
 {
     if (m_actualRequest) {
@@ skipping 28 matching lines @@
 
 void DocumentThreadableLoader::preflightFailure(unsigned long identifier, const String& url, const String& errorDescription)
 {
     ResourceError error(errorDomainWebKitInternal, 0, url, errorDescription);
     if (m_actualRequest)
         InspectorInstrumentation::didFailLoading(m_document->frame(), m_document->frame()->loader()->documentLoader(), identifier, error);
     m_actualRequest = nullptr; // Prevent didFinishLoading() from bypassing access check.
     m_client->didFailAccessControlCheck(error);
 }
 
+void DocumentThreadableLoader::timedOut(Timer<DocumentThreadableLoader>* timer)
+{
+    ASSERT_UNUSED(timer, timer == &m_timeoutTimer);
+
+    // Using values from net/base/net_error_list.h ERR_TIMED_OUT,
+    // Same as existing FIXME above - this error should be coming from FrameLoaderClient to be identifiable.
+    static const int timeoutError = -7;
+    static const char* const errorDomain = "net";
+    ResourceError error(errorDomain, timeoutError, m_resource->url(), String());

[abarth-chromium, 2013/05/17 05:10:40]

I would probably just inline the string constant into the one place it's used. 
The numeric constant for timeoutError is helpful though.

+    error.setIsTimeout(true);
+    cancel(error);
+}
+
+
 void DocumentThreadableLoader::loadRequest(const ResourceRequest& request, SecurityCheckPolicy securityCheck)
 {
     // Any credential should have been removed from the cross-site requests.
     const KURL& requestURL = request.url();
     m_options.securityCheck = securityCheck;
     ASSERT(m_sameOriginRequest || requestURL.user().isEmpty());
     ASSERT(m_sameOriginRequest || requestURL.pass().isEmpty());
 
     if (m_async) {
         ThreadableLoaderOptions options = m_options;
         options.crossOriginCredentialPolicy = DoNotAskClientForCrossOriginCredentials;
         if (m_actualRequest) {
             // Don't sniff content or send load callbacks for the preflight request.
             options.sendLoadCallbacks = DoNotSendCallbacks;
             options.sniffContent = DoNotSniffContent;
             // Keep buffering the data for the preflight request.
             options.dataBufferingPolicy = BufferData;
         }
 
+        if (m_options.timeoutMilliseconds > 0)
+            m_timeoutTimer.startOneShot(m_options.timeoutMilliseconds / 1000.0);
+
         CachedResourceRequest newRequest(request, options);
         newRequest.setInitiator(m_options.initiator);
         ASSERT(!m_resource);
         m_resource = m_document->cachedResourceLoader()->requestRawResource(newRequest);
         if (m_resource) {
             if (m_resource->loader()) {
                 unsigned long identifier = m_resource->loader()->identifier();
                 InspectorInstrumentation::documentThreadableLoaderStartedLoadingForClient(m_document, identifier, m_client);
             }
             m_resource->addClient(this);
@@ skipping 55 matching lines @@
         return true;
     return m_document->contentSecurityPolicy()->allowConnectToSource(url);
 }
 
 SecurityOrigin* DocumentThreadableLoader::securityOrigin() const
 {
     return m_options.securityOrigin ? m_options.securityOrigin.get() : m_document->securityOrigin();
 }
 
 } // namespace WebCore