[Resource Timing] Expose redirect timing information

Source/core/page/Performance.cpp

 /*
  * Copyright (C) 2010 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 23 matching lines @@
 
 #include "Document.h"
 #include "DocumentLoader.h"
 #include "MemoryInfo.h"
 #include "PerformanceEntry.h"
 #include "PerformanceNavigation.h"
 #include "PerformanceResourceTiming.h"
 #include "PerformanceTiming.h"
 #include "PerformanceUserTiming.h"
 #include "ResourceResponse.h"
+#include "ResourceTimingInfo.h"
 #include <wtf/CurrentTime.h>
 
 #include "Frame.h"
 
 namespace WebCore {
 
 static const size_t defaultResourceTimingBufferSize = 150;
 
 Performance::Performance(Frame* frame)
     : DOMWindowProperty(frame)
@@ skipping 99 matching lines @@
     m_resourceTimingBuffer.clear();
 }
 
 void Performance::webkitSetResourceTimingBufferSize(unsigned size)
 {
     m_resourceTimingBufferSize = size;
     if (isResourceTimingBufferFull())
         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())
         dispatchEvent(Event::create(eventNames().webkitresourcetimingbufferfullEvent, false, false));
 }
 
 bool Performance::isResourceTimingBufferFull()
 {
     return m_resourceTimingBuffer.size() >= m_resourceTimingBufferSize;
 }
@@ skipping 37 matching lines @@
         m_userTiming = UserTiming::create(this);
     m_userTiming->clearMeasures(measureName);
 }
 
 double Performance::now() const
 {
     return 1000.0 * m_frame->document()->loader()->timing()->monotonicTimeToZeroBasedDocumentTime(monotonicallyIncreasingTime());
 }
 
 } // namespace WebCore