webkitgtk-2.16.5HEADwebkitgtk-2.16.5master

1 files changed, 59 insertions, 70 deletions

diff --git a/Source/WebCore/page/PerformanceResourceTiming.cpp b/Source/WebCore/page/PerformanceResourceTiming.cpp
index bb6bc6ad9..270a0863c 100644
--- a/Source/WebCore/page/PerformanceResourceTiming.cpp
+++ b/Source/WebCore/page/PerformanceResourceTiming.cpp
@@ -32,56 +32,39 @@
 #include "config.h"
 #include "PerformanceResourceTiming.h"
 
-#if ENABLE(RESOURCE_TIMING)
+#if ENABLE(WEB_TIMING)
 
 #include "Document.h"
-#include "DocumentLoadTiming.h"
 #include "DocumentLoader.h"
-#include "URL.h"
-#include "ResourceRequest.h"
+#include "LoadTiming.h"
 #include "ResourceResponse.h"
-#include "SecurityOrigin.h"
-#include <wtf/Vector.h>
+#include "ResourceTiming.h"
+#include "URL.h"
 
 namespace WebCore {
 
-static double monotonicTimeToDocumentMilliseconds(Document* document, double seconds)
+static double monotonicTimeToDOMHighResTimeStamp(MonotonicTime timeOrigin, MonotonicTime timeStamp)
 {
-    ASSERT(seconds >= 0.0);
-    return document->loader()->timing()->monotonicTimeToZeroBasedDocumentTime(seconds) * 1000.0;
+    ASSERT(timeStamp.secondsSinceEpoch().seconds() >= 0);
+    if (!timeStamp || !timeOrigin)
+        return 0;
+
+    Seconds seconds = timeStamp - timeOrigin;
+    return Performance::reduceTimeResolution(seconds).milliseconds();
 }
 
-static bool passesTimingAllowCheck(const ResourceResponse& response, Document* requestingDocument)
+Ref<PerformanceResourceTiming> PerformanceResourceTiming::create(MonotonicTime timeOrigin, ResourceTiming&& resourceTiming)
 {
-    RefPtr<SecurityOrigin> resourceOrigin = SecurityOrigin::create(response.url());
-    if (resourceOrigin->isSameSchemeHostPort(requestingDocument->securityOrigin()))
-        return true;
-
-    const String& timingAllowOriginString = response.httpHeaderField("timing-allow-origin");
-    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;
+    return adoptRef(*new PerformanceResourceTiming(timeOrigin, WTFMove(resourceTiming)));
 }
 
-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))
-    , m_requestingDocument(requestingDocument)
+PerformanceResourceTiming::PerformanceResourceTiming(MonotonicTime timeOrigin, ResourceTiming&& resourceTiming)
+    : PerformanceEntry(PerformanceEntry::Type::Resource, resourceTiming.url().string(), ASCIILiteral("resource"), monotonicTimeToDOMHighResTimeStamp(timeOrigin, resourceTiming.loadTiming().startTime()), monotonicTimeToDOMHighResTimeStamp(timeOrigin, resourceTiming.loadTiming().responseEnd()))
+    , m_initiatorType(resourceTiming.initiator())
+    , m_timeOrigin(timeOrigin)
+    , m_loadTiming(resourceTiming.loadTiming())
+    , m_networkLoadTiming(resourceTiming.networkLoadTiming())
+    , m_shouldReportDetails(resourceTiming.allowTimingDetails())
 {
 }
 
@@ -89,30 +72,33 @@ PerformanceResourceTiming::~PerformanceResourceTiming()
 {
 }
 
-AtomicString PerformanceResourceTiming::initiatorType() const
+double PerformanceResourceTiming::workerStart() const
 {
-    return m_initiatorType;
+    return 0.0;
 }
 
 double PerformanceResourceTiming::redirectStart() const
 {
-    // FIXME: Need to track and report redirects for resources.
     if (!m_shouldReportDetails)
         return 0.0;
-    return 0;
+
+    return monotonicTimeToDOMHighResTimeStamp(m_timeOrigin, m_loadTiming.redirectStart());
 }
 
 double PerformanceResourceTiming::redirectEnd() const
 {
     if (!m_shouldReportDetails)
         return 0.0;
-    return 0;
+
+    return monotonicTimeToDOMHighResTimeStamp(m_timeOrigin, m_loadTiming.redirectEnd());
 }
 
 double PerformanceResourceTiming::fetchStart() const
 {
-    // FIXME: This should be different depending on redirects.
-    return (startTime());
+    // fetchStart is a required property.
+    ASSERT(m_loadTiming.fetchStart());
+
+    return monotonicTimeToDOMHighResTimeStamp(m_timeOrigin, m_loadTiming.fetchStart());
 }
 
 double PerformanceResourceTiming::domainLookupStart() const
@@ -120,10 +106,10 @@ double PerformanceResourceTiming::domainLookupStart() const
     if (!m_shouldReportDetails)
         return 0.0;
 
-    if (!m_timing || m_timing->dnsStart < 0)
+    if (m_networkLoadTiming.domainLookupStart <= 0)
         return fetchStart();
 
-    return resourceTimeToDocumentMilliseconds(m_timing->dnsStart);
+    return networkLoadTimeToDOMHighResTimeStamp(m_networkLoadTiming.domainLookupStart);
 }
 
 double PerformanceResourceTiming::domainLookupEnd() const
