DevTools: add support for logging fetch requests when XHR logging is enabled

Source/core/inspector/InspectorResourceAgent.cpp

 /*
  * Copyright (C) 2011 Google 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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 293 matching lines @@
 #endif
 }
 
 DEFINE_TRACE(InspectorResourceAgent)
 {
     visitor->trace(m_pageAgent);
     visitor->trace(m_replayXHRs);
     visitor->trace(m_replayXHRsToBeDeleted);
 
 #if ENABLE(OILPAN)
-    visitor->trace(m_pendingXHRReplayData);
+    visitor->trace(m_pendingRequest);
 #endif
     InspectorBaseAgent::trace(visitor);
 }
 
 void InspectorResourceAgent::willSendRequest(unsigned long identifier, DocumentLoader* loader, ResourceRequest& request, const ResourceResponse& redirectResponse, const FetchInitiatorInfo& initiatorInfo)
 {
     // Ignore the request initiated internally.
     if (initiatorInfo.name == FetchInitiatorTypeNames::internal)
         return;
 
@@ skipping 154 matching lines @@
     m_resourcesData->setResourceContent(IdentifiersFactory::requestId(identifier), sourceString);
 }
 
 void InspectorResourceAgent::didReceiveScriptResponse(unsigned long identifier)
 {
     m_resourcesData->setResourceType(IdentifiersFactory::requestId(identifier), InspectorPageAgent::ScriptResource);
 }
 
 void InspectorResourceAgent::documentThreadableLoaderStartedLoadingForClient(unsigned long identifier, ThreadableLoaderClient* client)
 {
-    if (!client)
+    if (!client || client != m_pendingRequest)
         return;
 
-    if (client == m_pendingEventSource) {
-        m_eventSourceRequestIdMap.set(client, identifier);
-        m_pendingEventSource = nullptr;
-    }
-
-    if (client == m_pendingXHR) {
-        String requestId = IdentifiersFactory::requestId(identifier);
-        m_resourcesData->setResourceType(requestId, InspectorPageAgent::XHRResource);
+    m_knownRequestIdMap.set(client, identifier);
+    String requestId = IdentifiersFactory::requestId(identifier);
+    m_resourcesData->setResourceType(requestId, m_pendingRequestType);
+    if (m_pendingRequestType == InspectorPageAgent::XHRResource) {
         m_resourcesData->setXHRReplayData(requestId, m_pendingXHRReplayData.get());
-        m_xhrRequestIdMap.set(client, identifier);
-        m_pendingXHR = nullptr;
         m_pendingXHRReplayData.clear();
     }
+    m_pendingRequest = nullptr;
 }
 
 void InspectorResourceAgent::willLoadXHR(XMLHttpRequest* xhr, ThreadableLoaderClient* client, const AtomicString& method, const KURL& url, bool async, PassRefPtr<FormData> formData, const HTTPHeaderMap& headers, bool includeCredentials)
 {
     ASSERT(xhr);
-    ASSERT(!m_pendingXHR);
-    m_pendingXHR = client;
+    ASSERT(!m_pendingRequest);
+    m_pendingRequest = client;
+    m_pendingRequestType = InspectorPageAgent::XHRResource;
     m_pendingXHRReplayData = XHRReplayData::create(xhr->executionContext(), method, urlWithoutFragment(url), async, formData.get(), includeCredentials);
     for (const auto& header : headers)
         m_pendingXHRReplayData->addHeader(header.key, header.value);
 }
 
 void InspectorResourceAgent::delayedRemoveReplayXHR(XMLHttpRequest* xhr)
 {
     if (!m_replayXHRs.contains(xhr))
         return;
 
     m_replayXHRsToBeDeleted.add(xhr);
     m_replayXHRs.remove(xhr);
     m_removeFinishedReplayXHRTimer.startOneShot(0, FROM_HERE);
 }
 
 void InspectorResourceAgent::didFailXHRLoading(ExecutionContext* context, XMLHttpRequest* xhr, ThreadableLoaderClient* client, const AtomicString& method, const String& url)
 {
     didFinishXHRInternal(context, xhr, client, method, url, false);
 }
 
 void InspectorResourceAgent::didFinishXHRLoading(ExecutionContext* context, XMLHttpRequest* xhr, ThreadableLoaderClient* client, const AtomicString& method, const String& url)
 {
     didFinishXHRInternal(context, xhr, client, method, url, true);
 }
 
 void InspectorResourceAgent::didFinishXHRInternal(ExecutionContext* context, XMLHttpRequest* xhr, ThreadableLoaderClient* client, const AtomicString& method, const String& url, bool success)
 {
-    m_pendingXHR = nullptr;
+    m_pendingRequest = nullptr;

[dgozman, 2015/07/29 15:26:07]

I think didFinishXHR may come asynchronously after delay and |m_pendingRequest|
may be the other one (or even fetch request).

     m_pendingXHRReplayData.clear();
 
     // This method will be called from the XHR.
     // We delay deleting the replay XHR, as deleting here may delete the caller.
     delayedRemoveReplayXHR(xhr);
 
-    ThreadableLoaderClientRequestIdMap::iterator it = m_xhrRequestIdMap.find(client);
-    if (it == m_xhrRequestIdMap.end())
+    ThreadableLoaderClientRequestIdMap::iterator it = m_knownRequestIdMap.find(client);
+    if (it == m_knownRequestIdMap.end())
         return;
 
     if (m_state->getBoolean(ResourceAgentState::monitoringXHR)) {
         String message = (success ? "XHR finished loading: " : "XHR failed loading: ") + method + " \"" + url + "\".";
         RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(NetworkMessageSource, DebugMessageLevel, message);
         consoleMessage->setRequestIdentifier(it->value);
         m_pageAgent->frameHost()->consoleMessageStorage().reportMessage(context, consoleMessage.release());
     }
-    m_xhrRequestIdMap.remove(client);
+    m_knownRequestIdMap.remove(client);
+}
+
+void InspectorResourceAgent::willStartFetch(ThreadableLoaderClient* client)
+{
+    ASSERT(!m_pendingRequest);
+    m_pendingRequest = client;
+    m_pendingRequestType = InspectorPageAgent::FetchResource;
+}
+
+void InspectorResourceAgent::didFailFetch(ThreadableLoaderClient* client)
+{
+    completeFetch(client);
+}
+
+void InspectorResourceAgent::didFinishFetch(ExecutionContext* context, ThreadableLoaderClient* client, const AtomicString& method, const String& url)
+{
+    ThreadableLoaderClientRequestIdMap::iterator it = m_knownRequestIdMap.find(client);
+    if (it == m_knownRequestIdMap.end())
+        return;
+
+    if (m_state->getBoolean(ResourceAgentState::monitoringXHR)) {
+        String message = "Fetch complete: " + method + " \"" + url + "\".";
+        RefPtrWillBeRawPtr<ConsoleMessage> consoleMessage = ConsoleMessage::create(NetworkMessageSource, DebugMessageLevel, message);
+        consoleMessage->setRequestIdentifier(it->value);
+        m_pageAgent->frameHost()->consoleMessageStorage().reportMessage(context, consoleMessage.release());
+    }
+    completeFetch(client);
+}
+
+void InspectorResourceAgent::completeFetch(ThreadableLoaderClient* client)

[dgozman, 2015/07/29 15:26:07]

Inline this?

+{
+    m_knownRequestIdMap.remove(client);
 }
 
 void InspectorResourceAgent::willSendEventSourceRequest(ThreadableLoaderClient* eventSource)
 {
-    ASSERT(!m_pendingEventSource);
-    m_pendingEventSource = eventSource;
+    ASSERT(!m_pendingRequest);
+    m_pendingRequest = eventSource;
+    m_pendingRequestType = InspectorPageAgent::EventSourceResource;
 }
 
 void InspectorResourceAgent::willDispachEventSourceEvent(ThreadableLoaderClient* eventSource, const AtomicString& eventName, const AtomicString& eventId, const Vector<UChar>& data)
 {
-    ThreadableLoaderClientRequestIdMap::iterator it = m_eventSourceRequestIdMap.find(eventSource);
-    if (it == m_eventSourceRequestIdMap.end())
+    ThreadableLoaderClientRequestIdMap::iterator it = m_knownRequestIdMap.find(eventSource);
+    if (it == m_knownRequestIdMap.end())
         return;
     frontend()->eventSourceMessageReceived(IdentifiersFactory::requestId(it->value), monotonicallyIncreasingTime(), eventName.string(), eventId.string(), String(data));
 }
 
 void InspectorResourceAgent::didFinishEventSourceRequest(ThreadableLoaderClient* eventSource)
 {
-    m_eventSourceRequestIdMap.remove(eventSource);
-    if (eventSource == m_pendingEventSource)
-        m_pendingEventSource = nullptr;
+    m_knownRequestIdMap.remove(eventSource);
+    m_pendingRequest = nullptr;
 }
 
 void InspectorResourceAgent::willDestroyResource(Resource* cachedResource)
 {
     Vector<String> requestIds = m_resourcesData->removeResource(cachedResource);
     if (!requestIds.size())
         return;
 
     String content;
     bool base64Encoded;
@@ skipping 128 matching lines @@
 void InspectorResourceAgent::enable()
 {
     if (!frontend())
         return;
     m_state->setBoolean(ResourceAgentState::resourceAgentEnabled, true);
     m_instrumentingAgents->setInspectorResourceAgent(this);
 }
 
 void InspectorResourceAgent::disable(ErrorString*)
 {
-    ASSERT(!m_pendingXHR);
-    ASSERT(!m_pendingEventSource);
+    ASSERT(!m_pendingRequest);

[dgozman, 2015/07/29 15:26:07]

Should we clear |m_knownRequestIdMap| here?

     m_state->setBoolean(ResourceAgentState::resourceAgentEnabled, false);
     m_state->setString(ResourceAgentState::userAgentOverride, "");
     m_instrumentingAgents->setInspectorResourceAgent(0);
     m_resourcesData->clear();
 }
 
 void InspectorResourceAgent::setUserAgentOverride(ErrorString*, const String& userAgent)
 {
     m_state->setString(ResourceAgentState::userAgentOverride, userAgent);
 }
@@ skipping 179 matching lines @@
 
 void InspectorResourceAgent::removeFinishedReplayXHRFired(Timer<InspectorResourceAgent>*)
 {
     m_replayXHRsToBeDeleted.clear();
 }
 
 InspectorResourceAgent::InspectorResourceAgent(InspectorPageAgent* pageAgent)
     : InspectorBaseAgent<InspectorResourceAgent, InspectorFrontend::Network>("Network")
     , m_pageAgent(pageAgent)
     , m_resourcesData(adoptPtr(new NetworkResourcesData()))
-    , m_pendingXHR(nullptr)
-    , m_pendingEventSource(nullptr)
+    , m_pendingRequest(nullptr)
     , m_isRecalculatingStyle(false)
     , m_removeFinishedReplayXHRTimer(this, &InspectorResourceAgent::removeFinishedReplayXHRFired)
 {
 }
 
 bool InspectorResourceAgent::shouldForceCORSPreflight()
 {
     return m_state->getBoolean(ResourceAgentState::cacheDisabled);
 }
 
 } // namespace blink