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

Source/modules/fetch/FetchManager.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "modules/fetch/FetchManager.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/fetch/FetchUtils.h"
 #include "core/fileapi/Blob.h"
 #include "core/frame/Frame.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/inspector/ConsoleMessage.h"
+#include "core/inspector/InspectorInstrumentation.h"
 #include "core/loader/ThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "modules/fetch/Body.h"
 #include "modules/fetch/BodyStreamBuffer.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
 #include "modules/fetch/FetchRequestData.h"
 #include "modules/fetch/Response.h"
 #include "modules/fetch/ResponseInit.h"
@@ skipping 119 matching lines @@
 
 void FetchManager::Loader::didFinishLoading(unsigned long, double)
 {
     ASSERT(!m_failed);
     m_finished = true;
 
     if (document() && document()->frame() && document()->frame()->page()
         && m_responseHttpStatusCode >= 200 && m_responseHttpStatusCode < 300) {
         document()->frame()->page()->chromeClient().ajaxSucceeded(document()->frame());
     }
-
+    InspectorInstrumentation::didFinishFetch(executionContext(), this, m_request->method(), m_request->url().string());
     notifyFinished();
 }
 
 void FetchManager::Loader::didFail(const ResourceError& error)
 {
     if (error.isCancellation() || error.isTimeout() || error.domain() != errorDomainBlinkInternal)
         failed(String());
     else
         failed("Fetch API cannot load " + error.failingURL() + ". " + error.localizedDescription());
 }
@@ skipping 204 matching lines @@
         threadableLoaderOptions.crossOriginRequestPolicy = DenyCrossOriginRequests;
         break;
     case WebURLRequest::FetchRequestModeNoCORS:
         threadableLoaderOptions.crossOriginRequestPolicy = AllowCrossOriginRequests;
         break;
     case WebURLRequest::FetchRequestModeCORS:
     case WebURLRequest::FetchRequestModeCORSWithForcedPreflight:
         threadableLoaderOptions.crossOriginRequestPolicy = UseAccessControl;
         break;
     }
+    InspectorInstrumentation::willStartFetch(executionContext(), this);
     m_loader = ThreadableLoader::create(*executionContext(), this, request, threadableLoaderOptions, resourceLoaderOptions);
-    if (!m_loader)
+    if (!m_loader) {
+        InspectorInstrumentation::didFailFetch(executionContext(), this);
         performNetworkError("Can't create ThreadableLoader");

[dgozman, 2015/07/31 06:50:38]

This method calls |failed| which in turn calls |didFailFetch|.
More generally, I think we should instrument exactly before every call to
|notifyFinished|.

+    }
 }
 
 void FetchManager::Loader::failed(const String& message)
 {
     if (m_failed || m_finished)
         return;
     m_failed = true;
     if (!message.isEmpty())
         executionContext()->addConsoleMessage(ConsoleMessage::create(JSMessageSource, ErrorMessageLevel, message));
     if (m_resolver) {
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
         ScriptState* state = m_resolver->scriptState();
         ScriptState::Scope scope(state);
         m_resolver->reject(V8ThrowException::createTypeError(state->isolate(), "Failed to fetch"));
     }
+    InspectorInstrumentation::didFailFetch(executionContext(), this);
     notifyFinished();
 }
 
 void FetchManager::Loader::notifyFinished()
 {
     if (m_fetchManager)
         m_fetchManager->onLoaderFinished(this);
 }
 
 FetchManager::FetchManager(ExecutionContext* executionContext)
@@ skipping 41 matching lines @@
 
 DEFINE_TRACE(FetchManager)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_executionContext);
     visitor->trace(m_loaders);
 #endif
 }
 
 } // namespace blink