[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 353ba82dbdd987ba69e15f32df1d43d180017eb3..2d27794c1da059eaa12256a490adbdadbc31b84f 100644
--- a/Source/core/page/Performance.cpp
+++ b/Source/core/page/Performance.cpp
@@ -40,7 +40,9 @@
 #include "core/page/PerformanceResourceTiming.h"
 #include "core/page/PerformanceTiming.h"
 #include "core/page/PerformanceUserTiming.h"
+#include "core/page/ResourceTimingInfo.h"
 #include "core/platform/network/ResourceResponse.h"
+#include "weborigin/SecurityOrigin.h"
 #include <wtf/CurrentTime.h>
 
 #include "core/page/Frame.h"
@@ -160,13 +162,77 @@ 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;
+}
+
+static bool allowsTimingRedirect(const Vector<ResourceResponse>& redirectChain, const ResourceResponse& finalResponse, Document* initiatorDocument)
+{
+    if (!passesTimingAllowCheck(finalResponse, initiatorDocument))
+        return false;
+
+    for (size_t i = 0; i < redirectChain.size(); i++)
+        if (!passesTimingAllowCheck(redirectChain[i], initiatorDocument))
+            return false;
+
+    return true;
+}
+
+void Performance::addResourceTiming(const ResourceTimingInfo& info, Document* initiatorDocument)
 {
     if (isResourceTimingBufferFull())
         return;
 
-    RefPtr<PerformanceEntry> entry = PerformanceResourceTiming::create(initiatorName, request, response, initiationTime, finishTime, initiatorDocument);
+    const ResourceResponse& finalResponse = info.finalResponse();
+    bool allowTimingFetch = passesTimingAllowCheck(finalResponse, initiatorDocument);
+    double startTime = info.initialTime();
+
+    if (info.redirectChain().isEmpty()) {
+        RefPtr<PerformanceEntry> entry = PerformanceResourceTiming::create(info, initiatorDocument, startTime, allowTimingFetch);

[James Simonsen, 2013/06/04 01:13:04]

Why not move this to populateResourceTimingEntry? It happens in both cases.

[Pan, 2013/06/04 02:48:34]

they are overload functions to distinguish non-redirect and redirect cases, I
thought it would be better to leave them close to code that prepare params :)

+        populateResourceTimingEntry(entry);
+        return;
+    }
+
+    const Vector<ResourceResponse>& redirectChain = info.redirectChain();
+    bool allowTimingRedirect = allowsTimingRedirect(redirectChain, finalResponse, initiatorDocument);
 
+    if (!allowTimingRedirect) {
+        ResourceLoadTiming* finalTiming = finalResponse.resourceLoadTiming();
+        ASSERT(finalTiming);
+        startTime = finalTiming->requestTime;
+    }
+
+    ResourceLoadTiming* lastRedirectTiming = redirectChain.last().resourceLoadTiming();
+    ASSERT(lastRedirectTiming);
+    double lastRedirectEndTime = lastRedirectTiming->receiveHeadersEnd;
+
+    RefPtr<PerformanceEntry> entry = PerformanceResourceTiming::create(info, initiatorDocument, startTime, lastRedirectEndTime, allowTimingFetch, allowTimingRedirect);
+    populateResourceTimingEntry(entry);
+}
+
+void Performance::populateResourceTimingEntry(PassRefPtr<PerformanceEntry> entry)

[James Simonsen, 2013/06/04 01:13:04]

Maybe call this addResourceTimingToBuffer()?

[Pan, 2013/06/04 02:48:34]

yes, thanks!

+{
     m_resourceTimingBuffer.append(entry);
 
     if (isResourceTimingBufferFull())