The Tor Browser: toolkit/components/telemetry/Telemetry.cpp@129ffea94266 (annotated)

toolkit/components/telemetry/Telemetry.cpp@129ffea94266 (annotated)

toolkit/components/telemetry/Telemetry.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include <algorithm>
 #include <fstream>
 #include <prio.h>
 #include "mozilla/Attributes.h"
 #include "mozilla/DebugOnly.h"
 #include "mozilla/Likely.h"
 #include "mozilla/MathAlgorithms.h"
 #include "base/histogram.h"
 #include "base/pickle.h"
 #include "nsIComponentManager.h"
 #include "nsIServiceManager.h"
 #include "nsThreadManager.h"
 #include "nsCOMArray.h"
 #include "nsCOMPtr.h"
 #include "nsXPCOMPrivate.h"
 #include "nsIXULAppInfo.h"
 #include "nsVersionComparator.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/ModuleUtils.h"
 #include "nsIXPConnect.h"
 #include "mozilla/Services.h"
 #include "jsapi.h"
 #include "jsfriendapi.h"
 #include "js/GCAPI.h"
 #include "nsString.h"
 #include "nsITelemetry.h"
 #include "nsIFile.h"
 #include "nsIFileStreams.h"
 #include "nsIMemoryReporter.h"
 #include "nsISeekableStream.h"
 #include "Telemetry.h"
 #include "nsTHashtable.h"
 #include "nsHashKeys.h"
 #include "nsBaseHashtable.h"
 #include "nsXULAppAPI.h"
 #include "nsReadableUtils.h"
 #include "nsThreadUtils.h"
 #if defined(XP_WIN)
 #include "nsUnicharUtils.h"
 #endif
 #include "nsNetCID.h"
 #include "nsNetUtil.h"
 #include "plstr.h"
 #include "nsAppDirectoryServiceDefs.h"
 #include "mozilla/BackgroundHangMonitor.h"
 #include "mozilla/ThreadHangStats.h"
 #include "mozilla/ProcessedStack.h"
 #include "mozilla/Mutex.h"
 #include "mozilla/FileUtils.h"
 #include "mozilla/Preferences.h"
 #include "mozilla/StaticPtr.h"
 #include "mozilla/IOInterposer.h"
 #include "mozilla/PoisonIOInterposer.h"
 #include "mozilla/StartupTimeline.h"
 #if defined(MOZ_ENABLE_PROFILER_SPS)
 #include "shared-libraries.h"
 #endif
 #define EXPIRED_ID "__expired__"
 namespace {
 using namespace base;
 using namespace mozilla;
 template<class EntryType>
 class AutoHashtable : public nsTHashtable<EntryType>
 {
 public:
   AutoHashtable(uint32_t initSize = PL_DHASH_MIN_SIZE);
   typedef bool (*ReflectEntryFunc)(EntryType *entry, JSContext *cx, JS::Handle<JSObject*> obj);
   bool ReflectIntoJS(ReflectEntryFunc entryFunc, JSContext *cx, JS::Handle<JSObject*> obj);
 private:
   struct EnumeratorArgs {
     JSContext *cx;
     JS::Handle<JSObject*> obj;
     ReflectEntryFunc entryFunc;
   };
   static PLDHashOperator ReflectEntryStub(EntryType *entry, void *arg);
 };
 template<class EntryType>
 AutoHashtable<EntryType>::AutoHashtable(uint32_t initSize)
   : nsTHashtable<EntryType>(initSize)
 {
 }
 template<typename EntryType>
 PLDHashOperator
 AutoHashtable<EntryType>::ReflectEntryStub(EntryType *entry, void *arg)
 {
   EnumeratorArgs *args = static_cast<EnumeratorArgs *>(arg);
   if (!args->entryFunc(entry, args->cx, args->obj)) {
     return PL_DHASH_STOP;
   }
   return PL_DHASH_NEXT;
 }
 /**
  * Reflect the individual entries of table into JS, usually by defining
  * some property and value of obj.  entryFunc is called for each entry.
  */
 template<typename EntryType>
 bool
 AutoHashtable<EntryType>::ReflectIntoJS(ReflectEntryFunc entryFunc,
                                         JSContext *cx, JS::Handle<JSObject*> obj)
 {
   EnumeratorArgs args = { cx, obj, entryFunc };
   uint32_t num = this->EnumerateEntries(ReflectEntryStub, static_cast<void*>(&args));
   return num == this->Count();
 }
 // This class is conceptually a list of ProcessedStack objects, but it represents them
 // more efficiently by keeping a single global list of modules.
 class CombinedStacks {
 public:
   typedef std::vector<Telemetry::ProcessedStack::Frame> Stack;
   const Telemetry::ProcessedStack::Module& GetModule(unsigned aIndex) const;
   size_t GetModuleCount() const;
   const Stack& GetStack(unsigned aIndex) const;
   void AddStack(const Telemetry::ProcessedStack& aStack);
   size_t GetStackCount() const;
   size_t SizeOfExcludingThis() const;
 private:
   std::vector<Telemetry::ProcessedStack::Module> mModules;
   std::vector<Stack> mStacks;
 };
 static JSObject *
 CreateJSStackObject(JSContext *cx, const CombinedStacks &stacks);
 size_t
 CombinedStacks::GetModuleCount() const {
   return mModules.size();
 }
 const Telemetry::ProcessedStack::Module&
 CombinedStacks::GetModule(unsigned aIndex) const {
   return mModules[aIndex];
 }
 void
 CombinedStacks::AddStack(const Telemetry::ProcessedStack& aStack) {
   mStacks.resize(mStacks.size() + 1);
   CombinedStacks::Stack& adjustedStack = mStacks.back();
   size_t stackSize = aStack.GetStackSize();
   for (size_t i = 0; i < stackSize; ++i) {
     const Telemetry::ProcessedStack::Frame& frame = aStack.GetFrame(i);
     uint16_t modIndex;
     if (frame.mModIndex == std::numeric_limits<uint16_t>::max()) {
       modIndex = frame.mModIndex;
     } else {
       const Telemetry::ProcessedStack::Module& module =
         aStack.GetModule(frame.mModIndex);
       std::vector<Telemetry::ProcessedStack::Module>::iterator modIterator =
         std::find(mModules.begin(), mModules.end(), module);
       if (modIterator == mModules.end()) {
         mModules.push_back(module);
         modIndex = mModules.size() - 1;
       } else {
         modIndex = modIterator - mModules.begin();
       }
     }
     Telemetry::ProcessedStack::Frame adjustedFrame = { frame.mOffset, modIndex };
     adjustedStack.push_back(adjustedFrame);
   }
 }
 const CombinedStacks::Stack&
 CombinedStacks::GetStack(unsigned aIndex) const {
   return mStacks[aIndex];
 }
 size_t
 CombinedStacks::GetStackCount() const {
   return mStacks.size();
 }
 size_t
 CombinedStacks::SizeOfExcludingThis() const {
   // This is a crude approximation. We would like to do something like
   // aMallocSizeOf(&mModules[0]), but on linux aMallocSizeOf will call
   // malloc_usable_size which is only safe on the pointers returned by malloc.
   // While it works on current libstdc++, it is better to be safe and not assume
   // that &vec[0] points to one. We could use a custom allocator, but
   // it doesn't seem worth it.
   size_t n = 0;
   n += mModules.capacity() * sizeof(Telemetry::ProcessedStack::Module);
   n += mStacks.capacity() * sizeof(Stack);
   for (std::vector<Stack>::const_iterator i = mStacks.begin(),
          e = mStacks.end(); i != e; ++i) {
     const Stack& s = *i;
     n += s.capacity() * sizeof(Telemetry::ProcessedStack::Frame);
   }
   return n;
 }
 class HangReports {
 public:
   size_t SizeOfExcludingThis() const;
   void AddHang(const Telemetry::ProcessedStack& aStack, uint32_t aDuration,
                int32_t aSystemUptime, int32_t aFirefoxUptime);
   uint32_t GetDuration(unsigned aIndex) const;
   int32_t GetSystemUptime(unsigned aIndex) const;
   int32_t GetFirefoxUptime(unsigned aIndex) const;
   const CombinedStacks& GetStacks() const;
 private:
   struct HangInfo {
     // Hang duration (in seconds)
     uint32_t mDuration;
     // System uptime (in minutes) at the time of the hang
     int32_t mSystemUptime;
     // Firefox uptime (in minutes) at the time of the hang
     int32_t mFirefoxUptime;
   };
   std::vector<HangInfo> mHangInfo;
   CombinedStacks mStacks;
 };
 void
 HangReports::AddHang(const Telemetry::ProcessedStack& aStack,
                      uint32_t aDuration,
                      int32_t aSystemUptime,
                      int32_t aFirefoxUptime) {
   HangInfo info = { aDuration, aSystemUptime, aFirefoxUptime };
   mHangInfo.push_back(info);
   mStacks.AddStack(aStack);
 }
 size_t
 HangReports::SizeOfExcludingThis() const {
   size_t n = 0;
   n += mStacks.SizeOfExcludingThis();
   // This is a crude approximation. See comment on
   // CombinedStacks::SizeOfExcludingThis.
   n += mHangInfo.capacity() * sizeof(HangInfo);
   return n;
 }
 const CombinedStacks&
 HangReports::GetStacks() const {
   return mStacks;
 }
 uint32_t
 HangReports::GetDuration(unsigned aIndex) const {
   return mHangInfo[aIndex].mDuration;
 }
 int32_t
 HangReports::GetSystemUptime(unsigned aIndex) const {
   return mHangInfo[aIndex].mSystemUptime;
 }
 int32_t
 HangReports::GetFirefoxUptime(unsigned aIndex) const {
   return mHangInfo[aIndex].mFirefoxUptime;
 }
 /**
  * IOInterposeObserver recording statistics of main-thread I/O during execution,
  * aimed at consumption by TelemetryImpl
  */
 class TelemetryIOInterposeObserver : public IOInterposeObserver
 {
   /** File-level statistics structure */
   struct FileStats {
     FileStats()
       : creates(0)
       , reads(0)
       , writes(0)
       , fsyncs(0)
       , stats(0)
       , totalTime(0)
     {}
     uint32_t  creates;      /** Number of create/open operations */
     uint32_t  reads;        /** Number of read operations */
     uint32_t  writes;       /** Number of write operations */
     uint32_t  fsyncs;       /** Number of fsync operations */
     uint32_t  stats;        /** Number of stat operations */
     double    totalTime;    /** Accumulated duration of all operations */
   };
   struct SafeDir {
     SafeDir(const nsAString& aPath, const nsAString& aSubstName)
       : mPath(aPath)
       , mSubstName(aSubstName)
     {}
     size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
       return mPath.SizeOfExcludingThisIfUnshared(aMallocSizeOf) +
              mSubstName.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
     }
     nsString  mPath;        /** Path to the directory */
     nsString  mSubstName;   /** Name to substitute with */
   };
 public:
   TelemetryIOInterposeObserver(nsIFile* aXreDir);
   /**
    * An implementation of Observe that records statistics of all
    * file IO operations.
    */
   void Observe(Observation& aOb);
   /**
    * Reflect recorded file IO statistics into Javascript
    */
   bool ReflectIntoJS(JSContext *cx, JS::Handle<JSObject*> rootObj);
   /**
    * Adds a path for inclusion in main thread I/O report.
    * @param aPath Directory path
    * @param aSubstName Name to substitute for aPath for privacy reasons
    */
   void AddPath(const nsAString& aPath, const nsAString& aSubstName);
   /**
    * Get size of hash table with file stats
    */
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
     return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
   }
   size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
     size_t size;
     size = mFileStats.SizeOfExcludingThis(SizeOfFileIOEntryTypeExcludingThis,
                                           aMallocSizeOf) +
            mSafeDirs.SizeOfExcludingThis(aMallocSizeOf);
     uint32_t safeDirsLen = mSafeDirs.Length();
     for (uint32_t i = 0; i < safeDirsLen; ++i) {
       size += mSafeDirs[i].SizeOfExcludingThis(aMallocSizeOf);
     }
     return size;
   }
 private:
   enum Stage
   {
     STAGE_STARTUP = 0,
     STAGE_NORMAL,
     STAGE_SHUTDOWN,
     NUM_STAGES
   };
   static inline Stage NextStage(Stage aStage)
   {
     switch (aStage) {
       case STAGE_STARTUP:
         return STAGE_NORMAL;
       case STAGE_NORMAL:
         return STAGE_SHUTDOWN;
       case STAGE_SHUTDOWN:
         return STAGE_SHUTDOWN;
       default:
         return NUM_STAGES;
     }
   }
   struct FileStatsByStage
   {
     FileStats mStats[NUM_STAGES];
   };
   typedef nsBaseHashtableET<nsStringHashKey, FileStatsByStage> FileIOEntryType;
   // Statistics for each filename
   AutoHashtable<FileIOEntryType> mFileStats;
   // Container for whitelisted directories
   nsTArray<SafeDir> mSafeDirs;
   Stage             mCurStage;
   /**
    * Reflect a FileIOEntryType object to a Javascript property on obj with
    * filename as key containing array:
    * [totalTime, creates, reads, writes, fsyncs, stats]
    */
   static bool ReflectFileStats(FileIOEntryType* entry, JSContext *cx,
                                JS::Handle<JSObject*> obj);
   static size_t SizeOfFileIOEntryTypeExcludingThis(FileIOEntryType* aEntry,
                                                    mozilla::MallocSizeOf mallocSizeOf,
                                                    void*)
   {
     return aEntry->GetKey().SizeOfExcludingThisIfUnshared(mallocSizeOf);
   }
 };
 TelemetryIOInterposeObserver::TelemetryIOInterposeObserver(nsIFile* aXreDir)
   : mCurStage(STAGE_STARTUP)
 {
   nsAutoString xreDirPath;
   nsresult rv = aXreDir->GetPath(xreDirPath);
   if (NS_SUCCEEDED(rv)) {
     AddPath(xreDirPath, NS_LITERAL_STRING("{xre}"));
   }
 }
 void TelemetryIOInterposeObserver::AddPath(const nsAString& aPath,
                                            const nsAString& aSubstName)
 {
   mSafeDirs.AppendElement(SafeDir(aPath, aSubstName));
 }
 void TelemetryIOInterposeObserver::Observe(Observation& aOb)
 {
   // We only report main-thread I/O
   if (!IsMainThread()) {
     return;
   }
   if (aOb.ObservedOperation() == OpNextStage) {
     mCurStage = NextStage(mCurStage);
     MOZ_ASSERT(mCurStage < NUM_STAGES);
     return;
   }
   // Get the filename
   const char16_t* filename = aOb.Filename();
   // Discard observations without filename
   if (!filename) {
     return;
   }
 #if defined(XP_WIN)
   nsCaseInsensitiveStringComparator comparator;
 #else
   nsDefaultStringComparator comparator;
 #endif
   nsAutoString      processedName;
   nsDependentString filenameStr(filename);
   uint32_t safeDirsLen = mSafeDirs.Length();
   for (uint32_t i = 0; i < safeDirsLen; ++i) {
     if (StringBeginsWith(filenameStr, mSafeDirs[i].mPath, comparator)) {
       processedName = mSafeDirs[i].mSubstName;
       processedName += Substring(filenameStr, mSafeDirs[i].mPath.Length());
       break;
     }
   }
   if (processedName.IsEmpty()) {
     return;
   }
   // Create a new entry or retrieve the existing one
   FileIOEntryType* entry = mFileStats.PutEntry(processedName);
   if (entry) {
     FileStats& stats = entry->mData.mStats[mCurStage];
     // Update the statistics
     stats.totalTime += (double) aOb.Duration().ToMilliseconds();
     switch (aOb.ObservedOperation()) {
       case OpCreateOrOpen:
         stats.creates++;
         break;
       case OpRead:
         stats.reads++;
         break;
       case OpWrite:
         stats.writes++;
         break;
       case OpFSync:
         stats.fsyncs++;
         break;
       case OpStat:
         stats.stats++;
         break;
       default:
         break;
     }
   }
 }
 bool TelemetryIOInterposeObserver::ReflectFileStats(FileIOEntryType* entry,
                                                     JSContext *cx,
                                                     JS::Handle<JSObject*> obj)
 {
   JS::AutoValueArray<NUM_STAGES> stages(cx);
   FileStatsByStage& statsByStage = entry->mData;
   for (int s = STAGE_STARTUP; s < NUM_STAGES; ++s) {
     FileStats& fileStats = statsByStage.mStats[s];
     if (fileStats.totalTime == 0 && fileStats.creates == 0 &&
         fileStats.reads == 0 && fileStats.writes == 0 &&
         fileStats.fsyncs == 0 && fileStats.stats == 0) {
       // Don't add an array that contains no information
       stages[s].setNull();
       continue;
     }
     // Array we want to report
     JS::AutoValueArray<6> stats(cx);
     stats[0].setNumber(fileStats.totalTime);
     stats[1].setNumber(fileStats.creates);
     stats[2].setNumber(fileStats.reads);
     stats[3].setNumber(fileStats.writes);
     stats[4].setNumber(fileStats.fsyncs);
     stats[5].setNumber(fileStats.stats);
     // Create jsStats as array of elements above
     JS::RootedObject jsStats(cx, JS_NewArrayObject(cx, stats));
     if (!jsStats) {
       continue;
     }
     stages[s].setObject(*jsStats);
   }
   JS::RootedObject jsEntry(cx, JS_NewArrayObject(cx, stages));
   if (!jsEntry) {
     return false;
   }
   // Add jsEntry to top-level dictionary
   const nsAString& key = entry->GetKey();
   return JS_DefineUCProperty(cx, obj, key.Data(), key.Length(),
                              OBJECT_TO_JSVAL(jsEntry), nullptr, nullptr,
                              JSPROP_ENUMERATE | JSPROP_READONLY);
 }
 bool TelemetryIOInterposeObserver::ReflectIntoJS(JSContext *cx,
                                                  JS::Handle<JSObject*> rootObj)
 {
   return mFileStats.ReflectIntoJS(ReflectFileStats, cx, rootObj);
 }
 // This is not a member of TelemetryImpl because we want to record I/O during
 // startup.
 StaticAutoPtr<TelemetryIOInterposeObserver> sTelemetryIOObserver;
 void
 ClearIOReporting()
 {
   if (!sTelemetryIOObserver) {
     return;
   }
   IOInterposer::Unregister(IOInterposeObserver::OpAllWithStaging,
                            sTelemetryIOObserver);
   sTelemetryIOObserver = nullptr;
 }
 class TelemetryImpl MOZ_FINAL
   : public nsITelemetry
   , public nsIMemoryReporter
 {
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSITELEMETRY
   NS_DECL_NSIMEMORYREPORTER
 public:
   ~TelemetryImpl();
   void InitMemoryReporter();
   static bool CanRecord();
   static already_AddRefed<nsITelemetry> CreateTelemetryInstance();
   static void ShutdownTelemetry();
   static void RecordSlowStatement(const nsACString &sql, const nsACString &dbName,
                                   uint32_t delay);
 #if defined(MOZ_ENABLE_PROFILER_SPS)
   static void RecordChromeHang(uint32_t aDuration,
                                Telemetry::ProcessedStack &aStack,
                                int32_t aSystemUptime,
                                int32_t aFirefoxUptime);
 #endif
   static void RecordThreadHangStats(Telemetry::ThreadHangStats& aStats);
   static nsresult GetHistogramEnumId(const char *name, Telemetry::ID *id);
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
   struct Stat {
     uint32_t hitCount;
     uint32_t totalTime;
   };
   struct StmtStats {
     struct Stat mainThread;
     struct Stat otherThreads;
   };
   typedef nsBaseHashtableET<nsCStringHashKey, StmtStats> SlowSQLEntryType;
 private:
   TelemetryImpl();
   static nsCString SanitizeSQL(const nsACString& sql);
   enum SanitizedState { Sanitized, Unsanitized };
   static void StoreSlowSQL(const nsACString &offender, uint32_t delay,
                            SanitizedState state);
   static bool ReflectMainThreadSQL(SlowSQLEntryType *entry, JSContext *cx,
                                    JS::Handle<JSObject*> obj);
   static bool ReflectOtherThreadsSQL(SlowSQLEntryType *entry, JSContext *cx,
                                      JS::Handle<JSObject*> obj);
   static bool ReflectSQL(const SlowSQLEntryType *entry, const Stat *stat,
                          JSContext *cx, JS::Handle<JSObject*> obj);
   bool AddSQLInfo(JSContext *cx, JS::Handle<JSObject*> rootObj, bool mainThread,
                   bool privateSQL);
   bool GetSQLStats(JSContext *cx, JS::MutableHandle<JS::Value> ret,
                    bool includePrivateSql);
   // Like GetHistogramById, but returns the underlying C++ object, not the JS one.
   nsresult GetHistogramByName(const nsACString &name, Histogram **ret);
   bool ShouldReflectHistogram(Histogram *h);
   void IdentifyCorruptHistograms(StatisticsRecorder::Histograms &hs);
   typedef StatisticsRecorder::Histograms::iterator HistogramIterator;
   struct AddonHistogramInfo {
     uint32_t min;
     uint32_t max;
     uint32_t bucketCount;
     uint32_t histogramType;
     Histogram *h;
   };
   typedef nsBaseHashtableET<nsCStringHashKey, AddonHistogramInfo> AddonHistogramEntryType;
   typedef AutoHashtable<AddonHistogramEntryType> AddonHistogramMapType;
   typedef nsBaseHashtableET<nsCStringHashKey, AddonHistogramMapType *> AddonEntryType;
   typedef AutoHashtable<AddonEntryType> AddonMapType;
   static bool AddonHistogramReflector(AddonHistogramEntryType *entry,
                                       JSContext *cx, JS::Handle<JSObject*> obj);
   static bool AddonReflector(AddonEntryType *entry, JSContext *cx, JS::Handle<JSObject*> obj);
   static bool CreateHistogramForAddon(const nsACString &name,
                                       AddonHistogramInfo &info);
   void ReadLateWritesStacks(nsIFile* aProfileDir);
   AddonMapType mAddonMap;
   // This is used for speedy string->Telemetry::ID conversions
   typedef nsBaseHashtableET<nsCharPtrHashKey, Telemetry::ID> CharPtrEntryType;
   typedef AutoHashtable<CharPtrEntryType> HistogramMapType;
   HistogramMapType mHistogramMap;
   bool mCanRecord;
   static TelemetryImpl *sTelemetry;
   AutoHashtable<SlowSQLEntryType> mPrivateSQL;
   AutoHashtable<SlowSQLEntryType> mSanitizedSQL;
   // This gets marked immutable in debug builds, so we can't use
   // AutoHashtable here.
   nsTHashtable<nsCStringHashKey> mTrackedDBs;
   Mutex mHashMutex;
   HangReports mHangReports;
   Mutex mHangReportsMutex;
   // mThreadHangStats stores recorded, inactive thread hang stats
   Vector<Telemetry::ThreadHangStats> mThreadHangStats;
   Mutex mThreadHangStatsMutex;
   CombinedStacks mLateWritesStacks; // This is collected out of the main thread.
   bool mCachedTelemetryData;
   uint32_t mLastShutdownTime;
   uint32_t mFailedLockCount;
   nsCOMArray<nsIFetchTelemetryDataCallback> mCallbacks;
   friend class nsFetchTelemetryData;
 };
 TelemetryImpl*  TelemetryImpl::sTelemetry = nullptr;
 MOZ_DEFINE_MALLOC_SIZE_OF(TelemetryMallocSizeOf)
 NS_IMETHODIMP
 TelemetryImpl::CollectReports(nsIHandleReportCallback* aHandleReport,
                               nsISupports* aData)
 {
   return MOZ_COLLECT_REPORT(
     "explicit/telemetry", KIND_HEAP, UNITS_BYTES,
     SizeOfIncludingThis(TelemetryMallocSizeOf),
     "Memory used by the telemetry system.");
 }
 // A initializer to initialize histogram collection
 StatisticsRecorder gStatisticsRecorder;
 // Hardcoded probes
 struct TelemetryHistogram {
   uint32_t min;
   uint32_t max;
   uint32_t bucketCount;
   uint32_t histogramType;
   uint32_t id_offset;
   uint32_t expiration_offset;
   bool extendedStatisticsOK;
   const char *id() const;
   const char *expiration() const;
 };
 #include "TelemetryHistogramData.inc"
 bool gCorruptHistograms[Telemetry::HistogramCount];
 const char *
 TelemetryHistogram::id() const
 {
   return &gHistogramStringTable[this->id_offset];
 }
 const char *
 TelemetryHistogram::expiration() const
 {
   return &gHistogramStringTable[this->expiration_offset];
 }
 bool
 IsExpired(const char *expiration){
   static Version current_version = Version(MOZ_APP_VERSION);
   MOZ_ASSERT(expiration);
   return strcmp(expiration, "never") && (mozilla::Version(expiration) <= current_version);
 }
 bool
 IsExpired(const Histogram *histogram){
   return histogram->histogram_name() == EXPIRED_ID;
 }
 nsresult
 HistogramGet(const char *name, const char *expiration, uint32_t min, uint32_t max,
              uint32_t bucketCount, uint32_t histogramType, Histogram **result)
 {
   if (histogramType != nsITelemetry::HISTOGRAM_BOOLEAN
       && histogramType != nsITelemetry::HISTOGRAM_FLAG) {
     // Sanity checks for histogram parameters.
     if (min >= max)
       return NS_ERROR_ILLEGAL_VALUE;
     if (bucketCount <= 2)
       return NS_ERROR_ILLEGAL_VALUE;
     if (min < 1)
       return NS_ERROR_ILLEGAL_VALUE;
   }
   if (IsExpired(expiration)) {
     name = EXPIRED_ID;
     min = 1;
     max = 2;
     bucketCount = 3;
     histogramType = nsITelemetry::HISTOGRAM_LINEAR;
   }
   switch (histogramType) {
   case nsITelemetry::HISTOGRAM_EXPONENTIAL:
     *result = Histogram::FactoryGet(name, min, max, bucketCount, Histogram::kUmaTargetedHistogramFlag);
     break;
   case nsITelemetry::HISTOGRAM_LINEAR:
     *result = LinearHistogram::FactoryGet(name, min, max, bucketCount, Histogram::kUmaTargetedHistogramFlag);
     break;
   case nsITelemetry::HISTOGRAM_BOOLEAN:
     *result = BooleanHistogram::FactoryGet(name, Histogram::kUmaTargetedHistogramFlag);
     break;
   case nsITelemetry::HISTOGRAM_FLAG:
     *result = FlagHistogram::FactoryGet(name, Histogram::kUmaTargetedHistogramFlag);
     break;
   default:
     return NS_ERROR_INVALID_ARG;
   }
   return NS_OK;
 }
 // O(1) histogram lookup by numeric id
 nsresult
 GetHistogramByEnumId(Telemetry::ID id, Histogram **ret)
 {
   static Histogram* knownHistograms[Telemetry::HistogramCount] = {0};
   Histogram *h = knownHistograms[id];
   if (h) {
     *ret = h;
     return NS_OK;
   }
   const TelemetryHistogram &p = gHistograms[id];
   nsresult rv = HistogramGet(p.id(), p.expiration(), p.min, p.max, p.bucketCount, p.histogramType, &h);
   if (NS_FAILED(rv))
     return rv;
 #ifdef DEBUG
   // Check that the C++ Histogram code computes the same ranges as the
   // Python histogram code.
   if (!IsExpired(p.expiration())) {
     const struct bounds &b = gBucketLowerBoundIndex[id];
     if (b.length != 0) {
       MOZ_ASSERT(size_t(b.length) == h->bucket_count(),
                  "C++/Python bucket # mismatch");
       for (int i = 0; i < b.length; ++i) {
         MOZ_ASSERT(gBucketLowerBounds[b.offset + i] == h->ranges(i),
                    "C++/Python bucket mismatch");
       }
     }
   }
 #endif
   if (p.extendedStatisticsOK) {
     h->SetFlags(Histogram::kExtendedStatisticsFlag);
   }
   *ret = knownHistograms[id] = h;
   return NS_OK;
 }
 bool
 FillRanges(JSContext *cx, JS::Handle<JSObject*> array, Histogram *h)
 {
   JS::Rooted<JS::Value> range(cx);
   for (size_t i = 0; i < h->bucket_count(); i++) {
     range = INT_TO_JSVAL(h->ranges(i));
     if (!JS_DefineElement(cx, array, i, range, nullptr, nullptr, JSPROP_ENUMERATE))
       return false;
   }
   return true;
 }
 enum reflectStatus {
   REFLECT_OK,
   REFLECT_CORRUPT,
   REFLECT_FAILURE
 };
 enum reflectStatus
 ReflectHistogramAndSamples(JSContext *cx, JS::Handle<JSObject*> obj, Histogram *h,
                            const Histogram::SampleSet &ss)
 {
   // We don't want to reflect corrupt histograms.
   if (h->FindCorruption(ss) != Histogram::NO_INCONSISTENCIES) {
     return REFLECT_CORRUPT;
   }
   if (!(JS_DefineProperty(cx, obj, "min", h->declared_min(), JSPROP_ENUMERATE)
         && JS_DefineProperty(cx, obj, "max", h->declared_max(), JSPROP_ENUMERATE)
         && JS_DefineProperty(cx, obj, "histogram_type", h->histogram_type(), JSPROP_ENUMERATE)
         && JS_DefineProperty(cx, obj, "sum", double(ss.sum()), JSPROP_ENUMERATE))) {
     return REFLECT_FAILURE;
   }
   if (h->histogram_type() == Histogram::HISTOGRAM) {
     if (!(JS_DefineProperty(cx, obj, "log_sum", ss.log_sum(), JSPROP_ENUMERATE)
           && JS_DefineProperty(cx, obj, "log_sum_squares", ss.log_sum_squares(), JSPROP_ENUMERATE))) {
       return REFLECT_FAILURE;
     }
   } else {
     // Export |sum_squares| as two separate 32-bit properties so that we
     // can accurately reconstruct it on the analysis side.
     uint64_t sum_squares = ss.sum_squares();
     // Cast to avoid implicit truncation warnings.
     uint32_t lo = static_cast<uint32_t>(sum_squares);
     uint32_t hi = static_cast<uint32_t>(sum_squares >> 32);
     if (!(JS_DefineProperty(cx, obj, "sum_squares_lo", lo, JSPROP_ENUMERATE)
           && JS_DefineProperty(cx, obj, "sum_squares_hi", hi, JSPROP_ENUMERATE))) {
       return REFLECT_FAILURE;
     }
   }
   const size_t count = h->bucket_count();
   JS::Rooted<JSObject*> rarray(cx, JS_NewArrayObject(cx, count));
   if (!rarray) {
     return REFLECT_FAILURE;
   }
   if (!(FillRanges(cx, rarray, h)
         && JS_DefineProperty(cx, obj, "ranges", rarray, JSPROP_ENUMERATE))) {
     return REFLECT_FAILURE;
   }
   JS::Rooted<JSObject*> counts_array(cx, JS_NewArrayObject(cx, count));
   if (!counts_array) {
     return REFLECT_FAILURE;
   }
   if (!JS_DefineProperty(cx, obj, "counts", counts_array, JSPROP_ENUMERATE)) {
     return REFLECT_FAILURE;
   }
   for (size_t i = 0; i < count; i++) {
     if (!JS_DefineElement(cx, counts_array, i, INT_TO_JSVAL(ss.counts(i)),
                           nullptr, nullptr, JSPROP_ENUMERATE)) {
       return REFLECT_FAILURE;
     }
   }
   return REFLECT_OK;
 }
 enum reflectStatus
 ReflectHistogramSnapshot(JSContext *cx, JS::Handle<JSObject*> obj, Histogram *h)
 {
   Histogram::SampleSet ss;
   h->SnapshotSample(&ss);
   return ReflectHistogramAndSamples(cx, obj, h, ss);
 }
 bool
 IsEmpty(const Histogram *h)
 {
   Histogram::SampleSet ss;
   h->SnapshotSample(&ss);
   return ss.counts(0) == 0 && ss.sum() == 0;
 }
 bool
 JSHistogram_Add(JSContext *cx, unsigned argc, JS::Value *vp)
 {
   JS::CallArgs args = CallArgsFromVp(argc, vp);
   if (!args.length()) {
     JS_ReportError(cx, "Expected one argument");
     return false;
   }
   if (!(args[0].isNumber() || args[0].isBoolean())) {
     JS_ReportError(cx, "Not a number");
     return false;
   }
   int32_t value;
   if (!JS::ToInt32(cx, args[0], &value)) {
     return false;
   }
   if (TelemetryImpl::CanRecord()) {
     JSObject *obj = JS_THIS_OBJECT(cx, vp);
     if (!obj) {
       return false;
     }
     Histogram *h = static_cast<Histogram*>(JS_GetPrivate(obj));
     h->Add(value);
   }
   return true;
 }
 bool
 JSHistogram_Snapshot(JSContext *cx, unsigned argc, JS::Value *vp)
 {
   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));
   JS::Rooted<JSObject*> snapshot(cx, JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr()));
   if (!snapshot)
     return false;
   switch (ReflectHistogramSnapshot(cx, snapshot, h)) {
   case REFLECT_FAILURE:
     return false;
   case REFLECT_CORRUPT:
     JS_ReportError(cx, "Histogram is corrupt");
     return false;
   case REFLECT_OK:
     args.rval().setObject(*snapshot);
     return true;
   default:
     MOZ_CRASH("unhandled reflection status");
   }
 }
 bool
 JSHistogram_Clear(JSContext *cx, unsigned argc, JS::Value *vp)
 {
   JSObject *obj = JS_THIS_OBJECT(cx, vp);
   if (!obj) {
     return false;
   }
   Histogram *h = static_cast<Histogram*>(JS_GetPrivate(obj));
   h->Clear();
   return true;
 }
 nsresult
 WrapAndReturnHistogram(Histogram *h, JSContext *cx, JS::MutableHandle<JS::Value> ret)
 {
   static const JSClass JSHistogram_class = {
     "JSHistogram",  /* name */
     JSCLASS_HAS_PRIVATE, /* flags */
     JS_PropertyStub, JS_DeletePropertyStub, JS_PropertyStub, JS_StrictPropertyStub,
     JS_EnumerateStub, JS_ResolveStub, JS_ConvertStub
   };
   JS::Rooted<JSObject*> obj(cx, JS_NewObject(cx, &JSHistogram_class, JS::NullPtr(), JS::NullPtr()));
   if (!obj)
     return NS_ERROR_FAILURE;
   if (!(JS_DefineFunction(cx, obj, "add", JSHistogram_Add, 1, 0)
         && JS_DefineFunction(cx, obj, "snapshot", JSHistogram_Snapshot, 0, 0)
         && JS_DefineFunction(cx, obj, "clear", JSHistogram_Clear, 0, 0))) {
     return NS_ERROR_FAILURE;
   }
   JS_SetPrivate(obj, h);
   ret.setObject(*obj);
   return NS_OK;
 }
 static uint32_t
 ReadLastShutdownDuration(const char *filename) {
   FILE *f = fopen(filename, "r");
   if (!f) {
     return 0;
   }
   int shutdownTime;
   int r = fscanf(f, "%d\n", &shutdownTime);
   fclose(f);
   if (r != 1) {
     return 0;
   }
   return shutdownTime;
 }
 const int32_t kMaxFailedProfileLockFileSize = 10;
 bool
 GetFailedLockCount(nsIInputStream* inStream, uint32_t aCount,
                    unsigned int& result)
 {
   nsAutoCString bufStr;
   nsresult rv;
   rv = NS_ReadInputStreamToString(inStream, bufStr, aCount);
   NS_ENSURE_SUCCESS(rv, false);
   result = bufStr.ToInteger(&rv);
   return NS_SUCCEEDED(rv) && result > 0;
 }
 nsresult
 GetFailedProfileLockFile(nsIFile* *aFile, nsIFile* aProfileDir)
 {
   NS_ENSURE_ARG_POINTER(aProfileDir);
   nsresult rv = aProfileDir->Clone(aFile);
   NS_ENSURE_SUCCESS(rv, rv);
   (*aFile)->AppendNative(NS_LITERAL_CSTRING("Telemetry.FailedProfileLocks.txt"));
   return NS_OK;
 }
 class nsFetchTelemetryData : public nsRunnable
 {
 public:
   nsFetchTelemetryData(const char* aShutdownTimeFilename,
                        nsIFile* aFailedProfileLockFile,
                        nsIFile* aProfileDir)
     : mShutdownTimeFilename(aShutdownTimeFilename),
       mFailedProfileLockFile(aFailedProfileLockFile),
       mTelemetry(TelemetryImpl::sTelemetry),
       mProfileDir(aProfileDir)
   {
   }
 private:
   const char* mShutdownTimeFilename;
   nsCOMPtr<nsIFile> mFailedProfileLockFile;
   nsRefPtr<TelemetryImpl> mTelemetry;
   nsCOMPtr<nsIFile> mProfileDir;
 public:
   void MainThread() {
     mTelemetry->mCachedTelemetryData = true;
     for (unsigned int i = 0, n = mTelemetry->mCallbacks.Count(); i < n; ++i) {
       mTelemetry->mCallbacks[i]->Complete();
     }
     mTelemetry->mCallbacks.Clear();
   }
   NS_IMETHOD Run() {
     LoadFailedLockCount(mTelemetry->mFailedLockCount);
     mTelemetry->mLastShutdownTime =
       ReadLastShutdownDuration(mShutdownTimeFilename);
     mTelemetry->ReadLateWritesStacks(mProfileDir);
     nsCOMPtr<nsIRunnable> e =
       NS_NewRunnableMethod(this, &nsFetchTelemetryData::MainThread);
     NS_ENSURE_STATE(e);
     NS_DispatchToMainThread(e, NS_DISPATCH_NORMAL);
     return NS_OK;
   }
 private:
   nsresult
   LoadFailedLockCount(uint32_t& failedLockCount)
   {
     failedLockCount = 0;
     int64_t fileSize = 0;
     nsresult rv = mFailedProfileLockFile->GetFileSize(&fileSize);
     if (NS_FAILED(rv)) {
       return rv;
     }
     NS_ENSURE_TRUE(fileSize <= kMaxFailedProfileLockFileSize,
                    NS_ERROR_UNEXPECTED);
     nsCOMPtr<nsIInputStream> inStream;
     rv = NS_NewLocalFileInputStream(getter_AddRefs(inStream),
                                     mFailedProfileLockFile,
                                     PR_RDONLY);
     NS_ENSURE_SUCCESS(rv, rv);
     NS_ENSURE_TRUE(GetFailedLockCount(inStream, fileSize, failedLockCount),
                    NS_ERROR_UNEXPECTED);
     inStream->Close();
     mFailedProfileLockFile->Remove(false);
     return NS_OK;
   }
 };
 static TimeStamp gRecordedShutdownStartTime;
 static bool gAlreadyFreedShutdownTimeFileName = false;
 static char *gRecordedShutdownTimeFileName = nullptr;
 static char *
 GetShutdownTimeFileName()
 {
   if (gAlreadyFreedShutdownTimeFileName) {
     return nullptr;
   }
   if (!gRecordedShutdownTimeFileName) {
     nsCOMPtr<nsIFile> mozFile;
     NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR, getter_AddRefs(mozFile));
     if (!mozFile)
       return nullptr;
     mozFile->AppendNative(NS_LITERAL_CSTRING("Telemetry.ShutdownTime.txt"));
     nsAutoCString nativePath;
     nsresult rv = mozFile->GetNativePath(nativePath);
     if (!NS_SUCCEEDED(rv))
       return nullptr;
     gRecordedShutdownTimeFileName = PL_strdup(nativePath.get());
   }
   return gRecordedShutdownTimeFileName;
 }
 NS_IMETHODIMP
 TelemetryImpl::GetLastShutdownDuration(uint32_t *aResult)
 {
   // The user must call AsyncFetchTelemetryData first. We return zero instead of
   // reporting a failure so that the rest of telemetry can uniformly handle
   // the read not being available yet.
   if (!mCachedTelemetryData) {
     *aResult = 0;
     return NS_OK;
   }
   *aResult = mLastShutdownTime;
   return NS_OK;
 }
 NS_IMETHODIMP
 TelemetryImpl::GetFailedProfileLockCount(uint32_t* aResult)
 {
   // The user must call AsyncFetchTelemetryData first. We return zero instead of
   // reporting a failure so that the rest of telemetry can uniformly handle
   // the read not being available yet.
   if (!mCachedTelemetryData) {
     *aResult = 0;
     return NS_OK;
   }
   *aResult = mFailedLockCount;
   return NS_OK;
 }
 NS_IMETHODIMP
 TelemetryImpl::AsyncFetchTelemetryData(nsIFetchTelemetryDataCallback *aCallback)
 {
   // We have finished reading the data already, just call the callback.
   if (mCachedTelemetryData) {
     aCallback->Complete();
     return NS_OK;
   }
   // We already have a read request running, just remember the callback.
   if (mCallbacks.Count() != 0) {
     mCallbacks.AppendObject(aCallback);
     return NS_OK;
   }
   // We make this check so that GetShutdownTimeFileName() doesn't get
   // called; calling that function without telemetry enabled violates
   // assumptions that the write-the-shutdown-timestamp machinery makes.
   if (!Telemetry::CanRecord()) {
     mCachedTelemetryData = true;
     aCallback->Complete();
     return NS_OK;
   }
   // Send the read to a background thread provided by the stream transport
   // service to avoid a read in the main thread.
   nsCOMPtr<nsIEventTarget> targetThread =
     do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
   if (!targetThread) {
     mCachedTelemetryData = true;
     aCallback->Complete();
     return NS_OK;
   }
   // We have to get the filename from the main thread.
   const char *shutdownTimeFilename = GetShutdownTimeFileName();
   if (!shutdownTimeFilename) {
     mCachedTelemetryData = true;
     aCallback->Complete();
     return NS_OK;
   }
   nsCOMPtr<nsIFile> profileDir;
   nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
                                        getter_AddRefs(profileDir));
   if (NS_FAILED(rv)) {
     mCachedTelemetryData = true;
     aCallback->Complete();
     return NS_OK;
   }
   nsCOMPtr<nsIFile> failedProfileLockFile;
   rv = GetFailedProfileLockFile(getter_AddRefs(failedProfileLockFile),
                                 profileDir);
   if (NS_FAILED(rv)) {
     mCachedTelemetryData = true;
     aCallback->Complete();
     return NS_OK;
   }
   mCallbacks.AppendObject(aCallback);
   nsCOMPtr<nsIRunnable> event = new nsFetchTelemetryData(shutdownTimeFilename,
                                                          failedProfileLockFile,
                                                          profileDir);
   targetThread->Dispatch(event, NS_DISPATCH_NORMAL);
   return NS_OK;
 }
 TelemetryImpl::TelemetryImpl():
 mHistogramMap(Telemetry::HistogramCount),
 mCanRecord(XRE_GetProcessType() == GeckoProcessType_Default),
 mHashMutex("Telemetry::mHashMutex"),
 mHangReportsMutex("Telemetry::mHangReportsMutex"),
 mThreadHangStatsMutex("Telemetry::mThreadHangStatsMutex"),
 mCachedTelemetryData(false),
 mLastShutdownTime(0),
 mFailedLockCount(0)
 {
   // A whitelist to prevent Telemetry reporting on Addon & Thunderbird DBs
   const char *trackedDBs[] = {
     "addons.sqlite", "content-prefs.sqlite", "cookies.sqlite",
     "downloads.sqlite", "extensions.sqlite", "formhistory.sqlite",
     "index.sqlite", "healthreport.sqlite", "netpredictions.sqlite",
     "permissions.sqlite", "places.sqlite", "search.sqlite", "signons.sqlite",
     "urlclassifier3.sqlite", "webappsstore.sqlite"
   };
   for (size_t i = 0; i < ArrayLength(trackedDBs); i++)
     mTrackedDBs.PutEntry(nsDependentCString(trackedDBs[i]));
 #ifdef DEBUG
   // Mark immutable to prevent asserts on simultaneous access from multiple threads
   mTrackedDBs.MarkImmutable();
 #endif
 }
 TelemetryImpl::~TelemetryImpl() {
   UnregisterWeakMemoryReporter(this);
 }
 void
 TelemetryImpl::InitMemoryReporter() {
   RegisterWeakMemoryReporter(this);
 }
 NS_IMETHODIMP
 TelemetryImpl::NewHistogram(const nsACString &name, const nsACString &expiration, uint32_t min,
                             uint32_t max, uint32_t bucketCount, uint32_t histogramType,
                             JSContext *cx, JS::MutableHandle<JS::Value> ret)
 {
   Histogram *h;
   nsresult rv = HistogramGet(PromiseFlatCString(name).get(), PromiseFlatCString(expiration).get(),
                              min, max, bucketCount, histogramType, &h);
   if (NS_FAILED(rv))
     return rv;
   h->ClearFlags(Histogram::kUmaTargetedHistogramFlag);
   h->SetFlags(Histogram::kExtendedStatisticsFlag);
   return WrapAndReturnHistogram(h, cx, ret);
 }
 bool
 TelemetryImpl::ReflectSQL(const SlowSQLEntryType *entry,
                           const Stat *stat,
                           JSContext *cx,
                           JS::Handle<JSObject*> obj)
 {
   if (stat->hitCount == 0)
     return true;
   const nsACString &sql = entry->GetKey();
   JS::Rooted<JSObject*> arrayObj(cx, JS_NewArrayObject(cx, 0));
   if (!arrayObj) {
     return false;
   }
   return (JS_SetElement(cx, arrayObj, 0, stat->hitCount)
           && JS_SetElement(cx, arrayObj, 1, stat->totalTime)
           && JS_DefineProperty(cx, obj, sql.BeginReading(), arrayObj,
                                JSPROP_ENUMERATE));
 }
 bool
 TelemetryImpl::ReflectMainThreadSQL(SlowSQLEntryType *entry, JSContext *cx,
                                     JS::Handle<JSObject*> obj)
 {
   return ReflectSQL(entry, &entry->mData.mainThread, cx, obj);
 }
 bool
 TelemetryImpl::ReflectOtherThreadsSQL(SlowSQLEntryType *entry, JSContext *cx,
                                       JS::Handle<JSObject*> obj)
 {
   return ReflectSQL(entry, &entry->mData.otherThreads, cx, obj);
 }
 bool
 TelemetryImpl::AddSQLInfo(JSContext *cx, JS::Handle<JSObject*> rootObj, bool mainThread,
                           bool privateSQL)
 {
   JS::Rooted<JSObject*> statsObj(cx, JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr()));
   if (!statsObj)
     return false;
   AutoHashtable<SlowSQLEntryType> &sqlMap =
     (privateSQL ? mPrivateSQL : mSanitizedSQL);
   AutoHashtable<SlowSQLEntryType>::ReflectEntryFunc reflectFunction =
     (mainThread ? ReflectMainThreadSQL : ReflectOtherThreadsSQL);
   if (!sqlMap.ReflectIntoJS(reflectFunction, cx, statsObj)) {
     return false;
   }
   return JS_DefineProperty(cx, rootObj,
                            mainThread ? "mainThread" : "otherThreads",
                            statsObj, JSPROP_ENUMERATE);
 }
 nsresult
 TelemetryImpl::GetHistogramEnumId(const char *name, Telemetry::ID *id)
 {
   if (!sTelemetry) {
     return NS_ERROR_FAILURE;
   }
   // Cache names
   // Note the histogram names are statically allocated
   TelemetryImpl::HistogramMapType *map = &sTelemetry->mHistogramMap;
   if (!map->Count()) {
     for (uint32_t i = 0; i < Telemetry::HistogramCount; i++) {
       CharPtrEntryType *entry = map->PutEntry(gHistograms[i].id());
       if (MOZ_UNLIKELY(!entry)) {
         map->Clear();
         return NS_ERROR_OUT_OF_MEMORY;
       }
       entry->mData = (Telemetry::ID) i;
     }
   }
   CharPtrEntryType *entry = map->GetEntry(name);
   if (!entry) {
     return NS_ERROR_INVALID_ARG;
   }
   *id = entry->mData;
   return NS_OK;
 }
 nsresult
 TelemetryImpl::GetHistogramByName(const nsACString &name, Histogram **ret)
 {
   Telemetry::ID id;
   nsresult rv = GetHistogramEnumId(PromiseFlatCString(name).get(), &id);
   if (NS_FAILED(rv)) {
     return rv;
   }
   rv = GetHistogramByEnumId(id, ret);
   if (NS_FAILED(rv))
     return rv;
   return NS_OK;
 }
 NS_IMETHODIMP
 TelemetryImpl::HistogramFrom(const nsACString &name, const nsACString &existing_name,
                              JSContext *cx, JS::MutableHandle<JS::Value> ret)
 {
   Telemetry::ID id;
   nsresult rv = GetHistogramEnumId(PromiseFlatCString(existing_name).get(), &id);
   if (NS_FAILED(rv)) {
     return rv;
   }
   const TelemetryHistogram &p = gHistograms[id];
   Histogram *existing;
   rv = GetHistogramByEnumId(id, &existing);
   if (NS_FAILED(rv)) {
     return rv;
   }
   Histogram *clone;
   rv = HistogramGet(PromiseFlatCString(name).get(), p.expiration(),
                     existing->declared_min(), existing->declared_max(),
                     existing->bucket_count(), p.histogramType, &clone);
   if (NS_FAILED(rv))
     return rv;
   Histogram::SampleSet ss;
   existing->SnapshotSample(&ss);
   clone->AddSampleSet(ss);
   return WrapAndReturnHistogram(clone, cx, ret);
 }
 void
 TelemetryImpl::IdentifyCorruptHistograms(StatisticsRecorder::Histograms &hs)
 {
   for (HistogramIterator it = hs.begin(); it != hs.end(); ++it) {
     Histogram *h = *it;
     Telemetry::ID id;
     nsresult rv = 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;
     }
     Histogram::SampleSet ss;
     h->SnapshotSample(&ss);
     Histogram::Inconsistencies check = h->FindCorruption(ss);
     bool corrupt = (check != Histogram::NO_INCONSISTENCIES);
     if (corrupt) {
       Telemetry::ID corruptID = Telemetry::HistogramCount;
       if (check & Histogram::RANGE_CHECKSUM_ERROR) {
         corruptID = Telemetry::RANGE_CHECKSUM_ERRORS;
       } else if (check & Histogram::BUCKET_ORDER_ERROR) {
         corruptID = Telemetry::BUCKET_ORDER_ERRORS;
       } else if (check & Histogram::COUNT_HIGH_ERROR) {
         corruptID = Telemetry::TOTAL_COUNT_HIGH_ERRORS;
       } else if (check & Histogram::COUNT_LOW_ERROR) {
         corruptID = Telemetry::TOTAL_COUNT_LOW_ERRORS;
       }
       Telemetry::Accumulate(corruptID, 1);
     }
     gCorruptHistograms[id] = corrupt;
   }
 }
 bool
 TelemetryImpl::ShouldReflectHistogram(Histogram *h)
 {
   const char *name = h->histogram_name().c_str();
   Telemetry::ID id;
   nsresult rv = 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.
     if (strcmp(name, "Histogram.InconsistentCountHigh") == 0
         || strcmp(name, "Histogram.InconsistentCountLow") == 0) {
       return false;
     }
     return true;
   } else {
     return !gCorruptHistograms[id];
   }
 }
 // Compute the name to pass into Histogram for the addon histogram
 // 'name' from the addon 'id'.  We can't use 'name' directly because it
 // might conflict with other histograms in other addons or even with our
 // own.
 void
 AddonHistogramName(const nsACString &id, const nsACString &name,
                    nsACString &ret)
 {
   ret.Append(id);
   ret.Append(NS_LITERAL_CSTRING(":"));
   ret.Append(name);
 }
 NS_IMETHODIMP
 TelemetryImpl::RegisterAddonHistogram(const nsACString &id,
                                       const nsACString &name,
                                       uint32_t min, uint32_t max,
                                       uint32_t bucketCount,
                                       uint32_t histogramType)
 {
   AddonEntryType *addonEntry = mAddonMap.GetEntry(id);
   if (!addonEntry) {
     addonEntry = mAddonMap.PutEntry(id);
     if (MOZ_UNLIKELY(!addonEntry)) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
     addonEntry->mData = new AddonHistogramMapType();
   }
   AddonHistogramMapType *histogramMap = addonEntry->mData;
   AddonHistogramEntryType *histogramEntry = histogramMap->GetEntry(name);
   // Can't re-register the same histogram.
   if (histogramEntry) {
     return NS_ERROR_FAILURE;
   }
   histogramEntry = histogramMap->PutEntry(name);
   if (MOZ_UNLIKELY(!histogramEntry)) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
   AddonHistogramInfo &info = histogramEntry->mData;
   info.min = min;
   info.max = max;
   info.bucketCount = bucketCount;
   info.histogramType = histogramType;
   return NS_OK;
 }
 NS_IMETHODIMP
 TelemetryImpl::GetAddonHistogram(const nsACString &id, const nsACString &name,
                                  JSContext *cx, JS::MutableHandle<JS::Value> ret)
 {
   AddonEntryType *addonEntry = mAddonMap.GetEntry(id);
   // The given id has not been registered.
   if (!addonEntry) {
     return NS_ERROR_INVALID_ARG;
   }
   AddonHistogramMapType *histogramMap = addonEntry->mData;
   AddonHistogramEntryType *histogramEntry = histogramMap->GetEntry(name);
   // The given histogram name has not been registered.
   if (!histogramEntry) {
     return NS_ERROR_INVALID_ARG;
   }
   AddonHistogramInfo &info = histogramEntry->mData;
   if (!info.h) {
     nsAutoCString actualName;
     AddonHistogramName(id, name, actualName);
     if (!CreateHistogramForAddon(actualName, info)) {
       return NS_ERROR_FAILURE;
     }
   }
   return WrapAndReturnHistogram(info.h, cx, ret);
 }
 NS_IMETHODIMP
 TelemetryImpl::UnregisterAddonHistograms(const nsACString &id)
 {
   AddonEntryType *addonEntry = mAddonMap.GetEntry(id);
   if (addonEntry) {
     // Histogram's destructor is private, so this is the best we can do.
     // The histograms the addon created *will* stick around, but they
     // will be deleted if and when the addon registers histograms with
     // the same names.
     delete addonEntry->mData;
     mAddonMap.RemoveEntry(id);
   }
   return NS_OK;
 }
 NS_IMETHODIMP
 TelemetryImpl::GetHistogramSnapshots(JSContext *cx, JS::MutableHandle<JS::Value> ret)
 {
   JS::Rooted<JSObject*> root_obj(cx, JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr()));
   if (!root_obj)
     return NS_ERROR_FAILURE;
   ret.setObject(*root_obj);
   // Ensure that all the HISTOGRAM_FLAG histograms have been created, so
   // that their values are snapshotted.
   for (size_t i = 0; i < Telemetry::HistogramCount; ++i) {
     if (gHistograms[i].histogramType == nsITelemetry::HISTOGRAM_FLAG) {
       Histogram *h;
       DebugOnly<nsresult> rv = GetHistogramByEnumId(Telemetry::ID(i), &h);
       MOZ_ASSERT(NS_SUCCEEDED(rv));
     }
   };
   StatisticsRecorder::Histograms hs;
   StatisticsRecorder::GetHistograms(&hs);
   // We identify corrupt histograms first, rather than interspersing it
   // in the loop below, to ensure that our corruption statistics don't
   // depend on histogram enumeration order.
   //
   // Of course, we hope that all of these corruption-statistics
   // histograms are not themselves corrupt...
   IdentifyCorruptHistograms(hs);
   // OK, now we can actually reflect things.
   JS::Rooted<JSObject*> hobj(cx);
   for (HistogramIterator it = hs.begin(); it != hs.end(); ++it) {
     Histogram *h = *it;
     if (!ShouldReflectHistogram(h) || IsEmpty(h) || IsExpired(h)) {
       continue;
     }
     hobj = JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr());
     if (!hobj) {
       return NS_ERROR_FAILURE;
     }
     switch (ReflectHistogramSnapshot(cx, hobj, h)) {
     case REFLECT_CORRUPT:
       // We can still hit this case even if ShouldReflectHistograms
       // returns true.  The histogram lies outside of our control
       // somehow; just skip it.
       continue;
     case REFLECT_FAILURE:
       return NS_ERROR_FAILURE;
     case REFLECT_OK:
       if (!JS_DefineProperty(cx, root_obj, h->histogram_name().c_str(), hobj,
                              JSPROP_ENUMERATE)) {
         return NS_ERROR_FAILURE;
       }
     }
   }
   return NS_OK;
 }
 bool
 TelemetryImpl::CreateHistogramForAddon(const nsACString &name,
                                        AddonHistogramInfo &info)
 {
   Histogram *h;
   nsresult rv = HistogramGet(PromiseFlatCString(name).get(), "never",
                              info.min, info.max, info.bucketCount,
                              info.histogramType, &h);
   if (NS_FAILED(rv)) {
     return false;
   }
   // Don't let this histogram be reported via the normal means
   // (e.g. Telemetry.registeredHistograms); we'll make it available in
   // other ways.
   h->ClearFlags(Histogram::kUmaTargetedHistogramFlag);
   info.h = h;
   return true;
 }
 bool
 TelemetryImpl::AddonHistogramReflector(AddonHistogramEntryType *entry,
                                        JSContext *cx, JS::Handle<JSObject*> obj)
 {
   AddonHistogramInfo &info = entry->mData;
   // Never even accessed the histogram.
   if (!info.h) {
     // Have to force creation of HISTOGRAM_FLAG histograms.
     if (info.histogramType != nsITelemetry::HISTOGRAM_FLAG)
       return true;
     if (!CreateHistogramForAddon(entry->GetKey(), info)) {
       return false;
     }
   }
   if (IsEmpty(info.h)) {
     return true;
   }
   JS::Rooted<JSObject*> snapshot(cx, JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr()));
   if (!snapshot) {
     // Just consider this to be skippable.
     return true;
   }
   switch (ReflectHistogramSnapshot(cx, snapshot, info.h)) {
   case REFLECT_FAILURE:
   case REFLECT_CORRUPT:
     return false;
   case REFLECT_OK:
     const nsACString &histogramName = entry->GetKey();
     if (!JS_DefineProperty(cx, obj, PromiseFlatCString(histogramName).get(),
                            snapshot, JSPROP_ENUMERATE)) {
       return false;
     }
     break;
   }
   return true;
 }
 bool
 TelemetryImpl::AddonReflector(AddonEntryType *entry,
                               JSContext *cx, JS::Handle<JSObject*> obj)
 {
   const nsACString &addonId = entry->GetKey();
   JS::Rooted<JSObject*> subobj(cx, JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr()));
   if (!subobj) {
     return false;
   }
   AddonHistogramMapType *map = entry->mData;
   if (!(map->ReflectIntoJS(AddonHistogramReflector, cx, subobj)
         && JS_DefineProperty(cx, obj, PromiseFlatCString(addonId).get(),
                              subobj, JSPROP_ENUMERATE))) {
     return false;
   }
   return true;
 }
 NS_IMETHODIMP
 TelemetryImpl::GetAddonHistogramSnapshots(JSContext *cx, JS::MutableHandle<JS::Value> ret)
 {
   JS::Rooted<JSObject*> obj(cx, JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr()));
   if (!obj) {
     return NS_ERROR_FAILURE;
   }
   if (!mAddonMap.ReflectIntoJS(AddonReflector, cx, obj)) {
     return NS_ERROR_FAILURE;
   }
   ret.setObject(*obj);
   return NS_OK;
 }
 bool
 TelemetryImpl::GetSQLStats(JSContext *cx, JS::MutableHandle<JS::Value> ret, bool includePrivateSql)
 {
   JS::Rooted<JSObject*> root_obj(cx, JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr()));
   if (!root_obj)
     return false;
   ret.setObject(*root_obj);
   MutexAutoLock hashMutex(mHashMutex);
   // Add info about slow SQL queries on the main thread
   if (!AddSQLInfo(cx, root_obj, true, includePrivateSql))
     return false;
   // Add info about slow SQL queries on other threads
   if (!AddSQLInfo(cx, root_obj, false, includePrivateSql))
     return false;
   return true;
 }
 NS_IMETHODIMP
 TelemetryImpl::GetSlowSQL(JSContext *cx, JS::MutableHandle<JS::Value> ret)
 {
   if (GetSQLStats(cx, ret, false))
     return NS_OK;
   return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 TelemetryImpl::GetDebugSlowSQL(JSContext *cx, JS::MutableHandle<JS::Value> ret)
 {
   bool revealPrivateSql =
     Preferences::GetBool("toolkit.telemetry.debugSlowSql", false);
   if (GetSQLStats(cx, ret, revealPrivateSql))
     return NS_OK;
   return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 TelemetryImpl::GetMaximalNumberOfConcurrentThreads(uint32_t *ret)
 {
   *ret = nsThreadManager::get()->GetHighestNumberOfThreads();
   return NS_OK;
 }
 NS_IMETHODIMP
 TelemetryImpl::GetChromeHangs(JSContext *cx, JS::MutableHandle<JS::Value> ret)
 {
   MutexAutoLock hangReportMutex(mHangReportsMutex);
   const CombinedStacks& stacks = mHangReports.GetStacks();
   JS::Rooted<JSObject*> fullReportObj(cx, CreateJSStackObject(cx, stacks));
   if (!fullReportObj) {
     return NS_ERROR_FAILURE;
   }
   ret.setObject(*fullReportObj);
   JS::Rooted<JSObject*> durationArray(cx, JS_NewArrayObject(cx, 0));
   JS::Rooted<JSObject*> systemUptimeArray(cx, JS_NewArrayObject(cx, 0));
   JS::Rooted<JSObject*> firefoxUptimeArray(cx, JS_NewArrayObject(cx, 0));
   if (!durationArray || !systemUptimeArray || !firefoxUptimeArray) {
     return NS_ERROR_FAILURE;
   }
   bool ok = JS_DefineProperty(cx, fullReportObj, "durations",
                               durationArray, JSPROP_ENUMERATE);
   if (!ok) {
     return NS_ERROR_FAILURE;
   }
   ok = JS_DefineProperty(cx, fullReportObj, "systemUptime",
                          systemUptimeArray, JSPROP_ENUMERATE);
   if (!ok) {
     return NS_ERROR_FAILURE;
   }
   ok = JS_DefineProperty(cx, fullReportObj, "firefoxUptime",
                          firefoxUptimeArray, JSPROP_ENUMERATE);
   if (!ok) {
     return NS_ERROR_FAILURE;
   }
   const size_t length = stacks.GetStackCount();
   for (size_t i = 0; i < length; ++i) {
     if (!JS_SetElement(cx, durationArray, i, mHangReports.GetDuration(i))) {
       return NS_ERROR_FAILURE;
     }
     if (!JS_SetElement(cx, systemUptimeArray, i, mHangReports.GetSystemUptime(i))) {
       return NS_ERROR_FAILURE;
     }
     if (!JS_SetElement(cx, firefoxUptimeArray, i, mHangReports.GetFirefoxUptime(i))) {
       return NS_ERROR_FAILURE;
     }
   }
   return NS_OK;
 }
 static JSObject *
 CreateJSStackObject(JSContext *cx, const CombinedStacks &stacks) {
   JS::Rooted<JSObject*> ret(cx, JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr()));
   if (!ret) {
     return nullptr;
   }
   JS::Rooted<JSObject*> moduleArray(cx, JS_NewArrayObject(cx, 0));
   if (!moduleArray) {
     return nullptr;
   }
   bool ok = JS_DefineProperty(cx, ret, "memoryMap", moduleArray,
                               JSPROP_ENUMERATE);
   if (!ok) {
     return nullptr;
   }
   const size_t moduleCount = stacks.GetModuleCount();
   for (size_t moduleIndex = 0; moduleIndex < moduleCount; ++moduleIndex) {
     // Current module
     const Telemetry::ProcessedStack::Module& module =
       stacks.GetModule(moduleIndex);
     JS::Rooted<JSObject*> moduleInfoArray(cx, JS_NewArrayObject(cx, 0));
     if (!moduleInfoArray) {
       return nullptr;
     }
     if (!JS_SetElement(cx, moduleArray, moduleIndex, moduleInfoArray)) {
       return nullptr;
     }
     unsigned index = 0;
     // Module name
     JS::Rooted<JSString*> str(cx, JS_NewStringCopyZ(cx, module.mName.c_str()));
     if (!str) {
       return nullptr;
     }
     if (!JS_SetElement(cx, moduleInfoArray, index++, str)) {
       return nullptr;
     }
     // Module breakpad identifier
     JS::Rooted<JSString*> id(cx, JS_NewStringCopyZ(cx, module.mBreakpadId.c_str()));
     if (!id) {
       return nullptr;
     }
     if (!JS_SetElement(cx, moduleInfoArray, index++, id)) {
       return nullptr;
     }
   }
   JS::Rooted<JSObject*> reportArray(cx, JS_NewArrayObject(cx, 0));
   if (!reportArray) {
     return nullptr;
   }
   ok = JS_DefineProperty(cx, ret, "stacks", reportArray, JSPROP_ENUMERATE);
   if (!ok) {
     return nullptr;
   }
   const size_t length = stacks.GetStackCount();
   for (size_t i = 0; i < length; ++i) {
     // Represent call stack PCs as (module index, offset) pairs.
     JS::Rooted<JSObject*> pcArray(cx, JS_NewArrayObject(cx, 0));
     if (!pcArray) {
       return nullptr;
     }
     if (!JS_SetElement(cx, reportArray, i, pcArray)) {
       return nullptr;
     }
     const CombinedStacks::Stack& stack = stacks.GetStack(i);
     const uint32_t pcCount = stack.size();
     for (size_t pcIndex = 0; pcIndex < pcCount; ++pcIndex) {
       const Telemetry::ProcessedStack::Frame& frame = stack[pcIndex];
       JS::Rooted<JSObject*> framePair(cx, JS_NewArrayObject(cx, 0));
       if (!framePair) {
         return nullptr;
       }
       int modIndex = (std::numeric_limits<uint16_t>::max() == frame.mModIndex) ?
         -1 : frame.mModIndex;
       if (!JS_SetElement(cx, framePair, 0, modIndex)) {
         return nullptr;
       }
       if (!JS_SetElement(cx, framePair, 1, static_cast<double>(frame.mOffset))) {
         return nullptr;
       }
       if (!JS_SetElement(cx, pcArray, pcIndex, framePair)) {
         return nullptr;
       }
     }
   }
   return ret;
 }
 static bool
 IsValidBreakpadId(const std::string &breakpadId) {
   if (breakpadId.size() < 33) {
     return false;
   }
   for (unsigned i = 0, n = breakpadId.size(); i < n; ++i) {
     char c = breakpadId[i];
     if ((c < '0' || c > '9') && (c < 'A' || c > 'F')) {
       return false;
     }
   }
   return true;
 }
 // Read a stack from the given file name. In case of any error, aStack is
 // unchanged.
 static void
 ReadStack(const char *aFileName, Telemetry::ProcessedStack &aStack)
 {
   std::ifstream file(aFileName);
   size_t numModules;
   file >> numModules;
   if (file.fail()) {
     return;
   }
   char newline = file.get();
   if (file.fail() || newline != '\n') {
     return;
   }
   Telemetry::ProcessedStack stack;
   for (size_t i = 0; i < numModules; ++i) {
     std::string breakpadId;
     file >> breakpadId;
     if (file.fail() || !IsValidBreakpadId(breakpadId)) {
       return;
     }
     char space = file.get();
     if (file.fail() || space != ' ') {
       return;
     }
     std::string moduleName;
     getline(file, moduleName);
     if (file.fail() || moduleName[0] == ' ') {
       return;
     }
     Telemetry::ProcessedStack::Module module = {
       moduleName,
       breakpadId
     };
     stack.AddModule(module);
   }
   size_t numFrames;
   file >> numFrames;
   if (file.fail()) {
     return;
   }
   newline = file.get();
   if (file.fail() || newline != '\n') {
     return;
   }
   for (size_t i = 0; i < numFrames; ++i) {
     uint16_t index;
     file >> index;
     uintptr_t offset;
     file >> std::hex >> offset >> std::dec;
     if (file.fail()) {
       return;
     }
     Telemetry::ProcessedStack::Frame frame = {
       offset,
       index
     };
     stack.AddFrame(frame);
   }
   aStack = stack;
 }
 static JSObject*
 CreateJSTimeHistogram(JSContext* cx, const Telemetry::TimeHistogram& time)
 {
   /* Create JS representation of TimeHistogram,
      in the format of Chromium-style histograms. */
   JS::RootedObject ret(cx, JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr()));
   if (!ret) {
     return nullptr;
   }
   if (!JS_DefineProperty(cx, ret, "min", time.GetBucketMin(0),
                          JSPROP_ENUMERATE) ||
       !JS_DefineProperty(cx, ret, "max",
                          time.GetBucketMax(ArrayLength(time) - 1),
                          JSPROP_ENUMERATE) ||
       !JS_DefineProperty(cx, ret, "histogram_type",
                          nsITelemetry::HISTOGRAM_EXPONENTIAL,
                          JSPROP_ENUMERATE)) {
     return nullptr;
   }
   // TODO: calculate "sum", "log_sum", and "log_sum_squares"
   if (!JS_DefineProperty(cx, ret, "sum", 0, JSPROP_ENUMERATE) ||
       !JS_DefineProperty(cx, ret, "log_sum", 0.0, JSPROP_ENUMERATE) ||
       !JS_DefineProperty(cx, ret, "log_sum_squares", 0.0, JSPROP_ENUMERATE)) {
     return nullptr;
   }
   JS::RootedObject ranges(
     cx, JS_NewArrayObject(cx, ArrayLength(time) + 1));
   JS::RootedObject counts(
     cx, JS_NewArrayObject(cx, ArrayLength(time) + 1));
   if (!ranges || !counts) {
     return nullptr;
   }
   /* In a Chromium-style histogram, the first bucket is an "under" bucket
      that represents all values below the histogram's range. */
   if (!JS_SetElement(cx, ranges, 0, time.GetBucketMin(0)) ||
       !JS_SetElement(cx, counts, 0, 0)) {
     return nullptr;
   }
   for (size_t i = 0; i < ArrayLength(time); i++) {
     if (!JS_SetElement(cx, ranges, i + 1, time.GetBucketMax(i)) ||
         !JS_SetElement(cx, counts, i + 1, time[i])) {
       return nullptr;
     }
   }
   if (!JS_DefineProperty(cx, ret, "ranges", ranges, JSPROP_ENUMERATE) ||
       !JS_DefineProperty(cx, ret, "counts", counts, JSPROP_ENUMERATE)) {
     return nullptr;
   }
   return ret;
 }
 static JSObject*
 CreateJSHangHistogram(JSContext* cx, const Telemetry::HangHistogram& hang)
 {
   JS::RootedObject ret(cx, JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr()));
   if (!ret) {
     return nullptr;
   }
   const Telemetry::HangHistogram::Stack& hangStack = hang.GetStack();
   JS::RootedObject stack(cx,
     JS_NewArrayObject(cx, hangStack.length()));
   if (!ret) {
     return nullptr;
   }
   for (size_t i = 0; i < hangStack.length(); i++) {
     JS::RootedString string(cx, JS_NewStringCopyZ(cx, hangStack[i]));
     if (!JS_SetElement(cx, stack, i, string)) {
       return nullptr;
     }
   }
   JS::RootedObject time(cx, CreateJSTimeHistogram(cx, hang));
   if (!time ||
       !JS_DefineProperty(cx, ret, "stack", stack, JSPROP_ENUMERATE) ||
       !JS_DefineProperty(cx, ret, "histogram", time, JSPROP_ENUMERATE)) {
     return nullptr;
   }
   return ret;
 }
 static JSObject*
 CreateJSThreadHangStats(JSContext* cx, const Telemetry::ThreadHangStats& thread)
 {
   JS::RootedObject ret(cx, JS_NewObject(cx, nullptr, JS::NullPtr(), JS::NullPtr()));
   if (!ret) {
     return nullptr;
   }
   JS::RootedString name(cx, JS_NewStringCopyZ(cx, thread.GetName()));
   if (!name ||
       !JS_DefineProperty(cx, ret, "name", name, JSPROP_ENUMERATE)) {
     return nullptr;
   }
   JS::RootedObject activity(cx, CreateJSTimeHistogram(cx, thread.mActivity));
   if (!activity ||
       !JS_DefineProperty(cx, ret, "activity", activity, JSPROP_ENUMERATE)) {
     return nullptr;
   }
   JS::RootedObject hangs(cx, JS_NewArrayObject(cx, 0));
   if (!hangs) {
     return nullptr;
   }
   for (size_t i = 0; i < thread.mHangs.length(); i++) {
     JS::RootedObject obj(cx, CreateJSHangHistogram(cx, thread.mHangs[i]));
     if (!JS_SetElement(cx, hangs, i, obj)) {
       return nullptr;
     }
   }
   if (!JS_DefineProperty(cx, ret, "hangs", hangs, JSPROP_ENUMERATE)) {
     return nullptr;
   }
   return ret;
 }
 NS_IMETHODIMP
 TelemetryImpl::GetThreadHangStats(JSContext* cx, JS::MutableHandle<JS::Value> ret)
 {
   JS::RootedObject retObj(cx, JS_NewArrayObject(cx, 0));
   if (!retObj) {
     return NS_ERROR_FAILURE;
   }
   size_t threadIndex = 0;
 #ifdef MOZ_ENABLE_BACKGROUND_HANG_MONITOR
   /* First add active threads; we need to hold |iter| (and its lock)
      throughout this method to avoid a race condition where a thread can
      be recorded twice if the thread is destroyed while this method is
      running */
   BackgroundHangMonitor::ThreadHangStatsIterator iter;
   for (Telemetry::ThreadHangStats* histogram = iter.GetNext();
        histogram; histogram = iter.GetNext()) {
     JS::RootedObject obj(cx,
       CreateJSThreadHangStats(cx, *histogram));
     if (!JS_SetElement(cx, retObj, threadIndex++, obj)) {
       return NS_ERROR_FAILURE;
     }
   }
 #endif
   // Add saved threads next
   MutexAutoLock autoLock(mThreadHangStatsMutex);
   for (size_t i = 0; i < mThreadHangStats.length(); i++) {
     JS::RootedObject obj(cx,
       CreateJSThreadHangStats(cx, mThreadHangStats[i]));
     if (!JS_SetElement(cx, retObj, threadIndex++, obj)) {
       return NS_ERROR_FAILURE;
     }
   }
   ret.setObject(*retObj);
   return NS_OK;
 }
 void
 TelemetryImpl::ReadLateWritesStacks(nsIFile* aProfileDir)
 {
   nsAutoCString nativePath;
   nsresult rv = aProfileDir->GetNativePath(nativePath);
   if (NS_FAILED(rv)) {
     return;
   }
   const char *name = nativePath.get();
   PRDir *dir = PR_OpenDir(name);
   if (!dir) {
     return;
   }
   PRDirEntry *ent;
   const char *prefix = "Telemetry.LateWriteFinal-";
   unsigned int prefixLen = strlen(prefix);
   while ((ent = PR_ReadDir(dir, PR_SKIP_NONE))) {
     if (strncmp(prefix, ent->name, prefixLen) != 0) {
       continue;
     }
     nsAutoCString stackNativePath = nativePath;
     stackNativePath += XPCOM_FILE_PATH_SEPARATOR;
     stackNativePath += nsDependentCString(ent->name);
     Telemetry::ProcessedStack stack;
     ReadStack(stackNativePath.get(), stack);
     if (stack.GetStackSize() != 0) {
       mLateWritesStacks.AddStack(stack);
     }
     // Delete the file so that we don't report it again on the next run.
     PR_Delete(stackNativePath.get());
   }
   PR_CloseDir(dir);
 }
 NS_IMETHODIMP
 TelemetryImpl::GetLateWrites(JSContext *cx, JS::MutableHandle<JS::Value> ret)
 {
   // The user must call AsyncReadTelemetryData first. We return an empty list
   // instead of reporting a failure so that the rest of telemetry can uniformly
   // handle the read not being available yet.
   // FIXME: we allocate the js object again and again in the getter. We should
   // figure out a way to cache it. In order to do that we have to call
   // JS_AddNamedObjectRoot. A natural place to do so is in the TelemetryImpl
   // constructor, but it is not clear how to get a JSContext in there.
   // Another option would be to call it in here when we first call
   // CreateJSStackObject, but we would still need to figure out where to call
   // JS_RemoveObjectRoot. Would it be ok to never call JS_RemoveObjectRoot
   // and just set the pointer to nullptr is the telemetry destructor?
   JSObject *report;
   if (!mCachedTelemetryData) {
     CombinedStacks empty;
     report = CreateJSStackObject(cx, empty);
   } else {
     report = CreateJSStackObject(cx, mLateWritesStacks);
   }
   if (report == nullptr) {
     return NS_ERROR_FAILURE;
   }
   ret.setObject(*report);
   return NS_OK;
 }
 NS_IMETHODIMP
 TelemetryImpl::RegisteredHistograms(uint32_t *aCount, char*** aHistograms)
 {
   size_t count = ArrayLength(gHistograms);
   size_t offset = 0;
   char** histograms = static_cast<char**>(nsMemory::Alloc(count * sizeof(char*)));
   for (size_t i = 0; i < count; ++i) {
     if (IsExpired(gHistograms[i].expiration())) {
       offset++;
       continue;
     }
     const char* h = gHistograms[i].id();
     size_t len = strlen(h);
     histograms[i - offset] = static_cast<char*>(nsMemory::Clone(h, len+1));
   }
   *aCount = count - offset;
   *aHistograms = histograms;
   return NS_OK;
 }
 NS_IMETHODIMP
 TelemetryImpl::GetHistogramById(const nsACString &name, JSContext *cx,
                                 JS::MutableHandle<JS::Value> ret)
 {
   Histogram *h;
   nsresult rv = GetHistogramByName(name, &h);
   if (NS_FAILED(rv))
     return rv;
   return WrapAndReturnHistogram(h, cx, ret);
 }
 NS_IMETHODIMP
 TelemetryImpl::GetCanRecord(bool *ret) {
   *ret = mCanRecord;
   return NS_OK;
 }
 NS_IMETHODIMP
 TelemetryImpl::SetCanRecord(bool canRecord) {
   mCanRecord = !!canRecord;
   return NS_OK;
 }
 bool
 TelemetryImpl::CanRecord() {
   return !sTelemetry || sTelemetry->mCanRecord;
 }
 NS_IMETHODIMP
 TelemetryImpl::GetCanSend(bool *ret) {
 #if defined(MOZILLA_OFFICIAL) && defined(MOZ_TELEMETRY_REPORTING)
   *ret = true;
 #else
   *ret = false;
 #endif
   return NS_OK;
 }
 already_AddRefed<nsITelemetry>
 TelemetryImpl::CreateTelemetryInstance()
 {
   NS_ABORT_IF_FALSE(sTelemetry == nullptr, "CreateTelemetryInstance may only be called once, via GetService()");
   sTelemetry = new TelemetryImpl();
   // AddRef for the local reference
   NS_ADDREF(sTelemetry);
   // AddRef for the caller
   nsCOMPtr<nsITelemetry> ret = sTelemetry;
   sTelemetry->InitMemoryReporter();
   return ret.forget();
 }
 void
 TelemetryImpl::ShutdownTelemetry()
 {
   // No point in collecting IO beyond this point
   ClearIOReporting();
   NS_IF_RELEASE(sTelemetry);
 }
 void
 TelemetryImpl::StoreSlowSQL(const nsACString &sql, uint32_t delay,
                             SanitizedState state)
 {
   AutoHashtable<SlowSQLEntryType> *slowSQLMap = nullptr;
   if (state == Sanitized)
     slowSQLMap = &(sTelemetry->mSanitizedSQL);
   else
     slowSQLMap = &(sTelemetry->mPrivateSQL);
   MutexAutoLock hashMutex(sTelemetry->mHashMutex);
   SlowSQLEntryType *entry = slowSQLMap->GetEntry(sql);
   if (!entry) {
     entry = slowSQLMap->PutEntry(sql);
     if (MOZ_UNLIKELY(!entry))
       return;
     entry->mData.mainThread.hitCount = 0;
     entry->mData.mainThread.totalTime = 0;
     entry->mData.otherThreads.hitCount = 0;
     entry->mData.otherThreads.totalTime = 0;
   }
   if (NS_IsMainThread()) {
     entry->mData.mainThread.hitCount++;
     entry->mData.mainThread.totalTime += delay;
   } else {
     entry->mData.otherThreads.hitCount++;
     entry->mData.otherThreads.totalTime += delay;
   }
 }
 /**
  * This method replaces string literals in SQL strings with the word :private
  *
  * States used in this state machine:
  *
  * NORMAL:
  *  - This is the active state when not iterating over a string literal or
  *  comment
  *
  * SINGLE_QUOTE:
  *  - Defined here: http://www.sqlite.org/lang_expr.html
  *  - This state represents iterating over a string literal opened with
  *  a single quote.
  *  - A single quote within the string can be encoded by putting 2 single quotes
  *  in a row, e.g. 'This literal contains an escaped quote '''
  *  - Any double quotes found within a single-quoted literal are ignored
  *  - This state covers BLOB literals, e.g. X'ABC123'
  *  - The string literal and the enclosing quotes will be replaced with
  *  the text :private
  *
  * DOUBLE_QUOTE:
  *  - Same rules as the SINGLE_QUOTE state.
  *  - According to http://www.sqlite.org/lang_keywords.html,
  *  SQLite interprets text in double quotes as an identifier unless it's used in
  *  a context where it cannot be resolved to an identifier and a string literal
  *  is allowed. This method removes text in double-quotes for safety.
  *
  *  DASH_COMMENT:
  *  - http://www.sqlite.org/lang_comment.html
  *  - A dash comment starts with two dashes in a row,
  *  e.g. DROP TABLE foo -- a comment
  *  - Any text following two dashes in a row is interpreted as a comment until
  *  end of input or a newline character
  *  - Any quotes found within the comment are ignored and no replacements made
  *
  *  C_STYLE_COMMENT:
  *  - http://www.sqlite.org/lang_comment.html
  *  - A C-style comment starts with a forward slash and an asterisk, and ends
  *  with an asterisk and a forward slash
  *  - Any text following comment start is interpreted as a comment up to end of
  *  input or comment end
  *  - Any quotes found within the comment are ignored and no replacements made
  */
 nsCString
 TelemetryImpl::SanitizeSQL(const nsACString &sql) {
   nsCString output;
   int length = sql.Length();
   typedef enum {
     NORMAL,
     SINGLE_QUOTE,
     DOUBLE_QUOTE,
     DASH_COMMENT,
     C_STYLE_COMMENT,
   } State;
   State state = NORMAL;
   int fragmentStart = 0;
   for (int i = 0; i < length; i++) {
     char character = sql[i];
     char nextCharacter = (i + 1 < length) ? sql[i + 1] : '\0';
     switch (character) {
       case '\'':
       case '"':
         if (state == NORMAL) {
           state = (character == '\'') ? SINGLE_QUOTE : DOUBLE_QUOTE;
           output += nsDependentCSubstring(sql, fragmentStart, i - fragmentStart);
           output += ":private";
           fragmentStart = -1;
         } else if ((state == SINGLE_QUOTE && character == '\'') ||
                    (state == DOUBLE_QUOTE && character == '"')) {
           if (nextCharacter == character) {
             // Two consecutive quotes within a string literal are a single escaped quote
             i++;
           } else {
             state = NORMAL;
             fragmentStart = i + 1;
           }
         }
         break;
       case '-':
         if (state == NORMAL) {
           if (nextCharacter == '-') {
             state = DASH_COMMENT;
             i++;
           }
         }
         break;
       case '\n':
         if (state == DASH_COMMENT) {
           state = NORMAL;
         }
         break;
       case '/':
         if (state == NORMAL) {
           if (nextCharacter == '*') {
             state = C_STYLE_COMMENT;
             i++;
           }
         }
         break;
       case '*':
         if (state == C_STYLE_COMMENT) {
           if (nextCharacter == '/') {
             state = NORMAL;
           }
         }
         break;
       default:
         continue;
     }
   }
   if ((fragmentStart >= 0) && fragmentStart < length)
     output += nsDependentCSubstring(sql, fragmentStart, length - fragmentStart);
   return output;
 }
 // Slow SQL statements will be automatically
 // trimmed to kMaxSlowStatementLength characters.
 // This limit doesn't include the ellipsis and DB name,
 // that are appended at the end of the stored statement.
 const uint32_t kMaxSlowStatementLength = 1000;
 void
 TelemetryImpl::RecordSlowStatement(const nsACString &sql,
                                    const nsACString &dbName,
                                    uint32_t delay)
 {
   if (!sTelemetry || !sTelemetry->mCanRecord)
     return;
   bool isFirefoxDB = sTelemetry->mTrackedDBs.Contains(dbName);
   if (isFirefoxDB) {
     nsAutoCString sanitizedSQL(SanitizeSQL(sql));
     if (sanitizedSQL.Length() > kMaxSlowStatementLength) {
       sanitizedSQL.SetLength(kMaxSlowStatementLength);
       sanitizedSQL += "...";
     }
     sanitizedSQL.AppendPrintf(" /* %s */", nsPromiseFlatCString(dbName).get());
     StoreSlowSQL(sanitizedSQL, delay, Sanitized);
   } else {
     // Report aggregate DB-level statistics for addon DBs
     nsAutoCString aggregate;
     aggregate.AppendPrintf("Untracked SQL for %s",
                            nsPromiseFlatCString(dbName).get());
     StoreSlowSQL(aggregate, delay, Sanitized);
   }
   nsAutoCString fullSQL;
   fullSQL.AppendPrintf("%s /* %s */",
                        nsPromiseFlatCString(sql).get(),
                        nsPromiseFlatCString(dbName).get());
   StoreSlowSQL(fullSQL, delay, Unsanitized);
 }
 #if defined(MOZ_ENABLE_PROFILER_SPS)
 void
 TelemetryImpl::RecordChromeHang(uint32_t aDuration,
                                 Telemetry::ProcessedStack &aStack,
                                 int32_t aSystemUptime,
                                 int32_t aFirefoxUptime)
 {
   if (!sTelemetry || !sTelemetry->mCanRecord)
     return;
   MutexAutoLock hangReportMutex(sTelemetry->mHangReportsMutex);
   sTelemetry->mHangReports.AddHang(aStack, aDuration,
                                    aSystemUptime, aFirefoxUptime);
 }
 #endif
 void
 TelemetryImpl::RecordThreadHangStats(Telemetry::ThreadHangStats& aStats)
 {
   if (!sTelemetry || !sTelemetry->mCanRecord)
     return;
   MutexAutoLock autoLock(sTelemetry->mThreadHangStatsMutex);
   sTelemetry->mThreadHangStats.append(Move(aStats));
 }
 NS_IMPL_ISUPPORTS(TelemetryImpl, nsITelemetry, nsIMemoryReporter)
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsITelemetry, TelemetryImpl::CreateTelemetryInstance)
 #define NS_TELEMETRY_CID \
   {0xaea477f2, 0xb3a2, 0x469c, {0xaa, 0x29, 0x0a, 0x82, 0xd1, 0x32, 0xb8, 0x29}}
 NS_DEFINE_NAMED_CID(NS_TELEMETRY_CID);
 const Module::CIDEntry kTelemetryCIDs[] = {
   { &kNS_TELEMETRY_CID, false, nullptr, nsITelemetryConstructor },
   { nullptr }
 };
 const Module::ContractIDEntry kTelemetryContracts[] = {
   { "@mozilla.org/base/telemetry;1", &kNS_TELEMETRY_CID },
   { nullptr }
 };
 const Module kTelemetryModule = {
   Module::kVersion,
   kTelemetryCIDs,
   kTelemetryContracts,
   nullptr,
   nullptr,
   nullptr,
   TelemetryImpl::ShutdownTelemetry
 };
 NS_IMETHODIMP
 TelemetryImpl::GetFileIOReports(JSContext *cx, JS::MutableHandleValue ret)
 {
   if (sTelemetryIOObserver) {
     JS::Rooted<JSObject*> obj(cx, JS_NewObject(cx, nullptr, JS::NullPtr(),
                                                JS::NullPtr()));
     if (!obj) {
       return NS_ERROR_FAILURE;
     }
     if (!sTelemetryIOObserver->ReflectIntoJS(cx, obj)) {
       return NS_ERROR_FAILURE;
     }
     ret.setObject(*obj);
     return NS_OK;
   }
   ret.setNull();
   return NS_OK;
 }
 NS_IMETHODIMP
 TelemetryImpl::MsSinceProcessStart(double* aResult)
 {
   bool error;
   *aResult = (TimeStamp::NowLoRes() -
               TimeStamp::ProcessCreation(error)).ToMilliseconds();
   if (error) {
     return NS_ERROR_NOT_AVAILABLE;
   }
   return NS_OK;
 }
 size_t
 TelemetryImpl::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
 {
   size_t n = aMallocSizeOf(this);
   // Ignore the hashtables in mAddonMap; they are not significant.
   n += mAddonMap.SizeOfExcludingThis(nullptr, aMallocSizeOf);
   n += mHistogramMap.SizeOfExcludingThis(nullptr, aMallocSizeOf);
   { // Scope for mHashMutex lock
     MutexAutoLock lock(mHashMutex);
     n += mPrivateSQL.SizeOfExcludingThis(nullptr, aMallocSizeOf);
     n += mSanitizedSQL.SizeOfExcludingThis(nullptr, aMallocSizeOf);
   }
   n += mTrackedDBs.SizeOfExcludingThis(nullptr, aMallocSizeOf);
   { // Scope for mHangReportsMutex lock
     MutexAutoLock lock(mHangReportsMutex);
     n += mHangReports.SizeOfExcludingThis();
   }
   { // Scope for mThreadHangStatsMutex lock
     MutexAutoLock lock(mThreadHangStatsMutex);
     n += mThreadHangStats.sizeOfExcludingThis(aMallocSizeOf);
   }
   // It's a bit gross that we measure this other stuff that lives outside of
   // TelemetryImpl... oh well.
   if (sTelemetryIOObserver) {
     n += sTelemetryIOObserver->SizeOfIncludingThis(aMallocSizeOf);
   }
   StatisticsRecorder::Histograms hs;
   StatisticsRecorder::GetHistograms(&hs);
   for (HistogramIterator it = hs.begin(); it != hs.end(); ++it) {
     Histogram *h = *it;
     n += h->SizeOfIncludingThis(aMallocSizeOf);
   }
   return n;
 }
 } // anonymous namespace
 namespace mozilla {
 void
 RecordShutdownStartTimeStamp() {
 #ifdef DEBUG
   // FIXME: this function should only be called once, since it should be called
   // at the earliest point we *know* we are shutting down. Unfortunately
   // this assert has been firing. Given that if we are called multiple times
   // we just keep the last timestamp, the assert is commented for now.
   static bool recorded = false;
   //  MOZ_ASSERT(!recorded);
   (void)recorded; // Silence unused-var warnings (remove when assert re-enabled)
   recorded = true;
 #endif
   if (!Telemetry::CanRecord())
     return;
   gRecordedShutdownStartTime = TimeStamp::Now();
   GetShutdownTimeFileName();
 }
 void
 RecordShutdownEndTimeStamp() {
   if (!gRecordedShutdownTimeFileName || gAlreadyFreedShutdownTimeFileName)
     return;
   nsCString name(gRecordedShutdownTimeFileName);
   PL_strfree(gRecordedShutdownTimeFileName);
   gRecordedShutdownTimeFileName = nullptr;
   gAlreadyFreedShutdownTimeFileName = true;
   nsCString tmpName = name;
   tmpName += ".tmp";
   FILE *f = fopen(tmpName.get(), "w");
   if (!f)
     return;
   // On a normal release build this should be called just before
   // calling _exit, but on a debug build or when the user forces a full
   // shutdown this is called as late as possible, so we have to
   // white list this write as write poisoning will be enabled.
   MozillaRegisterDebugFILE(f);
   TimeStamp now = TimeStamp::Now();
   MOZ_ASSERT(now >= gRecordedShutdownStartTime);
   TimeDuration diff = now - gRecordedShutdownStartTime;
   uint32_t diff2 = diff.ToMilliseconds();
   int written = fprintf(f, "%d\n", diff2);
   MozillaUnRegisterDebugFILE(f);
   int rv = fclose(f);
   if (written < 0 || rv != 0) {
     PR_Delete(tmpName.get());
     return;
   }
   PR_Delete(name.get());
   PR_Rename(tmpName.get(), name.get());
 }
 namespace Telemetry {
 void
 Accumulate(ID aHistogram, uint32_t aSample)
 {
   if (!TelemetryImpl::CanRecord()) {
     return;
   }
   Histogram *h;
   nsresult rv = GetHistogramByEnumId(aHistogram, &h);
   if (NS_SUCCEEDED(rv))
     h->Add(aSample);
 }
 void
 Accumulate(const char* name, uint32_t sample)
 {
   if (!TelemetryImpl::CanRecord()) {
     return;
   }
   ID id;
   nsresult rv = TelemetryImpl::GetHistogramEnumId(name, &id);
   if (NS_FAILED(rv)) {
     return;
   }
   Histogram *h;
   rv = GetHistogramByEnumId(id, &h);
   if (NS_SUCCEEDED(rv)) {
     h->Add(sample);
   }
 }
 void
 AccumulateTimeDelta(ID aHistogram, TimeStamp start, TimeStamp end)
 {
   Accumulate(aHistogram,
              static_cast<uint32_t>((end - start).ToMilliseconds()));
 }
 bool
 CanRecord()
 {
   return TelemetryImpl::CanRecord();
 }
 base::Histogram*
 GetHistogramById(ID id)
 {
   Histogram *h = nullptr;
   GetHistogramByEnumId(id, &h);
   return h;
 }
 void
 RecordSlowSQLStatement(const nsACString &statement,
                        const nsACString &dbName,
                        uint32_t delay)
 {
   TelemetryImpl::RecordSlowStatement(statement, dbName, delay);
 }
 void Init()
 {
   // Make the service manager hold a long-lived reference to the service
   nsCOMPtr<nsITelemetry> telemetryService =
     do_GetService("@mozilla.org/base/telemetry;1");
   MOZ_ASSERT(telemetryService);
 }
 #if defined(MOZ_ENABLE_PROFILER_SPS)
 void RecordChromeHang(uint32_t duration,
                       ProcessedStack &aStack,
                       int32_t aSystemUptime,
                       int32_t aFirefoxUptime)
 {
   TelemetryImpl::RecordChromeHang(duration, aStack,
                                   aSystemUptime, aFirefoxUptime);
 }
 #endif
 void RecordThreadHangStats(ThreadHangStats& aStats)
 {
   TelemetryImpl::RecordThreadHangStats(aStats);
 }
 ProcessedStack::ProcessedStack()
 {
 }
 size_t ProcessedStack::GetStackSize() const
 {
   return mStack.size();
 }
 const ProcessedStack::Frame &ProcessedStack::GetFrame(unsigned aIndex) const
 {
   MOZ_ASSERT(aIndex < mStack.size());
   return mStack[aIndex];
 }
 void ProcessedStack::AddFrame(const Frame &aFrame)
 {
   mStack.push_back(aFrame);
 }
 size_t ProcessedStack::GetNumModules() const
 {
   return mModules.size();
 }
 const ProcessedStack::Module &ProcessedStack::GetModule(unsigned aIndex) const
 {
   MOZ_ASSERT(aIndex < mModules.size());
   return mModules[aIndex];
 }
 void ProcessedStack::AddModule(const Module &aModule)
 {
   mModules.push_back(aModule);
 }
 void ProcessedStack::Clear() {
   mModules.clear();
   mStack.clear();
 }
 bool ProcessedStack::Module::operator==(const Module& aOther) const {
   return  mName == aOther.mName &&
     mBreakpadId == aOther.mBreakpadId;
 }
 struct StackFrame
 {
   uintptr_t mPC;      // The program counter at this position in the call stack.
   uint16_t mIndex;    // The number of this frame in the call stack.
   uint16_t mModIndex; // The index of module that has this program counter.
 };
 #ifdef MOZ_ENABLE_PROFILER_SPS
 static bool CompareByPC(const StackFrame &a, const StackFrame &b)
 {
   return a.mPC < b.mPC;
 }
 static bool CompareByIndex(const StackFrame &a, const StackFrame &b)
 {
   return a.mIndex < b.mIndex;
 }
 #endif
 ProcessedStack
 GetStackAndModules(const std::vector<uintptr_t>& aPCs)
 {
   std::vector<StackFrame> rawStack;
   for (std::vector<uintptr_t>::const_iterator i = aPCs.begin(),
          e = aPCs.end(); i != e; ++i) {
     uintptr_t aPC = *i;
     StackFrame Frame = {aPC, static_cast<uint16_t>(rawStack.size()),
                         std::numeric_limits<uint16_t>::max()};
     rawStack.push_back(Frame);
   }
 #ifdef MOZ_ENABLE_PROFILER_SPS
   // Remove all modules not referenced by a PC on the stack
   std::sort(rawStack.begin(), rawStack.end(), CompareByPC);
   size_t moduleIndex = 0;
   size_t stackIndex = 0;
   size_t stackSize = rawStack.size();
   SharedLibraryInfo rawModules = SharedLibraryInfo::GetInfoForSelf();
   rawModules.SortByAddress();
   while (moduleIndex < rawModules.GetSize()) {
     const SharedLibrary& module = rawModules.GetEntry(moduleIndex);
     uintptr_t moduleStart = module.GetStart();
     uintptr_t moduleEnd = module.GetEnd() - 1;
     // the interval is [moduleStart, moduleEnd)
     bool moduleReferenced = false;
     for (;stackIndex < stackSize; ++stackIndex) {
       uintptr_t pc = rawStack[stackIndex].mPC;
       if (pc >= moduleEnd)
         break;
       if (pc >= moduleStart) {
         // If the current PC is within the current module, mark
         // module as used
         moduleReferenced = true;
         rawStack[stackIndex].mPC -= moduleStart;
         rawStack[stackIndex].mModIndex = moduleIndex;
       } else {
         // PC does not belong to any module. It is probably from
         // the JIT. Use a fixed mPC so that we don't get different
         // stacks on different runs.
         rawStack[stackIndex].mPC =
           std::numeric_limits<uintptr_t>::max();
       }
     }
     if (moduleReferenced) {
       ++moduleIndex;
     } else {
       // Remove module if no PCs within its address range
       rawModules.RemoveEntries(moduleIndex, moduleIndex + 1);
     }
   }
   for (;stackIndex < stackSize; ++stackIndex) {
     // These PCs are past the last module.
     rawStack[stackIndex].mPC = std::numeric_limits<uintptr_t>::max();
   }
   std::sort(rawStack.begin(), rawStack.end(), CompareByIndex);
 #endif
   // Copy the information to the return value.
   ProcessedStack Ret;
   for (std::vector<StackFrame>::iterator i = rawStack.begin(),
          e = rawStack.end(); i != e; ++i) {
     const StackFrame &rawFrame = *i;
     ProcessedStack::Frame frame = { rawFrame.mPC, rawFrame.mModIndex };
     Ret.AddFrame(frame);
   }
 #ifdef MOZ_ENABLE_PROFILER_SPS
   for (unsigned i = 0, n = rawModules.GetSize(); i != n; ++i) {
     const SharedLibrary &info = rawModules.GetEntry(i);
     const std::string &name = info.GetName();
     std::string basename = name;
 #ifdef XP_MACOSX
     // FIXME: We want to use just the basename as the libname, but the
     // current profiler addon needs the full path name, so we compute the
     // basename in here.
     size_t pos = name.rfind('/');
     if (pos != std::string::npos) {
       basename = name.substr(pos + 1);
     }
 #endif
     ProcessedStack::Module module = {
       basename,
       info.GetBreakpadId()
     };
     Ret.AddModule(module);
   }
 #endif
   return Ret;
 }
 void
 WriteFailedProfileLock(nsIFile* aProfileDir)
 {
   nsCOMPtr<nsIFile> file;
   nsresult rv = GetFailedProfileLockFile(getter_AddRefs(file), aProfileDir);
   NS_ENSURE_SUCCESS_VOID(rv);
   int64_t fileSize = 0;
   rv = file->GetFileSize(&fileSize);
   // It's expected that the file might not exist yet
   if (NS_FAILED(rv) && rv != NS_ERROR_FILE_NOT_FOUND) {
     return;
   }
   nsCOMPtr<nsIFileStream> fileStream;
   rv = NS_NewLocalFileStream(getter_AddRefs(fileStream), file,
                              PR_RDWR | PR_CREATE_FILE, 0640);
   NS_ENSURE_SUCCESS_VOID(rv);
   NS_ENSURE_TRUE_VOID(fileSize <= kMaxFailedProfileLockFileSize);
   unsigned int failedLockCount = 0;
   if (fileSize > 0) {
     nsCOMPtr<nsIInputStream> inStream = do_QueryInterface(fileStream);
     NS_ENSURE_TRUE_VOID(inStream);
     if (!GetFailedLockCount(inStream, fileSize, failedLockCount)) {
       failedLockCount = 0;
     }
   }
   ++failedLockCount;
   nsAutoCString bufStr;
   bufStr.AppendInt(static_cast<int>(failedLockCount));
   nsCOMPtr<nsISeekableStream> seekStream = do_QueryInterface(fileStream);
   NS_ENSURE_TRUE_VOID(seekStream);
   // If we read in an existing failed lock count, we need to reset the file ptr
   if (fileSize > 0) {
     rv = seekStream->Seek(nsISeekableStream::NS_SEEK_SET, 0);
     NS_ENSURE_SUCCESS_VOID(rv);
   }
   nsCOMPtr<nsIOutputStream> outStream = do_QueryInterface(fileStream);
   uint32_t bytesLeft = bufStr.Length();
   const char* bytes = bufStr.get();
   do {
     uint32_t written = 0;
     rv = outStream->Write(bytes, bytesLeft, &written);
     if (NS_FAILED(rv)) {
       break;
     }
     bytes += written;
     bytesLeft -= written;
   } while (bytesLeft > 0);
   seekStream->SetEOF();
 }
 void
 InitIOReporting(nsIFile* aXreDir)
 {
   // Never initialize twice
   if (sTelemetryIOObserver) {
     return;
   }
   sTelemetryIOObserver = new TelemetryIOInterposeObserver(aXreDir);
   IOInterposer::Register(IOInterposeObserver::OpAllWithStaging,
                          sTelemetryIOObserver);
 }
 void
 SetProfileDir(nsIFile* aProfD)
 {
   if (!sTelemetryIOObserver || !aProfD) {
     return;
   }
   nsAutoString profDirPath;
   nsresult rv = aProfD->GetPath(profDirPath);
   if (NS_FAILED(rv)) {
     return;
   }
   sTelemetryIOObserver->AddPath(profDirPath, NS_LITERAL_STRING("{profile}"));
 }
 void
 TimeHistogram::Add(PRIntervalTime aTime)
 {
   uint32_t timeMs = PR_IntervalToMilliseconds(aTime);
   size_t index = mozilla::FloorLog2(timeMs);
   operator[](index)++;
 }
 uint32_t
 HangHistogram::GetHash(const Stack& aStack)
 {
   uint32_t hash = 0;
   for (const char* const* label = aStack.begin();
        label != aStack.end(); label++) {
     /* We only need to hash the pointer instead of the text content
        because we are assuming constant pointers */
     hash = AddToHash(hash, *label);
   }
   return hash;
 }
 bool
 HangHistogram::operator==(const HangHistogram& aOther) const
 {
   if (mHash != aOther.mHash) {
     return false;
   }
   if (mStack.length() != aOther.mStack.length()) {
     return false;
   }
   return PodEqual(mStack.begin(), aOther.mStack.begin(), mStack.length());
 }
 } // namespace Telemetry
 } // namespace mozilla
 NSMODULE_DEFN(nsTelemetryModule) = &kTelemetryModule;
 /**
  * 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);
 }

The Tor Browser / annotate

toolkit/components/telemetry/Telemetry.cpp@129ffea94266 (annotated)

toolkit/components/telemetry/Telemetry.cpp