[Resource Timing] Expose redirect timing information

Source/core/page/Performance.cpp

Index: Source/core/page/Performance.cpp
diff --git a/Source/core/page/Performance.cpp b/Source/core/page/Performance.cpp
index 4ca0392514287bc9b252ef01db408026726ddc56..47a30c659083d96ebb2ee40f0a1059a2c756d591 100644
--- a/Source/core/page/Performance.cpp
+++ b/Source/core/page/Performance.cpp
@@ -41,6 +41,7 @@
 #include "PerformanceTiming.h"
 #include "PerformanceUserTiming.h"
 #include "ResourceResponse.h"
+#include "ResourceTimingInfo.h"
 #include <wtf/CurrentTime.h>
 
 #include "Frame.h"
@@ -160,13 +161,58 @@ void Performance::webkitSetResourceTimingBufferSize(unsigned size)
         dispatchEvent(Event::create(eventNames().webkitresourcetimingbufferfullEvent, false, false));
 }
 
-void Performance::addResourceTiming(const String& initiatorName, Document* initiatorDocument, const ResourceRequest& request, const ResourceResponse& response, double initiationTime, double finishTime)
+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;
+}
+
+void Performance::addResourceTiming(const ResourceTimingInfo& info, Document* initiatorDocument)
 {
     if (isResourceTimingBufferFull())
         return;
 
-    RefPtr<PerformanceEntry> entry = PerformanceResourceTiming::create(initiatorName, request, response, initiationTime, finishTime, initiatorDocument);
+    bool shouldReportDetails = true;
+    Vector<ResourceResponse> redirectChain = info.redirectChain();
+
+    for (size_t i = 0; i < redirectChain.size(); i++)
+        if (false == (shouldReportDetails = passesTimingAllowCheck(redirectChain[i], initiatorDocument)))
+            break;
+
+    if (shouldReportDetails)
+        shouldReportDetails = passesTimingAllowCheck(info.finalResponse(), initiatorDocument);
+
+    double lastRedirectEndTime = 0.0;
+    if (redirectChain.size() != 0) {
+        ResourceLoadTiming* loadTiming = redirectChain.last().resourceLoadTiming();
+        ASSERT(loadTiming);

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

I observed that resourceLoadTiming is not contained in redirect reponse with
latest chromium code, I guess reason is browser process network stack doesn't
make it, will it be always exist there in future?

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

That's determined entirely by Blink, not Chrome.
ResourceLoadNotifier::dispatchWillSendRequest() is where we
setReportLoadTiming(true). The redirect must go through a path where that isn't
called. You should find it and fix it (in this CL).

+        lastRedirectEndTime = loadTiming->convertResourceLoadTimeToMonotonicTime(loadTiming->receiveHeadersEnd);

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

can we assume redirect response will never be cached in network stack? in other
word, only final response can be cached in network stack, so that we can get
lastRedirectEndTime in network stack, otherwise we have to catch that value in
blink(ResourceLoader::willSendRequest).

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

No, we do cache redirects. There's a bug to do a better job of it here:

https://code.google.com/p/chromium/issues/detail?id=49573

+    }
+
+    double startTime = info.initialTime();
+    if (!shouldReportDetails && lastRedirectEndTime)
+        startTime = info.finalResponse().resourceLoadTiming()->requestTime;
 
+    RefPtr<PerformanceEntry> entry = PerformanceResourceTiming::create(info, initiatorDocument, startTime, lastRedirectEndTime, shouldReportDetails);
     m_resourceTimingBuffer.append(entry);
 
     if (isResourceTimingBufferFull())