Remove Enumeration Histograms from the Blink Platform API.

third_party/WebKit/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 "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/Histogram.h"
 #include "platform/SharedBuffer.h"
 #include "platform/Task.h"
 #include "platform/ThreadSafeFunctional.h"
 #include "platform/TraceEvent.h"
-#include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "wtf/MainThread.h"
 #include "wtf/text/TextEncodingRegistry.h"
 
 namespace blink {
 
 namespace {
 
-const char* startedStreamingHistogramName(ScriptStreamer::Type scriptType)
+void recordStartedStreamingHistogram(ScriptStreamer::Type scriptType, int reason)
 {
     switch (scriptType) {
-    case ScriptStreamer::ParsingBlocking:
-        return "WebCore.Scripts.ParsingBlocking.StartedStreaming";
+    case ScriptStreamer::ParsingBlocking: {
+        DEFINE_STATIC_LOCAL(EnumerationHistogram, parseBlockingHistogram, ("WebCore.Scripts.ParsingBlocking.StartedStreaming", 2));

[esprehn, 2016/02/05 19:09:07]

You might want to ask haraken about this one. ScriptStreamer is used on another
thread, but I don't know if it's ever used on multiple threads.

[dtapuska, 2016/02/05 19:25:32]

All of these methods are called before an ASSERT(isMainThread()) is on the
stack...

Look at notifyFinished, startStreamingInternal, etc..

+        parseBlockingHistogram.count(reason);
         break;
-    case ScriptStreamer::Deferred:
-        return "WebCore.Scripts.Deferred.StartedStreaming";
+    }
+    case ScriptStreamer::Deferred: {
+        DEFINE_STATIC_LOCAL(EnumerationHistogram, deferredHistogram, ("WebCore.Scripts.Deferred.StartedStreaming", 2));
+        deferredHistogram.count(reason);
         break;
-    case ScriptStreamer::Async:
-        return "WebCore.Scripts.Async.StartedStreaming";
+    }
+    case ScriptStreamer::Async: {
+        DEFINE_STATIC_LOCAL(EnumerationHistogram, asyncHistogram, ("WebCore.Scripts.Async.StartedStreaming", 2));
+        asyncHistogram.count(reason);
         break;
+    }
     default:
         ASSERT_NOT_REACHED();
         break;
     }
-    return 0;
 }
 
 // For tracking why some scripts are not streamed. Not streaming is part of
 // normal operation (e.g., script already loaded, script too small) and doesn't
 // necessarily indicate a failure.
 enum NotStreamingReason {
     AlreadyLoaded,
     NotHTTP,
     Reload,
     ContextNotValid,
     EncodingNotSupported,
     ThreadBusy,
     V8CannotStream,
     ScriptTooSmall,
     NotStreamingReasonEnd
 };
 
-const char* notStreamingReasonHistogramName(ScriptStreamer::Type scriptType)
+void recordNotStreamingReasonHistogram(ScriptStreamer::Type scriptType, NotStreamingReason reason)
 {
     switch (scriptType) {
-    case ScriptStreamer::ParsingBlocking:
-        return "WebCore.Scripts.ParsingBlocking.NotStreamingReason";
+    case ScriptStreamer::ParsingBlocking: {
+        DEFINE_STATIC_LOCAL(EnumerationHistogram, parseBlockingHistogram, ("WebCore.Scripts.ParsingBlocking.NotStreamingReason", NotStreamingReasonEnd));
+        parseBlockingHistogram.count(reason);
         break;
-    case ScriptStreamer::Deferred:
-        return "WebCore.Scripts.Deferred.NotStreamingReason";
+    }
+    case ScriptStreamer::Deferred: {
+        DEFINE_STATIC_LOCAL(EnumerationHistogram, deferredHistogram, ("WebCore.Scripts.Deferred.NotStreamingReason", NotStreamingReasonEnd));
+        deferredHistogram.count(reason);
         break;
-    case ScriptStreamer::Async:
-        return "WebCore.Scripts.Async.NotStreamingReason";
+    }
+    case ScriptStreamer::Async: {
+        DEFINE_STATIC_LOCAL(EnumerationHistogram, asyncHistogram, ("WebCore.Scripts.Async.NotStreamingReason", NotStreamingReasonEnd));
+        asyncHistogram.count(reason);
         break;
+    }
     default:
         ASSERT_NOT_REACHED();
         break;
     }
-    return 0;
 }
 
 } // namespace
 
 // 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:
@@ skipping 288 matching lines @@
 
 size_t ScriptStreamer::s_smallScriptThreshold = 30 * 1024;
 
 void ScriptStreamer::startStreaming(PendingScript* script, Type scriptType, Settings* settings, ScriptState* scriptState, WebTaskRunner* loadingTaskRunner)
 {
     // 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, scriptType, settings, scriptState, loadingTaskRunner);
     if (!startedStreaming)
-        Platform::current()->histogramEnumeration(startedStreamingHistogramName(scriptType), 0, 2);
+        recordStartedStreamingHistogram(scriptType, 0);
 }
 
 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 87 matching lines @@
         const char* data = 0;
         size_t length = resource->resourceBuffer()->getSomeData(data, static_cast<size_t>(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();
-            Platform::current()->histogramEnumeration(notStreamingReasonHistogramName(m_scriptType), EncodingNotSupported, NotStreamingReasonEnd);
-            Platform::current()->histogramEnumeration(startedStreamingHistogramName(m_scriptType), 0, 2);
+            recordNotStreamingReasonHistogram(m_scriptType, EncodingNotSupported);
+            recordStartedStreamingHistogram(m_scriptType, 0);
             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();
-            Platform::current()->histogramEnumeration(notStreamingReasonHistogramName(m_scriptType), ThreadBusy, NotStreamingReasonEnd);
-            Platform::current()->histogramEnumeration(startedStreamingHistogramName(m_scriptType), 0, 2);
+            recordNotStreamingReasonHistogram(m_scriptType, ThreadBusy);
+            recordStartedStreamingHistogram(m_scriptType, 0);
             return;
         }
 
         if (!m_scriptState->contextIsValid()) {
             suppressStreaming();
-            Platform::current()->histogramEnumeration(notStreamingReasonHistogramName(m_scriptType), ContextNotValid, NotStreamingReasonEnd);
-            Platform::current()->histogramEnumeration(startedStreamingHistogramName(m_scriptType), 0, 2);
+            recordNotStreamingReasonHistogram(m_scriptType, ContextNotValid);
+            recordStartedStreamingHistogram(m_scriptType, 0);
             return;
         }
 
         ASSERT(!m_stream);
         ASSERT(!m_source);
         m_stream = new SourceStream(m_loadingTaskRunner.get());
         // 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();
-            Platform::current()->histogramEnumeration(notStreamingReasonHistogramName(m_scriptType), V8CannotStream, NotStreamingReasonEnd);
-            Platform::current()->histogramEnumeration(startedStreamingHistogramName(m_scriptType), 0, 2);
+            recordNotStreamingReasonHistogram(m_scriptType, V8CannotStream);
+            recordStartedStreamingHistogram(m_scriptType, 0);
             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();
         ScriptStreamerThread::shared()->postTask(new Task(threadSafeBind(&ScriptStreamerThread::runScriptStreamingTask, scriptStreamingTask.release(), AllowCrossThreadAccess(this))));
-        Platform::current()->histogramEnumeration(startedStreamingHistogramName(m_scriptType), 1, 2);
+        recordStartedStreamingHistogram(m_scriptType, 1);
     }
     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) {
-        Platform::current()->histogramEnumeration(notStreamingReasonHistogramName(m_scriptType), ScriptTooSmall, NotStreamingReasonEnd);
-        Platform::current()->histogramEnumeration(startedStreamingHistogramName(m_scriptType), 0, 2);
+        recordNotStreamingReasonHistogram(m_scriptType, ScriptTooSmall);
+        recordStartedStreamingHistogram(m_scriptType, 0);
         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 68 matching lines @@
     if (m_client)
         m_client->notifyFinished(m_resource);
 }
 
 bool ScriptStreamer::startStreamingInternal(PendingScript* script, Type scriptType, Settings* settings, ScriptState* scriptState, WebTaskRunner* loadingTaskRunner)
 {
     ASSERT(isMainThread());
     ASSERT(scriptState->contextIsValid());
     ScriptResource* resource = script->resource();
     if (resource->isLoaded()) {
-        Platform::current()->histogramEnumeration(notStreamingReasonHistogramName(scriptType), AlreadyLoaded, NotStreamingReasonEnd);
+        recordNotStreamingReasonHistogram(scriptType, AlreadyLoaded);
         return false;
     }
     if (!resource->url().protocolIsInHTTPFamily()) {
-        Platform::current()->histogramEnumeration(notStreamingReasonHistogramName(scriptType), NotHTTP, NotStreamingReasonEnd);
+        recordNotStreamingReasonHistogram(scriptType, NotHTTP);
         return false;
     }
     if (resource->isCacheValidator()) {
-        Platform::current()->histogramEnumeration(notStreamingReasonHistogramName(scriptType), Reload, NotStreamingReasonEnd);
+        recordNotStreamingReasonHistogram(scriptType, Reload);
         // 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.
 
     // Decide what kind of cached data we should produce while streaming. Only
     // produce parser cache if the non-streaming compile takes advantage of it.
     v8::ScriptCompiler::CompileOptions compileOption = v8::ScriptCompiler::kNoCompileOptions;
     if (settings->v8CacheOptions() == V8CacheOptionsParse)
         compileOption = v8::ScriptCompiler::kProduceParserCache;
 
     // 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, scriptType, scriptState, compileOption, loadingTaskRunner));
 
     return true;
 }
 
 } // namespace blink