[Resource Timing] Expose redirect timing information

Source/core/page/PerformanceResourceTiming.cpp

Index: Source/core/page/PerformanceResourceTiming.cpp
diff --git a/Source/core/page/PerformanceResourceTiming.cpp b/Source/core/page/PerformanceResourceTiming.cpp
index c2f3c2897d37334584257994ea75f62ba3477b61..9cb5556692f4110d559b9549ad0e82ab09a5f3ba 100644
--- a/Source/core/page/PerformanceResourceTiming.cpp
+++ b/Source/core/page/PerformanceResourceTiming.cpp
@@ -38,6 +38,7 @@
 #include "KURL.h"
 #include "ResourceRequest.h"
 #include "ResourceResponse.h"
+#include "ResourceTimingInfo.h"
 #include "SecurityOrigin.h"
 #include <wtf/Vector.h>
 
@@ -49,38 +50,14 @@ static double monotonicTimeToDocumentMilliseconds(Document* document, double sec
     return document->loader()->timing()->monotonicTimeToZeroBasedDocumentTime(seconds) * 1000.0;
 }
 
-static bool passesTimingAllowCheck(const ResourceResponse& response, Document* requestingDocument)
-{
-    AtomicallyInitializedStatic(AtomicString&, timingAllowOrigin = *new AtomicString("timing-allow-origin"));
-
-    RefPtr<SecurityOrigin> resourceOrigin = SecurityOrigin::create(response.url());
-    if (resourceOrigin->isSameSchemeHostPort(requestingDocument->securityOrigin()))
-        return true;
-
-    const String& timingAllowOriginString = response.httpHeaderField(timingAllowOrigin);
-    if (timingAllowOriginString.isEmpty() || equalIgnoringCase(timingAllowOriginString, "null"))
-        return false;
-
-    if (timingAllowOriginString == "*")
-        return true;
-
-    const String& securityOrigin = requestingDocument->securityOrigin()->toString();
-    Vector<String> timingAllowOrigins;
-    timingAllowOriginString.split(" ", timingAllowOrigins);
-    for (size_t i = 0; i < timingAllowOrigins.size(); ++i)
-        if (timingAllowOrigins[i] == securityOrigin)
-            return true;
-
-    return false;
-}
-
-PerformanceResourceTiming::PerformanceResourceTiming(const AtomicString& initiatorType, const ResourceRequest& request, const ResourceResponse& response, double initiationTime, double finishTime, Document* requestingDocument)
-    : PerformanceEntry(request.url().string(), "resource", monotonicTimeToDocumentMilliseconds(requestingDocument, initiationTime), monotonicTimeToDocumentMilliseconds(requestingDocument, finishTime))
-    , m_initiatorType(initiatorType)
-    , m_timing(response.resourceLoadTiming())
-    , m_finishTime(finishTime)
-    , m_didReuseConnection(response.connectionReused())
-    , m_shouldReportDetails(passesTimingAllowCheck(response, requestingDocument))
+PerformanceResourceTiming::PerformanceResourceTiming(const ResourceTimingInfo& info, Document* requestingDocument, double startTime, double lastRedirectEndTime, bool shouldReportDetails)
+    : PerformanceEntry(info.initialRequest().url().string(), "resource", monotonicTimeToDocumentMilliseconds(requestingDocument, startTime), monotonicTimeToDocumentMilliseconds(requestingDocument, info.loadFinishTime()))
+    , m_initiatorType(info.initiatorType())
+    , m_timing(info.finalResponse().resourceLoadTiming())
+    , m_lastRedirectEndTime(lastRedirectEndTime)
+    , m_finishTime(info.loadFinishTime())
+    , m_didReuseConnection(info.finalResponse().connectionReused())
+    , m_shouldReportDetails(shouldReportDetails)
     , m_requestingDocument(requestingDocument)
 {
 }
@@ -96,23 +73,27 @@ AtomicString PerformanceResourceTiming::initiatorType() const
 
 double PerformanceResourceTiming::redirectStart() const
 {
-    // FIXME: Need to track and report redirects for resources.
-    if (!m_shouldReportDetails)
+    if (!m_shouldReportDetails || !m_lastRedirectEndTime)
         return 0.0;
-    return 0;
+
+    return PerformanceEntry::startTime();
 }
 
 double PerformanceResourceTiming::redirectEnd() const
 {
-    if (!m_shouldReportDetails)
+    if (!m_shouldReportDetails || !m_lastRedirectEndTime)
         return 0.0;
-    return 0;
+
+    return monotonicTimeToDocumentMilliseconds(m_requestingDocument.get(), m_lastRedirectEndTime);
 }
 
 double PerformanceResourceTiming::fetchStart() const
 {
-    // FIXME: This should be different depending on redirects.
-    return (startTime());
+    ASSERT(m_timing.get());

[Pan, 2013/04/17 15:38:16]

in domainLoopUpStart/end connectStart/end, if m_timing is not existed, it will
fall back to fetchStart(), then what about fetchStart()? if loadTiming missing
in final response is common, shall we record the initialTime of any inner
request in ResourceLoader::willSendRequest? 

[James Simonsen, 2013/04/18 02:57:37]

I think we should go back to initiationTime, though I expect that once the other
bug is fixed, that should never happen. Perhaps it's best to just
ASSERT(m_timing) in the constructor.

+    if (m_lastRedirectEndTime)
+        return monotonicTimeToDocumentMilliseconds(m_requestingDocument.get(), m_timing->requestTime);

[Pan, 2013/04/19 14:54:59]

For redirect case, we need m_timing->requestTime here. Currently as "no received
response headers time" is filtered in glue, we won't get m_timing and its
requestTime here.
1) Can we let m_timing of http cached response(just requestTime there) pass
through glue? I really expect this, if true, consider 2), if not got to 3)
2) can we assume that timing of cached(network stack) response only has
requestTime, that of network response also have other break down timestamps? I
expected this, however I observed there are blank requestTime when run layout
test case by DRT.(never happened in real chromium test).
3) we have to catch any request initial Time in ResourceLoader::willSendRequest,
and let the last one as fetchStart in redirect case.

[James Simonsen, 2013/04/23 00:31:37]

Yeah, that seems like the right thing to do.
I believe Navigation Timing has explicit rules about which timing members should
be populated on a cache hit. So, these fields will be populated. If they're not,
it's a bug. And if Resource Timing doesn't use the same definitions as
Navigation Timing, it's a bug in the spec.
I like this idea. That's how Navigation Timing works.

We should store it in the initiator map. Perhaps we should rename that.

+
+    return PerformanceEntry::startTime();
 }
 
 double PerformanceResourceTiming::domainLookupStart() const