Loading: move V8DOMActivityLogger dependency from core/fetch

Now, core/fetch has a dependency to bindings/core/, but this won't be
permitted once the directory is moved to platform/loader/fetch.

This patch moves this last unexpected dependency, and make it
finally possible to move under platform/.

BUG=655920

Review-Url: https://codereview.chromium.org/2578983002
Cr-Commit-Position: refs/heads/master@{#439806}

third_party/WebKit/Source/core/fetch/DEPS

 include_rules = [
+    "-bindings",
     "-core",
     "+core/CoreExport.h",
     "+core/fetch",

third_party/WebKit/Source/core/fetch/FetchContext.cpp

@@ -89,9 +89,12 @@ void FetchContext::dispatchDidFail(unsigned long,
                                    int64_t,
                                    bool) {}
 
-void FetchContext::willStartLoadingResource(unsigned long,
-                                            ResourceRequest&,
-                                            Resource::Type) {}
+void FetchContext::willStartLoadingResource(
+    unsigned long,
+    ResourceRequest&,
+    Resource::Type,
+    const AtomicString& fetchInitiatorName,
+    bool) {}
 
 void FetchContext::didLoadResource(Resource*) {}
 

third_party/WebKit/Source/core/fetch/FetchContext.h

@@ -39,6 +39,7 @@
 #include "platform/heap/Handle.h"
 #include "platform/network/ResourceLoadPriority.h"
 #include "platform/network/ResourceRequest.h"
+#include "wtf/Forward.h"
 #include "wtf/Noncopyable.h"
 
 namespace blink {
@@ -122,13 +123,17 @@ class CORE_EXPORT FetchContext
   virtual bool shouldLoadNewResource(Resource::Type) const { return false; }
   // Called when a resource load is first requested, which may not be when the
   // load actually begins.
+  // TODO(toyoshim): Consider to use enum. See https://crbug.com/675883.
   virtual void willStartLoadingResource(unsigned long identifier,
                                         ResourceRequest&,
-                                        Resource::Type);
+                                        Resource::Type,
+                                        const AtomicString& fetchInitiatorName,
+                                        bool forPreload);
   virtual void didLoadResource(Resource*);
 
   virtual void addResourceTiming(const ResourceTimingInfo&);
   virtual bool allowImage(bool, const KURL&) const { return false; }
+  // TODO(toyoshim): Consider to use enum. See https://crbug.com/675883.
   virtual ResourceRequestBlockedReason canRequest(
       Resource::Type,
       const ResourceRequest&,

third_party/WebKit/Source/core/fetch/FetchRequest.h

@@ -55,6 +55,10 @@ class CORE_EXPORT FetchRequest {
     DisallowPlaceholder = 0,  // The requested image must not be a placeholder.
     AllowPlaceholder,         // The image is allowed to be a placeholder.
   };
+  // TODO(toyoshim): Consider to define an enum for preload options, and use it
+  // instead of bool in this class, FrameFetchContext, and so on. If it is
+  // reasonable, we try merging m_forPreload and m_linkPreload into one enum
+  // type. See https://crbug.com/675883.
 
   struct ResourceWidth {
     DISALLOW_NEW();

third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp

@@ -27,7 +27,6 @@
 
 #include "core/fetch/ResourceFetcher.h"
 
-#include "bindings/core/v8/V8DOMActivityLogger.h"
 #include "core/fetch/FetchContext.h"
 #include "core/fetch/FetchInitiatorTypeNames.h"
 #include "core/fetch/MemoryCache.h"
@@ -491,30 +490,11 @@ Resource* ResourceFetcher::requestResource(
   }
 
   context().willStartLoadingResource(
-      identifier, request.mutableResourceRequest(), factory.type());
+      identifier, request.mutableResourceRequest(), factory.type(),
+      request.options().initiatorInfo.name, request.forPreload());
   if (!request.url().isValid())
     return nullptr;
 
-  if (!request.forPreload()) {
-    V8DOMActivityLogger* activityLogger = nullptr;
-    if (request.options().initiatorInfo.name ==
-        FetchInitiatorTypeNames::xmlhttprequest) {
-      activityLogger = V8DOMActivityLogger::currentActivityLogger();
-    } else {
-      activityLogger =
-          V8DOMActivityLogger::currentActivityLoggerIfIsolatedWorld();
-    }
-
-    if (activityLogger) {
-      Vector<String> argv;
-      argv.push_back(Resource::resourceTypeToString(
-          factory.type(), request.options().initiatorInfo.name));
-      argv.push_back(request.url());
-      activityLogger->logEvent("blinkRequestResource", argv.size(),
-                               argv.data());
-    }
-  }
-
   bool isDataUrl = request.resourceRequest().url().protocolIsData();
   bool isStaticData = isDataUrl || substituteData.isValid() || m_archive;
   Resource* resource(nullptr);

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

@@ -31,8 +31,11 @@
 #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"
@@ -76,6 +79,7 @@
 #include "public/platform/WebDocumentSubresourceFilter.h"
 #include "public/platform/WebInsecureRequestPolicy.h"
 #include "public/platform/WebViewScheduler.h"
+#include "wtf/Vector.h"
 #include <algorithm>
 #include <memory>
 
@@ -528,9 +532,12 @@ loadResourceTraceData(unsigned long identifier, const KURL& url, int 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()));
@@ -545,6 +552,23 @@ void FrameFetchContext::willStartLoadingResource(unsigned long identifier,
   } 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) {

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

@@ -38,6 +38,7 @@
 #include "core/loader/LinkLoader.h"
 #include "platform/heap/Handle.h"
 #include "platform/network/ResourceRequest.h"
+#include "wtf/Forward.h"
 
 namespace blink {
 
@@ -112,7 +113,9 @@ class CORE_EXPORT FrameFetchContext final : public FetchContext {
   bool shouldLoadNewResource(Resource::Type) const override;
   void willStartLoadingResource(unsigned long identifier,
                                 ResourceRequest&,
-                                Resource::Type) override;
+                                Resource::Type,
+                                const AtomicString& fetchInitiatorName,
+                                bool forPreload) override;
   void didLoadResource(Resource*) override;
 
   void addResourceTiming(const ResourceTimingInfo&) override;

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

@@ -249,7 +249,8 @@ PingLoaderImpl::PingLoaderImpl(LocalFrame* frame,
 
   FetchContext& fetchContext = frame->document()->fetcher()->context();
 
-  fetchContext.willStartLoadingResource(m_identifier, request, Resource::Image);
+  fetchContext.willStartLoadingResource(m_identifier, request, Resource::Image,
+                                        initiator, false);
 
   FetchInitiatorInfo initiatorInfo;
   initiatorInfo.name = initiator;