[Resource Timing] Expose redirect timing information

Source/core/page/PerformanceResourceTiming.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2012 Intel 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.
@@ skipping 20 matching lines @@
 
 #include "config.h"
 #include "PerformanceResourceTiming.h"
 
 #include "Document.h"
 #include "DocumentLoadTiming.h"
 #include "DocumentLoader.h"
 #include "KURL.h"
 #include "ResourceRequest.h"
 #include "ResourceResponse.h"
+#include "ResourceTimingInfo.h"
 #include "SecurityOrigin.h"
 #include <wtf/Vector.h>
 
 namespace WebCore {
 
 static double monotonicTimeToDocumentMilliseconds(Document* document, double seconds)
 {
     ASSERT(seconds >= 0.0);
     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)
 {
 }
 
 PerformanceResourceTiming::~PerformanceResourceTiming()
 {
 }
 
 AtomicString PerformanceResourceTiming::initiatorType() const
 {
     return m_initiatorType;
 }
 
 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
 {
     if (!m_shouldReportDetails)
         return 0.0;
 
     if (!m_timing || m_timing->dnsStart < 0)
         return fetchStart();
 
@@ skipping 82 matching lines @@
 }
 
 double PerformanceResourceTiming::resourceTimeToDocumentMilliseconds(int deltaMilliseconds) const
 {
     if (!deltaMilliseconds)
         return 0.0;
     return monotonicTimeToDocumentMilliseconds(m_requestingDocument.get(), m_timing->requestTime) + deltaMilliseconds;
 }
 
 } // namespace WebCore