Add metrics for tracking time between "script loaded" and "script compiled".

Source/core/html/parser/HTMLScriptRunner.cpp

 /*
  * Copyright (C) 2010 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 20 matching lines @@
 #include "core/events/Event.h"
 #include "core/dom/IgnoreDestructiveWriteCountIncrementer.h"
 #include "core/dom/Microtask.h"
 #include "core/dom/ScriptLoader.h"
 #include "core/fetch/ScriptResource.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/parser/HTMLInputStream.h"
 #include "core/html/parser/HTMLScriptRunnerHost.h"
 #include "core/html/parser/NestingLevelIncrementer.h"
 #include "platform/NotImplemented.h"
+#include "public/platform/Platform.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 HTMLScriptRunner::HTMLScriptRunner(Document* document, HTMLScriptRunnerHost* host)
     : m_document(document)
     , m_host(host)
     , m_scriptNestingLevel(0)
     , m_hasScriptsWaitingForResources(false)
@@ skipping 108 matching lines @@
         NestingLevelIncrementer nestingLevelIncrementer(m_scriptNestingLevel);
         IgnoreDestructiveWriteCountIncrementer ignoreDestructiveWriteCountIncrementer(m_document);
         if (errorOccurred)
             scriptLoader->dispatchErrorEvent();
         else {
             ASSERT(isExecutingScript());
             scriptLoader->executeScript(sourceCode);
             element->dispatchEvent(createScriptLoadEvent());
         }
     }
+    if (sourceCode.resource()) {
+        double timeBetweenLoadedAndCompiledMs = (WTF::monotonicallyIncreasingTime() - sourceCode.resource()->loadFinishTime()) * 1000;
+        const char* histogramName = pendingScriptType == PendingScriptBlockingParser ? "WebCore.Scripts.ParsingBlocking.TimeBetweenLoadedAndCompiled" : "WebCore.Scripts.Deferred.TimeBetweenLoadedAndCompiled";
+        blink::Platform::current()->histogramCustomCounts(histogramName, timeBetweenLoadedAndCompiledMs, 0, 10000, 50);
+    }
+
     ASSERT(!isExecutingScript());
 }
 
 void HTMLScriptRunner::watchForLoad(PendingScript& pendingScript)
 {
     ASSERT(!pendingScript.watchingForLoad());
     ASSERT(!pendingScript.resource()->isLoaded());
     // addClient() will call notifyFinished() if the load is complete.
     // Callers do not expect to be re-entered from this call, so they
     // should not become a client of an already-loaded Resource.
@@ skipping 86 matching lines @@
     return true;
 }
 
 void HTMLScriptRunner::requestParsingBlockingScript(Element* element)
 {
     if (!requestPendingScript(m_parserBlockingScript, element))
         return;
 
     ASSERT(m_parserBlockingScript.resource());
 
+    blink::Platform::current()->histogramEnumeration("WebCore.Scripts.ParsingBlocking.AlreadyLoaded", m_parserBlockingScript.resource()->isLoaded() ? 1 : 0, 2);
     // We only care about a load callback if resource is not already
     // in the cache. Callers will attempt to run the m_parserBlockingScript
     // if possible before returning control to the parser.
     if (!m_parserBlockingScript.resource()->isLoaded())
         watchForLoad(m_parserBlockingScript);
 }
 
 void HTMLScriptRunner::requestDeferredScript(Element* element)
 {
     PendingScript pendingScript;
@@ skipping 66 matching lines @@
 
 void HTMLScriptRunner::trace(Visitor* visitor)
 {
     visitor->trace(m_document);
     visitor->trace(m_host);
     visitor->trace(m_parserBlockingScript);
     visitor->trace(m_scriptsToExecuteAfterParsing);
 }
 
 }