@@ -131,10 +117,10 @@ double PerformanceResourceTiming::domainLookupEnd() const
     if (!m_shouldReportDetails)
         return 0.0;
 
-    if (!m_timing || m_timing->dnsEnd < 0)
+    if (m_networkLoadTiming.domainLookupEnd <= 0)
         return domainLookupStart();
 
-    return resourceTimeToDocumentMilliseconds(m_timing->dnsEnd);
+    return networkLoadTimeToDOMHighResTimeStamp(m_networkLoadTiming.domainLookupEnd);
 }
 
 double PerformanceResourceTiming::connectStart() const
@@ -143,15 +129,15 @@ double PerformanceResourceTiming::connectStart() const
         return 0.0;
 
     // connectStart will be -1 when a network request is not made.
-    if (!m_timing || m_timing->connectStart < 0 || m_didReuseConnection)
+    if (m_networkLoadTiming.connectStart <= 0)
         return domainLookupEnd();
 
     // connectStart includes any DNS time, so we may need to trim that off.
-    int connectStart = m_timing->connectStart;
-    if (m_timing->dnsEnd >= 0)
-        connectStart = m_timing->dnsEnd;
+    double connectStart = m_networkLoadTiming.connectStart;
+    if (m_networkLoadTiming.domainLookupEnd >= 0)
+        connectStart = m_networkLoadTiming.domainLookupEnd;
 
-    return resourceTimeToDocumentMilliseconds(connectStart);
+    return networkLoadTimeToDOMHighResTimeStamp(connectStart);
 }
 
 double PerformanceResourceTiming::connectEnd() const
@@ -160,10 +146,10 @@ double PerformanceResourceTiming::connectEnd() const
         return 0.0;
 
     // connectStart will be -1 when a network request is not made.
-    if (!m_timing || m_timing->connectEnd < 0 || m_didReuseConnection)
+    if (m_networkLoadTiming.connectEnd <= 0)
         return connectStart();
 
-    return resourceTimeToDocumentMilliseconds(m_timing->connectEnd);
+    return networkLoadTimeToDOMHighResTimeStamp(m_networkLoadTiming.connectEnd);
 }
 
 double PerformanceResourceTiming::secureConnectionStart() const
@@ -171,10 +157,10 @@ double PerformanceResourceTiming::secureConnectionStart() const
     if (!m_shouldReportDetails)
         return 0.0;
 
-    if (!m_timing || m_timing->sslStart < 0) // Secure connection not negotiated.
+    if (m_networkLoadTiming.secureConnectionStart < 0) // Secure connection not negotiated.
         return 0.0;
 
-    return resourceTimeToDocumentMilliseconds(m_timing->sslStart);
+    return networkLoadTimeToDOMHighResTimeStamp(m_networkLoadTiming.secureConnectionStart);
 }
 
 double PerformanceResourceTiming::requestStart() const
@@ -182,10 +168,11 @@ double PerformanceResourceTiming::requestStart() const
     if (!m_shouldReportDetails)
         return 0.0;
 
-    if (!m_timing)
+    // requestStart is 0 when a network request is not made.
+    if (m_networkLoadTiming.requestStart <= 0)
         return connectEnd();
 
-    return resourceTimeToDocumentMilliseconds(m_timing->sendStart);
+    return networkLoadTimeToDOMHighResTimeStamp(m_networkLoadTiming.requestStart);
 }
 
 double PerformanceResourceTiming::responseStart() const
@@ -193,27 +180,29 @@ double PerformanceResourceTiming::responseStart() const
     if (!m_shouldReportDetails)
         return 0.0;
 
-    if (!m_timing)
+    // responseStart is 0 when a network request is not made.
+    if (m_networkLoadTiming.responseStart <= 0)
         return requestStart();
-    // FIXME: This number isn't exactly correct. See the notes in PerformanceTiming::responseStart().
-    return resourceTimeToDocumentMilliseconds(m_timing->receiveHeadersEnd);
+
+    return networkLoadTimeToDOMHighResTimeStamp(m_networkLoadTiming.responseStart);
 }
 
 double PerformanceResourceTiming::responseEnd() const
 {
-    if (!m_finishTime)
-        return responseStart();
+    // responseEnd is a required property.
+    ASSERT(m_loadTiming.responseEnd());
 
-    return monotonicTimeToDocumentMilliseconds(m_requestingDocument.get(), m_finishTime);
+    return monotonicTimeToDOMHighResTimeStamp(m_timeOrigin, m_loadTiming.responseEnd());
 }
 
-double PerformanceResourceTiming::resourceTimeToDocumentMilliseconds(int deltaMilliseconds) const
+double PerformanceResourceTiming::networkLoadTimeToDOMHighResTimeStamp(double deltaMilliseconds) const
 {
-    if (!deltaMilliseconds)
-        return 0.0;
-    return monotonicTimeToDocumentMilliseconds(m_requestingDocument.get(), m_timing->requestTime) + deltaMilliseconds;
+    ASSERT(deltaMilliseconds);
+    MonotonicTime combined = m_loadTiming.fetchStart() + Seconds::fromMilliseconds(deltaMilliseconds);
+    Seconds delta = combined - m_timeOrigin;
+    return Performance::reduceTimeResolution(delta).milliseconds();
 }
 
 } // namespace WebCore
 
-#endif // ENABLE(RESOURCE_TIMING)
+#endif // ENABLE(WEB_TIMING)