The Tor Browser: comparison xpcom/base/nsMemoryImpl.cpp

--1:000000000000
+:8961c5c467c2
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 "nsMemoryImpl.h"
+#include "nsThreadUtils.h"
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsISimpleEnumerator.h"
+#include "nsCOMPtr.h"
+#include "mozilla/Services.h"
+#ifdef ANDROID
+#include <stdio.h>
+// Minimum memory threshold for a device to be considered
+// a low memory platform. This value has be in sync with
+// Java's equivalent threshold, defined in
+// mobile/android/base/util/HardwareUtils.java
+#define LOW_MEMORY_THRESHOLD_KB (384 * 1024)
+#endif
+static nsMemoryImpl sGlobalMemory;
+NS_IMPL_QUERY_INTERFACE(nsMemoryImpl, nsIMemory)
+NS_IMETHODIMP_(void*)
+nsMemoryImpl::Alloc(size_t size)
+{
+return NS_Alloc(size);
+}
+NS_IMETHODIMP_(void*)
+nsMemoryImpl::Realloc(void* ptr, size_t size)
+{
+return NS_Realloc(ptr, size);
+}
+NS_IMETHODIMP_(void)
+nsMemoryImpl::Free(void* ptr)
+{
+NS_Free(ptr);
+}
+NS_IMETHODIMP
+nsMemoryImpl::HeapMinimize(bool aImmediate)
+{
+return FlushMemory(MOZ_UTF16("heap-minimize"), aImmediate);
+}
+NS_IMETHODIMP
+nsMemoryImpl::IsLowMemory(bool *result)
+{
+NS_ERROR("IsLowMemory is deprecated.  See bug 592308.");
+*result = false;
+return NS_OK;
+}
+NS_IMETHODIMP
+nsMemoryImpl::IsLowMemoryPlatform(bool *result)
+{
+#ifdef ANDROID
+static int sLowMemory = -1; // initialize to unknown, lazily evaluate to 0 or 1
+if (sLowMemory == -1) {
+sLowMemory = 0; // assume "not low memory" in case file operations fail
+*result = false;
+// check if MemTotal from /proc/meminfo is less than LOW_MEMORY_THRESHOLD_KB
+FILE* fd = fopen("/proc/meminfo", "r");
+if (!fd) {
+return NS_OK;
+}
+uint64_t mem = 0;
+int rv = fscanf(fd, "MemTotal: %llu kB", &mem);
+if (fclose(fd)) {
+return NS_OK;
+}
+if (rv != 1) {
+return NS_OK;
+}
+sLowMemory = (mem < LOW_MEMORY_THRESHOLD_KB) ? 1 : 0;
+}
+*result = (sLowMemory == 1);
+#else
+*result = false;
+#endif
+return NS_OK;
+}
+/*static*/ nsresult
+nsMemoryImpl::Create(nsISupports* outer, const nsIID& aIID, void **aResult)
+{
+if (NS_WARN_IF(outer))
+return NS_ERROR_NO_AGGREGATION;
+return sGlobalMemory.QueryInterface(aIID, aResult);
+}
+nsresult
+nsMemoryImpl::FlushMemory(const char16_t* aReason, bool aImmediate)
+{
+nsresult rv = NS_OK;
+if (aImmediate) {
+// They've asked us to run the flusher *immediately*. We've
+// got to be on the UI main thread for us to be able to do
+// that...are we?
+if (!NS_IsMainThread()) {
+NS_ERROR("can't synchronously flush memory: not on UI thread");
+return NS_ERROR_FAILURE;
+}
+}
+bool lastVal = sIsFlushing.exchange(true);
+if (lastVal)
+return NS_OK;
+PRIntervalTime now = PR_IntervalNow();
+// Run the flushers immediately if we can; otherwise, proxy to the
+// UI thread an run 'em asynchronously.
+if (aImmediate) {
+rv = RunFlushers(aReason);
+}
+else {
+// Don't broadcast more than once every 1000ms to avoid being noisy
+if (PR_IntervalToMicroseconds(now - sLastFlushTime) > 1000) {
+sFlushEvent.mReason = aReason;
+rv = NS_DispatchToMainThread(&sFlushEvent, NS_DISPATCH_NORMAL);
+}
+}
+sLastFlushTime = now;
+return rv;
+}
+nsresult
+nsMemoryImpl::RunFlushers(const char16_t* aReason)
+{
+nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+if (os) {
+// Instead of:
+//  os->NotifyObservers(this, "memory-pressure", aReason);
+// we are going to do this manually to see who/what is
+// deallocating.
+nsCOMPtr<nsISimpleEnumerator> e;
+os->EnumerateObservers("memory-pressure", getter_AddRefs(e));
+if ( e ) {
+nsCOMPtr<nsIObserver> observer;
+bool loop = true;
+while (NS_SUCCEEDED(e->HasMoreElements(&loop)) && loop)
+{
+nsCOMPtr<nsISupports> supports;
+e->GetNext(getter_AddRefs(supports));
+if (!supports)
+continue;
+observer = do_QueryInterface(supports);
+observer->Observe(observer, "memory-pressure", aReason);
+}
+}
+}
+sIsFlushing = false;
+return NS_OK;
+}
+// XXX need NS_IMPL_STATIC_ADDREF/RELEASE
+NS_IMETHODIMP_(MozExternalRefCountType) nsMemoryImpl::FlushEvent::AddRef() { return 2; }
+NS_IMETHODIMP_(MozExternalRefCountType) nsMemoryImpl::FlushEvent::Release() { return 1; }
+NS_IMPL_QUERY_INTERFACE(nsMemoryImpl::FlushEvent, nsIRunnable)
+NS_IMETHODIMP
+nsMemoryImpl::FlushEvent::Run()
+{
+sGlobalMemory.RunFlushers(mReason);
+return NS_OK;
+}
+mozilla::Atomic<bool>
+nsMemoryImpl::sIsFlushing;
+PRIntervalTime
+nsMemoryImpl::sLastFlushTime = 0;
+nsMemoryImpl::FlushEvent
+nsMemoryImpl::sFlushEvent;
+XPCOM_API(void*)
+NS_Alloc(size_t size)
+{
+return moz_xmalloc(size);
+}
+XPCOM_API(void*)
+NS_Realloc(void* ptr, size_t size)
+{
+return moz_xrealloc(ptr, size);
+}
+XPCOM_API(void)
+NS_Free(void* ptr)
+{
+moz_free(ptr);
+}
+nsresult
+NS_GetMemoryManager(nsIMemory* *result)
+{
+return sGlobalMemory.QueryInterface(NS_GET_IID(nsIMemory), (void**) result);
+}

The Tor Browser / file comparison

comparison: xpcom/base/nsMemoryImpl.cpp

xpcom/base/nsMemoryImpl.cpp