Reland [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 22 matching lines @@
 #include "core/page/Performance.h"
 
 #include "core/dom/Document.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/MemoryInfo.h"
 #include "core/page/PerformanceEntry.h"
 #include "core/page/PerformanceNavigation.h"
 #include "core/page/PerformanceResourceTiming.h"
 #include "core/page/PerformanceTiming.h"
 #include "core/page/PerformanceUserTiming.h"
+#include "core/page/ResourceTimingInfo.h"
+#include "weborigin/SecurityOrigin.h"
 #include <wtf/CurrentTime.h>
 
 #include "core/page/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;
+}
+
+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 allowTimingDetails = passesTimingAllowCheck(finalResponse, initiatorDocument);
+    double startTime = info.initialTime();
 
+    if (info.redirectChain().isEmpty()) {
+        RefPtr<PerformanceEntry> entry = PerformanceResourceTiming::create(info, initiatorDocument, startTime, allowTimingDetails);
+        addResourceTimingBuffer(entry);
+        return;
+    }
+
+    const Vector<ResourceResponse>& redirectChain = info.redirectChain();
+    bool allowRedirectDetails = allowsTimingRedirect(redirectChain, finalResponse, initiatorDocument);
+
+    if (!allowRedirectDetails) {
+        ResourceLoadTiming* finalTiming = finalResponse.resourceLoadTiming();
+        ASSERT(finalTiming);
+        startTime = finalTiming->requestTime;
+    }
+
+    ResourceLoadTiming* lastRedirectTiming = redirectChain.last().resourceLoadTiming();
+    ASSERT(lastRedirectTiming);
+    double lastRedirectEndTime = lastRedirectTiming->receiveHeadersEnd;

[Pan, 2013/06/21 15:22:28]

James and Tony

Resource Timing spec says last byte header end time from network as
"redirectEnd", so here it should come from
lastRedirectTiming->receiveHeadersEnd.
While, as ResourceLoadTiming is filled from chrome part, as we went through
network cache, app cache, HSTS redirect case, I feel it is risk to assume chrome
always feed blink a filled ResourceLoadTiming, so I prefer to record the
redirect receive time from blink as a fallback, when lastRedirectTiming here is
a none pointer, use timeticks recorded in blink, it would be better than crash.
The cons is losing the way to know who breaks the assumption.
any idea?

thanks
Pan

[James Simonsen, 2013/06/22 00:26:32]

Personally, I'd rather fix all the cases in net/ and keep the ASSERT where it
was. That way nobody would be able to regress it in Chrome, because they'd cause
tests to start failing. That's better than having it broken and have Blink cover
up the problem.

+
+    RefPtr<PerformanceEntry> entry = PerformanceResourceTiming::create(info, initiatorDocument, startTime, lastRedirectEndTime, allowTimingDetails, allowRedirectDetails);
+    addResourceTimingBuffer(entry);
+}
+
+void Performance::addResourceTimingBuffer(PassRefPtr<PerformanceEntry> entry)
+{
     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