Bug 964039 - Memory used by the new cache backend is not reported, r=michal

Author: mayhemer

netwerk/cache2/CacheEntry.cpp

@@ -15,6 +15,7 @@
 #include "nsICacheStorage.h"
 #include "nsISerializable.h"
 #include "nsIStreamTransportService.h"
+#include "nsISizeOf.h"
 
 #include "nsComponentManagerUtils.h"
 #include "nsServiceManagerUtils.h"
@@ -1545,5 +1546,40 @@ NS_IMETHODIMP CacheOutputCloseListener::Run()
   return NS_OK;
 }
 
+// Memory reporting
+
+size_t CacheEntry::SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+{
+  size_t n = 0;
+  nsCOMPtr<nsISizeOf> sizeOf;
+
+  n += mCallbacks.SizeOfExcludingThis(mallocSizeOf);
+  if (mFile) {
+    n += mFile->SizeOfIncludingThis(mallocSizeOf);
+  }
+
+  sizeOf = do_QueryInterface(mURI);
+  if (sizeOf) {
+    n += sizeOf->SizeOfIncludingThis(mallocSizeOf);
+  }
+
+  n += mEnhanceID.SizeOfExcludingThisIfUnshared(mallocSizeOf);
+  n += mStorageID.SizeOfExcludingThisIfUnshared(mallocSizeOf);
+
+  // mDoomCallback is an arbitrary class that is probably reported elsewhere.
+  // mOutputStream is reported in mFile.
+  // mWriter is one of many handles we create, but (intentionally) not keep
+  // any reference to, so those unfortunatelly cannot be reported.  Handles are
+  // small, though.
+  // mSecurityInfo doesn't impl nsISizeOf.
+
+  return n;
+}
+
+size_t CacheEntry::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+{
+  return mallocSizeOf(this) + SizeOfExcludingThis(mallocSizeOf);
+}
+
 } // net
 } // mozilla

netwerk/cache2/CacheEntry.h

@@ -105,6 +105,10 @@ class CacheEntry : public nsICacheEntry
   double mFrecency;
   uint32_t mSortingExpirationTime;
 
+  // Memory reporting
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
 private:
   virtual ~CacheEntry();
 

netwerk/cache2/CacheFile.cpp

@@ -933,7 +933,7 @@ CacheFile::Unlock()
 }
 
 void
-CacheFile::AssertOwnsLock()
+CacheFile::AssertOwnsLock() const
 {
   mLock.AssertCurrentThreadOwns();
 }
@@ -1578,5 +1578,57 @@ CacheFile::InitIndexEntry()
   return NS_OK;
 }
 
+// Memory reporting
+
+namespace { // anon
+
+size_t
+CollectChunkSize(uint32_t const & aIdx,
+                 nsRefPtr<mozilla::net::CacheFileChunk> const & aChunk,
+                 mozilla::MallocSizeOf mallocSizeOf, void* aClosure)
+{
+  return aChunk->SizeOfIncludingThis(mallocSizeOf);
+}
+
+} // anon
+
+size_t
+CacheFile::SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+{
+  CacheFileAutoLock lock(const_cast<CacheFile*>(this));
+
+  size_t n = 0;
+  n += mChunks.SizeOfExcludingThis(CollectChunkSize, mallocSizeOf);
+  n += mCachedChunks.SizeOfExcludingThis(CollectChunkSize, mallocSizeOf);
+  if (mMetadata) {
+    n += mMetadata->SizeOfIncludingThis(mallocSizeOf);
+  }
+
+  // Input streams are not elsewhere reported.
+  n += mInputs.SizeOfExcludingThis(mallocSizeOf);
+  for (uint32_t i = 0; i < mInputs.Length(); ++i) {
+    n += mInputs[i]->SizeOfIncludingThis(mallocSizeOf);
+  }
+
+  // Output streams are not elsewhere reported.
+  if (mOutput) {
+    n += mOutput->SizeOfIncludingThis(mallocSizeOf);
+  }
+
+  // The listeners are usually classes reported just above.
+  n += mChunkListeners.SizeOfExcludingThis(nullptr, mallocSizeOf);
+  n += mObjsToRelease.SizeOfExcludingThis(mallocSizeOf);
+
+  // mHandle reported directly from CacheFileIOManager.
+
+  return n;
+}
+
+size_t
+CacheFile::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+{
+  return mallocSizeOf(this) + SizeOfExcludingThis(mallocSizeOf);
+}
+
 } // net
 } // mozilla

