Bug 1330907 - Rename Telemetry::ID to Telemetry::HistogramID. r=dexter
authorVedant Sareen <vedant.sareen@students.iiit.ac.in>
Thu, 16 Feb 2017 00:45:15 +0530
changeset 390248 abdc71fec220dd2186e8a6cbc7d0e47cefe17d0a
parent 390247 e952a5cc4a140c1c4015d6a3311732f944a2b90f
child 390249 fb7e5fc472624a04ace2d8a6dc9cf08ffb61b24e
push id7198
push userjlorenzo@mozilla.com
push dateTue, 18 Apr 2017 12:07:49 +0000
treeherdermozilla-beta@d57aa49c3948 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdexter
bugs1330907
milestone54.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 1330907 - Rename Telemetry::ID to Telemetry::HistogramID. r=dexter Changed |print("enum ID : uint32_t {", file=output)| to |print("enum HistogramID : uint32_t {", file=output)| at line 53 of the file |toolkit/components/telemetry/gen-histogram-enum.py|, and then replaced all the textual occurrences of |Telemetry::ID| to |Telemetry::HistogramID| and |ID| to |HistogramID| in 43 other files.
dom/base/nsDocument.cpp
dom/media/Benchmark.cpp
dom/media/MediaDecoder.cpp
dom/media/eme/DetailedPromise.cpp
dom/media/eme/DetailedPromise.h
dom/media/ogg/OggDemuxer.cpp
dom/media/platforms/wmf/WMFAudioMFTManager.cpp
dom/media/platforms/wmf/WMFVideoMFTManager.cpp
dom/media/webaudio/MediaBufferDecoder.cpp
dom/storage/StorageCache.cpp
dom/storage/StorageCache.h
image/Decoder.h
image/decoders/nsGIFDecoder2.cpp
image/decoders/nsGIFDecoder2.h
image/decoders/nsJPEGDecoder.cpp
image/decoders/nsJPEGDecoder.h
image/decoders/nsPNGDecoder.cpp
image/decoders/nsPNGDecoder.h
layout/base/nsPresContext.cpp
media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.cpp
netwerk/base/nsSocketTransport2.cpp
netwerk/base/nsSocketTransport2.h
netwerk/cache/nsCacheService.cpp
netwerk/cache/nsCacheService.h
netwerk/cache2/CacheIOThread.cpp
netwerk/dns/nsHostResolver.cpp
netwerk/protocol/http/Http2Compression.h
security/certverifier/CertVerifier.h
security/manager/ssl/PublicKeyPinningService.cpp
security/manager/ssl/RootCertificateTelemetryUtils.cpp
security/manager/ssl/RootCertificateTelemetryUtils.h
security/manager/ssl/SSLServerCertVerification.cpp
security/manager/ssl/nsNSSCallbacks.cpp
security/manager/ssl/nsNSSIOLayer.cpp
storage/TelemetryVFS.cpp
toolkit/components/places/Helpers.h
toolkit/components/telemetry/Telemetry.cpp
toolkit/components/telemetry/Telemetry.h
toolkit/components/telemetry/TelemetryHistogram.cpp
toolkit/components/telemetry/TelemetryHistogram.h
toolkit/components/telemetry/gen-histogram-enum.py
toolkit/components/telemetry/ipc/TelemetryComms.h
toolkit/components/telemetry/ipc/TelemetryIPCAccumulator.cpp
toolkit/components/telemetry/ipc/TelemetryIPCAccumulator.h
widget/android/nsAppShell.cpp
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -12552,18 +12552,18 @@ nsDocument::ReportUseCounters(UseCounter
     if (IsTopLevelContentDocument()) {
       Telemetry::Accumulate(Telemetry::TOP_LEVEL_CONTENT_DOCUMENTS_DESTROYED, 1);
     }
 
     for (int32_t c = 0;
          c < eUseCounter_Count; ++c) {
       UseCounter uc = static_cast<UseCounter>(c);
 
-      Telemetry::ID id =
-        static_cast<Telemetry::ID>(Telemetry::HistogramFirstUseCounter + uc * 2);
+      Telemetry::HistogramID id =
+        static_cast<Telemetry::HistogramID>(Telemetry::HistogramFirstUseCounter + uc * 2);
       bool value = GetUseCounter(uc);
 
       if (value) {
         if (sDebugUseCounters) {
           const char* name = Telemetry::GetHistogramName(id);
           if (name) {
             printf("  %s", name);
           } else {
@@ -12571,18 +12571,18 @@ nsDocument::ReportUseCounters(UseCounter
           }
           printf(": %d\n", value);
         }
 
         Telemetry::Accumulate(id, 1);
       }
 
       if (IsTopLevelContentDocument()) {
-        id = static_cast<Telemetry::ID>(Telemetry::HistogramFirstUseCounter +
-                                        uc * 2 + 1);
+        id = static_cast<Telemetry::HistogramID>(Telemetry::HistogramFirstUseCounter +
+                                                 uc * 2 + 1);
         value = GetUseCounter(uc) || GetChildDocumentUseCounter(uc);
 
         if (value) {
           if (sDebugUseCounters) {
             const char* name = Telemetry::GetHistogramName(id);
             if (name) {
               printf("  %s", name);
             } else {
--- a/dom/media/Benchmark.cpp
+++ b/dom/media/Benchmark.cpp
@@ -68,17 +68,17 @@ VP9Benchmark::IsVP9DecodeFast()
           if (contentChild) {
             contentChild->SendNotifyBenchmarkResult(NS_LITERAL_STRING("VP9"),
                                                     aDecodeFps);
           }
         } else {
           Preferences::SetUint(sBenchmarkFpsPref, aDecodeFps);
           Preferences::SetUint(sBenchmarkFpsVersionCheck, sBenchmarkVersionID);
         }
-        Telemetry::Accumulate(Telemetry::ID::VIDEO_VP9_BENCHMARK_FPS, aDecodeFps);
+        Telemetry::Accumulate(Telemetry::HistogramID::VIDEO_VP9_BENCHMARK_FPS, aDecodeFps);
       },
       []() { });
   }
 
   if (!hasPref) {
     return false;
   }
 
--- a/dom/media/MediaDecoder.cpp
+++ b/dom/media/MediaDecoder.cpp
@@ -871,17 +871,17 @@ MediaDecoder::EnsureTelemetryReported()
     codecs.AppendElement(mInfo->mVideo.GetAsVideoInfo()->mMimeType);
   }
   if (codecs.IsEmpty()) {
     codecs.AppendElement(nsPrintfCString(
       "resource; %s", mResource->GetContentType().OriginalString().Data()));
   }
   for (const nsCString& codec : codecs) {
     DECODER_LOG("Telemetry MEDIA_CODEC_USED= '%s'", codec.get());
-    Telemetry::Accumulate(Telemetry::ID::MEDIA_CODEC_USED, codec);
+    Telemetry::Accumulate(Telemetry::HistogramID::MEDIA_CODEC_USED, codec);
   }
 
   mTelemetryReported = true;
 }
 
 const char*
 MediaDecoder::PlayStateStr()
 {
--- a/dom/media/eme/DetailedPromise.cpp
+++ b/dom/media/eme/DetailedPromise.cpp
@@ -17,18 +17,18 @@ DetailedPromise::DetailedPromise(nsIGlob
   , mName(aName)
   , mResponded(false)
   , mStartTime(TimeStamp::Now())
 {
 }
 
 DetailedPromise::DetailedPromise(nsIGlobalObject* aGlobal,
                                  const nsACString& aName,
-                                 Telemetry::ID aSuccessLatencyProbe,
-                                 Telemetry::ID aFailureLatencyProbe)
+                                 Telemetry::HistogramID aSuccessLatencyProbe,
+                                 Telemetry::HistogramID aFailureLatencyProbe)
   : DetailedPromise(aGlobal, aName)
 {
   mSuccessLatencyProbe.Construct(aSuccessLatencyProbe);
   mFailureLatencyProbe.Construct(aFailureLatencyProbe);
 }
 
 DetailedPromise::~DetailedPromise()
 {
@@ -70,18 +70,18 @@ DetailedPromise::Create(nsIGlobalObject*
   promise->CreateWrapper(nullptr, aRv);
   return aRv.Failed() ? nullptr : promise.forget();
 }
 
 /* static */ already_AddRefed<DetailedPromise>
 DetailedPromise::Create(nsIGlobalObject* aGlobal,
                         ErrorResult& aRv,
                         const nsACString& aName,
-                        Telemetry::ID aSuccessLatencyProbe,
-                        Telemetry::ID aFailureLatencyProbe)
+                        Telemetry::HistogramID aSuccessLatencyProbe,
+                        Telemetry::HistogramID aFailureLatencyProbe)
 {
   RefPtr<DetailedPromise> promise = new DetailedPromise(aGlobal, aName, aSuccessLatencyProbe, aFailureLatencyProbe);
   promise->CreateWrapper(nullptr, aRv);
   return aRv.Failed() ? nullptr : promise.forget();
 }
 
 void
 DetailedPromise::MaybeReportTelemetry(Status aStatus)
@@ -91,15 +91,15 @@ DetailedPromise::MaybeReportTelemetry(St
   }
   mResponded = true;
   if (!mSuccessLatencyProbe.WasPassed() || !mFailureLatencyProbe.WasPassed()) {
     return;
   }
   uint32_t latency = (TimeStamp::Now() - mStartTime).ToMilliseconds();
   EME_LOG("%s %s latency %ums reported via telemetry", mName.get(),
           ((aStatus == Succeeded) ? "succcess" : "failure"), latency);
-  Telemetry::ID tid = (aStatus == Succeeded) ? mSuccessLatencyProbe.Value()
-                                             : mFailureLatencyProbe.Value();
+  Telemetry::HistogramID tid = (aStatus == Succeeded) ? mSuccessLatencyProbe.Value()
+                                                      : mFailureLatencyProbe.Value();
   Telemetry::Accumulate(tid, latency);
 }
 
 } // namespace dom
 } // namespace mozilla
--- a/dom/media/eme/DetailedPromise.h
+++ b/dom/media/eme/DetailedPromise.h
@@ -25,18 +25,18 @@ public:
   static already_AddRefed<DetailedPromise>
   Create(nsIGlobalObject* aGlobal,
          ErrorResult& aRv,
          const nsACString& aName);
 
   static already_AddRefed<DetailedPromise>
   Create(nsIGlobalObject* aGlobal, ErrorResult& aRv,
          const nsACString& aName,
-         Telemetry::ID aSuccessLatencyProbe,
-         Telemetry::ID aFailureLatencyProbe);
+         Telemetry::HistogramID aSuccessLatencyProbe,
+         Telemetry::HistogramID aFailureLatencyProbe);
 
   template <typename T>
   void MaybeResolve(const T& aArg)
   {
     EME_LOG("%s promise resolved", mName.get());
     MaybeReportTelemetry(Succeeded);
     Promise::MaybeResolve<T>(aArg);
   }
@@ -48,26 +48,26 @@ public:
   void MaybeReject(ErrorResult&, const nsACString& aReason);
 
 private:
   explicit DetailedPromise(nsIGlobalObject* aGlobal,
                            const nsACString& aName);
 
   explicit DetailedPromise(nsIGlobalObject* aGlobal,
                            const nsACString& aName,
-                           Telemetry::ID aSuccessLatencyProbe,
-                           Telemetry::ID aFailureLatencyProbe);
+                           Telemetry::HistogramID aSuccessLatencyProbe,
+                           Telemetry::HistogramID aFailureLatencyProbe);
   virtual ~DetailedPromise();
 
   enum Status { Succeeded, Failed };
   void MaybeReportTelemetry(Status aStatus);
 
   nsCString mName;
   bool mResponded;
   TimeStamp mStartTime;
-  Optional<Telemetry::ID> mSuccessLatencyProbe;
-  Optional<Telemetry::ID> mFailureLatencyProbe;
+  Optional<Telemetry::HistogramID> mSuccessLatencyProbe;
+  Optional<Telemetry::HistogramID> mFailureLatencyProbe;
 };
 
 } // namespace dom
 } // namespace mozilla
 
 #endif // __DetailedPromise_h__
