Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 667 insertions, 0 deletions

diff --git a/dom/media/doctor/DDMediaLogs.cpp b/dom/media/doctor/DDMediaLogs.cpp
new file mode 100644
index 0000000000..442e03d3fa
--- /dev/null
+++ b/dom/media/doctor/DDMediaLogs.cpp
@@ -0,0 +1,667 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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 "DDMediaLogs.h"
+
+#include "DDLogUtils.h"
+#include "nsIThread.h"
+#include "nsIThreadManager.h"
+#include "mozilla/JSONStringWriteFuncs.h"
+
+namespace mozilla {
+
+/* static */ DDMediaLogs::ConstructionResult DDMediaLogs::New() {
+  nsCOMPtr<nsIThread> mThread;
+  nsresult rv =
+      NS_NewNamedThread("DDMediaLogs", getter_AddRefs(mThread), nullptr,
+                        {.stackSize = nsIThreadManager::kThreadPoolStackSize});
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return {rv, nullptr};
+  }
+
+  return {rv, new DDMediaLogs(std::move(mThread))};
+}
+
+DDMediaLogs::DDMediaLogs(nsCOMPtr<nsIThread>&& aThread)
+    : mMediaLogs(1), mMutex("DDMediaLogs"), mThread(std::move(aThread)) {
+  mMediaLogs.SetLength(1);
+  mMediaLogs[0].mMediaElement = nullptr;
+  DDL_INFO("DDMediaLogs constructed, processing thread: %p", mThread.get());
+}
+
+DDMediaLogs::~DDMediaLogs() {
+  // Perform end-of-life processing, ensure the processing thread is shutdown.
+  Shutdown(/* aPanic = */ false);
+}
+
+void DDMediaLogs::Panic() { Shutdown(/* aPanic = */ true); }
+
+void DDMediaLogs::Shutdown(bool aPanic) {
+  nsCOMPtr<nsIThread> thread;
+  {
+    MutexAutoLock lock(mMutex);
+    thread.swap(mThread);
+  }
+  if (!thread) {
+    // Already shutdown, nothing more to do.
+    return;
+  }
+
+  DDL_INFO("DDMediaLogs::Shutdown will shutdown thread: %p", thread.get());
+  // Will block until pending tasks have completed, and thread is dead.
+  thread->Shutdown();
+
+  if (aPanic) {
+    mMessagesQueue.PopAll([](const DDLogMessage&) {});
+    MutexAutoLock lock(mMutex);
+    mLifetimes.Clear();
+    mMediaLogs.Clear();
+    mObjectLinks.Clear();
+    mPendingPromises.Clear();
+    return;
+  }
+
+  // Final processing is only necessary to output to MOZ_LOG=DDLoggerEnd,
+  // so there's no point doing any of it if that MOZ_LOG is not enabled.
+  if (MOZ_LOG_TEST(sDecoderDoctorLoggerEndLog, mozilla::LogLevel::Info)) {
+    DDL_DEBUG("Perform final DDMediaLogs processing...");
+    // The processing thread is dead, so we can safely call ProcessLog()
+    // directly from this thread.
+    ProcessLog();
+
+    for (const DDMediaLog& mediaLog : mMediaLogs) {
+      if (mediaLog.mMediaElement) {
+        DDLE_INFO("---");
+      }
+      DDLE_INFO("--- Log for HTMLMediaElement[%p] ---", mediaLog.mMediaElement);
+      for (const DDLogMessage& message : mediaLog.mMessages) {
+        DDLE_LOG(message.mCategory <= DDLogCategory::_Unlink
+                     ? mozilla::LogLevel::Debug
+                     : mozilla::LogLevel::Info,
+                 "%s", message.Print(mLifetimes).get());
+      }
+      DDLE_DEBUG("--- End log for HTMLMediaElement[%p] ---",
+                 mediaLog.mMediaElement);
+    }
+  }
+}
+
+DDMediaLog& DDMediaLogs::LogForUnassociatedMessages() {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+  return mMediaLogs[0];
+}
+const DDMediaLog& DDMediaLogs::LogForUnassociatedMessages() const {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+  return mMediaLogs[0];
+}
+
+DDMediaLog* DDMediaLogs::GetLogFor(const dom::HTMLMediaElement* aMediaElement) {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+  if (!aMediaElement) {
+    return &LogForUnassociatedMessages();
+  }
+  for (DDMediaLog& log : mMediaLogs) {
+    if (log.mMediaElement == aMediaElement) {
+      return &log;
+    }
+  }
+  return nullptr;
+}
+
+DDMediaLog& DDMediaLogs::LogFor(const dom::HTMLMediaElement* aMediaElement) {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+  DDMediaLog* log = GetLogFor(aMediaElement);
+  if (!log) {
+    log = mMediaLogs.AppendElement();
+    log->mMediaElement = aMediaElement;
+  }
+  return *log;
+}
+
+void DDMediaLogs::SetMediaElement(DDLifetime& aLifetime,
+                                  const dom::HTMLMediaElement* aMediaElement) {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+  DDMediaLog& log = LogFor(aMediaElement);
+
+  // List of lifetimes that are to be linked to aMediaElement.
+  nsTArray<DDLifetime*> lifetimes;
+  // We start with the given lifetime.
+  lifetimes.AppendElement(&aLifetime);
+  for (size_t i = 0; i < lifetimes.Length(); ++i) {
+    DDLifetime& lifetime = *lifetimes[i];
+    // Link the lifetime to aMediaElement.
+    lifetime.mMediaElement = aMediaElement;
+    // Classified lifetime's tag is a positive index from the DDMediaLog.
+    lifetime.mTag = ++log.mLifetimeCount;
+    DDL_DEBUG("%s -> HTMLMediaElement[%p]", lifetime.Printf().get(),
+              aMediaElement);
+
+    // Go through the lifetime's existing linked lifetimes, if any is not
+    // already linked to aMediaElement, add it to the list so it will get
+    // linked in a later loop.
+    for (auto& link : mObjectLinks) {
+      if (lifetime.IsAliveAt(link.mLinkingIndex)) {
+        if (lifetime.mObject == link.mParent) {
+          DDLifetime* childLifetime =
+              mLifetimes.FindLifetime(link.mChild, link.mLinkingIndex);
+          if (childLifetime && !childLifetime->mMediaElement &&
+              !lifetimes.Contains(childLifetime)) {
+            lifetimes.AppendElement(childLifetime);
+          }
+        } else if (lifetime.mObject == link.mChild) {
+          DDLifetime* parentLifetime =
+              mLifetimes.FindLifetime(link.mParent, link.mLinkingIndex);
+          if (parentLifetime && !parentLifetime->mMediaElement &&
+              !lifetimes.Contains(parentLifetime)) {
+            lifetimes.AppendElement(parentLifetime);
+          }
+        }
+      }
+    }
+  }
+
+  // Now we need to move yet-unclassified messages related to the just-set
+  // elements, to the appropriate MediaElement list.
+  DDMediaLog::LogMessages& messages = log.mMessages;
+  DDMediaLog::LogMessages& messages0 = LogForUnassociatedMessages().mMessages;
+  for (size_t i = 0; i < messages0.Length();
+       /* increment inside the loop */) {
+    DDLogMessage& message = messages0[i];
+    bool found = false;
+    for (const DDLifetime* lifetime : lifetimes) {
+      if (lifetime->mObject == message.mObject) {
+        found = true;
+        break;
+      }
+    }
+    if (found) {
+      messages.AppendElement(std::move(message));
+      messages0.RemoveElementAt(i);
+      // No increment, as we've removed this element; next element is now at
+      // the same index.
+    } else {
+      // Not touching this element, increment index to go to next element.
+      ++i;
+    }
+  }
+}
+
+DDLifetime& DDMediaLogs::FindOrCreateLifetime(const DDLogObject& aObject,
+                                              DDMessageIndex aIndex,
+                                              const DDTimeStamp& aTimeStamp) {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+  // Try to find lifetime corresponding to message object.
+  DDLifetime* lifetime = mLifetimes.FindLifetime(aObject, aIndex);
+  if (!lifetime) {
+    // No lifetime yet, create one.
+    lifetime = &(mLifetimes.CreateLifetime(aObject, aIndex, aTimeStamp));
+    if (MOZ_UNLIKELY(aObject.TypeName() ==
+                     DDLoggedTypeTraits<dom::HTMLMediaElement>::Name())) {
+      const dom::HTMLMediaElement* mediaElement =
+          static_cast<const dom::HTMLMediaElement*>(aObject.Pointer());
+      SetMediaElement(*lifetime, mediaElement);
+      DDL_DEBUG("%s -> new lifetime: %s with MediaElement %p",
+                aObject.Printf().get(), lifetime->Printf().get(), mediaElement);
+    } else {
+      DDL_DEBUG("%s -> new lifetime: %s", aObject.Printf().get(),
+                lifetime->Printf().get());
+    }
+  }
+
+  return *lifetime;
+}
+
+void DDMediaLogs::LinkLifetimes(DDLifetime& aParentLifetime,
+                                const char* aLinkName,
+                                DDLifetime& aChildLifetime,
+                                DDMessageIndex aIndex) {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+  mObjectLinks.AppendElement(DDObjectLink{
+      aParentLifetime.mObject, aChildLifetime.mObject, aLinkName, aIndex});
+  if (aParentLifetime.mMediaElement) {
+    if (!aChildLifetime.mMediaElement) {
+      SetMediaElement(aChildLifetime, aParentLifetime.mMediaElement);
+    }
+  } else if (aChildLifetime.mMediaElement) {
+    if (!aParentLifetime.mMediaElement) {
+      SetMediaElement(aParentLifetime, aChildLifetime.mMediaElement);
+    }
+  }
+}
+
+void DDMediaLogs::UnlinkLifetime(DDLifetime& aLifetime, DDMessageIndex aIndex) {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+  for (DDObjectLink& link : mObjectLinks) {
+    if ((link.mParent == aLifetime.mObject ||
+         link.mChild == aLifetime.mObject) &&
+        aLifetime.IsAliveAt(link.mLinkingIndex) && !link.mUnlinkingIndex) {
+      link.mUnlinkingIndex = Some(aIndex);
+    }
+  }
+};
+
+void DDMediaLogs::UnlinkLifetimes(DDLifetime& aParentLifetime,
+                                  DDLifetime& aChildLifetime,
+                                  DDMessageIndex aIndex) {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+  for (DDObjectLink& link : mObjectLinks) {
+    if ((link.mParent == aParentLifetime.mObject &&
+         link.mChild == aChildLifetime.mObject) &&
+        aParentLifetime.IsAliveAt(link.mLinkingIndex) &&
+        aChildLifetime.IsAliveAt(link.mLinkingIndex) && !link.mUnlinkingIndex) {
+      link.mUnlinkingIndex = Some(aIndex);
+    }
+  }
+}
+
+void DDMediaLogs::DestroyLifetimeLinks(const DDLifetime& aLifetime) {
+  mObjectLinks.RemoveElementsBy([&](DDObjectLink& link) {
+    return (link.mParent == aLifetime.mObject ||
+            link.mChild == aLifetime.mObject) &&
+           aLifetime.IsAliveAt(link.mLinkingIndex);
+  });
+}
+
+size_t DDMediaLogs::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
+  size_t size = aMallocSizeOf(this) +
+                // This will usually be called after processing, so negligible
+                // external data should still be present in the queue.
+                mMessagesQueue.ShallowSizeOfExcludingThis(aMallocSizeOf) +
+                mLifetimes.SizeOfExcludingThis(aMallocSizeOf) +
+                mMediaLogs.ShallowSizeOfExcludingThis(aMallocSizeOf) +
+                mObjectLinks.ShallowSizeOfExcludingThis(aMallocSizeOf) +
+                mPendingPromises.ShallowSizeOfExcludingThis(aMallocSizeOf);
+  for (const DDMediaLog& log : mMediaLogs) {
+    size += log.SizeOfExcludingThis(aMallocSizeOf);
+  }
+  return size;
+}
+
+void DDMediaLogs::ProcessBuffer() {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+
+  mMessagesQueue.PopAll([this](const DDLogMessage& message) {
+    DDL_DEBUG("Processing: %s", message.Print().Data());
+
+    // Either this message will carry a new object for which to create a
+    // lifetime, or we'll find an existing one.
+    DDLifetime& lifetime = FindOrCreateLifetime(message.mObject, message.mIndex,
+                                                message.mTimeStamp);
+
+    // Copy the message contents (without the mValid flag) to the
+    // appropriate MediaLog corresponding to the message's object lifetime.
+    LogFor(lifetime.mMediaElement)
+        .mMessages.AppendElement(static_cast<const DDLogMessage&>(message));
+
+    switch (message.mCategory) {
+      case DDLogCategory::_Construction:
+        // The FindOrCreateLifetime above will have set a construction time,
+        // so there's nothing more we need to do here.
+        MOZ_ASSERT(lifetime.mConstructionTimeStamp);
+        break;
+
+      case DDLogCategory::_DerivedConstruction:
+        // The FindOrCreateLifetime above will have set a construction time.
+        MOZ_ASSERT(lifetime.mConstructionTimeStamp);
+        // A derived construction must come with the base object.
+        MOZ_ASSERT(message.mValue.is<DDLogObject>());
+        {
+          const DDLogObject& base = message.mValue.as<DDLogObject>();
+          DDLifetime& baseLifetime =
+              FindOrCreateLifetime(base, message.mIndex, message.mTimeStamp);
+          // FindOrCreateLifetime could have moved `lifetime`.
+          DDLifetime* lifetime2 =
+              mLifetimes.FindLifetime(message.mObject, message.mIndex);
+          MOZ_ASSERT(lifetime2);
+          // Assume there's no multiple-inheritance (at least for the types
+          // we're watching.)
+          if (baseLifetime.mDerivedObject.Pointer()) {
+            DDL_WARN(
+                "base '%s' was already derived as '%s', now deriving as '%s'",
+                baseLifetime.Printf().get(),
+                baseLifetime.mDerivedObject.Printf().get(),
+                lifetime2->Printf().get());
+          }
+          baseLifetime.mDerivedObject = lifetime2->mObject;
+          baseLifetime.mDerivedObjectLinkingIndex = message.mIndex;
+          // Link the base and derived objects, to ensure they go to the same
+          // log.
+          LinkLifetimes(*lifetime2, "is-a", baseLifetime, message.mIndex);
+        }
+        break;
+
+      case DDLogCategory::_Destruction:
+        lifetime.mDestructionIndex = message.mIndex;
+        lifetime.mDestructionTimeStamp = message.mTimeStamp;
+        UnlinkLifetime(lifetime, message.mIndex);
+        break;
+
+      case DDLogCategory::_Link:
+        MOZ_ASSERT(message.mValue.is<DDLogObject>());
+        {
+          const DDLogObject& child = message.mValue.as<DDLogObject>();
+          DDLifetime& childLifetime =
+              FindOrCreateLifetime(child, message.mIndex, message.mTimeStamp);
+          // FindOrCreateLifetime could have moved `lifetime`.
+          DDLifetime* lifetime2 =
+              mLifetimes.FindLifetime(message.mObject, message.mIndex);
+          MOZ_ASSERT(lifetime2);
+          LinkLifetimes(*lifetime2, message.mLabel, childLifetime,
+                        message.mIndex);
+        }
+        break;
+
+      case DDLogCategory::_Unlink:
+        MOZ_ASSERT(message.mValue.is<DDLogObject>());
+        {
+          const DDLogObject& child = message.mValue.as<DDLogObject>();
+          DDLifetime& childLifetime =
+              FindOrCreateLifetime(child, message.mIndex, message.mTimeStamp);
+          // FindOrCreateLifetime could have moved `lifetime`.
+          DDLifetime* lifetime2 =
+              mLifetimes.FindLifetime(message.mObject, message.mIndex);
+          MOZ_ASSERT(lifetime2);
+          UnlinkLifetimes(*lifetime2, childLifetime, message.mIndex);
+        }
+        break;
+
+      default:
+        // Anything else: Nothing more to do.
+        break;
+    }
+  });
+}
+
+void DDMediaLogs::FulfillPromises() {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+
+  MozPromiseHolder<LogMessagesPromise> promiseHolder;
+  const dom::HTMLMediaElement* mediaElement = nullptr;
+  {
+    // Grab the first pending promise (if any).
+    // Note that we don't pop it yet, so we don't potentially leave the list
+    // empty and therefore allow another processing task to be dispatched.
+    MutexAutoLock lock(mMutex);
+    if (mPendingPromises.IsEmpty()) {
+      return;
+    }
+    promiseHolder = std::move(mPendingPromises[0].mPromiseHolder);
+    mediaElement = mPendingPromises[0].mMediaElement;
+  }
+  for (;;) {
+    DDMediaLog* log = GetLogFor(mediaElement);
+    if (!log) {
+      // No such media element -> Reject this promise.
+      DDL_INFO("Rejecting promise for HTMLMediaElement[%p] - Cannot find log",
+               mediaElement);
+      promiseHolder.Reject(NS_ERROR_DOM_MEDIA_NOT_ALLOWED_ERR, __func__);
+      // Pop this rejected promise, fetch next one.
+      MutexAutoLock lock(mMutex);
+      mPendingPromises.RemoveElementAt(0);
+      if (mPendingPromises.IsEmpty()) {
+        break;
+      }
+      promiseHolder = std::move(mPendingPromises[0].mPromiseHolder);
+      mediaElement = mPendingPromises[0].mMediaElement;
+      continue;
+    }
+
+    JSONStringWriteFunc<nsCString> json;
+    JSONWriter jw{json};
+    jw.Start();
+    jw.StartArrayProperty("messages");
+    for (const DDLogMessage& message : log->mMessages) {
+      jw.StartObjectElement(JSONWriter::SingleLineStyle);
+      jw.IntProperty("i", message.mIndex.Value());
+      jw.DoubleProperty("ts", ToSeconds(message.mTimeStamp));
+      DDLifetime* lifetime =
+          mLifetimes.FindLifetime(message.mObject, message.mIndex);
+      if (lifetime) {
+        jw.IntProperty("ob", lifetime->mTag);
+      } else {
+        jw.StringProperty(
+            "ob", nsPrintfCString(R"("%s[%p]")", message.mObject.TypeName(),
+                                  message.mObject.Pointer()));
+      }
+      jw.StringProperty("cat",
+                        MakeStringSpan(ToShortString(message.mCategory)));
+      if (message.mLabel && message.mLabel[0] != '\0') {
+        jw.StringProperty("lbl", MakeStringSpan(message.mLabel));
+      }
+      if (!message.mValue.is<DDNoValue>()) {
+        if (message.mValue.is<DDLogObject>()) {
+          const DDLogObject& ob2 = message.mValue.as<DDLogObject>();
+          DDLifetime* lifetime2 = mLifetimes.FindLifetime(ob2, message.mIndex);
+          if (lifetime2) {
+            jw.IntProperty("val", lifetime2->mTag);
+          } else {
+            ToJSON(message.mValue, jw, "val");
+          }
+        } else {
+          ToJSON(message.mValue, jw, "val");
+        }
+      }
+      jw.EndObject();
+    }
+    jw.EndArray();
+    jw.StartObjectProperty("objects");
+    mLifetimes.Visit(
+        mediaElement,
+        [&](const DDLifetime& lifetime) {
+          jw.StartObjectProperty(nsPrintfCString("%" PRIi32, lifetime.mTag),
+                                 JSONWriter::SingleLineStyle);
+          jw.IntProperty("tag", lifetime.mTag);
+          jw.StringProperty("cls", MakeStringSpan(lifetime.mObject.TypeName()));
+          jw.StringProperty("ptr",
+                            nsPrintfCString("%p", lifetime.mObject.Pointer()));
+          jw.IntProperty("con", lifetime.mConstructionIndex.Value());
+          jw.DoubleProperty("con_ts",
+                            ToSeconds(lifetime.mConstructionTimeStamp));
+          if (lifetime.mDestructionTimeStamp) {
+            jw.IntProperty("des", lifetime.mDestructionIndex.Value());
+            jw.DoubleProperty("des_ts",
+                              ToSeconds(lifetime.mDestructionTimeStamp));
+          }
+          if (lifetime.mDerivedObject.Pointer()) {
+            DDLifetime* derived = mLifetimes.FindLifetime(
+                lifetime.mDerivedObject, lifetime.mDerivedObjectLinkingIndex);
+            if (derived) {
+              jw.IntProperty("drvd", derived->mTag);
+            }
+          }
+          jw.EndObject();
+        },
+        // If there were no (new) messages, only give the main HTMLMediaElement
+        // object (used to identify this log against the correct element.)
+        log->mMessages.IsEmpty());
+    jw.EndObject();
+    jw.End();
+    DDL_DEBUG("RetrieveMessages(%p) ->\n%s", mediaElement,
+              json.StringCRef().get());
+
+    // This log exists (new messages or not) -> Resolve this promise.
+    DDL_INFO("Resolving promise for HTMLMediaElement[%p] with messages %" PRImi
+             "-%" PRImi,
+             mediaElement,
+             log->mMessages.IsEmpty() ? 0 : log->mMessages[0].mIndex.Value(),
+             log->mMessages.IsEmpty()
+                 ? 0
+                 : log->mMessages[log->mMessages.Length() - 1].mIndex.Value());
+    promiseHolder.Resolve(std::move(json).StringRRef(), __func__);
+
+    // Remove exported messages.
+    log->mMessages.Clear();
+
+    // Pop this resolved promise, fetch next one.
+    MutexAutoLock lock(mMutex);
+    mPendingPromises.RemoveElementAt(0);
+    if (mPendingPromises.IsEmpty()) {
+      break;
+    }
+    promiseHolder = std::move(mPendingPromises[0].mPromiseHolder);
+    mediaElement = mPendingPromises[0].mMediaElement;
+  }
+}
+
+void DDMediaLogs::CleanUpLogs() {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+
+  DDTimeStamp now = DDNow();
+
+  // Keep up to 30s of unclassified messages (if a message doesn't get
+  // classified this quickly, it probably never will be.)
+  static const double sMaxAgeUnclassifiedMessages_s = 30.0;
+  // Keep "dead" log (video element and dependents were destroyed) for up to
+  // 2 minutes, in case the user wants to look at it after the facts.
+  static const double sMaxAgeDeadLog_s = 120.0;
+  // Keep old messages related to a live video for up to 5 minutes.
+  static const double sMaxAgeClassifiedMessages_s = 300.0;
+
+  for (size_t logIndexPlus1 = mMediaLogs.Length(); logIndexPlus1 != 0;
+       --logIndexPlus1) {
+    DDMediaLog& log = mMediaLogs[logIndexPlus1 - 1];
+    if (log.mMediaElement) {
+      // Remove logs for which no lifetime still existed some time ago.
+      bool used = mLifetimes.VisitBreakable(
+          log.mMediaElement, [&](const DDLifetime& lifetime) {
+            // Do we still have a lifetime that existed recently enough?
+            return !lifetime.mDestructionTimeStamp ||
+                   (now - lifetime.mDestructionTimeStamp).ToSeconds() <=
+                       sMaxAgeDeadLog_s;
+          });
+      if (!used) {
+        DDL_INFO("Removed old log for media element %p", log.mMediaElement);
+        mLifetimes.Visit(log.mMediaElement, [&](const DDLifetime& lifetime) {
+          DestroyLifetimeLinks(lifetime);
+        });
+        mLifetimes.RemoveLifetimesFor(log.mMediaElement);
+        mMediaLogs.RemoveElementAt(logIndexPlus1 - 1);
+        continue;
+      }
+    }
+
+    // Remove old messages.
+    size_t old = 0;
+    const size_t len = log.mMessages.Length();
+    while (old < len &&
+           (now - log.mMessages[old].mTimeStamp).ToSeconds() >
+               (log.mMediaElement ? sMaxAgeClassifiedMessages_s
+                                  : sMaxAgeUnclassifiedMessages_s)) {
+      ++old;
+    }
+    if (old != 0) {
+      // We are going to remove `old` messages.
+      // First, remove associated destroyed lifetimes that are not used after
+      // these old messages. (We want to keep non-destroyed lifetimes, in
+      // case they get used later on.)
+      size_t removedLifetimes = 0;
+      for (size_t i = 0; i < old; ++i) {
+        auto RemoveDestroyedUnusedLifetime = [&](DDLifetime* lifetime) {
+          if (!lifetime->mDestructionTimeStamp) {
+            // Lifetime is still alive, keep it.
+            return;
+          }
+          bool used = false;
+          for (size_t after = old; after < len; ++after) {
+            const DDLogMessage message = log.mMessages[i];
+            if (!lifetime->IsAliveAt(message.mIndex)) {
+              // Lifetime is already dead, and not used yet -> kill it.
+              break;
+            }
+            const DDLogObject& ob = message.mObject;
+            if (lifetime->mObject == ob) {
+              used = true;
+              break;
+            }
+            if (message.mValue.is<DDLogObject>()) {
+              if (lifetime->mObject == message.mValue.as<DDLogObject>()) {
+                used = true;
+                break;
+              }
+            }
+          }
+          if (!used) {
+            DestroyLifetimeLinks(*lifetime);
+            mLifetimes.RemoveLifetime(lifetime);
+            ++removedLifetimes;
+          }
+        };
+
+        const DDLogMessage message = log.mMessages[i];
+        const DDLogObject& ob = message.mObject;
+
+        DDLifetime* lifetime1 = mLifetimes.FindLifetime(ob, message.mIndex);
+        if (lifetime1) {
+          RemoveDestroyedUnusedLifetime(lifetime1);
+        }
+
+        if (message.mValue.is<DDLogObject>()) {
+          DDLifetime* lifetime2 = mLifetimes.FindLifetime(
+              message.mValue.as<DDLogObject>(), message.mIndex);
+          if (lifetime2) {
+            RemoveDestroyedUnusedLifetime(lifetime2);
+          }
+        }
+      }
+      DDL_INFO("Removed %zu messages (#%" PRImi " %f - #%" PRImi
+               " %f) and %zu lifetimes from log for media element %p",
+               old, log.mMessages[0].mIndex.Value(),
+               ToSeconds(log.mMessages[0].mTimeStamp),
+               log.mMessages[old - 1].mIndex.Value(),
+               ToSeconds(log.mMessages[old - 1].mTimeStamp), removedLifetimes,
+               log.mMediaElement);
+      log.mMessages.RemoveElementsAt(0, old);
+    }
+  }
+}
+
+void DDMediaLogs::ProcessLog() {
+  MOZ_ASSERT(!mThread || mThread.get() == NS_GetCurrentThread());
+  ProcessBuffer();
+  FulfillPromises();
+  CleanUpLogs();
+  DDL_INFO("ProcessLog() completed - DDMediaLog size: %zu",
+           SizeOfIncludingThis(moz_malloc_size_of));
+}
+
+nsresult DDMediaLogs::DispatchProcessLog(const MutexAutoLock& aProofOfLock) {
+  if (!mThread) {
+    return NS_ERROR_SERVICE_NOT_AVAILABLE;
+  }
+  return mThread->Dispatch(
+      NS_NewRunnableFunction("ProcessLog", [this] { ProcessLog(); }),
+      NS_DISPATCH_NORMAL);
+}
+
+nsresult DDMediaLogs::DispatchProcessLog() {
+  DDL_INFO("DispatchProcessLog() - Yet-unprocessed message buffers: %d",
+           mMessagesQueue.LiveBuffersStats().mCount);
+  MutexAutoLock lock(mMutex);
+  return DispatchProcessLog(lock);
+}
+
+RefPtr<DDMediaLogs::LogMessagesPromise> DDMediaLogs::RetrieveMessages(
+    const dom::HTMLMediaElement* aMediaElement) {
+  MozPromiseHolder<LogMessagesPromise> holder;
+  RefPtr<LogMessagesPromise> promise = holder.Ensure(__func__);
+  {
+    MutexAutoLock lock(mMutex);
+    // If there were unfulfilled promises, we know processing has already
+    // been requested.
+    if (mPendingPromises.IsEmpty()) {
+      // But if we're the first one, start processing.
+      nsresult rv = DispatchProcessLog(lock);
+      if (NS_FAILED(rv)) {
+        holder.Reject(rv, __func__);
+      }
+    }
+    mPendingPromises.AppendElement(
+        PendingPromise{std::move(holder), aMediaElement});
+  }
+  return promise;
+}
+
+}  // namespace mozilla