The Tor Browser: xpcom/base/nsMemoryImpl.cpp@6474c204b198 (annotated)

xpcom/base/nsMemoryImpl.cpp@6474c204b198 (annotated)

xpcom/base/nsMemoryImpl.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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 / annotate

xpcom/base/nsMemoryImpl.cpp@6474c204b198 (annotated)

xpcom/base/nsMemoryImpl.cpp