--- a/dom/media/ogg/OggDemuxer.cpp
+++ b/dom/media/ogg/OggDemuxer.cpp
@@ -125,17 +125,17 @@ OggDemuxer::~OggDemuxer()
   Reset(TrackInfo::kAudioTrack);
   Reset(TrackInfo::kVideoTrack);
   if (HasAudio() || HasVideo()) {
     // If we were able to initialize our decoders, report whether we encountered
     // a chained stream or not.
     bool isChained = mIsChained;
     nsCOMPtr<nsIRunnable> task = NS_NewRunnableFunction([=]() -> void {
       OGG_DEBUG("Reporting telemetry MEDIA_OGG_LOADED_IS_CHAINED=%d", isChained);
-      Telemetry::Accumulate(Telemetry::ID::MEDIA_OGG_LOADED_IS_CHAINED, isChained);
+      Telemetry::Accumulate(Telemetry::HistogramID::MEDIA_OGG_LOADED_IS_CHAINED, isChained);
     });
     // Non-DocGroup version of AbstractThread::MainThread is fine for Telemetry.
     AbstractThread::MainThread()->Dispatch(task.forget());
   }
 }
 
 void
 OggDemuxer::SetChainingEvents(TimedMetadataEventProducer* aMetadataEvent,
--- a/dom/media/platforms/wmf/WMFAudioMFTManager.cpp
+++ b/dom/media/platforms/wmf/WMFAudioMFTManager.cpp
@@ -246,17 +246,17 @@ WMFAudioMFTManager::Output(int64_t aStre
   }
 
   NS_ENSURE_TRUE(SUCCEEDED(hr), hr);
 
   if (!sample) {
     LOG("Audio MFTDecoder returned success but null output.");
     nsCOMPtr<nsIRunnable> task = NS_NewRunnableFunction([]() -> void {
       LOG("Reporting telemetry AUDIO_MFT_OUTPUT_NULL_SAMPLES");
-      Telemetry::Accumulate(Telemetry::ID::AUDIO_MFT_OUTPUT_NULL_SAMPLES, 1);
+      Telemetry::Accumulate(Telemetry::HistogramID::AUDIO_MFT_OUTPUT_NULL_SAMPLES, 1);
     });
     // Non-DocGroup version of AbstractThread::MainThread is fine for Telemetry.
     AbstractThread::MainThread()->Dispatch(task.forget());
     return E_FAIL;
   }
 
   RefPtr<IMFMediaBuffer> buffer;
   hr = sample->ConvertToContiguousBuffer(getter_AddRefs(buffer));
--- a/dom/media/platforms/wmf/WMFVideoMFTManager.cpp
+++ b/dom/media/platforms/wmf/WMFVideoMFTManager.cpp
@@ -126,17 +126,17 @@ WMFVideoMFTManager::~WMFVideoMFTManager(
       : mGotExcessiveNullOutput
         ? 2
         : mGotValidOutputAfterNullOutput ? 3 : 4;
 
   nsCOMPtr<nsIRunnable> task = NS_NewRunnableFunction([=]() -> void {
     LOG(nsPrintfCString("Reporting telemetry VIDEO_MFT_OUTPUT_NULL_SAMPLES=%d",
                         telemetry)
         .get());
-    Telemetry::Accumulate(Telemetry::ID::VIDEO_MFT_OUTPUT_NULL_SAMPLES,
+    Telemetry::Accumulate(Telemetry::HistogramID::VIDEO_MFT_OUTPUT_NULL_SAMPLES,
                           telemetry);
   });
   // Non-DocGroup version of AbstractThread::MainThread is fine for Telemetry.
   AbstractThread::MainThread()->Dispatch(task.forget());
 }
 
 const GUID&
 WMFVideoMFTManager::GetMFTGUID()
--- a/dom/media/webaudio/MediaBufferDecoder.cpp
+++ b/dom/media/webaudio/MediaBufferDecoder.cpp
@@ -284,17 +284,17 @@ MediaDecodeTask::OnMetadataRead(Metadata
                             mContainerType.Type().AsString().Data());
   }
 
   nsCOMPtr<nsIRunnable> task = NS_NewRunnableFunction([codec]() -> void {
     MOZ_ASSERT(!codec.IsEmpty());
     MOZ_LOG(gMediaDecoderLog,
             LogLevel::Debug,
             ("Telemetry (WebAudio) MEDIA_CODEC_USED= '%s'", codec.get()));
-    Telemetry::Accumulate(Telemetry::ID::MEDIA_CODEC_USED, codec);
+    Telemetry::Accumulate(Telemetry::HistogramID::MEDIA_CODEC_USED, codec);
   });
   // Non-DocGroup version of AbstractThread::MainThread is fine for Telemetry.
   AbstractThread::MainThread()->Dispatch(task.forget());
 
   RequestSample();
 }
 
 void
@@ -635,9 +635,8 @@ WebAudioDecodeJob::SizeOfExcludingThis(M
 
 size_t
 WebAudioDecodeJob::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const
 {
   return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
 }
 
 } // namespace mozilla
-
--- a/dom/storage/StorageCache.cpp
+++ b/dom/storage/StorageCache.cpp
@@ -314,34 +314,34 @@ StorageCache::KeepAlive()
 namespace {
 
 // The AutoTimer provided by telemetry headers is only using static,
 // i.e. compile time known ID, but here we know the ID only at run time.
 // Hence a new class.
 class TelemetryAutoTimer
 {
 public:
-  explicit TelemetryAutoTimer(Telemetry::ID aId)
+  explicit TelemetryAutoTimer(Telemetry::HistogramID aId)
     : id(aId), start(TimeStamp::Now())
   {}
 
   ~TelemetryAutoTimer()
   {
     Telemetry::AccumulateDelta_impl<Telemetry::Millisecond>::compute(id, start);
   }
 
 private:
-  Telemetry::ID id;
+  Telemetry::HistogramID id;
   const TimeStamp start;
 };
 
 } // namespace
 
 void
-StorageCache::WaitForPreload(Telemetry::ID aTelemetryID)
+StorageCache::WaitForPreload(Telemetry::HistogramID aTelemetryID)
 {
   if (!mPersistent) {
     return;
   }
 
   bool loaded = mLoaded;
 
   // Telemetry of rates of pending preloads
--- a/dom/storage/StorageCache.h
+++ b/dom/storage/StorageCache.h
@@ -167,17 +167,17 @@ private:
 #ifdef DOM_STORAGE_TESTS
   static const uint32_t kTestReload    = 1 << 15;
 #endif
 
   void UnloadItems(uint32_t aUnloadFlags);
 
 private:
   // Synchronously blocks until the cache is fully loaded from the database
-  void WaitForPreload(mozilla::Telemetry::ID aTelemetryID);
+  void WaitForPreload(mozilla::Telemetry::HistogramID aTelemetryID);
 
   // Helper to get one of the 3 data sets (regular, private, session)
   Data& DataSet(const Storage* aStorage);
 
   // Whether the storage change is about to persist
   bool Persist(const Storage* aStorage) const;
 
   // Changes the quota usage on the given data set if it fits the quota.
--- a/image/Decoder.h
+++ b/image/Decoder.h
@@ -18,17 +18,17 @@
 #include "Orientation.h"
 #include "SourceBuffer.h"
 #include "StreamingLexer.h"
 #include "SurfaceFlags.h"
 
 namespace mozilla {
 
 namespace Telemetry {
-  enum ID : uint32_t;
+  enum HistogramID : uint32_t;
 } // namespace Telemetry
 
 namespace image {
 
 struct DecoderFinalStatus final
 {
   DecoderFinalStatus(bool aWasMetadataDecode,
                      bool aFinished,
@@ -51,17 +51,17 @@ struct DecoderFinalStatus final
 
   /// True if this decoder encountered the kind of error that should be reported
   /// to the console.
   const bool mShouldReportError : 1;
 };
 
 struct DecoderTelemetry final
 {
-  DecoderTelemetry(const Maybe<Telemetry::ID>& aSpeedHistogram,
+  DecoderTelemetry(const Maybe<Telemetry::HistogramID>& aSpeedHistogram,
                    size_t aBytesDecoded,
                    uint32_t aChunkCount,
                    TimeDuration aDecodeTime)
     : mSpeedHistogram(aSpeedHistogram)
     , mBytesDecoded(aBytesDecoded)
     , mChunkCount(aChunkCount)
     , mDecodeTime(aDecodeTime)
   { }
@@ -72,17 +72,17 @@ struct DecoderTelemetry final
     return mBytesDecoded / (1024 * mDecodeTime.ToSeconds());
   }
 
   /// @return our decoder's decode time, in microseconds.
   int32_t DecodeTimeMicros() { return mDecodeTime.ToMicroseconds(); }
 
   /// The per-image-format telemetry ID for recording our decoder's speed, or
   /// Nothing() if we don't record speed telemetry for this kind of decoder.
-  const Maybe<Telemetry::ID> mSpeedHistogram;
+  const Maybe<Telemetry::HistogramID> mSpeedHistogram;
 
   /// The number of bytes of input our decoder processed.
   const size_t mBytesDecoded;
 
   /// The number of chunks our decoder's input was divided into.
   const uint32_t mChunkCount;
 
   /// The amount of time our decoder spent inside DoDecode().
@@ -398,17 +398,17 @@ protected:
   virtual nsresult FinishInternal();
   virtual nsresult FinishWithErrorInternal();
 
   /**
    * @return the per-image-format telemetry ID for recording this decoder's
    * speed, or Nothing() if we don't record speed telemetry for this kind of
    * decoder.
    */
-  virtual Maybe<Telemetry::ID> SpeedHistogram() const { return Nothing(); }
+  virtual Maybe<Telemetry::HistogramID> SpeedHistogram() const { return Nothing(); }
 
 
   /*
    * Progress notifications.
    */
 
   // Called by decoders when they determine the size of the image. Informs
   // the image of its size and sends notifications.
--- a/image/decoders/nsGIFDecoder2.cpp
+++ b/image/decoders/nsGIFDecoder2.cpp
@@ -1078,16 +1078,16 @@ nsGIFDecoder2::SkipSubBlocks(const char*
   }
 
   // Skip to the next sub-block length value.
   return Transition::ToUnbuffered(State::FINISHED_SKIPPING_DATA,
                                   State::SKIP_DATA_THEN_SKIP_SUB_BLOCKS,
                                   nextSubBlockLength);
 }
 
-Maybe<Telemetry::ID>
+Maybe<Telemetry::HistogramID>
 nsGIFDecoder2::SpeedHistogram() const
 {
   return Some(Telemetry::IMAGE_DECODE_SPEED_GIF);
 }
 
 } // namespace image
 } // namespace mozilla
--- a/image/decoders/nsGIFDecoder2.h
+++ b/image/decoders/nsGIFDecoder2.h
@@ -24,17 +24,17 @@ class nsGIFDecoder2 : public Decoder
 public:
   ~nsGIFDecoder2();
 
 protected:
   LexerResult DoDecode(SourceBufferIterator& aIterator,
                        IResumable* aOnResume) override;
   nsresult FinishInternal() override;
 
-  Maybe<Telemetry::ID> SpeedHistogram() const override;
+  Maybe<Telemetry::HistogramID> SpeedHistogram() const override;
 
 private:
   friend class DecoderFactory;
 
   // Decoders should only be instantiated via DecoderFactory.
   explicit nsGIFDecoder2(RasterImage* aImage);
 
   /// Called when we begin decoding the image.
--- a/image/decoders/nsJPEGDecoder.cpp
+++ b/image/decoders/nsJPEGDecoder.cpp
@@ -117,17 +117,17 @@ nsJPEGDecoder::~nsJPEGDecoder()
     qcms_profile_release(mInProfile);
   }
 
   MOZ_LOG(sJPEGDecoderAccountingLog, LogLevel::Debug,
          ("nsJPEGDecoder::~nsJPEGDecoder: Destroying JPEG decoder %p",
           this));
 }
 