netwerk/cache2/CacheFile.h

@@ -99,6 +99,10 @@ class CacheFile : public CacheFileChunkListener
   void Key(nsACString& aKey) { aKey = mKey; }
   bool IsDoomed();
 
+  // Memory reporting
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+
 private:
   friend class CacheFileIOManager;
   friend class CacheFileChunk;
@@ -111,7 +115,7 @@ class CacheFile : public CacheFileChunkListener
 
   void     Lock();
   void     Unlock();
-  void     AssertOwnsLock();
+  void     AssertOwnsLock() const;
   void     ReleaseOutsideLock(nsISupports *aObject);
 
   nsresult GetChunk(uint32_t aIndex, bool aWriter,

netwerk/cache2/CacheFileChunk.cpp

@@ -597,23 +597,23 @@ CacheFileChunk::OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult)
 }
 
 bool
-CacheFileChunk::IsReady()
+CacheFileChunk::IsReady() const
 {
   mFile->AssertOwnsLock();
 
   return (mState == READY || mState == WRITING);
 }
 
 bool
-CacheFileChunk::IsDirty()
+CacheFileChunk::IsDirty() const
 {
   mFile->AssertOwnsLock();
 
   return mIsDirty;
 }
 
 char *
-CacheFileChunk::BufForWriting()
+CacheFileChunk::BufForWriting() const
 {
   mFile->AssertOwnsLock();
 
@@ -627,7 +627,7 @@ CacheFileChunk::BufForWriting()
 }
 
 const char *
-CacheFileChunk::BufForReading()
+CacheFileChunk::BufForReading() const
 {
   mFile->AssertOwnsLock();
 
@@ -677,5 +677,24 @@ CacheFileChunk::EnsureBufSize(uint32_t aBufSize)
   DoMemoryReport(MemorySize());
 }
 
+// Memory reporting
+
+size_t
+CacheFileChunk::SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+{
+  size_t n = 0;
+  n += mallocSizeOf(mBuf);
+  n += mallocSizeOf(mRWBuf);
+  n += mValidityMap.SizeOfExcludingThis(mallocSizeOf);
+
+  return n;
+}
+
+size_t
+CacheFileChunk::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
+{
+  return mallocSizeOf(this) + SizeOfExcludingThis(mallocSizeOf);
+}
+
 } // net
 } // mozilla

netwerk/cache2/CacheFileChunk.h

@@ -94,13 +94,17 @@ class CacheFileChunk : public CacheFileIOListener
   NS_IMETHOD OnEOFSet(CacheFileHandle *aHandle, nsresult aResult);
   NS_IMETHOD OnFileRenamed(CacheFileHandle *aHandle, nsresult aResult);
 
-  bool   IsReady();
-  bool   IsDirty();
+  bool   IsReady() const;
+  bool   IsDirty() const;
 
-  char *       BufForWriting();
-  const char * BufForReading();
+  char *       BufForWriting() const;
+  const char * BufForReading() const;
   void         EnsureBufSize(uint32_t aBufSize);
-  uint32_t     MemorySize() { return mRWBufSize + mBufSize; }
+  uint32_t     MemorySize() const { return mRWBufSize + mBufSize; }
+
+  // Memory reporting
+  size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
+  size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
 
 private:
   friend class CacheFileInputStream;