Implementing timeout support for XHR

Source/WebCore/platform/network/chromium/ResourceHandle.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.

[jamesr, 2013/04/17 17:51:05]

are we doing this?

[abarth-chromium, 2013/04/18 05:34:09]

In general, yes.

  *
  * 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
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
@@ skipping 38 matching lines @@
 
 namespace WebCore {
 
 // ResourceHandleInternal -----------------------------------------------------
 ResourceHandleInternal::ResourceHandleInternal(NetworkingContext* context, const ResourceRequest& request, ResourceHandleClient* client)
     : m_context(context)
     , m_request(request)
     , m_owner(0)
     , m_client(client)
     , m_state(ConnectionStateNew)
+    , m_timer(this, &ResourceHandleInternal::timerFired)
 {
 }
 
 void ResourceHandleInternal::start()
 {
     if (m_state != ConnectionStateNew)
         CRASH();
     m_state = ConnectionStateStarted;
 
     m_loader = adoptPtr(Platform::current()->createURLLoader());
     ASSERT(m_loader);
 
     WrappedResourceRequest wrappedRequest(m_request);
     wrappedRequest.setAllowStoredCredentials(allowStoredCredentials());
     m_loader->loadAsynchronously(wrappedRequest, this);
+
+    if (m_request.timeoutInterval() > 0)
+        m_timer.startOneShot(m_request.timeoutInterval());
 }
 
 void ResourceHandleInternal::cancel()
 {
     m_state = ConnectionStateCanceled;
     m_loader->cancel();
 
     // Do not make any further calls to the client.
     m_client = 0;
 }
@@ skipping 84 matching lines @@
     ASSERT(m_client);
     m_state = ConnectionStateFailed;
     m_client->didFail(m_owner, error);
 }
 
 ResourceHandleInternal* ResourceHandleInternal::FromResourceHandle(ResourceHandle* handle)
 {
     return handle->d.get();
 }
 
+void ResourceHandleInternal::timerFired(Timer<ResourceHandleInternal>*)
+{
+    // Use the same value as in NSURLError.h
+    static const int timeoutError = -1001;

[darin (slow to review), 2013/04/16 19:03:45]

Hmm, the network layer can also generate net::ERR_TIMED_OUT independently of
this code.  It looks like that would not be seen by XMLHttpRequest as a timeout.
 I assume that's intentional?

[Dominik Röttsches, 2013/04/17 08:26:52]

Yes, the way I read the spec, the ontimeout event should only fire in response
to an "author specified timeout", not due to implementation dependent network
timeouts. The latter would be handled by the more general onerror case.

+    static const char* const errorDomain = "WebKitNetworkError";
+
+    m_state = ConnectionStateCanceled;
+    m_loader->cancel();
+    if (m_client) {
+        ResourceError error(errorDomain, timeoutError, m_request.url().string(), String());
+        error.setIsTimeout(true);
+        m_client->didFail(m_owner, error);
+    }
+}
+
 // ResourceHandle -------------------------------------------------------------
 
 ResourceHandle::ResourceHandle(NetworkingContext* context, const ResourceRequest& request, ResourceHandleClient* client, bool defersLoading, bool shouldContentSniff)
     : d(adoptPtr(new ResourceHandleInternal(context, request, client)))
 {
     d->setOwner(this);
 
     // FIXME: Figure out what to do with the bool params.
 }
 
@@ skipping 85 matching lines @@
     d->didChangePriority(static_cast<WebURLRequest::Priority>(newPriority));
 }
 
 // static
 void ResourceHandle::cacheMetadata(const ResourceResponse& response, const Vector<char>& data)
 {
     WebKit::Platform::current()->cacheMetadata(response.url(), response.responseTime(), data.data(), data.size());
 }
 
 } // namespace WebCore