Script streaming: add UMA for tracking the reason why we don't stream.

Source/bindings/core/v8/ScriptStreamer.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 "bindings/core/v8/ScriptStreamer.h"
 
 #include "bindings/core/v8/ScriptStreamerThread.h"
 #include "bindings/core/v8/V8ScriptRunner.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/PendingScript.h"
 #include "core/fetch/ScriptResource.h"
 #include "core/frame/Settings.h"
 #include "core/html/parser/TextResourceDecoder.h"
 #include "platform/SharedBuffer.h"
 #include "platform/TraceEvent.h"
 #include "public/platform/Platform.h"
 #include "wtf/MainThread.h"
 #include "wtf/text/TextEncodingRegistry.h"
 
 namespace blink {
 
 namespace {
-const char* kHistogramName = "WebCore.Scripts.Async.StartedStreaming";
+const char* kStartedStreamingHistogramName = "WebCore.Scripts.Async.StartedStreaming";
+const char* kNotStreamingReasonHistogramName = "WebCore.Scripts.Async.NotStreamingReason";
 }
 
 // For passing data between the main thread (producer) and the streamer thread
 // (consumer). The main thread prepares the data (copies it from Resource) and
 // the streamer thread feeds it to V8.
 class SourceStreamDataQueue {
     WTF_MAKE_NONCOPYABLE(SourceStreamDataQueue);
 public:
     SourceStreamDataQueue()
         : m_finished(false) { }
@@ skipping 186 matching lines @@
 
 size_t ScriptStreamer::kSmallScriptThreshold = 30 * 1024;
 
 void ScriptStreamer::startStreaming(PendingScript& script, Settings* settings, ScriptState* scriptState)
 {
     // We don't yet know whether the script will really be streamed. E.g.,
     // suppressing streaming for short scripts is done later. Record only the
     // sure negative cases here.
     bool startedStreaming = startStreamingInternal(script, settings, scriptState);
     if (!startedStreaming)
-        blink::Platform::current()->histogramEnumeration(kHistogramName, 0, 2);
+        blink::Platform::current()->histogramEnumeration(kStartedStreamingHistogramName, 0, 2);
 }
 
 bool ScriptStreamer::convertEncoding(const char* encodingName, v8::ScriptCompiler::StreamedSource::Encoding* encoding)
 {
     // Here's a list of encodings we can use for streaming. These are
     // the canonical names.
     if (strcmp(encodingName, "windows-1252") == 0
         || strcmp(encodingName, "ISO-8859-1") == 0
         || strcmp(encodingName, "US-ASCII") == 0) {
         *encoding = v8::ScriptCompiler::StreamedSource::ONE_BYTE;
@@ skipping 73 matching lines @@
         const char* data = 0;
         unsigned length = resource->resourceBuffer()->getSomeData(data, 0);
 
         OwnPtr<TextResourceDecoder> decoder(TextResourceDecoder::create("application/javascript", resource->encoding()));
         lengthOfBOM = decoder->checkForBOM(data, length);
 
         // Maybe the encoding changed because we saw the BOM; get the encoding
         // from the decoder.
         if (!convertEncoding(decoder->encoding().name(), &m_encoding)) {
             suppressStreaming();
-            blink::Platform::current()->histogramEnumeration(kHistogramName, 0, 2);
+            blink::Platform::current()->histogramEnumeration(kNotStreamingReasonHistogramName, 4, 8);
+            blink::Platform::current()->histogramEnumeration(kStartedStreamingHistogramName, 0, 2);
             return;
         }
         if (ScriptStreamerThread::shared()->isRunningTask()) {
             // At the moment we only have one thread for running the tasks. A
             // new task shouldn't be queued before the running task completes,
             // because the running task can block and wait for data from the
             // network.
             suppressStreaming();
-            blink::Platform::current()->histogramEnumeration(kHistogramName, 0, 2);
+            blink::Platform::current()->histogramEnumeration(kNotStreamingReasonHistogramName, 5, 8);
+            blink::Platform::current()->histogramEnumeration(kStartedStreamingHistogramName, 0, 2);
             return;
         }
 
         if (!m_scriptState->contextIsValid()) {
             suppressStreaming();
-            blink::Platform::current()->histogramEnumeration(kHistogramName, 0, 2);
+            blink::Platform::current()->histogramEnumeration(kNotStreamingReasonHistogramName, 3, 8);
+            blink::Platform::current()->histogramEnumeration(kStartedStreamingHistogramName, 0, 2);
             return;
         }
 
         ASSERT(!m_stream);
         ASSERT(!m_source);
         m_stream = new SourceStream();
         // m_source takes ownership of m_stream.
         m_source = adoptPtr(new v8::ScriptCompiler::StreamedSource(m_stream, m_encoding));
 
         ScriptState::Scope scope(m_scriptState.get());
         WTF::OwnPtr<v8::ScriptCompiler::ScriptStreamingTask> scriptStreamingTask(adoptPtr(v8::ScriptCompiler::StartStreamingScript(m_scriptState->isolate(), m_source.get(), m_compileOptions)));
         if (!scriptStreamingTask) {
             // V8 cannot stream the script.
             suppressStreaming();
             m_stream = 0;
             m_source.clear();
-            blink::Platform::current()->histogramEnumeration(kHistogramName, 0, 2);
+            blink::Platform::current()->histogramEnumeration(kNotStreamingReasonHistogramName, 6, 8);
+            blink::Platform::current()->histogramEnumeration(kStartedStreamingHistogramName, 0, 2);
             return;
         }
 
         // ScriptStreamer needs to stay alive as long as the background task is
         // running. This is taken care of with a manual ref() & deref() pair;
         // the corresponding deref() is in streamingComplete.
         ref();
         ScriptStreamingTask* task = new ScriptStreamingTask(scriptStreamingTask.release(), this);
         ScriptStreamerThread::shared()->postTask(task);
-        blink::Platform::current()->histogramEnumeration(kHistogramName, 1, 2);
+        blink::Platform::current()->histogramEnumeration(kStartedStreamingHistogramName, 1, 2);
     }
     if (m_stream)
         m_stream->didReceiveData(this, lengthOfBOM);
 }
 
 void ScriptStreamer::notifyFinished(Resource* resource)
 {
     ASSERT(isMainThread());
     ASSERT(m_resource == resource);
     // A special case: empty and small scripts. We didn't receive enough data to
     // start the streaming before this notification. In that case, there won't
     // be a "parsing complete" notification either, and we should not wait for
     // it.
     if (!m_haveEnoughDataForStreaming) {
-        blink::Platform::current()->histogramEnumeration(kHistogramName, 0, 2);
+        blink::Platform::current()->histogramEnumeration(kNotStreamingReasonHistogramName, 7, 8);
+        blink::Platform::current()->histogramEnumeration(kStartedStreamingHistogramName, 0, 2);
         suppressStreaming();
     }
     if (m_stream)
         m_stream->didFinishLoading();
     m_loadingFinished = true;
 
     // Calling notifyFinishedToClient can result into the upper layers dropping
     // references to ScriptStreamer. Keep it alive until this function ends.
     RefPtrWillBeRawPtr<ScriptStreamer> protect(this);
 
@@ skipping 66 matching lines @@
             return;
     }
     if (m_client)
         m_client->notifyFinished(m_resource);
 }
 
 bool ScriptStreamer::startStreamingInternal(PendingScript& script, Settings* settings, ScriptState* scriptState)
 {
     ASSERT(isMainThread());
     ScriptResource* resource = script.resource();
-    if (resource->isLoaded())
+    if (resource->isLoaded()) {
+        blink::Platform::current()->histogramEnumeration(kNotStreamingReasonHistogramName, 0, 8);
         return false;
-    if (!resource->url().protocolIsInHTTPFamily())
+    }
+    if (!resource->url().protocolIsInHTTPFamily()) {
+        blink::Platform::current()->histogramEnumeration(kNotStreamingReasonHistogramName, 1, 8);
         return false;
+    }
     if (resource->resourceToRevalidate()) {
+        blink::Platform::current()->histogramEnumeration(kNotStreamingReasonHistogramName, 2, 8);
         // This happens e.g., during reloads. We're actually not going to load
         // the current Resource of the PendingScript but switch to another
         // Resource -> don't stream.
         return false;
     }
     // We cannot filter out short scripts, even if we wait for the HTTP headers
     // to arrive: the Content-Length HTTP header is not sent for chunked
     // downloads.
 
-    if (!scriptState->contextIsValid())
+    if (!scriptState->contextIsValid()) {
+        blink::Platform::current()->histogramEnumeration(kNotStreamingReasonHistogramName, 3, 8);

[Ilya Sherman, 2015/03/23 22:14:44]

Could you please use enumerated constant names, rather than using opaque
constants?  One advantage is that if you ever need to update the list, it's a
lot less likely that the upper bound will be forgotten.

         return false;
+    }
 
     // Decide what kind of cached data we should produce while streaming. By
     // default, we generate the parser cache for streamed scripts, to emulate
     // the non-streaming behavior (see V8ScriptRunner::compileScript).
     v8::ScriptCompiler::CompileOptions compileOption = v8::ScriptCompiler::kProduceParserCache;
     if (settings->v8CacheOptions() == V8CacheOptionsCode || settings->v8CacheOptions() == V8CacheOptionsCodeCompressed)
         compileOption = v8::ScriptCompiler::kProduceCodeCache;
 
     // The Resource might go out of scope if the script is no longer
     // needed. This makes PendingScript notify the ScriptStreamer when it is
     // destroyed.
     script.setStreamer(ScriptStreamer::create(resource, scriptState, compileOption));
 
     return true;
 }
 
 } // namespace blink