The Tor Browser: comparison image/src/DiscardTracker.cpp

--1:000000000000
+:e3c77e651c9a
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "nsComponentManagerUtils.h"
+#include "nsITimer.h"
+#include "RasterImage.h"
+#include "DiscardTracker.h"
+#include "mozilla/Preferences.h"
+namespace mozilla {
+namespace image {
+static const char* sDiscardTimeoutPref = "image.mem.min_discard_timeout_ms";
+/* static */ LinkedList<DiscardTracker::Node> DiscardTracker::sDiscardableImages;
+/* static */ nsCOMPtr<nsITimer> DiscardTracker::sTimer;
+/* static */ bool DiscardTracker::sInitialized = false;
+/* static */ bool DiscardTracker::sTimerOn = false;
+/* static */ Atomic<bool> DiscardTracker::sDiscardRunnablePending(false);
+/* static */ uint64_t DiscardTracker::sCurrentDecodedImageBytes = 0;
+/* static */ uint32_t DiscardTracker::sMinDiscardTimeoutMs = 10000;
+/* static */ uint32_t DiscardTracker::sMaxDecodedImageKB = 42 * 1024;
+/* static */ uint32_t DiscardTracker::sHardLimitDecodedImageKB = 0;
+/* static */ PRLock * DiscardTracker::sAllocationLock = nullptr;
+/* static */ mozilla::Mutex* DiscardTracker::sNodeListMutex = nullptr;
+/* static */ Atomic<bool> DiscardTracker::sShutdown(false);
+/*
+* When we notice we're using too much memory for decoded images, we enqueue a
+* DiscardRunnable, which runs this code.
+*/
+NS_IMETHODIMP
+DiscardTracker::DiscardRunnable::Run()
+{
+sDiscardRunnablePending = false;
+DiscardTracker::DiscardNow();
+return NS_OK;
+}
+void
+DiscardTimeoutChangedCallback(const char* aPref, void *aClosure)
+{
+DiscardTracker::ReloadTimeout();
+}
+nsresult
+DiscardTracker::Reset(Node *node)
+{
+// We shouldn't call Reset() with a null |img| pointer, on images which can't
+// be discarded, or on animated images (which should be marked as
+// non-discardable, anyway).
+MutexAutoLock lock(*sNodeListMutex);
+MOZ_ASSERT(sInitialized);
+MOZ_ASSERT(node->img);
+MOZ_ASSERT(node->img->CanDiscard());
+MOZ_ASSERT(!node->img->mAnim);
+// Insert the node at the front of the list and note when it was inserted.
+bool wasInList = node->isInList();
+if (wasInList) {
+node->remove();
+}
+node->timestamp = TimeStamp::Now();
+sDiscardableImages.insertFront(node);
+// If the node wasn't already in the list of discardable images, then we may
+// need to discard some images to stay under the sMaxDecodedImageKB limit.
+// Call MaybeDiscardSoon to do this check.
+if (!wasInList) {
+MaybeDiscardSoon();
+}
+// Make sure the timer is running.
+nsresult rv = EnableTimer();
+NS_ENSURE_SUCCESS(rv,rv);
+return NS_OK;
+}
+void
+DiscardTracker::Remove(Node *node)
+{
+if (sShutdown) {
+// Already shutdown. List should be empty, so just return.
+return;
+}
+MutexAutoLock lock(*sNodeListMutex);
+if (node->isInList())
+node->remove();
+if (sDiscardableImages.isEmpty())
+DisableTimer();
+}
+/**
+* Shut down the tracker, deallocating the timer.
+*/
+void
+DiscardTracker::Shutdown()
+{
+sShutdown = true;
+if (sTimer) {
+sTimer->Cancel();
+sTimer = nullptr;
+}
+// Clear the sDiscardableImages linked list so that its destructor
+// (LinkedList.h) finds an empty array, which is required after bug 803688.
+DiscardAll();
+delete sNodeListMutex;
+sNodeListMutex = nullptr;
+}
+/*
+* Discard all the images we're tracking.
+*/
+void
+DiscardTracker::DiscardAll()
+{
+MutexAutoLock lock(*sNodeListMutex);
+if (!sInitialized)
+return;
+// Be careful: Calling Discard() on an image might cause it to be removed
+// from the list!
+Node *n;
+while ((n = sDiscardableImages.popFirst())) {
+n->img->Discard();
+}
+// The list is empty, so there's no need to leave the timer on.
+DisableTimer();
+}
+/* static */ bool
+DiscardTracker::TryAllocation(uint64_t aBytes)
+{
+MOZ_ASSERT(sInitialized);
+PR_Lock(sAllocationLock);
+bool enoughSpace =
+!sHardLimitDecodedImageKB ||
+(sHardLimitDecodedImageKB * 1024) - sCurrentDecodedImageBytes >= aBytes;
+if (enoughSpace) {
+sCurrentDecodedImageBytes += aBytes;
+}
+PR_Unlock(sAllocationLock);
+// If we're using too much memory for decoded images, MaybeDiscardSoon will
+// enqueue a callback to discard some images.
+MaybeDiscardSoon();
+return enoughSpace;
+}
+/* static */ void
+DiscardTracker::InformDeallocation(uint64_t aBytes)
+{
+// This function is called back e.g. from RasterImage::Discard(); be careful!
+MOZ_ASSERT(sInitialized);
+PR_Lock(sAllocationLock);
+MOZ_ASSERT(aBytes <= sCurrentDecodedImageBytes);
+sCurrentDecodedImageBytes -= aBytes;
+PR_Unlock(sAllocationLock);
+}
+/**
+* Initialize the tracker.
+*/
+nsresult
+DiscardTracker::Initialize()
+{
+// Watch the timeout pref for changes.
+Preferences::RegisterCallback(DiscardTimeoutChangedCallback,
+sDiscardTimeoutPref);
+Preferences::AddUintVarCache(&sMaxDecodedImageKB,
+"image.mem.max_decoded_image_kb",
+50 * 1024);
+Preferences::AddUintVarCache(&sHardLimitDecodedImageKB,
+"image.mem.hard_limit_decoded_image_kb",
+0);
+// Create the timer.
+sTimer = do_CreateInstance("@mozilla.org/timer;1");
+// Create a lock for safegarding the 64-bit sCurrentDecodedImageBytes
+sAllocationLock = PR_NewLock();
+// Create a lock for the node list.
+MOZ_ASSERT(!sNodeListMutex);
+sNodeListMutex = new Mutex("image::DiscardTracker");
+// Mark us as initialized
+sInitialized = true;
+// Read the timeout pref and start the timer.
+ReloadTimeout();
+return NS_OK;
+}
+/**
+* Read the discard timeout from about:config.
+*/
+void
+DiscardTracker::ReloadTimeout()
+{
+// Read the timeout pref.
+int32_t discardTimeout;
+nsresult rv = Preferences::GetInt(sDiscardTimeoutPref, &discardTimeout);
+// If we got something bogus, return.
+if (!NS_SUCCEEDED(rv) || discardTimeout <= 0)
+return;
+// If the value didn't change, return.
+if ((uint32_t) discardTimeout == sMinDiscardTimeoutMs)
+return;
+// Update the value.
+sMinDiscardTimeoutMs = (uint32_t) discardTimeout;
+// Restart the timer so the new timeout takes effect.
+DisableTimer();
+EnableTimer();
+}
+/**
+* Enables the timer. No-op if the timer is already running.
+*/
+nsresult
+DiscardTracker::EnableTimer()
+{
+// Nothing to do if the timer's already on or we haven't yet been
+// initialized.  !sTimer probably means we've shut down, so just ignore that,
+// too.
+if (sTimerOn || !sInitialized || !sTimer)
+return NS_OK;
+sTimerOn = true;
+// Activate the timer.  Have it call us back in (sMinDiscardTimeoutMs / 2)
+// ms, so that an image is discarded between sMinDiscardTimeoutMs and
+// (3/2 * sMinDiscardTimeoutMs) ms after it's unlocked.
+return sTimer->InitWithFuncCallback(TimerCallback,
+nullptr,
+sMinDiscardTimeoutMs / 2,
+nsITimer::TYPE_REPEATING_SLACK);
+}
+/*
+* Disables the timer. No-op if the timer isn't running.
+*/
+void
+DiscardTracker::DisableTimer()
+{
+// Nothing to do if the timer's already off.
+if (!sTimerOn || !sTimer)
+return;
+sTimerOn = false;
+// Deactivate
+sTimer->Cancel();
+}
+/**
+* Routine activated when the timer fires. This discards everything that's
+* older than sMinDiscardTimeoutMs, and tries to discard enough images so that
+* we go under sMaxDecodedImageKB.
+*/
+void
+DiscardTracker::TimerCallback(nsITimer *aTimer, void *aClosure)
+{
+DiscardNow();
+}
+void
+DiscardTracker::DiscardNow()
+{
+// Assuming the list is ordered with oldest discard tracker nodes at the back
+// and newest ones at the front, iterate from back to front discarding nodes
+// until we encounter one which is new enough to keep and until we go under
+// our sMaxDecodedImageKB limit.
+TimeStamp now = TimeStamp::Now();
+Node* node;
+while ((node = sDiscardableImages.getLast())) {
+if ((now - node->timestamp).ToMilliseconds() > sMinDiscardTimeoutMs ||
+sCurrentDecodedImageBytes > sMaxDecodedImageKB * 1024) {
+// Discarding the image should cause sCurrentDecodedImageBytes to
+// decrease via a call to InformDeallocation().
+node->img->Discard();
+// Careful: Discarding may have caused the node to have been removed
+// from the list.
+Remove(node);
+}
+else {
+break;
+}
+}
+// If the list is empty, disable the timer.
+if (sDiscardableImages.isEmpty())
+DisableTimer();
+}
+void
+DiscardTracker::MaybeDiscardSoon()
+{
+// Are we carrying around too much decoded image data?  If so, enqueue an
+// event to try to get us down under our limit.
+if (sCurrentDecodedImageBytes > sMaxDecodedImageKB * 1024 &&
+!sDiscardableImages.isEmpty()) {
+// Check if the value of sDiscardRunnablePending used to be false
+if (!sDiscardRunnablePending.exchange(true)) {
+nsRefPtr<DiscardRunnable> runnable = new DiscardRunnable();
+NS_DispatchToMainThread(runnable);
+}
+}
+}
+} // namespace image
+} // namespace mozilla

The Tor Browser / file comparison

comparison: image/src/DiscardTracker.cpp

image/src/DiscardTracker.cpp