Loading: move V8DOMActivityLogger dependency from core/fetch

third_party/WebKit/Source/core/loader/FrameFetchContext.cpp

 /*
  * Copyright (C) 2013 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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/loader/FrameFetchContext.h"
 
 #include "bindings/core/v8/ScriptController.h"
+#include "bindings/core/v8/V8DOMActivityLogger.h"
 #include "core/dom/Document.h"
 #include "core/fetch/ClientHintsPreferences.h"
+#include "core/fetch/FetchInitiatorTypeNames.h"
+#include "core/fetch/Resource.h"
 #include "core/fetch/ResourceLoadingLog.h"
 #include "core/fetch/UniqueIdentifier.h"
 #include "core/frame/FrameConsole.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLFrameOwnerElement.h"
@@ skipping 23 matching lines @@
 #include "platform/network/NetworkUtils.h"
 #include "platform/network/ResourceLoadPriority.h"
 #include "platform/network/ResourceTimingInfo.h"
 #include "platform/tracing/TracedValue.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebDocumentSubresourceFilter.h"
 #include "public/platform/WebInsecureRequestPolicy.h"
 #include "public/platform/WebViewScheduler.h"
+#include "wtf/Vector.h"
 #include <algorithm>
 #include <memory>
 
 namespace blink {
 
 namespace {
 
 void emitWarningForDocWriteScripts(const String& url, Document& document) {
   String message = "A Parser-blocking, cross-origin script, " + url +
                    ", is invoked via document.write. This may be blocked by "
@@ skipping 432 matching lines @@
 loadResourceTraceData(unsigned long identifier, const KURL& url, int priority) {
   String requestId = IdentifiersFactory::requestId(identifier);
 
   std::unique_ptr<TracedValue> value = TracedValue::create();
   value->setString("requestId", requestId);
   value->setString("url", url.getString());
   value->setInteger("priority", priority);
   return value;
 }
 
-void FrameFetchContext::willStartLoadingResource(unsigned long identifier,
-                                                 ResourceRequest& request,
-                                                 Resource::Type type) {
+void FrameFetchContext::willStartLoadingResource(
+    unsigned long identifier,
+    ResourceRequest& request,
+    Resource::Type type,
+    const AtomicString& fetchInitiatorName,
+    bool forPreload) {
   TRACE_EVENT_ASYNC_BEGIN1(
       "blink.net", "Resource", identifier, "data",
       loadResourceTraceData(identifier, request.url(), request.priority()));
   prepareRequest(request);
 
   if (!m_documentLoader || m_documentLoader->fetcher()->archive() ||
       !request.url().isValid())
     return;
   if (type == Resource::MainResource) {
     m_documentLoader->applicationCacheHost()->willStartLoadingMainResource(
         request);
   } else {
     m_documentLoader->applicationCacheHost()->willStartLoadingResource(request);
   }
+  if (!forPreload) {
+    V8DOMActivityLogger* activityLogger = nullptr;
+    if (fetchInitiatorName == FetchInitiatorTypeNames::xmlhttprequest) {
+      activityLogger = V8DOMActivityLogger::currentActivityLogger();
+    } else {
+      activityLogger =
+          V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
+    }
+
+    if (activityLogger) {
+      Vector<String> argv;
+      argv.append(Resource::resourceTypeToString(type, fetchInitiatorName));
+      argv.append(request.url());
+      activityLogger->logEvent("blinkRequestResource", argv.size(),
+                               argv.data());
+    }
+  }
 }
 
 void FrameFetchContext::didLoadResource(Resource* resource) {
   if (resource->isLoadEventBlockingResourceType())
     frame()->loader().checkCompleted();
   if (m_document)
     FirstMeaningfulPaintDetector::from(*m_document).checkNetworkStable();
 }
 
 void FrameFetchContext::addResourceTiming(const ResourceTimingInfo& info) {
@@ skipping 457 matching lines @@
                                                     response);
 }
 
 DEFINE_TRACE(FrameFetchContext) {
   visitor->trace(m_document);
   visitor->trace(m_documentLoader);
   FetchContext::trace(visitor);
 }
 
 }  // namespace blink