ResourceTiming should not depend on Document

Source/core/timing/PerformanceBase.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 152 matching lines @@
     m_frameTimingBuffer.clear();
 }
 
 void PerformanceBase::setFrameTimingBufferSize(unsigned size)
 {
     m_frameTimingBufferSize = size;
     if (isFrameTimingBufferFull())
         dispatchEvent(Event::create(EventTypeNames::frametimingbufferfull));
 }
 
-static bool passesTimingAllowCheck(const ResourceResponse& response, Document* requestingDocument, const AtomicString& originalTimingAllowOrigin)
+static bool passesTimingAllowCheck(const ResourceResponse& response, const SecurityOrigin& initiatorSecurityOrigin, const AtomicString& originalTimingAllowOrigin)
 {
     AtomicallyInitializedStaticReference(AtomicString, timingAllowOrigin, new AtomicString("timing-allow-origin"));
 
     RefPtr<SecurityOrigin> resourceOrigin = SecurityOrigin::create(response.url());
-    if (resourceOrigin->isSameSchemeHostPort(requestingDocument->securityOrigin()))
+    if (resourceOrigin->isSameSchemeHostPort(&initiatorSecurityOrigin))
         return true;
 
     const AtomicString& timingAllowOriginString = originalTimingAllowOrigin.isEmpty() ? response.httpHeaderField(timingAllowOrigin) : originalTimingAllowOrigin;
     if (timingAllowOriginString.isEmpty() || equalIgnoringCase(timingAllowOriginString, "null"))
         return false;
 
     if (timingAllowOriginString == starAtom)
         return true;
 
-    const String& securityOrigin = requestingDocument->securityOrigin()->toString();
+    const String& securityOrigin = initiatorSecurityOrigin.toString();
     Vector<String> timingAllowOrigins;
     timingAllowOriginString.string().split(' ', timingAllowOrigins);
     for (const String& allowOrigin : timingAllowOrigins) {
         if (allowOrigin == securityOrigin)
             return true;
     }
 
     return false;
 }
 
-static bool allowsTimingRedirect(const Vector<ResourceResponse>& redirectChain, const ResourceResponse& finalResponse, Document* initiatorDocument)
+static bool allowsTimingRedirect(const Vector<ResourceResponse>& redirectChain, const ResourceResponse& finalResponse, const SecurityOrigin& initiatorSecurityOrigin)
 {
-    if (!passesTimingAllowCheck(finalResponse, initiatorDocument, emptyAtom))
+    if (!passesTimingAllowCheck(finalResponse, initiatorSecurityOrigin, emptyAtom))
         return false;
 
     for (const ResourceResponse& response : redirectChain) {
-        if (!passesTimingAllowCheck(response, initiatorDocument, emptyAtom))
+        if (!passesTimingAllowCheck(response, initiatorSecurityOrigin, emptyAtom))
             return false;
     }
 
     return true;
 }
 
-void PerformanceBase::addResourceTiming(const ResourceTimingInfo& info, Document* initiatorDocument)
+void PerformanceBase::addResourceTiming(const ResourceTimingInfo& info)
 {
     if (isResourceTimingBufferFull())
         return;
+    SecurityOrigin* securityOrigin = nullptr;
+    if (ExecutionContext* context = executionContext())
+        securityOrigin = context->securityOrigin();
+    if (!securityOrigin)
+        return;
 
     const ResourceResponse& finalResponse = info.finalResponse();
-    bool allowTimingDetails = passesTimingAllowCheck(finalResponse, initiatorDocument, info.originalTimingAllowOrigin());
+    bool allowTimingDetails = passesTimingAllowCheck(finalResponse, *securityOrigin, info.originalTimingAllowOrigin());
     double startTime = info.initialTime();
 
     if (info.redirectChain().isEmpty()) {
-        PerformanceEntry* entry = PerformanceResourceTiming::create(info, initiatorDocument, startTime, allowTimingDetails);
+        PerformanceEntry* entry = PerformanceResourceTiming::create(info, timeOrigin(), startTime, allowTimingDetails);
         addResourceTimingBuffer(entry);
         return;
     }
 
     const Vector<ResourceResponse>& redirectChain = info.redirectChain();
-    bool allowRedirectDetails = allowsTimingRedirect(redirectChain, finalResponse, initiatorDocument);
+    bool allowRedirectDetails = allowsTimingRedirect(redirectChain, finalResponse, *securityOrigin);
 
     if (!allowRedirectDetails) {
         ResourceLoadTiming* finalTiming = finalResponse.resourceLoadTiming();
         ASSERT(finalTiming);
         if (finalTiming)
             startTime = finalTiming->requestTime();
     }
 
     ResourceLoadTiming* lastRedirectTiming = redirectChain.last().resourceLoadTiming();
     ASSERT(lastRedirectTiming);
     double lastRedirectEndTime = lastRedirectTiming->receiveHeadersEnd();
 
-    PerformanceEntry* entry = PerformanceResourceTiming::create(info, initiatorDocument, startTime, lastRedirectEndTime, allowTimingDetails, allowRedirectDetails);
+    PerformanceEntry* entry = PerformanceResourceTiming::create(info, timeOrigin(), startTime, lastRedirectEndTime, allowTimingDetails, allowRedirectDetails);
     addResourceTimingBuffer(entry);
 }
 
 void PerformanceBase::addResourceTimingBuffer(PerformanceEntry* entry)
 {
     m_resourceTimingBuffer.append(entry);
 
     if (isResourceTimingBufferFull())
         dispatchEvent(Event::create(EventTypeNames::webkitresourcetimingbufferfull));
 }
@@ skipping 69 matching lines @@
 
 DEFINE_TRACE(PerformanceBase)
 {
     visitor->trace(m_frameTimingBuffer);
     visitor->trace(m_resourceTimingBuffer);
     visitor->trace(m_userTiming);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace blink