Bug 1461672 - Remove Telemetry probe added to tune the JSBC. r=francois,bkelly
authorNicolas B. Pierron <nicolas.b.pierron@gmail.com>
Mon, 21 May 2018 13:40:04 +0000
changeset 419174 7ae884246635638898303dbceb50901a18fb5bf0
parent 419173 7614c38e5c0f7b3e8e0d34c3cf05f5a2bdac0789
child 419175 f266f3f133a9853da8381c591f174116a7fc6b8f
push id34029
push usershindli@mozilla.com
push dateMon, 21 May 2018 21:30:22 +0000
treeherdermozilla-central@51f2535c7974 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfrancois, bkelly
bugs1461672
milestone62.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1461672 - Remove Telemetry probe added to tune the JSBC. r=francois,bkelly
dom/base/UseCounter.h
dom/base/nsDocument.cpp
dom/base/nsIDocument.h
dom/script/ScriptLoadHandler.cpp
dom/script/ScriptLoader.cpp
toolkit/components/telemetry/Histograms.json
toolkit/components/telemetry/histogram-whitelists.json
--- a/dom/base/UseCounter.h
+++ b/dom/base/UseCounter.h
@@ -30,17 +30,11 @@ enum UseCounter : int16_t {
 #define DEPRECATED_OPERATION(op_) \
   eUseCounter_##op_,
 #include "nsDeprecatedOperationList.h"
 #undef DEPRECATED_OPERATION
 
   eUseCounter_Count
 };
 
-enum IncCounter : int16_t {
-  eIncCounter_UNKNOWN = -1,
-  eIncCounter_ScriptTag,
-  eIncCounter_Count
-};
-
 }
 
 #endif
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -1487,36 +1487,32 @@ nsIDocument::nsIDocument()
     mStaticCloneCount(0),
     mWindow(nullptr),
     mBFCacheEntry(nullptr),
     mInSyncOperationCount(0),
     mBlockDOMContentLoaded(0),
     mUseCounters(0),
     mChildDocumentUseCounters(0),
     mNotifiedPageForUseCounter(0),
-    mIncCounters(),
     mUserHasInteracted(false),
     mUserHasActivatedInteraction(false),
     mStackRefCnt(0),
     mUpdateNestLevel(0),
     mViewportType(Unknown),
     mSubDocuments(nullptr),
     mHeaderData(nullptr),
     mFlashClassification(FlashClassification::Unclassified),
     mBoxObjectTable(nullptr),
     mCurrentOrientationAngle(0),
     mCurrentOrientationType(OrientationType::Portrait_primary),
     mServoRestyleRootDirtyBits(0),
     mThrowOnDynamicMarkupInsertionCounter(0),
     mIgnoreOpensDuringUnloadCounter(0)
 {
   SetIsInDocument();
-  for (auto& cnt : mIncCounters) {
-    cnt = 0;
-  }
 }
 
 nsDocument::nsDocument(const char* aContentType)
   : nsIDocument()
 {
   SetContentTypeInternal(nsDependentCString(aContentType));
 
   MOZ_LOG(gDocumentLeakPRLog, LogLevel::Debug, ("DOCUMENT %p created", this));
@@ -12154,21 +12150,16 @@ nsIDocument::ReportUseCounters(UseCounte
             printf(": %d\n", value);
           }
 
           Telemetry::Accumulate(id, 1);
         }
       }
     }
   }