-Maybe<Telemetry::ID>
+Maybe<Telemetry::HistogramID>
 nsJPEGDecoder::SpeedHistogram() const
 {
   return Some(Telemetry::IMAGE_DECODE_SPEED_JPEG);
 }
 
 nsresult
 nsJPEGDecoder::InitInternal()
 {
--- a/image/decoders/nsJPEGDecoder.h
+++ b/image/decoders/nsJPEGDecoder.h
@@ -55,17 +55,17 @@ public:
   void NotifyDone();
 
 protected:
   nsresult InitInternal() override;
   LexerResult DoDecode(SourceBufferIterator& aIterator,
                        IResumable* aOnResume) override;
   nsresult FinishInternal() override;
 
-  Maybe<Telemetry::ID> SpeedHistogram() const override;
+  Maybe<Telemetry::HistogramID> SpeedHistogram() const override;
 
 protected:
   Orientation ReadOrientationFromEXIF();
   void OutputScanlines(bool* suspend);
 
 private:
   friend class DecoderFactory;
 
--- a/image/decoders/nsPNGDecoder.cpp
+++ b/image/decoders/nsPNGDecoder.cpp
@@ -1049,17 +1049,17 @@ nsPNGDecoder::error_callback(png_structp
 
 
 void
 nsPNGDecoder::warning_callback(png_structp png_ptr, png_const_charp warning_msg)
 {
   MOZ_LOG(sPNGLog, LogLevel::Warning, ("libpng warning: %s\n", warning_msg));
 }
 
-Maybe<Telemetry::ID>
+Maybe<Telemetry::HistogramID>
 nsPNGDecoder::SpeedHistogram() const
 {
   return Some(Telemetry::IMAGE_DECODE_SPEED_PNG);
 }
 
 bool
 nsPNGDecoder::IsValidICO() const
 {
--- a/image/decoders/nsPNGDecoder.h
+++ b/image/decoders/nsPNGDecoder.h
@@ -25,17 +25,17 @@ public:
   /// @return true if this PNG is a valid ICO resource.
   bool IsValidICO() const;
 
 protected:
   nsresult InitInternal() override;
   LexerResult DoDecode(SourceBufferIterator& aIterator,
                        IResumable* aOnResume) override;
 
-  Maybe<Telemetry::ID> SpeedHistogram() const override;
+  Maybe<Telemetry::HistogramID> SpeedHistogram() const override;
 
 private:
   friend class DecoderFactory;
 
   // Decoders should only be instantiated via DecoderFactory.
   explicit nsPNGDecoder(RasterImage* aImage);
 
   /// The information necessary to create a frame.
--- a/layout/base/nsPresContext.cpp
+++ b/layout/base/nsPresContext.cpp
@@ -1658,17 +1658,17 @@ nsPresContext::RecordInteractionTime(Int
     &nsPresContext::mFirstClickTime,
     &nsPresContext::mFirstKeyTime,
     &nsPresContext::mFirstMouseMoveTime,
     &nsPresContext::mFirstScrollTime
   };
 
   // Array of histogram IDs for the different interaction types,
   // keyed by InteractionType.
-  Telemetry::ID histogramIds[] = {
+  Telemetry::HistogramID histogramIds[] = {
     Telemetry::TIME_TO_FIRST_CLICK_MS,
     Telemetry::TIME_TO_FIRST_KEY_INPUT_MS,
     Telemetry::TIME_TO_FIRST_MOUSE_MOVE_MS,
     Telemetry::TIME_TO_FIRST_SCROLL_MS
   };
 
   TimeStamp& interactionTime = this->*(
     interactionTimes[static_cast<uint32_t>(aType)]);
--- a/media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.cpp
+++ b/media/webrtc/signaling/src/peerconnection/PeerConnectionCtx.cpp
@@ -249,58 +249,58 @@ EverySecondTelemetryCallback_s(nsAutoPtr
       }
       // Then, look for the things we want telemetry on
       auto& array = r.mInboundRTPStreamStats.Value();
       for (decltype(array.Length()) i = 0; i < array.Length(); i++) {
         auto& s = array[i];
         bool isAudio = (s.mId.Value().Find("audio") != -1);
         if (s.mPacketsLost.WasPassed() && s.mPacketsReceived.WasPassed() &&
             (s.mPacketsLost.Value() + s.mPacketsReceived.Value()) != 0) {
-          ID id;
+          HistogramID id;
           if (s.mIsRemote) {
             id = isAudio ? WEBRTC_AUDIO_QUALITY_OUTBOUND_PACKETLOSS_RATE :
                            WEBRTC_VIDEO_QUALITY_OUTBOUND_PACKETLOSS_RATE;
           } else {
             id = isAudio ? WEBRTC_AUDIO_QUALITY_INBOUND_PACKETLOSS_RATE :
                            WEBRTC_VIDEO_QUALITY_INBOUND_PACKETLOSS_RATE;
           }
           // *1000 so we can read in 10's of a percent (permille)
           Accumulate(id,
                      (s.mPacketsLost.Value() * 1000) /
                      (s.mPacketsLost.Value() + s.mPacketsReceived.Value()));
         }
         if (s.mJitter.WasPassed()) {
-          ID id;
+          HistogramID id;
           if (s.mIsRemote) {
             id = isAudio ? WEBRTC_AUDIO_QUALITY_OUTBOUND_JITTER :
                            WEBRTC_VIDEO_QUALITY_OUTBOUND_JITTER;
           } else {
             id = isAudio ? WEBRTC_AUDIO_QUALITY_INBOUND_JITTER :
                            WEBRTC_VIDEO_QUALITY_INBOUND_JITTER;
           }
           Accumulate(id, s.mJitter.Value());
         }
         if (s.mMozRtt.WasPassed()) {
           MOZ_ASSERT(s.mIsRemote);
-          ID id = isAudio ? WEBRTC_AUDIO_QUALITY_OUTBOUND_RTT :
-                            WEBRTC_VIDEO_QUALITY_OUTBOUND_RTT;
+          HistogramID id = isAudio ? WEBRTC_AUDIO_QUALITY_OUTBOUND_RTT :
+                                     WEBRTC_VIDEO_QUALITY_OUTBOUND_RTT;
           Accumulate(id, s.mMozRtt.Value());
         }
         if (lastInboundStats && s.mBytesReceived.WasPassed()) {
           auto& laststats = *lastInboundStats;
           auto i = FindId(laststats, s.mId.Value());
           if (i != laststats.NoIndex) {
             auto& lasts = laststats[i];
             if (lasts.mBytesReceived.WasPassed()) {
               auto delta_ms = int32_t(s.mTimestamp.Value() -
                                       lasts.mTimestamp.Value());
               // In theory we're called every second, so delta *should* be in that range.
               // Small deltas could cause errors due to division
               if (delta_ms > 500 && delta_ms < 60000) {
-                ID id;
+                HistogramID id;
                 if (s.mIsRemote) {
                   id = isAudio ? WEBRTC_AUDIO_QUALITY_OUTBOUND_BANDWIDTH_KBITS :
                                  WEBRTC_VIDEO_QUALITY_OUTBOUND_BANDWIDTH_KBITS;
                 } else {
                   id = isAudio ? WEBRTC_AUDIO_QUALITY_INBOUND_BANDWIDTH_KBITS :
                                  WEBRTC_VIDEO_QUALITY_INBOUND_BANDWIDTH_KBITS;
                 }
                 Accumulate(id, ((s.mBytesReceived.Value() -
--- a/netwerk/base/nsSocketTransport2.cpp
+++ b/netwerk/base/nsSocketTransport2.cpp
@@ -3217,21 +3217,21 @@ nsSocketTransport::CloseSocket(PRFileDes
             Telemetry::PRCLOSE_TCP_BLOCKING_TIME_CONNECTIVITY_CHANGE,
             Telemetry::PRCLOSE_TCP_BLOCKING_TIME_LINK_CHANGE,
             Telemetry::PRCLOSE_TCP_BLOCKING_TIME_OFFLINE);
     }
 }
 
 void
 nsSocketTransport::SendPRBlockingTelemetry(PRIntervalTime aStart,
-                                           Telemetry::ID aIDNormal,
-                                           Telemetry::ID aIDShutdown,
-                                           Telemetry::ID aIDConnectivityChange,
-                                           Telemetry::ID aIDLinkChange,
-                                           Telemetry::ID aIDOffline)
+                                           Telemetry::HistogramID aIDNormal,
+                                           Telemetry::HistogramID aIDShutdown,
+                                           Telemetry::HistogramID aIDConnectivityChange,
+                                           Telemetry::HistogramID aIDLinkChange,
+                                           Telemetry::HistogramID aIDOffline)
 {
     PRIntervalTime now = PR_IntervalNow();
     if (gIOService->IsNetTearingDown()) {
         Telemetry::Accumulate(aIDShutdown,
                               PR_IntervalToMilliseconds(now - aStart));
 
     } else if (PR_IntervalToSeconds(now - gIOService->LastConnectivityChange())
                < 60) {
--- a/netwerk/base/nsSocketTransport2.h
+++ b/netwerk/base/nsSocketTransport2.h
@@ -166,21 +166,21 @@ public:
 
     // called when a socket event is handled
     void OnSocketEvent(uint32_t type, nsresult status, nsISupports *param);
 
     uint64_t ByteCountReceived() override { return mInput.ByteCount(); }
     uint64_t ByteCountSent() override { return mOutput.ByteCount(); }
     static void CloseSocket(PRFileDesc *aFd, bool aTelemetryEnabled);
     static void SendPRBlockingTelemetry(PRIntervalTime aStart,
-        Telemetry::ID aIDNormal,
-        Telemetry::ID aIDShutdown,
-        Telemetry::ID aIDConnectivityChange,
-        Telemetry::ID aIDLinkChange,
-        Telemetry::ID aIDOffline);
+        Telemetry::HistogramID aIDNormal,
+        Telemetry::HistogramID aIDShutdown,
+        Telemetry::HistogramID aIDConnectivityChange,
+        Telemetry::HistogramID aIDLinkChange,
+        Telemetry::HistogramID aIDOffline);
 protected:
 
     virtual ~nsSocketTransport();
     void     CleanupTypes();
 
 private:
 
     // event types
--- a/netwerk/cache/nsCacheService.cpp
+++ b/netwerk/cache/nsCacheService.cpp
@@ -2640,20 +2640,20 @@ nsCacheService::LockReleased()
 void
 nsCacheService::Lock()
 {
     gService->mLock.Lock();
     gService->LockAcquired();
 }
 
 void
-nsCacheService::Lock(mozilla::Telemetry::ID mainThreadLockerID)
+nsCacheService::Lock(mozilla::Telemetry::HistogramID mainThreadLockerID)
 {
-    mozilla::Telemetry::ID lockerID;
-    mozilla::Telemetry::ID generalID;
+    mozilla::Telemetry::HistogramID lockerID;
+    mozilla::Telemetry::HistogramID generalID;
 
     if (NS_IsMainThread()) {
         lockerID = mainThreadLockerID;
         generalID = mozilla::Telemetry::CACHE_SERVICE_LOCK_WAIT_MAINTHREAD_2;
     } else {
         lockerID = mozilla::Telemetry::HistogramCount;
         generalID = mozilla::Telemetry::CACHE_SERVICE_LOCK_WAIT_2;
     }
--- a/netwerk/cache/nsCacheService.h
+++ b/netwerk/cache/nsCacheService.h
@@ -250,17 +250,17 @@ private:
     friend class nsAsyncDoomEvent;
     friend class nsCacheEntryDescriptor;
 
     /**
      * Internal Methods
      */
 
     static void      Lock();
-    static void      Lock(::mozilla::Telemetry::ID mainThreadLockerID);
+    static void      Lock(::mozilla::Telemetry::HistogramID mainThreadLockerID);
     static void      Unlock();
     void             LockAcquired();
     void             LockReleased();
 
     nsresult         CreateDiskDevice();
     nsresult         CreateOfflineDevice();
     nsresult         CreateCustomOfflineDevice(nsIFile *aProfileDir,
                                                int32_t aQuota,
@@ -376,17 +376,17 @@ private:
 
 // Instantiate this class to acquire the cache service lock for a particular
 // execution scope.
 class nsCacheServiceAutoLock {
 public:
     nsCacheServiceAutoLock() {
         nsCacheService::Lock();
     }
-    explicit nsCacheServiceAutoLock(mozilla::Telemetry::ID mainThreadLockerID) {
+    explicit nsCacheServiceAutoLock(mozilla::Telemetry::HistogramID mainThreadLockerID) {
         nsCacheService::Lock(mainThreadLockerID);
     }
     ~nsCacheServiceAutoLock() {
         nsCacheService::Unlock();
     }
 };
 
 #endif // _nsCacheService_h_
--- a/netwerk/cache2/CacheIOThread.cpp
+++ b/netwerk/cache2/CacheIOThread.cpp
@@ -44,17 +44,17 @@ CacheIOTelemetry::mMinLengthToReport[Cac
 
 // static
 void CacheIOTelemetry::Report(uint32_t aLevel, CacheIOTelemetry::size_type aLength)
 {
   if (mMinLengthToReport[aLevel] > aLength) {
     return;
   }
 
-  static Telemetry::ID telemetryID[] = {
+  static Telemetry::HistogramID telemetryID[] = {
     Telemetry::HTTP_CACHE_IO_QUEUE_2_OPEN_PRIORITY,
     Telemetry::HTTP_CACHE_IO_QUEUE_2_READ_PRIORITY,
     Telemetry::HTTP_CACHE_IO_QUEUE_2_MANAGEMENT,
     Telemetry::HTTP_CACHE_IO_QUEUE_2_OPEN,
     Telemetry::HTTP_CACHE_IO_QUEUE_2_READ,
     Telemetry::HTTP_CACHE_IO_QUEUE_2_WRITE_PRIORITY,
     Telemetry::HTTP_CACHE_IO_QUEUE_2_WRITE,
     Telemetry::HTTP_CACHE_IO_QUEUE_2_INDEX,
--- a/netwerk/dns/nsHostResolver.cpp
+++ b/netwerk/dns/nsHostResolver.cpp
@@ -1478,17 +1478,17 @@ nsHostResolver::ThreadFunc(void *arg)
         {   // obtain lock to check shutdown and manage inter-module telemetry
             MutexAutoLock lock(resolver->mLock);
 
             if (!resolver->mShutdown) {
                 TimeDuration elapsed = TimeStamp::Now() - startTime;
                 uint32_t millis = static_cast<uint32_t>(elapsed.ToMilliseconds());
 
                 if (NS_SUCCEEDED(status)) {
-                    Telemetry::ID histogramID;
+                    Telemetry::HistogramID histogramID;
                     if (!rec->addr_info_gencnt) {
                         // Time for initial lookup.
                         histogramID = Telemetry::DNS_LOOKUP_TIME;
                     } else if (!getTtl) {
                         // Time for renewal; categorized by expiration strategy.
                         histogramID = Telemetry::DNS_RENEWAL_TIME;
                     } else {
                         // Time to get TTL; categorized by expiration strategy.
--- a/netwerk/protocol/http/Http2Compression.h
+++ b/netwerk/protocol/http/Http2Compression.h
@@ -81,19 +81,19 @@ protected:
 
   uint32_t mMaxBuffer;
   uint32_t mMaxBufferSetting;
   bool mSetInitialMaxBufferSizeAllowed;
 
   uint32_t mPeakSize;
   uint32_t mPeakCount;
   MOZ_INIT_OUTSIDE_CTOR
-  Telemetry::ID mPeakSizeID;
+  Telemetry::HistogramID mPeakSizeID;
   MOZ_INIT_OUTSIDE_CTOR
-  Telemetry::ID mPeakCountID;
+  Telemetry::HistogramID mPeakCountID;
 
 private:
   RefPtr<HpackDynamicTableReporter> mDynamicReporter;
 };
 
 class Http2Compressor;
 
 class Http2Decompressor final : public Http2BaseCompressor
--- a/security/certverifier/CertVerifier.h
+++ b/security/certverifier/CertVerifier.h
@@ -63,17 +63,17 @@ enum class NetscapeStepUpPolicy : uint32
 
 class PinningTelemetryInfo
 {
 public:
   PinningTelemetryInfo() { Reset(); }
 
   // Should we accumulate pinning telemetry for the result?
   bool accumulateResult;
-  Telemetry::ID certPinningResultHistogram;
+  Telemetry::HistogramID certPinningResultHistogram;
   int32_t certPinningResultBucket;
   // Should we accumulate telemetry for the root?
   bool accumulateForRoot;
   int32_t rootBucket;
 
   void Reset() { accumulateForRoot = false; accumulateResult = false; }
 };
 
--- a/security/manager/ssl/PublicKeyPinningService.cpp
+++ b/security/manager/ssl/PublicKeyPinningService.cpp
@@ -268,17 +268,17 @@ CheckPinsForHostname(const UniqueCERTCer
   if (staticFingerprints) {
     bool enforceTestModeResult;
     rv = EvalChain(certList, staticFingerprints->pinset, nullptr,
                    enforceTestModeResult);
     if (NS_FAILED(rv)) {
       return rv;
     }
     chainHasValidPins = enforceTestModeResult;
-    Telemetry::ID histogram = staticFingerprints->mIsMoz
+    Telemetry::HistogramID histogram = staticFingerprints->mIsMoz
       ? Telemetry::CERT_PINNING_MOZ_RESULTS
       : Telemetry::CERT_PINNING_RESULTS;
     if (staticFingerprints->mTestMode) {
       histogram = staticFingerprints->mIsMoz
         ? Telemetry::CERT_PINNING_MOZ_TEST_RESULTS
         : Telemetry::CERT_PINNING_TEST_RESULTS;
       if (!enforceTestMode) {
         chainHasValidPins = true;
--- a/security/manager/ssl/RootCertificateTelemetryUtils.cpp
+++ b/security/manager/ssl/RootCertificateTelemetryUtils.cpp
@@ -71,17 +71,17 @@ RootCABinNumber(const SECItem* cert)
   // Didn't match.
   return ROOT_CERTIFICATE_UNKNOWN;
 }
 
 
 // Attempt to increment the appropriate bin in the provided Telemetry probe ID. If
 // there was a hash failure, we do nothing.
 void
-AccumulateTelemetryForRootCA(mozilla::Telemetry::ID probe, 
+AccumulateTelemetryForRootCA(mozilla::Telemetry::HistogramID probe,
   const CERTCertificate* cert)
 {
   int32_t binId = RootCABinNumber(&cert->derCert);
 
   if (binId != ROOT_CERTIFICATE_HASH_FAILURE) {
     Accumulate(probe, binId);
   }
 }
--- a/security/manager/ssl/RootCertificateTelemetryUtils.h
+++ b/security/manager/ssl/RootCertificateTelemetryUtils.h
@@ -17,14 +17,14 @@ namespace mozilla { namespace psm {
 // genRootCAHashes.js for the unknowns.
 #define ROOT_CERTIFICATE_UNKNOWN  0
 #define ROOT_CERTIFICATE_HASH_FAILURE -1
 
 int32_t
 RootCABinNumber(const SECItem* cert);
 
 void
-AccumulateTelemetryForRootCA(mozilla::Telemetry::ID probe, const CERTCertificate* cert);
+AccumulateTelemetryForRootCA(mozilla::Telemetry::HistogramID probe, const CERTCertificate* cert);
 
 } // namespace psm
 } // namespace mozilla
 
 #endif // RootCertificateTelemetryUtils_h
--- a/security/manager/ssl/SSLServerCertVerification.cpp
+++ b/security/manager/ssl/SSLServerCertVerification.cpp
@@ -239,28 +239,28 @@ LogInvalidCertError(nsNSSSocketInfo* soc
 // descriptor that is waiting for this result.
 class SSLServerCertVerificationResult : public Runnable
 {
 public:
   NS_DECL_NSIRUNNABLE
 
   SSLServerCertVerificationResult(nsNSSSocketInfo* infoObject,
                                   PRErrorCode errorCode,
-                                  Telemetry::ID telemetryID = Telemetry::HistogramCount,
+                                  Telemetry::HistogramID telemetryID = Telemetry::HistogramCount,
                                   uint32_t telemetryValue = -1,
                                   SSLErrorMessageType errorMessageType =
                                       PlainErrorMessage);
 
   void Dispatch();
 private:
   const RefPtr<nsNSSSocketInfo> mInfoObject;
 public:
   const PRErrorCode mErrorCode;
   const SSLErrorMessageType mErrorMessageType;
-  const Telemetry::ID mTelemetryID;
+  const Telemetry::HistogramID mTelemetryID;
   const uint32_t mTelemetryValue;
 };
 
 class CertErrorRunnable : public SyncRunnableBase
 {
  public:
   CertErrorRunnable(const void* fdForLogging,
                     nsIX509Cert* cert,
@@ -1498,19 +1498,19 @@ SSLServerCertVerificationJob::Run()
           ("[%p] SSLServerCertVerificationJob::Run\n", mInfoObject.get()));
 
   PRErrorCode error;
 
   nsNSSShutDownPreventionLock nssShutdownPrevention;
   if (mInfoObject->isAlreadyShutDown()) {
     error = SEC_ERROR_USER_CANCELLED;
   } else {
-    Telemetry::ID successTelemetry
+    Telemetry::HistogramID successTelemetry
       = Telemetry::SSL_SUCCESFUL_CERT_VALIDATION_TIME_MOZILLAPKIX;
-    Telemetry::ID failureTelemetry
+    Telemetry::HistogramID failureTelemetry
       = Telemetry::SSL_INITIAL_FAILED_CERT_VALIDATION_TIME_MOZILLAPKIX;
 
     // Reset the error code here so we can detect if AuthCertificate fails to
     // set the error code if/when it fails.
     PR_SetError(0, 0);
     SECStatus rv = AuthCertificate(*mCertVerifier, mInfoObject, mCert,
                                    mPeerCertChain, mStapledOCSPResponse.get(),
                                    mSCTsFromTLSExtension.get(),
@@ -1752,17 +1752,17 @@ AuthCertificateHook(void* arg, PRFileDes
   }
 
   PR_SetError(error, 0);
   return SECFailure;
 }
 
 SSLServerCertVerificationResult::SSLServerCertVerificationResult(
         nsNSSSocketInfo* infoObject, PRErrorCode errorCode,
-        Telemetry::ID telemetryID, uint32_t telemetryValue,
+        Telemetry::HistogramID telemetryID, uint32_t telemetryValue,
         SSLErrorMessageType errorMessageType)
   : mInfoObject(infoObject)
   , mErrorCode(errorCode)
   , mErrorMessageType(errorMessageType)
   , mTelemetryID(telemetryID)
   , mTelemetryValue(telemetryValue)
 {
 // We accumulate telemetry for (only) successful validations on the main thread
--- a/security/manager/ssl/nsNSSCallbacks.cpp
+++ b/security/manager/ssl/nsNSSCallbacks.cpp
@@ -34,17 +34,17 @@
 #include "ssl.h"
 #include "sslproto.h"
 
 using namespace mozilla;
 using namespace mozilla::psm;
 
 extern LazyLogModule gPIPNSSLog;
 
-static void AccumulateCipherSuite(Telemetry::ID probe,
+static void AccumulateCipherSuite(Telemetry::HistogramID probe,
                                   const SSLChannelInfo& channelInfo);
 
 namespace {
 
 // Bits in bit mask for SSL_REASONS_FOR_NOT_FALSE_STARTING telemetry probe
 // These bits are numbered so that the least subtle issues have higher values.
 // This should make it easier for us to interpret the results.
 const uint32_t POSSIBLE_VERSION_DOWNGRADE = 4;
@@ -976,17 +976,17 @@ CanFalseStartCallback(PRFileDesc* fd, vo
     infoObject->NoteTimeUntilReady();
     MOZ_LOG(gPIPNSSLog, LogLevel::Debug, ("CanFalseStartCallback [%p] ok\n", fd));
   }
 
   return SECSuccess;
 }
 
 static void
-AccumulateNonECCKeySize(Telemetry::ID probe, uint32_t bits)
+AccumulateNonECCKeySize(Telemetry::HistogramID probe, uint32_t bits)
 {
   unsigned int value = bits <   512 ?  1 : bits ==   512 ?  2
                      : bits <   768 ?  3 : bits ==   768 ?  4
                      : bits <  1024 ?  5 : bits ==  1024 ?  6
                      : bits <  1280 ?  7 : bits ==  1280 ?  8
                      : bits <  1536 ?  9 : bits ==  1536 ? 10
                      : bits <  2048 ? 11 : bits ==  2048 ? 12
                      : bits <  3072 ? 13 : bits ==  3072 ? 14
@@ -999,27 +999,27 @@ AccumulateNonECCKeySize(Telemetry::ID pr
 
 // XXX: This attempts to map a bit count to an ECC named curve identifier. In
 // the vast majority of situations, we only have the Suite B curves available.
 // In that case, this mapping works fine. If we were to have more curves
 // available, the mapping would be ambiguous since there could be multiple
 // named curves for a given size (e.g. secp256k1 vs. secp256r1). We punt on
 // that for now. See also NSS bug 323674.
 static void
-AccumulateECCCurve(Telemetry::ID probe, uint32_t bits)
+AccumulateECCCurve(Telemetry::HistogramID probe, uint32_t bits)
 {
   unsigned int value = bits == 256 ? 23 // P-256
                      : bits == 384 ? 24 // P-384
                      : bits == 521 ? 25 // P-521
                      : 0; // Unknown
   Telemetry::Accumulate(probe, value);
 }
 
 static void
-AccumulateCipherSuite(Telemetry::ID probe, const SSLChannelInfo& channelInfo)
+AccumulateCipherSuite(Telemetry::HistogramID probe, const SSLChannelInfo& channelInfo)
 {
   uint32_t value;
   switch (channelInfo.cipherSuite) {
     // ECDHE key exchange
     case TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256: value = 1; break;
     case TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256: value = 2; break;
     case TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA: value = 3; break;
     case TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA: value = 4; break;
--- a/security/manager/ssl/nsNSSIOLayer.cpp
+++ b/security/manager/ssl/nsNSSIOLayer.cpp
@@ -1103,18 +1103,18 @@ retryDueToTLSIntolerance(PRErrorCode err
     return false;
   }
 
   uint32_t reason = tlsIntoleranceTelemetryBucket(err);
   if (reason == 0) {
     return false;
   }
 
-  Telemetry::ID pre;
-  Telemetry::ID post;
+  Telemetry::HistogramID pre;
+  Telemetry::HistogramID post;
   switch (range.max) {
     case SSL_LIBRARY_VERSION_TLS_1_3:
       pre = Telemetry::SSL_TLS13_INTOLERANCE_REASON_PRE;
       post = Telemetry::SSL_TLS13_INTOLERANCE_REASON_POST;
       break;
     case SSL_LIBRARY_VERSION_TLS_1_2:
       pre = Telemetry::SSL_TLS12_INTOLERANCE_REASON_PRE;
       post = Telemetry::SSL_TLS12_INTOLERANCE_REASON_POST;
--- a/storage/TelemetryVFS.cpp
+++ b/storage/TelemetryVFS.cpp
@@ -32,21 +32,21 @@
 
 namespace {
 
 using namespace mozilla;
 using namespace mozilla::dom::quota;
 
 struct Histograms {
   const char *name;
-  const Telemetry::ID readB;
-  const Telemetry::ID writeB;
-  const Telemetry::ID readMS;
-  const Telemetry::ID writeMS;
-  const Telemetry::ID syncMS;
+  const Telemetry::HistogramID readB;
+  const Telemetry::HistogramID writeB;
+  const Telemetry::HistogramID readMS;
+  const Telemetry::HistogramID writeMS;
+  const Telemetry::HistogramID syncMS;
 };
 
 #define SQLITE_TELEMETRY(FILENAME, HGRAM) \
   { FILENAME, \
     Telemetry::MOZ_SQLITE_ ## HGRAM ## _READ_B, \
     Telemetry::MOZ_SQLITE_ ## HGRAM ## _WRITE_B, \
     Telemetry::MOZ_SQLITE_ ## HGRAM ## _READ_MS, \
     Telemetry::MOZ_SQLITE_ ## HGRAM ## _WRITE_MS, \
@@ -73,17 +73,17 @@ public:
    * @param id takes a telemetry histogram id. The id+1 must be an
    * equivalent histogram for the main thread. Eg, MOZ_SQLITE_OPEN_MS 
    * is followed by MOZ_SQLITE_OPEN_MAIN_THREAD_MS.
    *
    * @param aOp optionally takes an IO operation to report through the
    * IOInterposer. Filename will be reported as NULL, and reference will be
    * either "sqlite-mainthread" or "sqlite-otherthread".
    */
-  explicit IOThreadAutoTimer(Telemetry::ID aId,
+  explicit IOThreadAutoTimer(Telemetry::HistogramID aId,
     IOInterposeObserver::Operation aOp = IOInterposeObserver::OpNone)
     : start(TimeStamp::Now()),
       id(aId)
 #if defined(MOZ_GECKO_PROFILER) && !defined(XP_WIN)
       , op(aOp)
 #endif
   {
   }
@@ -103,17 +103,17 @@ public:
   {
   }
 
   ~IOThreadAutoTimer()
   {
     TimeStamp end(TimeStamp::Now());
     uint32_t mainThread = NS_IsMainThread() ? 1 : 0;
     if (id != Telemetry::HistogramCount) {
-      Telemetry::AccumulateTimeDelta(static_cast<Telemetry::ID>(id + mainThread),
+      Telemetry::AccumulateTimeDelta(static_cast<Telemetry::HistogramID>(id + mainThread),
                                      start, end);
     }
     // We don't report SQLite I/O on Windows because we have a comprehensive
     // mechanism for intercepting I/O on that platform that captures a superset
     // of the data captured here.
 #if defined(MOZ_GECKO_PROFILER) && !defined(XP_WIN)
     if (IOInterposer::IsObservedOperation(op)) {
       const char* main_ref  = "sqlite-mainthread";
@@ -125,17 +125,17 @@ public:
       // Report observation
       IOInterposer::Report(ob);
     }
 #endif /* defined(MOZ_GECKO_PROFILER) && !defined(XP_WIN) */
   }
 
 private:
   const TimeStamp start;
-  const Telemetry::ID id;
+  const Telemetry::HistogramID id;
 #if defined(MOZ_GECKO_PROFILER) && !defined(XP_WIN)
   IOInterposeObserver::Operation op;
 #endif
 };
 
 struct telemetry_file {
   // Base class.  Must be first
   sqlite3_file base;
--- a/toolkit/components/places/Helpers.h
+++ b/toolkit/components/places/Helpers.h
@@ -271,26 +271,26 @@ private:
 };
 
 /**
  * Used to notify a topic to system observers on async execute completion.
  */
 class AsyncStatementTelemetryTimer : public AsyncStatementCallback
 {
 public:
-  explicit AsyncStatementTelemetryTimer(Telemetry::ID aHistogramId,
+  explicit AsyncStatementTelemetryTimer(Telemetry::HistogramID aHistogramId,
                                         TimeStamp aStart = TimeStamp::Now())
     : mHistogramId(aHistogramId)
     , mStart(aStart)
   {
   }
 
   NS_IMETHOD HandleCompletion(uint16_t aReason);
 
 private:
-  const Telemetry::ID mHistogramId;
+  const Telemetry::HistogramID mHistogramId;
   const TimeStamp mStart;
 };
 
 } // namespace places
 } // namespace mozilla
 
 #endif // mozilla_places_Helpers_h_
--- a/toolkit/components/telemetry/Telemetry.cpp
+++ b/toolkit/components/telemetry/Telemetry.cpp
@@ -2815,17 +2815,17 @@ NSMODULE_DEFN(nsTelemetryModule) = &kTel
 
 /**
  * The XRE_TelemetryAdd function is to be used by embedding applications
  * that can't use mozilla::Telemetry::Accumulate() directly.
  */
 void
 XRE_TelemetryAccumulate(int aID, uint32_t aSample)
 {
-  mozilla::Telemetry::Accumulate((mozilla::Telemetry::ID) aID, aSample);
+  mozilla::Telemetry::Accumulate((mozilla::Telemetry::HistogramID) aID, aSample);
 }
 
 
 ////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////
 //
 // EXTERNALLY VISIBLE FUNCTIONS in mozilla::
 // These are NOT listed in Telemetry.h
@@ -3142,29 +3142,29 @@ HangHistogram::operator==(const HangHist
 // EXTERNALLY VISIBLE FUNCTIONS in mozilla::Telemetry::
 // These are listed in Telemetry.h
 
 namespace mozilla {
 namespace Telemetry {
 
 // The external API for controlling recording state
 void
-SetHistogramRecordingEnabled(ID aID, bool aEnabled)
+SetHistogramRecordingEnabled(HistogramID aID, bool aEnabled)
 {
   TelemetryHistogram::SetHistogramRecordingEnabled(aID, aEnabled);
 }
 
 void
-Accumulate(ID aHistogram, uint32_t aSample)
+Accumulate(HistogramID aHistogram, uint32_t aSample)
 {
   TelemetryHistogram::Accumulate(aHistogram, aSample);
 }
 
 void
-Accumulate(ID aID, const nsCString& aKey, uint32_t aSample)
+Accumulate(HistogramID aID, const nsCString& aKey, uint32_t aSample)
 {
   TelemetryHistogram::Accumulate(aID, aKey, aSample);
 }
 
 void
 Accumulate(const char* name, uint32_t sample)
 {
   TelemetryHistogram::Accumulate(name, sample);
@@ -3172,30 +3172,30 @@ Accumulate(const char* name, uint32_t sa
 
 void
 Accumulate(const char *name, const nsCString& key, uint32_t sample)
 {
   TelemetryHistogram::Accumulate(name, key, sample);
 }
 
 void
-AccumulateCategorical(ID id, const nsCString& label)
+AccumulateCategorical(HistogramID id, const nsCString& label)
 {
   TelemetryHistogram::AccumulateCategorical(id, label);
 }
 
 void
-AccumulateTimeDelta(ID aHistogram, TimeStamp start, TimeStamp end)
+AccumulateTimeDelta(HistogramID aHistogram, TimeStamp start, TimeStamp end)
 {
   Accumulate(aHistogram,
              static_cast<uint32_t>((end - start).ToMilliseconds()));
 }
 
 const char*
-GetHistogramName(ID id)
+GetHistogramName(HistogramID id)
 {
   return TelemetryHistogram::GetHistogramName(id);
 }
 
 bool
 CanRecordBase()
 {
   return TelemetryHistogram::CanRecordBase();
--- a/toolkit/components/telemetry/Telemetry.h
+++ b/toolkit/components/telemetry/Telemetry.h
@@ -57,26 +57,26 @@ void DestroyStatisticsRecorder();
 void Init();
 
 /**
  * Adds sample to a histogram defined in TelemetryHistogramEnums.h
  *
  * @param id - histogram id
  * @param sample - value to record.
  */
-void Accumulate(ID id, uint32_t sample);
+void Accumulate(HistogramID id, uint32_t sample);
 
 /**
  * Adds sample to a keyed histogram defined in TelemetryHistogramEnums.h
  *
  * @param id - keyed histogram id
  * @param key - the string key
  * @param sample - (optional) value to record, defaults to 1.
  */
-void Accumulate(ID id, const nsCString& key, uint32_t sample = 1);
+void Accumulate(HistogramID id, const nsCString& key, uint32_t sample = 1);
 
 /**
  * Adds a sample to a histogram defined in TelemetryHistogramEnums.h.
  * This function is here to support telemetry measurements from Java,
  * where we have only names and not numeric IDs.  You should almost
  * certainly be using the by-enum-id version instead of this one.
  *
  * @param name - histogram name
@@ -102,87 +102,87 @@ void Accumulate(const char *name, const 
  * by passing values from the corresponding Telemetry::LABELS_* enum.
  *
  * @param enumValue - Label value from one of the Telemetry::LABELS_* enums.
  */
 template<class E>
 void AccumulateCategorical(E enumValue) {
   static_assert(IsCategoricalLabelEnum<E>::value,
                 "Only categorical label enum types are supported.");
-  Accumulate(static_cast<ID>(CategoricalLabelId<E>::value),
+  Accumulate(static_cast<HistogramID>(CategoricalLabelId<E>::value),
              static_cast<uint32_t>(enumValue));
 };
 
 /**
  * Adds sample to a categorical histogram defined in TelemetryHistogramEnums.h
  * This string will be matched against the labels defined in Histograms.json.
  * If the string does not match a label defined for the histogram, nothing will
  * be recorded.
  *
  * @param id - The histogram id.
  * @param label - A string label value that is defined in Histograms.json for this histogram.
  */
-void AccumulateCategorical(ID id, const nsCString& label);
+void AccumulateCategorical(HistogramID id, const nsCString& label);
 
 /**
  * Adds time delta in milliseconds to a histogram defined in TelemetryHistogramEnums.h
  *
  * @param id - histogram id
  * @param start - start time
  * @param end - end time
  */
-void AccumulateTimeDelta(ID id, TimeStamp start, TimeStamp end = TimeStamp::Now());
+void AccumulateTimeDelta(HistogramID id, TimeStamp start, TimeStamp end = TimeStamp::Now());
 
 /**
  * Enable/disable recording for this histogram at runtime.
  * Recording is enabled by default, unless listed at kRecordingInitiallyDisabledIDs[].
  * id must be a valid telemetry enum, otherwise an assertion is triggered.
  *
  * @param id - histogram id
  * @param enabled - whether or not to enable recording from now on.
  */
-void SetHistogramRecordingEnabled(ID id, bool enabled);
+void SetHistogramRecordingEnabled(HistogramID id, bool enabled);
 
-const char* GetHistogramName(ID id);
+const char* GetHistogramName(HistogramID id);
 
 /**
  * Those wrappers are needed because the VS versions we use do not support free
  * functions with default template arguments.
  */
 template<TimerResolution res>
 struct AccumulateDelta_impl
 {
-  static void compute(ID id, TimeStamp start, TimeStamp end = TimeStamp::Now());
-  static void compute(ID id, const nsCString& key, TimeStamp start, TimeStamp end = TimeStamp::Now());
+  static void compute(HistogramID id, TimeStamp start, TimeStamp end = TimeStamp::Now());
+  static void compute(HistogramID id, const nsCString& key, TimeStamp start, TimeStamp end = TimeStamp::Now());
 };
 
 template<>
 struct AccumulateDelta_impl<Millisecond>
 {
-  static void compute(ID id, TimeStamp start, TimeStamp end = TimeStamp::Now()) {
+  static void compute(HistogramID id, TimeStamp start, TimeStamp end = TimeStamp::Now()) {
     Accumulate(id, static_cast<uint32_t>((end - start).ToMilliseconds()));
   }
-  static void compute(ID id, const nsCString& key, TimeStamp start, TimeStamp end = TimeStamp::Now()) {
+  static void compute(HistogramID id, const nsCString& key, TimeStamp start, TimeStamp end = TimeStamp::Now()) {
     Accumulate(id, key, static_cast<uint32_t>((end - start).ToMilliseconds()));
   }
 };
 
 template<>
 struct AccumulateDelta_impl<Microsecond>
 {
-  static void compute(ID id, TimeStamp start, TimeStamp end = TimeStamp::Now()) {
+  static void compute(HistogramID id, TimeStamp start, TimeStamp end = TimeStamp::Now()) {
     Accumulate(id, static_cast<uint32_t>((end - start).ToMicroseconds()));
   }
-  static void compute(ID id, const nsCString& key, TimeStamp start, TimeStamp end = TimeStamp::Now()) {
+  static void compute(HistogramID id, const nsCString& key, TimeStamp start, TimeStamp end = TimeStamp::Now()) {
     Accumulate(id, key, static_cast<uint32_t>((end - start).ToMicroseconds()));
   }
 };
 
 
-template<ID id, TimerResolution res = Millisecond>
+template<HistogramID id, TimerResolution res = Millisecond>
 class MOZ_RAII AutoTimer {
 public:
   explicit AutoTimer(TimeStamp aStart = TimeStamp::Now() MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
      : start(aStart)
   {
     MOZ_GUARD_OBJECT_NOTIFIER_INIT;
   }
 
@@ -202,17 +202,17 @@ public:
   }
 
 private:
   const TimeStamp start;
   const nsCString key;
   MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
 };
 
-template<ID id>
+template<HistogramID id>
 class MOZ_RAII AutoCounter {
 public:
   explicit AutoCounter(uint32_t counterStart = 0 MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
     : counter(counterStart)
   {
     MOZ_GUARD_OBJECT_NOTIFIER_INIT;
   }
 
--- a/toolkit/components/telemetry/TelemetryHistogram.cpp
+++ b/toolkit/components/telemetry/TelemetryHistogram.cpp
@@ -107,17 +107,17 @@ namespace {
 
 using mozilla::Telemetry::Common::AutoHashtable;
 using mozilla::Telemetry::Common::IsExpiredVersion;
 using mozilla::Telemetry::Common::CanRecordDataset;
 using mozilla::Telemetry::Common::IsInDataset;
 
 class KeyedHistogram;
 
-typedef nsBaseHashtableET<nsDepCharHashKey, mozilla::Telemetry::ID>
+typedef nsBaseHashtableET<nsDepCharHashKey, mozilla::Telemetry::HistogramID>
           CharPtrEntryType;
 
 typedef AutoHashtable<CharPtrEntryType> HistogramMapType;
 
 typedef nsClassHashtable<nsCStringHashKey, KeyedHistogram>
           KeyedHistogramMapType;
 
 // Hardcoded probes
@@ -201,17 +201,17 @@ base::StatisticsRecorder* gStatisticsRec
 ////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////
 //
 // PRIVATE CONSTANTS
 
 namespace {
 
 // List of histogram IDs which should have recording disabled initially.
-const mozilla::Telemetry::ID kRecordingInitiallyDisabledIDs[] = {
+const mozilla::Telemetry::HistogramID kRecordingInitiallyDisabledIDs[] = {
   mozilla::Telemetry::FX_REFRESH_DRIVER_SYNC_SCROLL_FRAME_DELAY_MS,
 
   // The array must not be empty. Leave these item here.
   mozilla::Telemetry::TELEMETRY_TEST_COUNT_INIT_NO_RECORD,
   mozilla::Telemetry::TELEMETRY_TEST_KEYED_COUNT_INIT_NO_RECORD
 };
 
 } // namespace
@@ -230,19 +230,19 @@ internal_CanRecordBase() {
 }
 
 bool
 internal_CanRecordExtended() {
   return gCanRecordExtended;
 }
 
 bool
-internal_IsHistogramEnumId(mozilla::Telemetry::ID aID)
+internal_IsHistogramEnumId(mozilla::Telemetry::HistogramID aID)
 {
-  static_assert(((mozilla::Telemetry::ID)-1 > 0), "ID should be unsigned.");
+  static_assert(((mozilla::Telemetry::HistogramID)-1 > 0), "ID should be unsigned.");
   return aID < mozilla::Telemetry::HistogramCount;
 }
 
 // Note: this is completely unrelated to mozilla::IsEmpty.
 bool
 internal_IsEmpty(const Histogram *h)
 {
   Histogram::SampleSet ss;
@@ -444,33 +444,33 @@ internal_GetHistogramMapEntry(const char
     return gHistogramMap.GetEntry(aName);
   }
 
   auto root = Substring(name, 0, name.Length() - strlen(suffix));
   return gHistogramMap.GetEntry(PromiseFlatCString(root).get());
 }
 
 nsresult
-internal_GetHistogramEnumId(const char *name, mozilla::Telemetry::ID *id)
+internal_GetHistogramEnumId(const char *name, mozilla::Telemetry::HistogramID *id)
 {
   if (!gInitDone) {
     return NS_ERROR_FAILURE;
   }
 
   CharPtrEntryType *entry = internal_GetHistogramMapEntry(name);
   if (!entry) {
     return NS_ERROR_INVALID_ARG;
   }
   *id = entry->mData;
   return NS_OK;
 }
 
 // O(1) histogram lookup by numeric id
 nsresult
-internal_GetHistogramByEnumId(mozilla::Telemetry::ID id, Histogram **ret, GeckoProcessType aProcessType)
+internal_GetHistogramByEnumId(mozilla::Telemetry::HistogramID id, Histogram **ret, GeckoProcessType aProcessType)
 {
   static Histogram* knownHistograms[mozilla::Telemetry::HistogramCount] = {0};
   static Histogram* knownContentHistograms[mozilla::Telemetry::HistogramCount] = {0};
   static Histogram* knownGPUHistograms[mozilla::Telemetry::HistogramCount] = {0};
 
   Histogram** knownList = nullptr;
 
   switch (aProcessType) {
@@ -530,17 +530,17 @@ internal_GetHistogramByEnumId(mozilla::T
   knownList[id] = h;
   *ret = h;
   return NS_OK;
 }
 
 nsresult
 internal_GetHistogramByName(const nsACString &name, Histogram **ret)
 {
-  mozilla::Telemetry::ID id;
+  mozilla::Telemetry::HistogramID id;
   nsresult rv
     = internal_GetHistogramEnumId(PromiseFlatCString(name).get(), &id);
   if (NS_FAILED(rv)) {
     return rv;
   }
 
   GeckoProcessType process = GetProcessFromName(name);
   rv = internal_GetHistogramByEnumId(id, ret, process);
@@ -555,17 +555,17 @@ internal_GetHistogramByName(const nsACSt
 
 /**
  * This clones a histogram |existing| with the id |existingId| to a
  * new histogram with the name |newName|.
  * For simplicity this is limited to registered histograms.
  */
 Histogram*
 internal_CloneHistogram(const nsACString& newName,
-                        mozilla::Telemetry::ID existingId,
+                        mozilla::Telemetry::HistogramID existingId,
                         Histogram& existing)
 {
   const HistogramInfo &info = gHistograms[existingId];
   Histogram *clone = nullptr;
   nsresult rv;
 
   rv = internal_HistogramGet(PromiseFlatCString(newName).get(),
                              info.expiration(),
@@ -588,17 +588,17 @@ GetProcessFromName(const std::string& aS
 {
   nsDependentCString string(aString.c_str(), aString.length());
   return GetProcessFromName(string);
 }
 
 Histogram*
 internal_GetSubsessionHistogram(Histogram& existing)
 {
-  mozilla::Telemetry::ID id;
+  mozilla::Telemetry::HistogramID id;
   nsresult rv
     = internal_GetHistogramEnumId(existing.histogram_name().c_str(), &id);
   if (NS_FAILED(rv) || gHistograms[id].keyed) {
     return nullptr;
   }
 
   static Histogram* subsession[mozilla::Telemetry::HistogramCount] = {};
   static Histogram* subsessionContent[mozilla::Telemetry::HistogramCount] = {};
@@ -667,17 +667,17 @@ internal_HistogramAdd(Histogram& histogr
 
 nsresult
 internal_HistogramAdd(Histogram& histogram, int32_t value)
 {
   uint32_t dataset = nsITelemetry::DATASET_RELEASE_CHANNEL_OPTIN;
   // We only really care about the dataset of the histogram if we are not recording
   // extended telemetry. Otherwise, we always record histogram data.
   if (!internal_CanRecordExtended()) {
-    mozilla::Telemetry::ID id;
+    mozilla::Telemetry::HistogramID id;
     nsresult rv
       = internal_GetHistogramEnumId(histogram.histogram_name().c_str(), &id);
     if (NS_FAILED(rv)) {
       // If we can't look up the dataset, it might be because the histogram was added
       // at runtime. Since we're not recording extended telemetry, bail out.
       return NS_OK;
     }
     dataset = gHistograms[id].dataset;
@@ -709,23 +709,23 @@ internal_HistogramClear(Histogram& aHist
 
 ////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////
 //
 // PRIVATE: Histogram corruption helpers
 
 namespace {
 
-void internal_Accumulate(mozilla::Telemetry::ID aHistogram, uint32_t aSample);
+void internal_Accumulate(mozilla::Telemetry::HistogramID aHistogram, uint32_t aSample);
 
 void
 internal_IdentifyCorruptHistograms(StatisticsRecorder::Histograms &hs)
 {
   for (auto h : hs) {
-    mozilla::Telemetry::ID id;
+    mozilla::Telemetry::HistogramID id;
     nsresult rv = internal_GetHistogramEnumId(h->histogram_name().c_str(), &id);
     // This histogram isn't a static histogram, just ignore it.
     if (NS_FAILED(rv)) {
       continue;
     }
 
     if (gCorruptHistograms[id]) {
       continue;
@@ -733,17 +733,17 @@ internal_IdentifyCorruptHistograms(Stati
 
     Histogram::SampleSet ss;
     h->SnapshotSample(&ss);
 
     Histogram::Inconsistencies check = h->FindCorruption(ss);
     bool corrupt = (check != Histogram::NO_INCONSISTENCIES);
 
     if (corrupt) {
-      mozilla::Telemetry::ID corruptID = mozilla::Telemetry::HistogramCount;
+      mozilla::Telemetry::HistogramID corruptID = mozilla::Telemetry::HistogramCount;
       if (check & Histogram::RANGE_CHECKSUM_ERROR) {
         corruptID = mozilla::Telemetry::RANGE_CHECKSUM_ERRORS;
       } else if (check & Histogram::BUCKET_ORDER_ERROR) {
         corruptID = mozilla::Telemetry::BUCKET_ORDER_ERRORS;
       } else if (check & Histogram::COUNT_HIGH_ERROR) {
         corruptID = mozilla::Telemetry::TOTAL_COUNT_HIGH_ERRORS;
       } else if (check & Histogram::COUNT_LOW_ERROR) {
         corruptID = mozilla::Telemetry::TOTAL_COUNT_LOW_ERRORS;
@@ -833,17 +833,17 @@ internal_ReflectHistogramSnapshot(JSCont
   h->SnapshotSample(&ss);
   return internal_ReflectHistogramAndSamples(cx, obj, h, ss);
 }
 
 bool
 internal_ShouldReflectHistogram(Histogram *h)
 {
   const char *name = h->histogram_name().c_str();
-  mozilla::Telemetry::ID id;
+  mozilla::Telemetry::HistogramID id;
   nsresult rv = internal_GetHistogramEnumId(name, &id);
   if (NS_FAILED(rv)) {
     // GetHistogramEnumId generally should not fail.  But a lookup
     // failure shouldn't prevent us from reflecting histograms into JS.
     //
     // However, these two histograms are created by Histogram itself for
     // tracking corruption.  We have our own histograms for that, so
     // ignore these two.
@@ -880,17 +880,17 @@ public:
                          bool subsession, bool clearSubsession);
 
   void SetRecordingEnabled(bool aEnabled) { mRecordingEnabled = aEnabled; };
   bool IsRecordingEnabled() const { return mRecordingEnabled; };
 
   nsresult Add(const nsCString& key, uint32_t aSample);
   void Clear(bool subsession);
 
-  nsresult GetEnumId(mozilla::Telemetry::ID& id);
+  nsresult GetEnumId(mozilla::Telemetry::HistogramID& id);
 
 private:
   typedef nsBaseHashtableET<nsCStringHashKey, Histogram*> KeyedHistogramEntry;
   typedef AutoHashtable<KeyedHistogramEntry> KeyedHistogramMapType;
   KeyedHistogramMapType mHistogramMap;
 #if !defined(MOZ_WIDGET_GONK) && !defined(MOZ_WIDGET_ANDROID)
   KeyedHistogramMapType mSubsessionMap;
 #endif
@@ -1116,17 +1116,17 @@ KeyedHistogram::GetJSSnapshot(JSContext*
     Clear(true);
   }
 #endif
 
   return NS_OK;
 }
 
 nsresult
-KeyedHistogram::GetEnumId(mozilla::Telemetry::ID& id)
+KeyedHistogram::GetEnumId(mozilla::Telemetry::HistogramID& id)
 {
   return internal_GetHistogramEnumId(mName.get(), &id);
 }
 
 } // namespace
 
 
 ////////////////////////////////////////////////////////////////////////
@@ -1264,17 +1264,17 @@ internal_AddonReflector(AddonEntryType *
 // a normal Mutex would show up as a leak in BloatView.  StaticMutex
 // also has the "OffTheBooks" property, so it won't show as a leak
 // in BloatView.
 static StaticMutex gTelemetryHistogramMutex;
 
 namespace {
 
 void
-internal_SetHistogramRecordingEnabled(mozilla::Telemetry::ID aID, bool aEnabled)
+internal_SetHistogramRecordingEnabled(mozilla::Telemetry::HistogramID aID, bool aEnabled)
 {
   if (gHistograms[aID].keyed) {
     const nsDependentCString id(gHistograms[aID].id());
     KeyedHistogram* keyed = internal_GetKeyedHistogramById(id);
     if (keyed) {
       keyed->SetRecordingEnabled(aEnabled);
       return;
     }
@@ -1286,63 +1286,63 @@ internal_SetHistogramRecordingEnabled(mo
       return;
     }
   }
 
   MOZ_ASSERT(false, "Telemetry::SetHistogramRecordingEnabled(...) id not found");
 }
 
 bool
-internal_RemoteAccumulate(mozilla::Telemetry::ID aId, uint32_t aSample)
+internal_RemoteAccumulate(mozilla::Telemetry::HistogramID aId, uint32_t aSample)
 {
   if (XRE_IsParentProcess()) {
     return false;
   }
   Histogram *h;
   nsresult rv = internal_GetHistogramByEnumId(aId, &h, GeckoProcessType_Default);
   if (NS_SUCCEEDED(rv) && !h->IsRecordingEnabled()) {
     return true;
   }
   TelemetryIPCAccumulator::AccumulateChildHistogram(aId, aSample);
   return true;
 }
 
 bool
-internal_RemoteAccumulate(mozilla::Telemetry::ID aId,
+internal_RemoteAccumulate(mozilla::Telemetry::HistogramID aId,
                     const nsCString& aKey, uint32_t aSample)
 {
   if (XRE_IsParentProcess()) {
     return false;
   }
   const HistogramInfo& th = gHistograms[aId];
   KeyedHistogram* keyed
      = internal_GetKeyedHistogramById(nsDependentCString(th.id()));
   MOZ_ASSERT(keyed);
   if (!keyed->IsRecordingEnabled()) {
     return false;
   }
   TelemetryIPCAccumulator::AccumulateChildKeyedHistogram(aId, aKey, aSample);
   return true;
 }
 
-void internal_Accumulate(mozilla::Telemetry::ID aHistogram, uint32_t aSample)
+void internal_Accumulate(mozilla::Telemetry::HistogramID aHistogram, uint32_t aSample)
 {
   if (!internal_CanRecordBase() ||
       internal_RemoteAccumulate(aHistogram, aSample)) {
     return;
   }
   Histogram *h;
   nsresult rv = internal_GetHistogramByEnumId(aHistogram, &h, GeckoProcessType_Default);
   if (NS_SUCCEEDED(rv)) {
     internal_HistogramAdd(*h, aSample, gHistograms[aHistogram].dataset);
   }
 }
 
 void
-internal_Accumulate(mozilla::Telemetry::ID aID,
+internal_Accumulate(mozilla::Telemetry::HistogramID aID,
                     const nsCString& aKey, uint32_t aSample)
 {
   if (!gInitDone || !internal_CanRecordBase() ||
       internal_RemoteAccumulate(aID, aKey, aSample)) {
     return;
   }
   const HistogramInfo& th = gHistograms[aID];
   KeyedHistogram* keyed
@@ -1354,55 +1354,55 @@ internal_Accumulate(mozilla::Telemetry::
 void
 internal_Accumulate(Histogram& aHistogram, uint32_t aSample)
 {
   if (XRE_IsParentProcess()) {
     internal_HistogramAdd(aHistogram, aSample);
     return;
   }
 
-  mozilla::Telemetry::ID id;
+  mozilla::Telemetry::HistogramID id;
   nsresult rv = internal_GetHistogramEnumId(aHistogram.histogram_name().c_str(), &id);
   if (NS_SUCCEEDED(rv)) {
     internal_RemoteAccumulate(id, aSample);
   }
 }
 
 void
 internal_Accumulate(KeyedHistogram& aKeyed,
                     const nsCString& aKey, uint32_t aSample)
 {
   if (XRE_IsParentProcess()) {
     aKeyed.Add(aKey, aSample);
     return;
   }
 
-  mozilla::Telemetry::ID id;
+  mozilla::Telemetry::HistogramID id;
   if (NS_SUCCEEDED(aKeyed.GetEnumId(id))) {
     internal_RemoteAccumulate(id, aKey, aSample);
   }
 }
 
 void
-internal_AccumulateChild(GeckoProcessType aProcessType, mozilla::Telemetry::ID aId, uint32_t aSample)
+internal_AccumulateChild(GeckoProcessType aProcessType, mozilla::Telemetry::HistogramID aId, uint32_t aSample)
 {
   if (!internal_CanRecordBase()) {
     return;
   }
   Histogram* h;
   nsresult rv = internal_GetHistogramByEnumId(aId, &h, aProcessType);
   if (NS_SUCCEEDED(rv)) {
     internal_HistogramAdd(*h, aSample, gHistograms[aId].dataset);
   } else {
     NS_WARNING("NS_FAILED GetHistogramByEnumId for CHILD");
   }
 }
 
 void
-internal_AccumulateChildKeyed(GeckoProcessType aProcessType, mozilla::Telemetry::ID aId,
+internal_AccumulateChildKeyed(GeckoProcessType aProcessType, mozilla::Telemetry::HistogramID aId,
                               const nsCString& aKey, uint32_t aSample)
 {
   if (!gInitDone || !internal_CanRecordBase()) {
     return;
   }
 
   const char* suffix = SuffixForProcessType(aProcessType);
   if (!suffix) {
@@ -1465,17 +1465,17 @@ internal_JSHistogram_Add(JSContext *cx, 
   // rather report failures using the console.
   args.rval().setUndefined();
 
   if (!internal_CanRecordBase()) {
     return true;
   }
 
   uint32_t value = 0;
-  mozilla::Telemetry::ID id;
+  mozilla::Telemetry::HistogramID id;
   if ((type == base::CountHistogram::COUNT_HISTOGRAM) && (args.length() == 0)) {
     // If we don't have an argument for the count histogram, assume an increment of 1.
     // Otherwise, make sure to run some sanity checks on the argument.
     value = 1;
   } else if (type == base::LinearHistogram::LINEAR_HISTOGRAM &&
       (args.length() > 0) && args[0].isString() &&
       NS_SUCCEEDED(internal_GetHistogramEnumId(h->histogram_name().c_str(), &id)) &&
       gHistograms[id].histogramType == nsITelemetry::HISTOGRAM_CATEGORICAL) {
@@ -1581,17 +1581,17 @@ internal_JSHistogram_Dataset(JSContext *
 {
   JS::CallArgs args = JS::CallArgsFromVp(argc, vp);
   JSObject *obj = JS_THIS_OBJECT(cx, vp);
   if (!obj) {
     return false;
   }
 
   Histogram *h = static_cast<Histogram*>(JS_GetPrivate(obj));
-  mozilla::Telemetry::ID id;
+  mozilla::Telemetry::HistogramID id;
   nsresult rv = internal_GetHistogramEnumId(h->histogram_name().c_str(), &id);
   if (NS_SUCCEEDED(rv)) {
     args.rval().setNumber(gHistograms[id].dataset);
     return true;
   }
 
   return false;
 }
@@ -1962,17 +1962,17 @@ void TelemetryHistogram::InitializeGloba
 
   // gHistogramMap should have been pre-sized correctly at the
   // declaration point further up in this file.
 
   // Populate the static histogram name->id cache.
   // Note that the histogram names are statically allocated.
   for (uint32_t i = 0; i < mozilla::Telemetry::HistogramCount; i++) {
     CharPtrEntryType *entry = gHistogramMap.PutEntry(gHistograms[i].id());
-    entry->mData = (mozilla::Telemetry::ID) i;
+    entry->mData = (mozilla::Telemetry::HistogramID) i;
   }
 
 #ifdef DEBUG
   gHistogramMap.MarkImmutable();
 #endif
 
   mozilla::PodArrayZero(gCorruptHistograms);
 
@@ -2074,17 +2074,17 @@ TelemetryHistogram::InitHistogramRecordi
   StaticMutexAutoLock locker(gTelemetryHistogramMutex);
   for (auto recordingInitiallyDisabledID : kRecordingInitiallyDisabledIDs) {
     internal_SetHistogramRecordingEnabled(recordingInitiallyDisabledID,
                                           false);
   }
 }
 
 void
-TelemetryHistogram::SetHistogramRecordingEnabled(mozilla::Telemetry::ID aID,
+TelemetryHistogram::SetHistogramRecordingEnabled(mozilla::Telemetry::HistogramID aID,
                                                  bool aEnabled)
 {
   if (NS_WARN_IF(!internal_IsHistogramEnumId(aID))) {
     MOZ_ASSERT_UNREACHABLE("Histogram usage requires valid ids.");
     return;
   }
 
   StaticMutexAutoLock locker(gTelemetryHistogramMutex);
@@ -2110,30 +2110,30 @@ TelemetryHistogram::SetHistogramRecordin
     return NS_OK;
   }
 
   return NS_ERROR_FAILURE;
 }
 
 
 void
-TelemetryHistogram::Accumulate(mozilla::Telemetry::ID aID,
+TelemetryHistogram::Accumulate(mozilla::Telemetry::HistogramID aID,
                                uint32_t aSample)
 {
   if (NS_WARN_IF(!internal_IsHistogramEnumId(aID))) {
     MOZ_ASSERT_UNREACHABLE("Histogram usage requires valid ids.");
     return;
   }
 
   StaticMutexAutoLock locker(gTelemetryHistogramMutex);
   internal_Accumulate(aID, aSample);
 }
 
 void
-TelemetryHistogram::Accumulate(mozilla::Telemetry::ID aID,
+TelemetryHistogram::Accumulate(mozilla::Telemetry::HistogramID aID,
                                const nsCString& aKey, uint32_t aSample)
 {
   if (NS_WARN_IF(!internal_IsHistogramEnumId(aID))) {
     MOZ_ASSERT_UNREACHABLE("Histogram usage requires valid ids.");
     return;
   }
 
   StaticMutexAutoLock locker(gTelemetryHistogramMutex);
@@ -2142,41 +2142,41 @@ TelemetryHistogram::Accumulate(mozilla::
 
 void
 TelemetryHistogram::Accumulate(const char* name, uint32_t sample)
 {
   StaticMutexAutoLock locker(gTelemetryHistogramMutex);
   if (!internal_CanRecordBase()) {
     return;
   }
-  mozilla::Telemetry::ID id;
+  mozilla::Telemetry::HistogramID id;
   nsresult rv = internal_GetHistogramEnumId(name, &id);
   if (NS_FAILED(rv)) {
     return;
   }
   internal_Accumulate(id, sample);
 }
 
 void
 TelemetryHistogram::Accumulate(const char* name,
                                const nsCString& key, uint32_t sample)
 {
   StaticMutexAutoLock locker(gTelemetryHistogramMutex);
   if (!internal_CanRecordBase()) {
     return;
   }
-  mozilla::Telemetry::ID id;
+  mozilla::Telemetry::HistogramID id;
   nsresult rv = internal_GetHistogramEnumId(name, &id);
   if (NS_SUCCEEDED(rv)) {
     internal_Accumulate(id, key, sample);
   }
 }
 
 void
-TelemetryHistogram::AccumulateCategorical(mozilla::Telemetry::ID aId,
+TelemetryHistogram::AccumulateCategorical(mozilla::Telemetry::HistogramID aId,
                                           const nsCString& label)
 {
   if (NS_WARN_IF(!internal_IsHistogramEnumId(aId))) {
     MOZ_ASSERT_UNREACHABLE("Histogram usage requires valid ids.");
     return;
   }
 
   StaticMutexAutoLock locker(gTelemetryHistogramMutex);
@@ -2257,17 +2257,17 @@ TelemetryHistogram::GetKeyedHistogramByI
       return NS_ERROR_FAILURE;
     }
   }
   // Runs without protection from |gTelemetryHistogramMutex|
   return internal_WrapAndReturnKeyedHistogram(keyed, cx, ret);
 }
 
 const char*
-TelemetryHistogram::GetHistogramName(mozilla::Telemetry::ID id)
+TelemetryHistogram::GetHistogramName(mozilla::Telemetry::HistogramID id)
 {
   if (NS_WARN_IF(!internal_IsHistogramEnumId(id))) {
     MOZ_ASSERT_UNREACHABLE("Histogram usage requires valid ids.");
     return nullptr;
   }
 
   StaticMutexAutoLock locker(gTelemetryHistogramMutex);
   const HistogramInfo& h = gHistograms[id];
@@ -2299,17 +2299,17 @@ TelemetryHistogram::CreateHistogramSnaps
     if (gHistograms[i].keyed) {
       continue;
     }
     const uint32_t type = gHistograms[i].histogramType;
     if (type == nsITelemetry::HISTOGRAM_FLAG ||
         type == nsITelemetry::HISTOGRAM_COUNT) {
       Histogram *h;
       mozilla::DebugOnly<nsresult> rv;
-      mozilla::Telemetry::ID id = mozilla::Telemetry::ID(i);
+      mozilla::Telemetry::HistogramID id = mozilla::Telemetry::HistogramID(i);
 
       rv = internal_GetHistogramByEnumId(id, &h, GeckoProcessType_Default);
       MOZ_ASSERT(NS_SUCCEEDED(rv));
 
       rv = internal_GetHistogramByEnumId(id, &h, GeckoProcessType_Content);
       MOZ_ASSERT(NS_SUCCEEDED(rv));
 
       if (includeGPUProcess) {
--- a/toolkit/components/telemetry/TelemetryHistogram.h
+++ b/toolkit/components/telemetry/TelemetryHistogram.h
@@ -28,43 +28,43 @@ bool GlobalStateHasBeenInitialized();
 #endif
 
 bool CanRecordBase();
 void SetCanRecordBase(bool b);
 bool CanRecordExtended();
 void SetCanRecordExtended(bool b);
 
 void InitHistogramRecordingEnabled();
-void SetHistogramRecordingEnabled(mozilla::Telemetry::ID aID, bool aEnabled);
+void SetHistogramRecordingEnabled(mozilla::Telemetry::HistogramID aID, bool aEnabled);
 
 nsresult SetHistogramRecordingEnabled(const nsACString &id, bool aEnabled);
 
-void Accumulate(mozilla::Telemetry::ID aHistogram, uint32_t aSample);
-void Accumulate(mozilla::Telemetry::ID aID, const nsCString& aKey,
+void Accumulate(mozilla::Telemetry::HistogramID aHistogram, uint32_t aSample);
+void Accumulate(mozilla::Telemetry::HistogramID aID, const nsCString& aKey,
                                             uint32_t aSample);
 void Accumulate(const char* name, uint32_t sample);
 void Accumulate(const char* name, const nsCString& key, uint32_t sample);
 
-void AccumulateCategorical(mozilla::Telemetry::ID aId, const nsCString& aLabel);
+void AccumulateCategorical(mozilla::Telemetry::HistogramID aId, const nsCString& aLabel);
 
 void AccumulateChild(GeckoProcessType aProcessType,
                      const nsTArray<mozilla::Telemetry::Accumulation>& aAccumulations);
 void AccumulateChildKeyed(GeckoProcessType aProcessType,
                           const nsTArray<mozilla::Telemetry::KeyedAccumulation>& aAccumulations);
 
 nsresult
 GetHistogramById(const nsACString &name, JSContext *cx,
                  JS::MutableHandle<JS::Value> ret);
 
 nsresult
 GetKeyedHistogramById(const nsACString &name, JSContext *cx,
                       JS::MutableHandle<JS::Value> ret);
 
 const char*
-GetHistogramName(mozilla::Telemetry::ID id);
+GetHistogramName(mozilla::Telemetry::HistogramID id);
 
 nsresult
 CreateHistogramSnapshots(JSContext *cx, JS::MutableHandle<JS::Value> ret,
                          bool subsession, bool clearSubsession);
 
 nsresult
 RegisteredHistograms(uint32_t aDataset, uint32_t *aCount,
                      char*** aHistograms);
--- a/toolkit/components/telemetry/gen-histogram-enum.py
+++ b/toolkit/components/telemetry/gen-histogram-enum.py
@@ -45,17 +45,17 @@ def main(output, *filenames):
     all_histograms = list(histogram_tools.from_files(filenames))
     groups = itertools.groupby(all_histograms,
                                lambda h: h.name().startswith("USE_COUNTER2_"))
 
     # Print the histogram enums.
     # Note that histogram_tools.py guarantees that all of the USE_COUNTER2_*
     # histograms are defined in a contiguous block.  We therefore assume
     # that there's at most one group for which use_counter_group is true.
-    print("enum ID : uint32_t {", file=output)
+    print("enum HistogramID : uint32_t {", file=output)
     seen_use_counters = False
     for (use_counter_group, histograms) in groups:
         if use_counter_group:
             seen_use_counters = True
 
         # The HistogramDUMMY* enum variables are used to make the computation
         # of Histogram{First,Last}UseCounter easier.  Otherwise, we'd have to
         # special case the first and last histogram in the group.
--- a/toolkit/components/telemetry/ipc/TelemetryComms.h
+++ b/toolkit/components/telemetry/ipc/TelemetryComms.h
@@ -9,27 +9,27 @@
 #include "ipc/IPCMessageUtils.h"
 #include "nsITelemetry.h"
 #include "nsVariant.h"
 
 namespace mozilla {
 namespace Telemetry {
 
 // Histogram accumulation types.
-enum ID : uint32_t;
+enum HistogramID : uint32_t;
 
 struct Accumulation
 {
-  mozilla::Telemetry::ID mId;
+  mozilla::Telemetry::HistogramID mId;
   uint32_t mSample;
 };
 
 struct KeyedAccumulation
 {
-  mozilla::Telemetry::ID mId;
+  mozilla::Telemetry::HistogramID mId;
   uint32_t mSample;
   nsCString mKey;
 };
 
 // Scalar accumulation types.
 enum class ScalarID : uint32_t;
 
 enum class ScalarActionType : uint32_t {
--- a/toolkit/components/telemetry/ipc/TelemetryIPCAccumulator.cpp
+++ b/toolkit/components/telemetry/ipc/TelemetryIPCAccumulator.cpp
@@ -102,33 +102,34 @@ void ArmIPCTimer(const StaticMutexAutoLo
 } // anonymous namespace
 
 ////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////
 //
 // EXTERNALLY VISIBLE FUNCTIONS in namespace TelemetryIPCAccumulator::
 
 void
-TelemetryIPCAccumulator::AccumulateChildHistogram(mozilla::Telemetry::ID aId, uint32_t aSample)
+TelemetryIPCAccumulator::AccumulateChildHistogram(mozilla::Telemetry::HistogramID aId,
+                                                  uint32_t aSample)
 {
   StaticMutexAutoLock locker(gTelemetryIPCAccumulatorMutex);
   if (!gHistogramAccumulations) {
     gHistogramAccumulations = new nsTArray<Accumulation>();
   }
   if (gHistogramAccumulations->Length() == kHistogramAccumulationsArrayHighWaterMark) {
     TelemetryIPCAccumulator::DispatchToMainThread(NS_NewRunnableFunction([]() -> void {
       TelemetryIPCAccumulator::IPCTimerFired(nullptr, nullptr);
     }));
   }
   gHistogramAccumulations->AppendElement(Accumulation{aId, aSample});
   ArmIPCTimer(locker);
 }
 
 void
-TelemetryIPCAccumulator::AccumulateChildKeyedHistogram(mozilla::Telemetry::ID aId,
+TelemetryIPCAccumulator::AccumulateChildKeyedHistogram(mozilla::Telemetry::HistogramID aId,
                                                        const nsCString& aKey, uint32_t aSample)
 {
   StaticMutexAutoLock locker(gTelemetryIPCAccumulatorMutex);
   if (!gKeyedHistogramAccumulations) {
     gKeyedHistogramAccumulations = new nsTArray<KeyedAccumulation>();
   }
   if (gKeyedHistogramAccumulations->Length() == kHistogramAccumulationsArrayHighWaterMark) {
     TelemetryIPCAccumulator::DispatchToMainThread(NS_NewRunnableFunction([]() -> void {
--- a/toolkit/components/telemetry/ipc/TelemetryIPCAccumulator.h
+++ b/toolkit/components/telemetry/ipc/TelemetryIPCAccumulator.h
@@ -13,18 +13,18 @@ class nsIRunnable;
 class nsITimer;
 class nsAString;
 class nsCString;
 
 namespace mozilla {
 namespace TelemetryIPCAccumulator {
 
 // Histogram accumulation functions.
-void AccumulateChildHistogram(mozilla::Telemetry::ID aId, uint32_t aSample);
-void AccumulateChildKeyedHistogram(mozilla::Telemetry::ID aId, const nsCString& aKey,
+void AccumulateChildHistogram(mozilla::Telemetry::HistogramID aId, uint32_t aSample);
+void AccumulateChildKeyedHistogram(mozilla::Telemetry::HistogramID aId, const nsCString& aKey,
                                    uint32_t aSample);
 
 // Scalar accumulation functions.
 void RecordChildScalarAction(mozilla::Telemetry::ScalarID aId,
                              mozilla::Telemetry::ScalarActionType aAction,
                              const mozilla::Telemetry::ScalarVariant& aValue);
 
 void RecordChildKeyedScalarAction(mozilla::Telemetry::ScalarID aId, const nsAString& aKey,
--- a/widget/android/nsAppShell.cpp
+++ b/widget/android/nsAppShell.cpp
@@ -444,19 +444,19 @@ nsAppShell::NotifyNativeEvent()
 
 void
 nsAppShell::RecordLatencies()
 {
     if (!mozilla::Telemetry::CanRecordExtended()) {
         return;
     }
 
-    const mozilla::Telemetry::ID timeIDs[] = {
-        mozilla::Telemetry::ID::FENNEC_LOOP_UI_LATENCY,
-        mozilla::Telemetry::ID::FENNEC_LOOP_OTHER_LATENCY
+    const mozilla::Telemetry::HistogramID timeIDs[] = {
+        mozilla::Telemetry::HistogramID::FENNEC_LOOP_UI_LATENCY,
+        mozilla::Telemetry::HistogramID::FENNEC_LOOP_OTHER_LATENCY
     };
 
     static_assert(ArrayLength(Queue::sLatencyCount) == Queue::LATENCY_COUNT,
                   "Count array length mismatch");
     static_assert(ArrayLength(Queue::sLatencyTime) == Queue::LATENCY_COUNT,
                   "Time array length mismatch");
     static_assert(ArrayLength(timeIDs) == Queue::LATENCY_COUNT,
                   "Time ID array length mismatch");