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

Source/core/loader/DocumentThreadableLoader.cpp

Index: Source/core/loader/DocumentThreadableLoader.cpp
diff --git a/Source/core/loader/DocumentThreadableLoader.cpp b/Source/core/loader/DocumentThreadableLoader.cpp
index 2840dce77f4d9e26c4eae1e3c59f20864f715df6..f104e3a706623f5266d03d428001712625972b63 100644
--- a/Source/core/loader/DocumentThreadableLoader.cpp
+++ b/Source/core/loader/DocumentThreadableLoader.cpp
@@ -76,6 +76,7 @@ DocumentThreadableLoader::DocumentThreadableLoader(Document& document, Threadabl
     , 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.
@@ -138,6 +139,26 @@ DocumentThreadableLoader::~DocumentThreadableLoader()
 {
 }
 
+void DocumentThreadableLoader::overrideTimeout(unsigned long timeoutMilliseconds)
+{
+    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 elapsedTime = monotonicallyIncreasingTime() - m_requestStarted;
+        double nextFire = timeoutMilliseconds / 1000.0;
+        double resolvedTime = nextFire > elapsedTime ? nextFire - elapsedTime : 0.0;
+        m_timeoutTimer.startOneShot(resolvedTime, FROM_HERE);

[tyoshino (SeeGerritForStatus), 2014/05/15 09:15:43]

We should start the timer only when there's active fetch. There's no convenient
way to know whether there's an active fetch. We cannot check that by looking at
m_timeoutTimer.is_active() since it may not be active because the user didn't
set timeout option when the XHR is started. Maybe the right thing to do is
checking if resource() is NULL or not but currently resource() is cleared when
cancel() is called or didTimeout is called, but not when notifyFinished() is
called.

Could you please try clearing resource at the end of notifyFinished (and maybe
also m_client)?

[caitp (gmail), 2014/05/15 11:51:03]

What about just `m_requestStarted > 0.0` ? It gets reset on
cancel/timeout/error/finish --- But I think in practice, there's always an
active fetch, since DocumentThreadableLoader starts a request immediately after
being constructed, provided it doesn't fail

[tyoshino (SeeGerritForStatus), 2014/05/15 12:33:42]

Sounds fine as far as well commented.
I'm concerned about race between overrideTimeout call and completion of loading.
XMLHttpRequest is checking if m_loader is empty or not, but even with that check
when it's run in a worker, overrideTimeout call goes through the task queue and
can be run after notifyFinished in the main thread.

+    }
+}
+
 void DocumentThreadableLoader::cancel()
 {
     cancelWithError(ResourceError());
@@ -396,6 +417,7 @@ void DocumentThreadableLoader::loadRequest(const ResourceRequest& request)
 
         if (m_options.timeoutMilliseconds > 0)
             m_timeoutTimer.startOneShot(m_options.timeoutMilliseconds / 1000.0, FROM_HERE);
+        m_requestStarted = monotonicallyIncreasingTime();
 
         FetchRequest newRequest(request, m_options.initiator, options);
         ASSERT(!resource());