[Resource Timing] Expose redirect timing information

Source/core/loader/cache/CachedResourceLoader.cpp

 /*
     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
     Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
     Copyright (C) 2009 Torch Mobile Inc. http://www.torchmobile.com/
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
@@ skipping 32 matching lines @@
 #include "DocumentLoader.h"
 #include "Frame.h"
 #include "FrameLoader.h"
 #include "FrameLoaderClient.h"
 #include "HTMLElement.h"
 #include "HTMLFrameOwnerElement.h"
 #include "Logging.h"
 #include "MemoryCache.h"
 #include "Performance.h"
 #include "PingLoader.h"
+#include "ResourceTimingInfo.h"
 #include "SecurityOrigin.h"
 #include "Settings.h"
 #include <wtf/MemoryInstrumentationHashMap.h>
 #include <wtf/MemoryInstrumentationHashSet.h>
 #include <wtf/MemoryInstrumentationListHashSet.h>
 #include <wtf/UnusedParam.h>
 #include <wtf/text/CString.h>
 #include <wtf/text/WTFString.h>
 
 #include "CachedTextTrack.h"
@@ skipping 415 matching lines @@
 
     if (!memoryCache()->add(resource.get()))
         resource->setOwningCachedResourceLoader(this);
     storeResourceTimingInitiatorInformation(resource, request);
     return resource;
 }
 
 void CachedResourceLoader::storeResourceTimingInitiatorInformation(const CachedResourceHandle<CachedResource>& resource, const CachedResourceRequest& request)
 {
     if (resource->type() == CachedResource::MainResource) {
         // <iframe>s should report the initial navigation requested by the parent document, but not subsequent navigations.

[Pan, 2013/04/23 15:27:38]

I don't quite understand here, and seems it affects 
some tests that use iframe, like
http/tests/w3c/webperf/submission/Intel/resource-timing/test_resource_timing_cross_origin_resource_request.html
any idea? or I'm going to investigate tomorrow.

[Pan, 2013/04/25 12:40:51]

The problem is
m_documentLoader->frameLoader()->stateMachine()->committingFirstRealLoad(),
consider:
Case A: iframe mark up with src="", then changed to src=R2 via script.
Case B: iframe mark up with src=R1, then changed to src=R2 via script.
In current loader implementation, stateMachine of frameLoader is in state
"CommittedFirstRealLoad" at the time just before loading R2 for both A and B. (A
load "about:blank" firstly), so R2 won't be populated.

In latest editor draft of Resource Timing[1], section 4.2 example 3 describes
case A, it said "about:blank" and R2 should be populated (Personally, I don't
think populating "about:blank" make sense, especially un-touch network at all).

To populate R2 in case A, and avoid touch the state machine, I think we may need
a new flag in FrameLoader, named like "LoadedNonEmptyDocument", set it true when
state machine advanced to "CommittedFirstRealLoad" for a non-empty load.

is it practical?

thanks
Pan

[1]
https://dvcs.w3.org/hg/webperf/raw-file/tip/specs/ResourceTiming/Overview.html

         if (frame()->ownerElement() && m_documentLoader->frameLoader()->stateMachine()->committingFirstRealLoad()) {
-            InitiatorInfo info = { frame()->ownerElement()->localName(), monotonicallyIncreasingTime() };
-            m_initiatorMap.add(resource.get(), info);
+            ResourceTimingInfo info(frame()->ownerElement()->localName(), monotonicallyIncreasingTime());
+            m_resourceTimingInfoMap.add(resource.get(), info);
         }
     } else {
-        InitiatorInfo info = { request.initiatorName(), monotonicallyIncreasingTime() };
-        m_initiatorMap.add(resource.get(), info);
+        ResourceTimingInfo info(request.initiatorName(), monotonicallyIncreasingTime());
+        m_resourceTimingInfoMap.add(resource.get(), info);
     }
 }
 
 CachedResourceLoader::RevalidationPolicy CachedResourceLoader::determineRevalidationPolicy(CachedResource::Type type, ResourceRequest& request, bool forPreload, CachedResource* existingResource, CachedResourceRequest::DeferOption defer) const
 {
     if (!existingResource)
         return Load;
 
     // We already have a preload going for this URL.
     if (forPreload && existingResource->isPreloaded())
@@ skipping 161 matching lines @@
 void CachedResourceLoader::removeCachedResource(CachedResource* resource) const
 {
 #ifndef NDEBUG
     DocumentResourceMap::iterator it = m_documentResources.find(resource->url());
     if (it != m_documentResources.end())
         ASSERT(it->value.get() == resource);
 #endif
     m_documentResources.remove(resource->url());
 }
 
+void CachedResourceLoader::redirectReceived(CachedResource* resource, const ResourceResponse& redirectResponse)
+{
+    HashMap<CachedResource*, ResourceTimingInfo>::iterator infoIter = m_resourceTimingInfoMap.find(resource);
+    if (infoIter != m_resourceTimingInfoMap.end())
+        infoIter->value.addRedirect(redirectResponse);
+}
+
 void CachedResourceLoader::loadDone(CachedResource* resource)
 {
     RefPtr<DocumentLoader> protectDocumentLoader(m_documentLoader);
     RefPtr<Document> protectDocument(m_document);
 
     if (resource && resource->response().isHTTP() && ((!resource->errorOccurred() && !resource->wasCanceled()) || resource->response().httpStatusCode() == 304)) {
-        HashMap<CachedResource*, InitiatorInfo>::iterator initiatorIt = m_initiatorMap.find(resource);
-        if (initiatorIt != m_initiatorMap.end()) {
+        HashMap<CachedResource*, ResourceTimingInfo>::iterator infoIt = m_resourceTimingInfoMap.find(resource);
+        if (infoIt != m_resourceTimingInfoMap.end()) {
             ASSERT(document());
             Document* initiatorDocument = document();
             if (resource->type() == CachedResource::MainResource)
                 initiatorDocument = document()->parentDocument();
             ASSERT(initiatorDocument);
-            const InitiatorInfo& info = initiatorIt->value;
-            initiatorDocument->domWindow()->performance()->addResourceTiming(info.name, initiatorDocument, resource->resourceRequest(), resource->response(), info.startTime, resource->loadFinishTime());
-            m_initiatorMap.remove(initiatorIt);
+            ResourceTimingInfo& info = infoIt->value;
+            info.setInitialRequest(resource->resourceRequest());
+            info.setFinalResponse(resource->response());
+            info.setLoadFinishTime(resource->loadFinishTime());
+            initiatorDocument->domWindow()->performance()->addResourceTiming(info, initiatorDocument);
+            m_resourceTimingInfoMap.remove(infoIt);
         }
     }
 
     if (frame())
         frame()->loader()->loadDone();
     performPostLoadActions();
 
     if (!m_garbageCollectDocumentResourcesTimer.isActive())
         m_garbageCollectDocumentResourcesTimer.startOneShot(0);
 }
@@ skipping 212 matching lines @@
 void CachedResourceLoader::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 {
     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::Loader);
     info.addMember(m_documentResources, "documentResources");
     info.addMember(m_document, "document");
     info.addMember(m_documentLoader, "documentLoader");
     info.addMember(m_validatedURLs, "validatedURLs");
     info.addMember(m_preloads, "preloads");
     info.addMember(m_pendingPreloads, "pendingPreloads");
     info.addMember(m_garbageCollectDocumentResourcesTimer, "garbageCollectDocumentResourcesTimer");
-    // FIXME: m_initiatorMap has pointers to already deleted CachedResources
-    info.ignoreMember(m_initiatorMap);
+    // FIXME: m_resourceTimingInfoMap has pointers to already deleted CachedResources
+    info.ignoreMember(m_resourceTimingInfoMap);
 }
 
 const ResourceLoaderOptions& CachedResourceLoader::defaultCachedResourceOptions()
 {
     static ResourceLoaderOptions options(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck);
     return options;
 }
 
 }