Allow XHR timeout attribute to be overridden after send(), per spec

Source/core/loader/DocumentThreadableLoader.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013, Intel Corporation
  *
  * 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 58 matching lines @@
 }
 
 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::didTimeout)
+    , m_requestStarted(0.0)
 {
     ASSERT(client);
     // Setting an outgoing referer is only supported in the async code path.
     ASSERT(m_async || request.httpReferrer().isEmpty());
 
     // Save any CORS simple headers on the request here. If this request redirects cross-origin, we cancel the old request
     // create a new one, and copy these headers.
     const HTTPHeaderMap& headerMap = request.httpHeaderFields();
     HTTPHeaderMap::const_iterator end = headerMap.end();
     for (HTTPHeaderMap::const_iterator it = headerMap.begin(); it != end; ++it) {
@@ skipping 42 matching lines @@
             ResourceRequest preflightRequest = createAccessControlPreflightRequest(*m_actualRequest, securityOrigin());
             loadRequest(preflightRequest);
         }
     }
 }
 
 DocumentThreadableLoader::~DocumentThreadableLoader()
 {
 }
 
+void DocumentThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds)
+{
+    if (m_async) {

[tyoshino (SeeGerritForStatus), 2014/05/09 08:04:36]

if (!m_async)
    return;

...

+        m_timeoutTimer.stop();
+        // At the time of this method's implementation, it is only ever called by
+        // XMLHttpRequest, when the timeout attribute is set after sending the
+        // request.
+        //
+        // The XHR request says to resolve the time relative to when the request
+        // was initially sent, however other uses of this method may need to
+        // behave differently, in which case this should be re-arranged somehow.
+        if (timeoutMilliseconds) {
+            double resolvedTime = m_requestStarted + timeoutMilliseconds / 1000.0;
+            m_timeoutTimer.startOneShotExact(resolvedTime, FROM_HERE);

[tyoshino (SeeGerritForStatus), 2014/05/09 08:04:36]

any reason you chose to add this new method to Timer than calculating the time
from now until the new timeout?

[caitp (gmail), 2014/05/09 08:39:49]

For IEEE floating point math, you lose accuracy if you mix small additions with
large ones in a weird order, so adding the extra subtract is potentially an
issue.

But you're right, it's better to have less code, and it's probably not going to
introduce major flakiness, so I'll remove the Timer methods

+        }
+    }
+}
+
 void DocumentThreadableLoader::cancel()
 {
     cancelWithError(ResourceError());
 }
 
 void DocumentThreadableLoader::cancelWithError(const ResourceError& error)
 {
     RefPtr<DocumentThreadableLoader> protect(this);
 
     // Cancel can re-enter and m_resource might be null here as a result.
@@ skipping 229 matching lines @@
     m_client->didFailAccessControlCheck(error);
 }
 
 void DocumentThreadableLoader::loadRequest(const ResourceRequest& request)
 {
     // Any credential should have been removed from the cross-site requests.
     const KURL& requestURL = request.url();
     ASSERT(m_sameOriginRequest || requestURL.user().isEmpty());
     ASSERT(m_sameOriginRequest || requestURL.pass().isEmpty());
 
+    m_requestStarted = monotonicallyIncreasingTime();

[tyoshino (SeeGerritForStatus), 2014/05/09 08:04:36]

move this to between L419 and L420 (outside of if-clause)?

+
     ThreadableLoaderOptions options = m_options;
     if (m_async) {
         if (m_actualRequest) {
             options.sniffContent = DoNotSniffContent;
             options.dataBufferingPolicy = BufferData;
         }
 
         if (m_options.timeoutMilliseconds > 0)
             m_timeoutTimer.startOneShot(m_options.timeoutMilliseconds / 1000.0, FROM_HERE);
 
@@ skipping 61 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