-
-  if (IsContentDocument() || IsResourceDoc()) {
-    uint16_t num = mIncCounters[eIncCounter_ScriptTag];
-    Telemetry::Accumulate(Telemetry::DOM_SCRIPT_EVAL_PER_DOCUMENT, num);
-  }
 }
 
 void
 nsIDocument::UpdateIntersectionObservations()
 {
   if (mIntersectionObservers.IsEmpty()) {
     return;
   }
--- a/dom/base/nsIDocument.h
+++ b/dom/base/nsIDocument.h
@@ -3376,21 +3376,16 @@ public:
   void SetDocumentAndPageUseCounter(mozilla::UseCounter aUseCounter)
   {
     SetDocumentUseCounter(aUseCounter);
     SetPageUseCounter(aUseCounter);
   }
 
   void PropagateUseCounters(nsIDocument* aParentDocument);
 
-  void SetDocumentIncCounter(mozilla::IncCounter aIncCounter, uint32_t inc = 1)
-  {
-    mIncCounters[aIncCounter] += inc;
-  }
-
   void SetUserHasInteracted(bool aUserHasInteracted);
   bool UserHasInteracted()
   {
     return mUserHasInteracted;
   }
 
   // This would be called when document get activated by specific user gestures
   // and propagate the user activation flag to its parent.
@@ -4236,19 +4231,16 @@ protected:
   // Flags for use counters used directly by this document.
   std::bitset<mozilla::eUseCounter_Count> mUseCounters;
   // Flags for use counters used by any child documents of this document.
   std::bitset<mozilla::eUseCounter_Count> mChildDocumentUseCounters;
   // Flags for whether we've notified our top-level "page" of a use counter
   // for this child document.
   std::bitset<mozilla::eUseCounter_Count> mNotifiedPageForUseCounter;
 
-  // Count the number of times something is seen in a document.
-  mozilla::Array<uint16_t, mozilla::eIncCounter_Count> mIncCounters;
-
   // Whether the user has interacted with the document or not:
   bool mUserHasInteracted;
 
   // Whether the user has interacted with the document via some specific user
   // gestures.
   bool mUserHasActivatedInteraction;
 
   mozilla::TimeStamp mPageUnloadingEventTimeStamp;
--- a/dom/script/ScriptLoadHandler.cpp
+++ b/dom/script/ScriptLoadHandler.cpp
@@ -158,21 +158,16 @@ ScriptLoadHandler::EnsureDecoder(nsIIncr
   if (mDecoder) {
     return true;
   }
 
   nsAutoCString charset;
   if (!EnsureDecoder(aLoader, aData, aDataLength, aEndOfStream, charset)) {
     return false;
   }
-  if (charset.Length() == 0) {
-    charset = "?";
-  }
-  mozilla::Telemetry::Accumulate(mozilla::Telemetry::DOM_SCRIPT_SRC_ENCODING,
-    charset);
   return true;
 }
 
 bool
 ScriptLoadHandler::EnsureDecoder(nsIIncrementalStreamLoader* aLoader,
                                  const uint8_t* aData,
                                  uint32_t aDataLength,
                                  bool aEndOfStream,
--- a/dom/script/ScriptLoader.cpp
+++ b/dom/script/ScriptLoader.cpp
@@ -188,72 +188,53 @@ ScriptLoader::~ScriptLoader()
   for (size_t i = 0; i < mPreloads.Length(); i++) {
     AccumulateCategorical(LABELS_DOM_SCRIPT_PRELOAD_RESULT::NotUsed);
   }
 }
 
 // Collect telemtry data about the cache information, and the kind of source
 // which are being loaded, and where it is being loaded from.
 static void
-CollectScriptTelemetry(nsIIncrementalStreamLoader* aLoader,
-                       ScriptLoadRequest* aRequest)
+CollectScriptTelemetry(ScriptLoadRequest* aRequest)
 {
   using namespace mozilla::Telemetry;
 
   // Skip this function if we are not running telemetry.
   if (!CanRecordExtended()) {
     return;
   }
 
   // Report the script kind.
   if (aRequest->IsModuleRequest()) {
     AccumulateCategorical(LABELS_DOM_SCRIPT_KIND::ModuleScript);
   } else {
     AccumulateCategorical(LABELS_DOM_SCRIPT_KIND::ClassicScript);
   }
 
-  // Report the type of source, as well as the size of the source.
+  // Report the type of source. This is used to monitor the status of the
+  // JavaScript Start-up Bytecode Cache, with the expectation of an almost zero
+  // source-fallback and alternate-data being roughtly equal to source loads.
   if (aRequest->IsLoadingSource()) {
     if (aRequest->mIsInline) {
       AccumulateCategorical(LABELS_DOM_SCRIPT_LOADING_SOURCE::Inline);
       nsAutoString inlineData;
       aRequest->mElement->GetScriptText(inlineData);
-      Accumulate(DOM_SCRIPT_INLINE_SIZE, inlineData.Length());
     } else if (aRequest->IsTextSource()) {
       AccumulateCategorical(LABELS_DOM_SCRIPT_LOADING_SOURCE::SourceFallback);
-      Accumulate(DOM_SCRIPT_SOURCE_SIZE, aRequest->ScriptText().length());
     }
     // TODO: Add telemetry for BinAST encoded source.
   } else {
     MOZ_ASSERT(aRequest->IsLoading());
     if (aRequest->IsTextSource()) {
       AccumulateCategorical(LABELS_DOM_SCRIPT_LOADING_SOURCE::Source);
-      Accumulate(DOM_SCRIPT_SOURCE_SIZE, aRequest->ScriptText().length());
     } else if (aRequest->IsBytecode()) {
       AccumulateCategorical(LABELS_DOM_SCRIPT_LOADING_SOURCE::AltData);
-      Accumulate(DOM_SCRIPT_BYTECODE_SIZE, aRequest->mScriptBytecode.length());
     }
     // TODO: Add telemetry for BinAST encoded source.
   }
-
-  // Skip if we do not have any cache information for the given script.
-  if (!aLoader) {
-    return;
-  }
-  nsCOMPtr<nsIRequest> channel;
-  aLoader->GetRequest(getter_AddRefs(channel));
-  nsCOMPtr<nsICacheInfoChannel> cic(do_QueryInterface(channel));
-  if (!cic) {
-    return;
-  }
-
-  int32_t fetchCount = 0;
-  if (NS_SUCCEEDED(cic->GetCacheTokenFetchCount(&fetchCount))) {
-    Accumulate(DOM_SCRIPT_FETCH_COUNT, fetchCount);
-  }
 }
 
 // Helper method for checking if the script element is an event-handler
 // This means that it has both a for-attribute and a event-attribute.
 // Also, if the for-attribute has a value that matches "\s*window\s*",
 // and the event-attribute matches "\s*onload([ \(].*)?" then it isn't an
 // eventhandler. (both matches are case insensitive).
 // This is how IE seems to filter out a window's onload handler from a
@@ -1514,17 +1495,17 @@ ScriptLoader::ProcessInlineScript(nsIScr
                       SRIMetadata(), // SRI doesn't apply
                       mDocument->GetReferrerPolicy());
   request->mIsInline = true;
   request->mTriggeringPrincipal = mDocument->NodePrincipal();
   request->mLineNo = aElement->GetScriptLineNumber();
   request->mProgress = ScriptLoadRequest::Progress::eLoading_Source;
   request->SetTextSource();
   TRACE_FOR_TEST_BOOL(request->mElement, "scriptloader_load_source");
-  CollectScriptTelemetry(nullptr, request);
+  CollectScriptTelemetry(request);
 
   // Only the 'async' attribute is heeded on an inline module script and
   // inline classic scripts ignore both these attributes.
   MOZ_ASSERT(!aElement->GetScriptDeferred());
   MOZ_ASSERT_IF(!request->IsModuleRequest(), !aElement->GetScriptAsync());
   request->SetScriptMode(false, aElement->GetScriptAsync());
 
   LOG(("ScriptLoadRequest (%p): Created request for inline script",
@@ -2194,30 +2175,16 @@ ScriptLoader::ShouldCacheBytecode(Script
       return false;
     }
   }
 
   LOG(("ScriptLoadRequest (%p): Bytecode-cache: Trigger encoding.", aRequest));
   return true;
 }
 
-static bool
-ShouldRecordParseTimeTelemetry(ScriptLoadRequest* aRequest)
-{
-  static const size_t MinScriptChars = 1024;
-  static const size_t MinBinASTBytes = 700;
-
-  if (aRequest->IsTextSource()) {
-    return aRequest->ScriptText().length() >= MinScriptChars;
-  } else {
-    MOZ_ASSERT(aRequest->IsBinASTSource());
-    return aRequest->ScriptBinASTData().length() >= MinBinASTBytes;
-  }
-}
-
 nsresult
 ScriptLoader::EvaluateScript(ScriptLoadRequest* aRequest)
 {
   using namespace mozilla::Telemetry;
   MOZ_ASSERT(aRequest->IsReadyToRun());
 
   // We need a document to evaluate scripts.
   if (!mDocument) {
@@ -2226,19 +2193,16 @@ ScriptLoader::EvaluateScript(ScriptLoadR
 
   nsCOMPtr<nsIContent> scriptContent(do_QueryInterface(aRequest->mElement));
   nsIDocument* ownerDoc = scriptContent->OwnerDoc();
   if (ownerDoc != mDocument) {
     // Willful violation of HTML5 as of 2010-12-01
     return NS_ERROR_FAILURE;
   }
 
-  // Report telemetry results of the number of scripts evaluated.
-  mDocument->SetDocumentIncCounter(IncCounter::eIncCounter_ScriptTag);
-
   // Get the script-type to be used by this element.
   NS_ASSERTION(scriptContent, "no content - what is default script-type?");
 
   nsCOMPtr<nsIScriptGlobalObject> globalObject = GetScriptGlobalObject();
   if (!globalObject) {
     return NS_ERROR_FAILURE;
   }
 
@@ -2313,80 +2277,58 @@ ScriptLoader::EvaluateScript(ScriptLoadR
       rv = FillCompileOptionsForRequest(aes, aRequest, global, &options);
 
       if (NS_SUCCEEDED(rv)) {
         if (aRequest->IsBytecode()) {
           TRACE_FOR_TEST(aRequest->mElement, "scriptloader_execute");
           nsJSUtils::ExecutionContext exec(cx, global);
           if (aRequest->mOffThreadToken) {
             LOG(("ScriptLoadRequest (%p): Decode Bytecode & Join and Execute", aRequest));
-            AutoTimer<DOM_SCRIPT_OFF_THREAD_DECODE_EXEC_MS> timer;
             rv = exec.DecodeJoinAndExec(&aRequest->mOffThreadToken);
           } else {
             LOG(("ScriptLoadRequest (%p): Decode Bytecode and Execute", aRequest));
-            AutoTimer<DOM_SCRIPT_MAIN_THREAD_DECODE_EXEC_MS> timer;
             rv = exec.DecodeAndExec(options, aRequest->mScriptBytecode,
                                     aRequest->mBytecodeOffset);
           }
           // We do not expect to be saving anything when we already have some
           // bytecode.
           MOZ_ASSERT(!aRequest->mCacheInfo);
         } else {
           MOZ_ASSERT(aRequest->IsSource());
           JS::Rooted<JSScript*> script(cx);
           bool encodeBytecode = ShouldCacheBytecode(aRequest);
 
-          TimeStamp start;
-          if (Telemetry::CanRecordExtended()) {
-            // Only record telemetry for scripts which are above a threshold.
-            if (aRequest->mCacheInfo && ShouldRecordParseTimeTelemetry(aRequest)) {
-                start = TimeStamp::Now();
-            }
-          }
-
           {
             nsJSUtils::ExecutionContext exec(cx, global);
             exec.SetEncodeBytecode(encodeBytecode);
             TRACE_FOR_TEST(aRequest->mElement, "scriptloader_execute");
             if (aRequest->mOffThreadToken) {
               // Off-main-thread parsing.
               LOG(("ScriptLoadRequest (%p): Join (off-thread parsing) and Execute",
                    aRequest));
               if (aRequest->IsBinASTSource()) {
                 rv = exec.DecodeBinASTJoinAndExec(&aRequest->mOffThreadToken, &script);
               } else {
                 MOZ_ASSERT(aRequest->IsTextSource());
                 rv = exec.JoinAndExec(&aRequest->mOffThreadToken, &script);
               }
-              if (start) {
-                AccumulateTimeDelta(encodeBytecode
-                                    ? DOM_SCRIPT_OFF_THREAD_PARSE_ENCODE_EXEC_MS
-                                    : DOM_SCRIPT_OFF_THREAD_PARSE_EXEC_MS,
-                                    start);
-              }
             } else {
               // Main thread parsing (inline and small scripts)
               LOG(("ScriptLoadRequest (%p): Compile And Exec", aRequest));
               if (aRequest->IsBinASTSource()) {
                 rv = exec.DecodeBinASTAndExec(options,
                                               aRequest->ScriptBinASTData().begin(),
                                               aRequest->ScriptBinASTData().length(),
                                               &script);
               } else {
                 MOZ_ASSERT(aRequest->IsTextSource());
                 nsAutoString inlineData;
                 SourceBufferHolder srcBuf = GetScriptSource(aRequest, inlineData);
                 rv = exec.CompileAndExec(options, srcBuf, &script);
               }
-              if (start) {
-                AccumulateTimeDelta(encodeBytecode
-                                    ? DOM_SCRIPT_MAIN_THREAD_PARSE_ENCODE_EXEC_MS
-                                    : DOM_SCRIPT_MAIN_THREAD_PARSE_EXEC_MS,
-                                    start);
-              }
             }
           }
 
           // Queue the current script load request to later save the bytecode.
           if (script && encodeBytecode) {
             aRequest->mScript = script;
             HoldJSObjects(aRequest);
             TRACE_FOR_TEST(aRequest->mElement, "scriptloader_encode");
@@ -2494,17 +2436,16 @@ ScriptLoader::EncodeBytecode()
   }
 
   nsCOMPtr<nsIScriptContext> context = globalObject->GetScriptContext();
   if (!context) {
     GiveUpBytecodeEncoding();
     return;
   }
 
-  Telemetry::AutoTimer<Telemetry::DOM_SCRIPT_ENCODING_MS_PER_DOCUMENT> timer;
   AutoEntryScript aes(globalObject, "encode bytecode", true);
   RefPtr<ScriptLoadRequest> request;
   while (!mBytecodeEncodingQueue.isEmpty()) {
     request = mBytecodeEncodingQueue.StealFirst();
     EncodeRequestBytecode(aes.cx(), request);
     request->mScriptBytecode.clearAndFree();
     request->DropBytecodeCacheReferences();
   }
@@ -2519,63 +2460,55 @@ ScriptLoader::EncodeRequestBytecode(JSCo
   auto bytecodeFailed = mozilla::MakeScopeExit([&]() {
     TRACE_FOR_TEST_NONE(aRequest->mElement, "scriptloader_bytecode_failed");
   });
 
   JS::RootedScript script(aCx, aRequest->mScript);
   if (!JS::FinishIncrementalEncoding(aCx, script, aRequest->mScriptBytecode)) {
     LOG(("ScriptLoadRequest (%p): Cannot serialize bytecode",
          aRequest));
-    AccumulateCategorical(LABELS_DOM_SCRIPT_ENCODING_STATUS::EncodingFailure);
     return;
   }
 
   if (aRequest->mScriptBytecode.length() >= UINT32_MAX) {
     LOG(("ScriptLoadRequest (%p): Bytecode cache is too large to be decoded correctly.",
          aRequest));
-    AccumulateCategorical(LABELS_DOM_SCRIPT_ENCODING_STATUS::BufferTooLarge);
     return;
   }
 
   // Open the output stream to the cache entry alternate data storage. This
   // might fail if the stream is already open by another request, in which
   // case, we just ignore the current one.
   nsCOMPtr<nsIOutputStream> output;
   rv = aRequest->mCacheInfo->OpenAlternativeOutputStream(nsContentUtils::JSBytecodeMimeType(),
                                                          aRequest->mScriptBytecode.length(),
                                                          getter_AddRefs(output));
   if (NS_FAILED(rv)) {
     LOG(("ScriptLoadRequest (%p): Cannot open bytecode cache (rv = %X, output = %p)",
          aRequest, unsigned(rv), output.get()));
-    AccumulateCategorical(LABELS_DOM_SCRIPT_ENCODING_STATUS::OpenFailure);
     return;
   }
   MOZ_ASSERT(output);
   auto closeOutStream = mozilla::MakeScopeExit([&]() {
     nsresult rv = output->Close();
     LOG(("ScriptLoadRequest (%p): Closing (rv = %X)",
          aRequest, unsigned(rv)));
-    if (NS_FAILED(rv)) {
-      AccumulateCategorical(LABELS_DOM_SCRIPT_ENCODING_STATUS::CloseFailure);
-    }
   });
 
   uint32_t n;
   rv = output->Write(reinterpret_cast<char*>(aRequest->mScriptBytecode.begin()),
                      aRequest->mScriptBytecode.length(), &n);
   LOG(("ScriptLoadRequest (%p): Write bytecode cache (rv = %X, length = %u, written = %u)",
        aRequest, unsigned(rv), unsigned(aRequest->mScriptBytecode.length()), n));
   if (NS_FAILED(rv)) {
-    AccumulateCategorical(LABELS_DOM_SCRIPT_ENCODING_STATUS::WriteFailure);
     return;
   }
 
   bytecodeFailed.release();
   TRACE_FOR_TEST_NONE(aRequest->mElement, "scriptloader_bytecode_saved");
-  AccumulateCategorical(LABELS_DOM_SCRIPT_ENCODING_STATUS::EncodingSuccess);
 }
 
 void
 ScriptLoader::GiveUpBytecodeEncoding()
 {
   // If the document went away prematurely, we still want to set this, in order
   // to avoid queuing more scripts.
   mGiveUpEncoding = true;
@@ -2811,20 +2744,16 @@ ScriptLoader::ConvertToUTF16(nsIChannel*
   Tie(result, read, written, hadErrors) = unicodeDecoder->DecodeToUTF16(
     data, MakeSpan(aBufOut, unicodeLength.value()), true);
   MOZ_ASSERT(result == kInputEmpty);
   MOZ_ASSERT(read == aLength);
   MOZ_ASSERT(written <= unicodeLength.value());
   Unused << hadErrors;
   aLengthOut = written;
 
-  nsAutoCString charset;
-  unicodeDecoder->Encoding()->Name(charset);
-  mozilla::Telemetry::Accumulate(mozilla::Telemetry::DOM_SCRIPT_SRC_ENCODING,
-    charset);
   return NS_OK;
 }
 
 nsresult
 ScriptLoader::OnStreamComplete(nsIIncrementalStreamLoader* aLoader,
                                ScriptLoadRequest* aRequest,
                                nsresult aChannelStatus,
                                nsresult aSRIStatus,
@@ -3130,17 +3059,17 @@ ScriptLoader::PrepareLoadedRequest(Scrip
   if (NS_FAILED(aStatus)) {
     return aStatus;
   }
 
   if (aRequest->IsCanceled()) {
     return NS_BINDING_ABORTED;
   }
   MOZ_ASSERT(aRequest->IsLoading());
-  CollectScriptTelemetry(aLoader, aRequest);
+  CollectScriptTelemetry(aRequest);
 
   // If we don't have a document, then we need to abort further
   // evaluation.
   if (!mDocument) {
     return NS_ERROR_NOT_AVAILABLE;
   }
 
   // If the load returned an error page, then we need to abort
--- a/toolkit/components/telemetry/Histograms.json
+++ b/toolkit/components/telemetry/Histograms.json
@@ -12393,168 +12393,25 @@
     "record_in_processes": ["main", "content"],
     "alert_emails": ["jcoppeard@mozilla.com"],
     "expires_in_version": "63",
     "kind": "categorical",
     "bug_numbers": [1430145],
     "labels": ["ClassicScript", "ModuleScript"],
     "description": "Record the kind of every script loaded in a document."
   },
-  "DOM_SCRIPT_SRC_ENCODING": {
-    "record_in_processes": ["main", "content"],
-    "alert_emails": ["dteller@mozilla.com"],
-    "expires_in_version": "61",
-    "kind": "count",
-    "keyed": true,
-    "bug_numbers": [1344152],
-    "description": "Note the encoding (e.g. 'UTF-8', 'windows-1252', 'ASCII') of each external <script> element that is successfully loaded and decoded."
-  },
   "DOM_SCRIPT_LOADING_SOURCE": {
     "record_in_processes": ["content"],
     "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
+    "expires_in_version": "never",
     "kind": "categorical",
     "bug_numbers": [1362114],
     "labels": ["Inline", "SourceFallback", "Source", "AltData"],
     "description": "Record the input from which the bytes are coming from, for each script in a document."
   },
-  "DOM_SCRIPT_INLINE_SIZE": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "exponential",
-    "low": 64,
-    "high": 16000000,
-    "n_buckets": 50,
-    "bug_numbers": [1362114],
-    "description": "Size (in number of characters) of each script which is inlined in a document."
-  },
-  "DOM_SCRIPT_SOURCE_SIZE": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "exponential",
-    "low": 64,
-    "high": 16000000,
-    "n_buckets": 50,
-    "bug_numbers": [1362114],
-    "description": "Size (in number of characters) of each script which is streamed in plain-text in a document."
-  },
-  "DOM_SCRIPT_BYTECODE_SIZE": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "exponential",
-    "low": 64,
-    "high": 16000000,
-    "n_buckets": 50,
-    "bug_numbers": [1362114],
-    "description": "Size (in number of bytes) of each script which is streamed in encoded-format in a document."
-  },
-  "DOM_SCRIPT_FETCH_COUNT": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "linear",
-    "low": 1,
-    "high": 100,
-    "n_buckets": 99,
-    "bug_numbers": [1362114],
-    "description": "For each script in a document, record the number of times it was requested since it got saved in the cache."
-  },
-  "DOM_SCRIPT_MAIN_THREAD_PARSE_EXEC_MS": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "exponential",
-    "high": 50000,
-    "n_buckets": 100,
-    "bug_numbers": [1362114],
-    "description": "Time, in milliseconds, needed to parse and execute a script (which might be encoded later) on the main thread."
-  },
-  "DOM_SCRIPT_MAIN_THREAD_PARSE_ENCODE_EXEC_MS": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "exponential",
-    "high": 50000,
-    "n_buckets": 100,
-    "bug_numbers": [1362114],
-    "description": "Time, in milliseconds, needed to parse, encode and execute a script on the main thread."
-  },
-  "DOM_SCRIPT_MAIN_THREAD_DECODE_EXEC_MS": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "exponential",
-    "high": 50000,
-    "n_buckets": 100,
-    "bug_numbers": [1362114],
-    "description": "Time, in milliseconds, needed to decode and execute a script on the main thread."
-  },
-  "DOM_SCRIPT_OFF_THREAD_PARSE_EXEC_MS": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "exponential",
-    "high": 50000,
-    "n_buckets": 100,
-    "bug_numbers": [1362114],
-    "description": "Time, in milliseconds, needed to parse off-main-thread and execute a script (which might be encoded later) on the main thread."
-  },
-  "DOM_SCRIPT_OFF_THREAD_PARSE_ENCODE_EXEC_MS": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "exponential",
-    "high": 50000,
-    "n_buckets": 100,
-    "bug_numbers": [1362114],
-    "description": "Time, in milliseconds, needed to parse off-main-thread, encode and execute a script on the main thread."
-  },
-  "DOM_SCRIPT_OFF_THREAD_DECODE_EXEC_MS": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "exponential",
-    "high": 50000,
-    "n_buckets": 100,
-    "bug_numbers": [1362114],
-    "description": "Time, in milliseconds, needed to decode off-main-thread and execute a script on the main thread."
-  },
-  "DOM_SCRIPT_ENCODING_MS_PER_DOCUMENT": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "linear",
-    "high": 64,
-    "n_buckets": 32,
-    "bug_numbers": [1362114],
-    "description": "Time, in milliseconds, needed to encode all scripts in a document."
-  },
-  "DOM_SCRIPT_ENCODING_STATUS": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "categorical",
-    "bug_numbers": [1362114],
-    "labels": ["EncodingFailure", "BufferTooLarge", "OpenFailure", "WriteFailure", "CloseFailure", "EncodingSuccess"],
-    "description": "Record the failure reasons of the JavaScript Start-up Bytecode Cache encoder."
-  },
-  "DOM_SCRIPT_EVAL_PER_DOCUMENT": {
-    "record_in_processes": ["content"],
-    "alert_emails": ["nicolas.b.pierron@mozilla.com"],
-    "expires_in_version": "62",
-    "kind": "linear",
-    "low": 1,
-    "high": 200,
-    "n_buckets": 50,
-    "bug_numbers": [1362114],
-    "description": "Number of script tags evaluated per document."
-  },
   "DOM_SCRIPT_PRELOAD_RESULT": {
     "record_in_processes": ["main", "content"],
     "alert_emails": ["jcoppeard@mozilla.com"],
     "expires_in_version": "63",
     "kind": "categorical",
     "bug_numbers": [1430145],
     "labels": ["Used", "RejectedByPolicy", "RequestMismatch", "LoadError", "NotUsed"],
     "description": "Whether a preloaded script was used or the reason it was not used."
--- a/toolkit/components/telemetry/histogram-whitelists.json
+++ b/toolkit/components/telemetry/histogram-whitelists.json
@@ -1548,17 +1548,16 @@
     "DEVTOOLS_STORAGE_OPENED_COUNT",
     "DEVTOOLS_STYLEEDITOR_OPENED_COUNT",
     "DEVTOOLS_TOOLBOX_OPENED_COUNT",
     "DEVTOOLS_WEBAUDIOEDITOR_OPENED_COUNT",
     "DEVTOOLS_WEBCONSOLE_OPENED_COUNT",
     "DEVTOOLS_WEBIDE_IMPORT_PROJECT_COUNT",
     "DEVTOOLS_WEBIDE_NEW_PROJECT_COUNT",
     "DEVTOOLS_WEBIDE_OPENED_COUNT",
-    "DOM_SCRIPT_SRC_ENCODING",
     "ENABLE_PRIVILEGE_EVER_CALLED",
     "FENNEC_DISTRIBUTION_REFERRER_INVALID",
     "FENNEC_ORBOT_INSTALLED",
     "FENNEC_RESTORING_ACTIVITY",
     "FENNEC_SESSIONSTORE_ALL_FILES_DAMAGED",
     "FENNEC_SESSIONSTORE_DAMAGED_SESSION_FILE",
     "FENNEC_SESSIONSTORE_RESTORING_FROM_BACKUP",
     "FENNEC_SYNC11_MIGRATIONS_COMPLETED",