removed the report of db filesize in GetStorageInUse.

git-svn-id: svn://10.0.0.236/branches/CacheIntegration_BRANCH@55763 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/netwerk/cache/build/Makefile.in

@@ -22,8 +22,8 @@ VPATH		= @srcdir@
 
 include $(DEPTH)/config/autoconf.mk
 
-MODULE		= nkcache
-LIBRARY_NAME	= nkcache
+MODULE		= nkcacke
+LIBRARY_NAME	= necko_cache
 IS_COMPONENT	= 1
 
 CPPSRCS		= nsNetDataCacheModule.cpp

mozilla/netwerk/cache/filecache/Makefile.in

@@ -35,7 +35,11 @@ REQUIRES	= nspr dbm
 
 EXTRA_DSO_LDOPTS  +=  -L$(DIST)/lib  -lmozdbm_s
 
-EXPORTS=nsNetDiskCacheCID.h
+EXPORTS=nsNetDiskCacheCID.h \
+	nsNetDiskCache.h \
+	nsIDBAccessor.h \
+	nsDBAccessor.h \
+	$(NULL)
 
 CPPSRCS		= \
         nsDBAccessor.cpp\

mozilla/netwerk/cache/filecache/nsDBAccessor.cpp

@@ -1,4 +1,5 @@
-/*
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
  * The contents of this file are subject to the Mozilla Public
  * License Version 1.1 (the "License"); you may not use this file
  * except in compliance with the License. You may obtain a copy of
@@ -20,7 +21,19 @@
  *                 Carl Wong <carl.wong@intel.com>
  */
 
-// FUR - Add overall description comment here
+/*
+ * This file is part of filecache implementation.
+ * 
+ * nsIDBAccessor is a interface that shields all the direct database access 
+ * method from nsNetDiskCache. 
+ * 
+ * nsDBAccessor is a implementation of the nsIDBAccessor interface. It
+ * uses dbm(Berkely) as the database. 
+ * 
+ * a nsDiskCacheRecord is mapped into two entries in the database, 
+ *    key->recordID
+ *    recordID->metadata
+ */
 
 #include "nsDBAccessor.h"
 #include "nscore.h"
@@ -28,20 +41,21 @@
 #include "prtypes.h"
 #include "plhash.h"
 #include "nsCRT.h"
-#include "nsAutoLock.h"
 
 nsDBAccessor::nsDBAccessor() :
   mDB(0) ,
+  mDBFile(0) ,
   mSessionID(0) ,
-  mSessionCntr(0)
+  mSessionCntr(0) ,
+  mDBFilesize(0) 
 {
+  mLastSyncTime = PR_IntervalNow() ;
 
   NS_INIT_REFCNT();
 }
 
 nsDBAccessor::~nsDBAccessor()
 {
-  printf(" ~nsDBAccessor\n") ;
   Shutdown() ;
 }
 
@@ -57,15 +71,12 @@ NS_IMPL_ISUPPORTS(nsDBAccessor, NS_GET_IID(nsIDBAccessor))
 NS_IMETHODIMP
 nsDBAccessor::Init(nsIFileSpec* dbfile)
 {
-  // FUR - lock not needed
-  m_Lock = PR_NewLock() ;
-  if(!m_Lock)
-    return NS_ERROR_OUT_OF_MEMORY ;
-
   char* dbname ;
 
   // this should cover all platforms. 
   dbfile->GetNativePath(&dbname) ;
+  
+  mDBFile = dbfile ;
 
   // FUR - how is page size chosen ?  It's worth putting a comment
   // in here about the possible usefulness of tuning these parameters
@@ -77,27 +88,22 @@ nsDBAccessor::Init(nsIFileSpec* dbfile)
     0 ,       /* hash function */
     0} ;      /* byte order */
 
-  // FUR - lock not needed
-  nsAutoLock lock(m_Lock) ;
-
   mDB = dbopen(dbname,
                O_RDWR | O_CREAT ,
                0600 ,
                DB_HASH ,
                & hash_info) ;
 
-  // FUR - does dbname have to be free'ed ?
+  nsCRT::free(dbname) ;
 
   if(!mDB)
     return NS_ERROR_FAILURE ;
 
   // set mSessionID
-  // FUR - Why the +1 ?  (No need for key to be NUL-terminated string.)
-  PRUint32 len = PL_strlen(SessionKey)+1 ;
   DBT db_key, db_data ;
 
   db_key.data = NS_CONST_CAST(char*, SessionKey) ;
-  db_key.size = len ;
+  db_key.size = PL_strlen(SessionKey) ;
 
   int status = (*mDB->get)(mDB, &db_key, &db_data, 0) ;
   if(status == -1) {
@@ -113,8 +119,6 @@ nsDBAccessor::Init(nsIFileSpec* dbfile)
       return NS_ERROR_FAILURE ;
     }
 
-    // FUR - need to comment out all printfs, or turn them into PR_LOG statements
-    printf("found previous session, id = %d\n", *old_ID) ;
     mSessionID = *old_ID + 1 ;
   } 
   else if(status == 1) {
@@ -126,14 +130,18 @@ nsDBAccessor::Init(nsIFileSpec* dbfile)
 
   // store the new session id
   status = (*mDB->put)(mDB, &db_key, &db_data, 0) ;
+
   if(status == 0) {
     (*mDB->sync)(mDB, 0) ;
-    return NS_OK ;
+
+    // initialize database filesize
+    return mDBFile->GetFileSize(&mDBFilesize) ;
   } 
   else {
     NS_ERROR("reset session ID failure.") ;
     return NS_ERROR_FAILURE ;
   }
+  
 }
 
 NS_IMETHODIMP
@@ -145,9 +153,6 @@ nsDBAccessor::Shutdown(void)
     mDB = nsnull ;
   }
 
-  // FUR - locks not necessary
-  if(m_Lock) 
-    PR_DestroyLock(m_Lock);
   return NS_OK ;
 }
   
@@ -162,8 +167,6 @@ nsDBAccessor::Get(PRInt32 aID, void** anEntry, PRUint32 *aLength)
 
   NS_ASSERTION(mDB, "no database") ;
 
-  // Lock the db
-  nsAutoLock lock(m_Lock) ;
   DBT db_key, db_data ;
 
   db_key.data = NS_REINTERPRET_CAST(void*, &aID) ;
@@ -189,8 +192,6 @@ nsDBAccessor::Put(PRInt32 aID, void* anEntry, PRUint32 aLength)
 {
   NS_ASSERTION(mDB, "no database") ;
 
-  // Lock the db
-  nsAutoLock lock(m_Lock) ;
   DBT db_key, db_data ;
 
   db_key.data = NS_REINTERPRET_CAST(void*, &aID) ;
@@ -200,15 +201,9 @@ nsDBAccessor::Put(PRInt32 aID, void* anEntry, PRUint32 aLength)
   db_data.size = aLength ;
 
   if(0 == (*mDB->put)(mDB, &db_key, &db_data, 0)) {
-    // FUR - I would avoid unnecessary sync'ing for performance's
-    // sake.  Maybe you could limit sync to max rate of, say, once
-    // every few seconds by keeping track of last sync time, using PR_Now().
-    (*mDB->sync)(mDB, 0) ;
-    return NS_OK ;
+    return Sync() ;
   }
   else {
-    // FUR - Try to avoid using NS_ERROR unless error is unrecoverable and serious
-    NS_ERROR("ERROR: Failed to put anEntry into db.\n") ;
     return NS_ERROR_FAILURE ;
   }
 }
@@ -222,9 +217,6 @@ nsDBAccessor::Del(PRInt32 aID, void* anEntry, PRUint32 aLength)
 {
   NS_ASSERTION(mDB, "no database") ;
 
-  // FUR - no locks necessary
-  // Lock the db
-  nsAutoLock lock(m_Lock) ;
   DBT db_key ;
 
   // delete recordID->metadata
@@ -235,8 +227,6 @@ nsDBAccessor::Del(PRInt32 aID, void* anEntry, PRUint32 aLength)
   status = (*mDB->del)(mDB, &db_key, 0) ;
 
   if(-1 == status) {
-    // FUR - no printf's, use PR_LOG, NS_WARNING, or NS_ASSERTION, as the situation warrants
-    printf(" delete error\n") ;
     return NS_ERROR_FAILURE ;
   } 
 
@@ -245,15 +235,10 @@ nsDBAccessor::Del(PRInt32 aID, void* anEntry, PRUint32 aLength)
   db_key.size = aLength ;
   status = (*mDB->del)(mDB, &db_key, 0) ;
   if(-1 == status) {
-    // FUR - no printf's
-    printf(" delete error\n") ;
     return NS_ERROR_FAILURE ;
   } 
 
-  // FUR - Defer sync ?  See above
-  (*mDB->sync)(mDB, 0) ;
-
-  return NS_OK ;
+  return Sync() ;
 }
 
 NS_IMETHODIMP
@@ -261,9 +246,6 @@ nsDBAccessor::GetID(const char* key, PRUint32 length, PRInt32* aID)
 {
   NS_ASSERTION(mDB, "no database") ;
 
-  // Lock the db
-  nsAutoLock lock(m_Lock) ;
-
   DBT db_key, db_data ;
 
   db_key.data = NS_CONST_CAST(char*, key) ;
@@ -289,10 +271,8 @@ nsDBAccessor::GetID(const char* key, PRUint32 length, PRInt32* aID)
       NS_ERROR("updating db failure.") ;
       return NS_ERROR_FAILURE ;
     }
-    // FUR - defer sync ?
-    (*mDB->sync)(mDB, 0) ;
     *aID = id ;
-    return NS_OK ;
+    return Sync() ;
   } 
   else {
     NS_ERROR("ERROR: keydb failure.") ;
@@ -318,12 +298,9 @@ nsDBAccessor::EnumEntry(void** anEntry, PRUint32* aLength, PRBool bReset)
   else
     flag = R_NEXT ;
 
-  // Lock the db
-  nsAutoLock lock(m_Lock) ;
   DBT db_key, db_data ;
 
-  // FUR - +1 unnecessary ?
-  PRUint32 len = PL_strlen(SessionKey)+1 ;
+  PRUint32 len = PL_strlen(SessionKey) ;
 
   int status ;
 
@@ -349,3 +326,91 @@ nsDBAccessor::EnumEntry(void** anEntry, PRUint32* aLength, PRBool bReset)
   }
   return NS_OK ;
 }
+
+/*
+ * returns the cached database file size.
+ * mDBFilesize will be updated during Sync().
+ */
+NS_IMETHODIMP
+nsDBAccessor::GetDBFilesize(PRUint32* aSize)
+{
+  *aSize = mDBFilesize ;
+  return NS_OK ; 
+}
+
+NS_IMETHODIMP
+nsDBAccessor::GetSpecialEntry(void** anEntry, PRUint32* aLength)
+{
+  if(!anEntry)
+    return NS_ERROR_NULL_POINTER ;
+
+  *anEntry = nsnull ;
+  *aLength = 0 ;
+
+  DBT db_key, db_data ;
+
+  db_key.data = NS_CONST_CAST(char*, SpecialEntry) ;
+  db_key.size = PL_strlen(SpecialEntry) ;
+
+  int status = (*mDB->get)(mDB, &db_key, &db_data, 0) ;
+
+  if(status == -1) {
+    NS_ERROR("ERROR: failed get special entry in database.") ;
+    return NS_ERROR_FAILURE ;
+  }
+
+  if(status == 0) {
+    *anEntry = db_data.data ;
+    *aLength = db_data.size ;
+  } 
+  
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDBAccessor::SetSpecialEntry(void* anEntry, PRUint32 aLength)
+{
+  DBT db_key, db_data ;
+
+  db_key.data = NS_CONST_CAST(char*, SpecialEntry) ;
+  db_key.size = PL_strlen(SpecialEntry) ;
+
+  db_data.data = anEntry ;
+  db_data.size = aLength ;
+
+  if(0 == (*mDB->put)(mDB, &db_key, &db_data, 0)) {
+    (*mDB->sync)(mDB, 0) ;
+    return NS_OK ;
+  }
+  else {
+    return NS_ERROR_FAILURE ;
+  }
+}
+
+/*
+ * sync routine is only called when the SyncInterval is reached. Otherwise
+ * it just returns. If db synced, the filesize will be updated at the
+ * same time.
+ */
+nsresult
+nsDBAccessor::Sync(void)
+{
+  PRIntervalTime time = PR_IntervalNow() ;
+  PRIntervalTime duration = time - mLastSyncTime ;
+  
+  if (PR_IntervalToMilliseconds(duration) > SyncInterval) {
+    int status = (*mDB->sync)(mDB, 0) ;
+    if(status == 0) {
+//      printf("\tsynced\n") ;
+      mLastSyncTime = time ;
+      
+      // update db filesize here
+      return mDBFile->GetFileSize(&mDBFilesize) ;
+      
+    } else
+      return NS_ERROR_FAILURE ;
+  } else {
+//    printf("\tnot synced\n") ;
+    return NS_OK ;
+  }
+}

mozilla/netwerk/cache/filecache/nsDBAccessor.h

@@ -1,4 +1,5 @@
-/*
+/*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
  * The contents of this file are subject to the Mozilla Public
  * License Version 1.1 (the "License"); you may not use this file
  * except in compliance with the License. You may obtain a copy of
@@ -20,21 +21,36 @@
  *                 Carl Wong <carl.wong@intel.com>
  */
 
-// FUR - Add overall description comment here
+/*
+ * This file is part of filecache implementation.
+ * 
+ * nsIDBAccessor is a interface that shields all the direct database access 
+ * method from nsNetDiskCache. 
+ * 
+ * nsDBAccessor is a implementation of the nsIDBAccessor interface. It
+ * uses dbm(Berkely) as the database. 
+ *
+ */
 
 #ifndef _NSIDBACCESSOR_H_
 #define _NSIDBACCESSOR_H_
 
 #include "nsIDBAccessor.h"
 #include "mcom_db.h"
+#include "prinrval.h"
+#include "nsCOMPtr.h"
 
 // bogus string for the key of session id 
-// FUR - suggest "SK" instead of "^^"
-static const char * const SessionKey = "^^" ;
+static const char * const SessionKey = "SK" ;
+
+// bogus string for the size 
+static const char * const SpecialEntry = "SE" ;
 
 // initial session id number 
 static const PRInt16 ini_sessionID = 0xff ;
 
+static const PRUint16 SyncInterval = 1000 ;
+
 class nsDBAccessor : public nsIDBAccessor
 {
   public:
@@ -55,14 +71,23 @@ class nsDBAccessor : public nsIDBAccessor
   NS_IMETHOD GetID(const char* key, PRUint32 length, PRInt32* aID) ;
 
   NS_IMETHOD EnumEntry(void* *anEntry, PRUint32* aLength, PRBool bReset) ;
+  
+  NS_IMETHOD GetDBFilesize(PRUint32* aSize) ;
+  
+  NS_IMETHOD GetSpecialEntry(void** anEntry, PRUint32 *aLength) ;
+  NS_IMETHOD SetSpecialEntry(void* anEntry, PRUint32 aLength) ;
 
   protected:
+  nsresult Sync(void) ;
 
   private:
   DB *                          mDB ;
+  nsCOMPtr<nsIFileSpec>         mDBFile ;
   PRInt16                       mSessionID ;
   PRInt16                       mSessionCntr ;
-  PRLock *                      m_Lock ;
+  PRIntervalTime                mLastSyncTime ;
+  PRUint32                      mDBFilesize ; // cached DB filesize, 
+                                              // updated on every sync for now
 } ;
 
 #endif // _NSIDBACCESSOR_H_

mozilla/netwerk/cache/filecache/nsDBEnumerator.cpp

@@ -1,4 +1,5 @@
-/*
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
  * The contents of this file are subject to the Mozilla Public
  * License Version 1.1 (the "License"); you may not use this file
  * except in compliance with the License. You may obtain a copy of
@@ -20,7 +21,11 @@
  *                 Carl Wong <carl.wong@intel.com>
  */
 
-// FUR - Add overall description comment here
+/*
+ * This file is part of filecache implementation.
+ *
+ * It implements a simple iterator for the database, see nsDBAccessor. 
+ */
 
 #include "nsDBEnumerator.h"
 #include "nsDiskCacheRecord.h"
@@ -28,10 +33,10 @@
 nsDBEnumerator::nsDBEnumerator(nsIDBAccessor* aDB, nsNetDiskCache* aCache) :
   m_DB(aDB) ,
   m_DiskCache(aCache) ,
-  tempEntry(0) ,
-  tempEntry_length(0) ,
+  m_tempEntry(0) ,
+  m_tempEntry_length(0) ,
   m_CacheEntry(0) ,
-  bReset(PR_TRUE) 
+  m_bReset(PR_TRUE) 
 {
   NS_INIT_REFCNT();
 
@@ -39,7 +44,6 @@ nsDBEnumerator::nsDBEnumerator(nsIDBAccessor* aDB, nsNetDiskCache* aCache) :
 
 nsDBEnumerator::~nsDBEnumerator()
 {
-//  printf(" ~nsDBEnumerator()\n") ;
   NS_IF_RELEASE(m_CacheEntry) ;
 }
 
@@ -56,10 +60,17 @@ nsDBEnumerator::HasMoreElements(PRBool *_retval)
 {
   *_retval = PR_FALSE ;
 
-  m_DB->EnumEntry(&tempEntry, &tempEntry_length, bReset) ;
-  bReset = PR_FALSE ;
+  nsresult rv = m_DB->EnumEntry(&m_tempEntry, &m_tempEntry_length, m_bReset) ;
 
-  if(tempEntry && tempEntry_length != 0)
+  if(NS_FAILED(rv)) {
+    // do some error recovery
+    m_DiskCache->DBRecovery() ;
+    return rv ;
+  }
+
+  m_bReset = PR_FALSE ;
+
+  if(m_tempEntry && m_tempEntry_length != 0)
     *_retval = PR_TRUE ;
 
   return NS_OK ;
@@ -86,7 +97,7 @@ nsDBEnumerator::GetNext(nsISupports **_retval)
     return NS_ERROR_NULL_POINTER ;
   *_retval = nsnull ;
 
-  nsresult rv = m_CacheEntry->RetrieveInfo(tempEntry, tempEntry_length) ;
+  nsresult rv = m_CacheEntry->RetrieveInfo(m_tempEntry, m_tempEntry_length) ;
   if(NS_FAILED(rv))
     return rv ;
 

mozilla/netwerk/cache/filecache/nsDBEnumerator.h

@@ -1,4 +1,5 @@
-/*
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
  * The contents of this file are subject to the Mozilla Public
  * License Version 1.1 (the "License"); you may not use this file
  * except in compliance with the License. You may obtain a copy of
@@ -20,7 +21,11 @@
  *                 Carl Wong <carl.wong@intel.com>
  */
 
-// FUR - Add overall description comment here
+/*
+ * This file is part of filecache implementation.
+ *
+ * It implements a simple iterator for the database, see nsDBAccessor. 
+ */
 
 #ifndef _NS_DBENUMERATOR_H_
 #define _NS_DBENUMERATOR_H_
@@ -38,24 +43,18 @@ class nsDBEnumerator : public nsISimpleEnumerator {
 public:
     NS_DECL_ISUPPORTS
 
-    // FUR can use NS_DECL_NSISIMPLEENUMERATOR here
-    /* boolean HasMoreElements (); */
-    NS_IMETHOD HasMoreElements(PRBool *_retval) ;
-
-    /* nsISupports GetNext (); */
-    NS_IMETHOD GetNext(nsISupports **_retval) ;
+    NS_DECL_NSISIMPLEENUMERATOR 
 
     nsDBEnumerator(nsIDBAccessor* aDB, nsNetDiskCache* aCache) ;
     virtual ~nsDBEnumerator() ;
 
-    // FUR all members should be prefixed by 'm', e.g. mbReset
 private:
     nsCOMPtr<nsIDBAccessor>                m_DB ;
-    nsCOMPtr<nsNetDiskCache>                        m_DiskCache ;
-    void *                                 tempEntry ;
-    PRUint32                               tempEntry_length ;
-    nsDiskCacheRecord*                    m_CacheEntry ;
-    PRBool                                 bReset ;
+    nsCOMPtr<nsNetDiskCache>               m_DiskCache ;
+    void *                                 m_tempEntry ;
+    PRUint32                               m_tempEntry_length ;
+    nsDiskCacheRecord*                     m_CacheEntry ;
+    PRBool                                 m_bReset ;
 };
 
 #endif // _NS_DBENUMERATOR_H_

mozilla/netwerk/cache/filecache/nsDiskCacheRecord.cpp

@@ -1,4 +1,5 @@
-/*
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
  * The contents of this file are subject to the Mozilla Public
  * License Version 1.1 (the "License"); you may not use this file
  * except in compliance with the License. You may obtain a copy of
@@ -69,13 +70,14 @@ nsDiskCacheRecord::nsDiskCacheRecord(nsIDBAccessor* db, nsNetDiskCache* aCache)
   mNumChannels(0) ,
   mDiskCache(aCache) 
 {
-
   NS_INIT_REFCNT();
+  NS_ASSERTION(mDiskCache, "Must have an nsNetDiskCache");
+  NS_ADDREF(mDiskCache);
 }
 
 // mem alloced. so caller should do free() on key. 
 NS_IMETHODIMP
-nsDiskCacheRecord::Init(const char* key, PRUint32 length) 
+nsDiskCacheRecord::Init(const char* key, PRUint32 length, PRInt32 ID) 
 {
   NS_NewFileSpec(getter_AddRefs(mFile));
   if(!mFile)
@@ -90,9 +92,7 @@ nsDiskCacheRecord::Init(const char* key, PRUint32 length)
   memcpy(mKey, key, length) ;
 
   // get RecordID
-  // FUR!! Another disk access ?  If called from GetCachedData, ID is already known
-  mDB->GetID(key, length, &mRecordID) ;
-  // FUR - check for GetID failure
+  mRecordID = ID ;
 
   // setup the file name
   nsCOMPtr<nsIFileSpec> dbFolder ;
@@ -105,12 +105,10 @@ nsDiskCacheRecord::Init(const char* key, PRUint32 length)
   // dir is a hash result of mRecordID%32, hope it's enough 
   char filename[9], dirName[3] ;
   
-  // FUR!! - should the format string be "%.02x".  How does this work !?
-  PR_snprintf(dirName, 3, "%.2x", (((PRUint32)mRecordID) % 32)) ;
+  PR_snprintf(dirName, 3, "%02x", (((PRUint32)mRecordID) % 32)) ;
   mFile->AppendRelativeUnixPath(dirName) ;
 
-  // FUR!! - should the format string be "%.08x".  How does this work !?
-  PR_snprintf(filename, 9, "%.8x", mRecordID) ;
+  PR_snprintf(filename, 9, "%08x", mRecordID) ;
   mFile->AppendRelativeUnixPath(filename) ;
 
   return NS_OK ;
@@ -118,12 +116,14 @@ nsDiskCacheRecord::Init(const char* key, PRUint32 length)
 
 nsDiskCacheRecord::~nsDiskCacheRecord()
 {
-//  printf(" ~nsDiskCacheRecord()\n") ;
   if(mKey)
     nsAllocator::Free(mKey) ;
   if(mMetaData)
     nsAllocator::Free(mMetaData) ;
+  if(mInfo) 
+    nsAllocator::Free(mInfo) ;
 
+  NS_IF_RELEASE(mDiskCache);
 }
 
 //
@@ -202,7 +202,6 @@ nsDiskCacheRecord::SetMetaData(PRUint32 length, const char* data)
   // write through into mDB
   rv = mDB->Put(mRecordID, mInfo, mInfoSize) ;
 
-  // FUR - mInfo leaking ?
   return rv ;
 }
 
@@ -226,8 +225,14 @@ nsDiskCacheRecord::SetStoredContentLength(PRUint32 aStoredContentLength)
     NS_ERROR("Error: can not set filesize to something bigger than itself.\n") ;
     return NS_ERROR_FAILURE ;
   }
-  else 
-    return mFile->Truncate(aStoredContentLength) ;
+  else {
+    rv = mFile->Truncate(aStoredContentLength) ;
+    if(NS_FAILED(rv))
+      return rv ;
+    
+    mDiskCache->m_StorageInUse -= (len - aStoredContentLength) ;
+    return NS_OK ;
+  }
 }
 
 NS_IMETHODIMP

mozilla/netwerk/cache/filecache/nsDiskCacheRecord.h

@@ -1,4 +1,5 @@
-/*
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
  * The contents of this file are subject to the Mozilla Public
  * License Version 1.1 (the "License"); you may not use this file
  * except in compliance with the License. You may obtain a copy of
@@ -44,7 +45,7 @@ class nsDiskCacheRecord : public nsINetDataCacheRecord
   virtual ~nsDiskCacheRecord() ;
 
   NS_IMETHOD RetrieveInfo(void* aInfo, PRUint32 aInfoLength) ;
-  NS_IMETHOD Init(const char* key, PRUint32 length) ;
+  NS_IMETHOD Init(const char* key, PRUint32 length, PRInt32 ID) ;
 
   nsresult GenInfo(void) ;
 
@@ -60,7 +61,7 @@ class nsDiskCacheRecord : public nsINetDataCacheRecord
   void*                     mInfo ;
   PRUint32                  mInfoSize ;
   PRUint32                  mNumChannels ;
-  nsCOMPtr<nsNetDiskCache>           mDiskCache ;
+  nsNetDiskCache*           mDiskCache ;
 
   friend class nsDiskCacheRecordChannel ;
   friend class nsDBEnumerator ;

mozilla/netwerk/cache/filecache/nsDiskCacheRecordChannel.cpp

@@ -21,14 +21,24 @@
  *                 Carl Wong <carl.wong@intel.com>
  */
 
+/*
+ * Most of the code are taken from nsFileChannel.  
+ */
+
 #include "nsDiskCacheRecordChannel.h"
-//#include "nsFileTransport.h"
-#include "nsIIOService.h"
+#include "nsIFileTransportService.h"
+//#include "nsIIOService.h"
 #include "nsIServiceManager.h"
-
+#include "nsIURL.h"
 #include "nsIOutputStream.h"
+#include "netCore.h"
+#include "nsIMIMEService.h"
+#include "nsISupportsUtils.h"
 
-static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
+//static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
+static NS_DEFINE_CID(kFileTransportServiceCID, NS_FILETRANSPORTSERVICE_CID);
+static NS_DEFINE_CID(kStandardURLCID, NS_STANDARDURL_CID);
+static NS_DEFINE_CID(kMIMEServiceCID, NS_MIMESERVICE_CID);
 
 // This is copied from nsMemCacheChannel, We should consolidate these two.
 class WriteStreamWrapper : public nsIOutputStream 
@@ -104,16 +114,16 @@ nsDiskCacheRecordChannel::nsDiskCacheRecordChannel(nsDiskCacheRecord *aRecord,
     mLoadGroup(aLoadGroup) 
 {
   NS_INIT_REFCNT() ;
+  NS_ADDREF(mRecord);
   mRecord->mNumChannels++ ;
 }
 
 nsDiskCacheRecordChannel::~nsDiskCacheRecordChannel()
 {
   mRecord->mNumChannels-- ;
+  NS_RELEASE(mRecord);
 }
 
-// FUR!!
-//
 //  I know that I gave conflicting advice on the issue of file
 //  transport versus file protocol handler, but I thought that the
 //  last word was that we would use the raw transport, when I wrote:
@@ -133,24 +143,23 @@ nsDiskCacheRecordChannel::~nsDiskCacheRecordChannel()
 nsresult 
 nsDiskCacheRecordChannel::Init(void) 
 {
-  char* urlStr ;
-  mRecord->mFile->GetURLString(&urlStr) ;
+  nsresult rv = mRecord->mFile->GetFileSpec(&mSpec) ;
+  
+#ifdef XP_MAC
 
-  nsresult rv ;
-  NS_WITH_SERVICE(nsIIOService, serv, kIOServiceCID, &rv);
-  if (NS_FAILED(rv)) return rv;
+  // Don't assume we actually created a good file spec
+  FSSpec theSpec = mSpec.GetFSSpec();
+  if (!theSpec.name[0]) {
+    NS_ERROR("failed to create a file spec");
 
-  rv = serv->NewChannel("load",    // XXX what should this be?
-                        urlStr,
-                        nsnull,    // no base uri
-                        mLoadGroup,
-                        nsnull,    // no eventsink getter
-                        0,
-                        nsnull,    // no original URI
-                        0,
-                        0,
-                        getter_AddRefs(mFileTransport));
+    // Since we didn't actually create the file spec
+    // we return an error
+    return NS_ERROR_MALFORMED_URI;
+  }
+#endif
+  
   return rv ;
+
 }
 
 nsresult 
@@ -160,7 +169,11 @@ nsDiskCacheRecordChannel::NotifyStorageInUse(PRInt32 aBytesUsed)
 }
 
 // implement nsISupports
-NS_IMPL_ISUPPORTS(nsDiskCacheRecordChannel, NS_GET_IID(nsIChannel))
+NS_IMPL_ISUPPORTS4(nsDiskCacheRecordChannel, 
+                   nsIChannel, 
+                   nsIRequest,
+                   nsIStreamListener,
+                   nsIStreamObserver)
 
 // implement nsIRequest
 NS_IMETHODIMP
@@ -201,6 +214,14 @@ nsDiskCacheRecordChannel::Resume(void)
 }
 
 // implement nsIChannel
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetOriginalURI(nsIURI* *aURI)
+{
+  // FUR - might need to implement this - not sure
+  return NS_ERROR_NOT_IMPLEMENTED ;
+}
+  
 NS_IMETHODIMP
 nsDiskCacheRecordChannel::GetURI(nsIURI * *aURI)
 {
@@ -215,12 +236,25 @@ nsDiskCacheRecordChannel::OpenInputStream(PRUint32 aStartPosition,
                                           PRInt32 aReadCount,
                                           nsIInputStream* *aResult)
 {
-  if(!mFileTransport)
-    return NS_ERROR_FAILURE ;
+  nsresult rv ;
 
-  return mFileTransport->OpenInputStream(aStartPosition,
-                                         aReadCount,
-                                         aResult) ;
+  if(mFileTransport)
+    return NS_ERROR_IN_PROGRESS ;
+
+  NS_WITH_SERVICE(nsIFileTransportService, fts, kFileTransportServiceCID, &rv) ;
+  if(NS_FAILED(rv)) return rv ;
+  
+  rv = fts->CreateTransport(mSpec, "load", 0, 0, getter_AddRefs(mFileTransport)) ;
+  if(NS_FAILED(rv))
+    return rv ;
+  
+  // we don't need to worry about notification callbacks
+  
+  rv = mFileTransport->OpenInputStream(aStartPosition, aReadCount, aResult) ;
+  if(NS_FAILED(rv)) 
+    mFileTransport = nsnull ;
+
+  return rv ;
 }
 
 NS_IMETHODIMP
@@ -229,37 +263,36 @@ nsDiskCacheRecordChannel::OpenOutputStream(PRUint32 startPosition,
 {
   nsresult rv ;
   NS_ENSURE_ARG(aResult) ;
+  
+  if(mFileTransport)
+    return NS_ERROR_IN_PROGRESS ;
 
   nsCOMPtr<nsIOutputStream> outputStream ;
 
-  PRUint32 oldLength ;
-  mRecord->GetStoredContentLength(&oldLength) ;
-
-  if(startPosition < oldLength) {
-    NotifyStorageInUse(startPosition - oldLength) ;
-
-    // we should truncate the file at here. 
-    rv = mRecord->SetStoredContentLength(startPosition) ;
-    if(NS_FAILED(rv)) {
-      printf(" failed to truncate\n") ;
-      return rv ;
-    }
-  }
-
-  rv = mFileTransport->OpenOutputStream(startPosition, getter_AddRefs(outputStream)) ;
+  NS_WITH_SERVICE(nsIFileTransportService, fts, kFileTransportServiceCID, &rv) ;
   if(NS_FAILED(rv)) return rv ;
-
+  
+  rv = fts->CreateTransport(mSpec, "load", 0, 0, getter_AddRefs(mFileTransport)) ;
+  if(NS_FAILED(rv))
+    return rv ;
+ 
+  // we don't need to worry about notification callbacks
+  
+  rv = mFileTransport->OpenOutputStream(startPosition, getter_AddRefs(outputStream)) ;
+  if(NS_FAILED(rv)) {
+    mFileTransport = nsnull ;
+    return rv ;
+  }
+ 
   return WriteStreamWrapper::Create(this, outputStream, aResult) ;
+
 }
 
 NS_IMETHODIMP
 nsDiskCacheRecordChannel::AsyncOpen(nsIStreamObserver *observer, 
                                     nsISupports *ctxt)
 {
-  if(!mFileTransport)
-    return NS_ERROR_FAILURE ;
-
-  return mFileTransport->AsyncOpen(observer, ctxt) ;
+  return NS_ERROR_NOT_IMPLEMENTED ;
 }
 
 NS_IMETHODIMP
@@ -268,13 +301,52 @@ nsDiskCacheRecordChannel::AsyncRead(PRUint32 aStartPosition,
                                     nsISupports *aContext, 
                                     nsIStreamListener *aListener)
 {
-  if(!mFileTransport)
-    return NS_ERROR_FAILURE ;
+  nsresult rv ;
 
-  return mFileTransport->AsyncRead(aStartPosition , 
-                                   aReadCount , 
-                                   aContext , 
-                                   aListener) ;
+  if(mFileTransport)
+    return NS_ERROR_IN_PROGRESS ;
+  
+  mRealListener = aListener;
+  nsCOMPtr<nsIStreamListener> tempListener = this;
+
+  if (mLoadGroup) {
+    nsCOMPtr<nsILoadGroupListenerFactory> factory;
+    //
+    // Create a load group "proxy" listener...
+    //
+    rv = mLoadGroup->GetGroupListenerFactory(getter_AddRefs(factory));
+    if (factory) {
+      nsIStreamListener *newListener;
+      rv = factory->CreateLoadGroupListener(mRealListener, &newListener);
+      if (NS_SUCCEEDED(rv)) {
+        mRealListener = newListener;
+        NS_RELEASE(newListener);
+        }
+      }
+
+      rv = mLoadGroup->AddChannel(this, nsnull);
+      if (NS_FAILED(rv)) return rv;
+  }
+
+
+  NS_WITH_SERVICE(nsIFileTransportService, fts, kFileTransportServiceCID, &rv);
+  if (NS_FAILED(rv)) return rv;
+
+  rv = fts->CreateTransport(mSpec, "load", 0, 0, getter_AddRefs(mFileTransport));
+  if (NS_FAILED(rv)) return rv;
+
+  // no callbacks
+
+  rv = mFileTransport->AsyncRead(aStartPosition, 
+                                 aReadCount, 
+                                 aContext, 
+                                 tempListener);
+
+  if (NS_FAILED(rv)) {
+    // release the transport so that we don't think we're in progress
+    mFileTransport = nsnull;
+  }
+  return rv;
 }
 
 NS_IMETHODIMP
@@ -304,37 +376,79 @@ nsDiskCacheRecordChannel::AsyncWrite(nsIInputStream *fromStream,
 NS_IMETHODIMP
 nsDiskCacheRecordChannel::GetLoadAttributes(nsLoadFlags *aLoadAttributes)
 {
-  if(!mFileTransport)
-    return NS_ERROR_FAILURE ;
-
-  return mFileTransport->GetLoadAttributes(aLoadAttributes) ;
+  // Not required to be implemented, since it is implemented by cache manager
+  NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
+  return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsDiskCacheRecordChannel::SetLoadAttributes(nsLoadFlags aLoadAttributes)
 {
-  if(!mFileTransport)
-    return NS_ERROR_FAILURE ;
-
-  return mFileTransport->SetLoadAttributes(aLoadAttributes) ;
+  // Not required to be implemented, since it is implemented by cache manager
+  NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
+  return NS_ERROR_NOT_IMPLEMENTED;
 }
 
+#define DUMMY_TYPE "text/html"
+
 NS_IMETHODIMP
 nsDiskCacheRecordChannel::GetContentType(char * *aContentType)
 {
-  if(!mFileTransport)
-    return NS_ERROR_FAILURE ;
+  nsresult rv ;
 
-  return mFileTransport->GetContentType(aContentType) ;
+  if (mSpec.IsDirectory()) {
+    *aContentType = nsCRT::strdup("application/http-index-format");
+    return *aContentType ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
+  }
+  else {
+    // I wish I can make this simplier
+
+    char* urlStr ;
+    mRecord->mFile->GetURLString(&urlStr) ;
+
+    // file: URLs (currently) have no additional structure beyond that provided by standard
+    // URLs, so there is no "outer" given to CreateInstance 
+
+    nsCOMPtr<nsIURI> url;
+    rv = nsComponentManager::CreateInstance(kStandardURLCID, nsnull,
+                                            NS_GET_IID(nsIURI),
+                                            //(void**)&url);
+                                            getter_AddRefs(url)) ;
+    if (NS_FAILED(rv)) return rv;
+
+    rv = url->SetSpec((char*)urlStr);
+    if (NS_FAILED(rv)) 
+        return rv;
+
+    NS_WITH_SERVICE(nsIMIMEService, MIMEService, kMIMEServiceCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = MIMEService->GetTypeFromURI(url, aContentType);
+    if (NS_SUCCEEDED(rv)) return rv;
+  }
+
+  // if all else fails treat it as text/html?
+  *aContentType = nsCRT::strdup(DUMMY_TYPE);
+  if (!*aContentType) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  } else {
+    return NS_OK;
+  }
 }
 
 NS_IMETHODIMP
 nsDiskCacheRecordChannel::GetContentLength(PRInt32 *aContentLength)
 {
-  if(!mFileTransport)
-    return NS_ERROR_FAILURE ;
+  nsresult rv;
+  PRUint32 length;
 
-  return mFileTransport->GetContentLength(aContentLength) ;
+  rv = mRecord->mFile->GetFileSize(&length);
+  if (NS_SUCCEEDED(rv)) {
+    *aContentLength = (PRInt32)length;
+  } else {
+    *aContentLength = -1;
+  }
+  return rv;
 }
 
 NS_IMETHODIMP
@@ -352,41 +466,87 @@ nsDiskCacheRecordChannel::SetOwner(nsISupports* aOwner)
   return NS_OK ;
 }
 
-NS_IMETHODIMP
-nsDiskCacheRecordChannel::GetOriginalURI(nsIURI* *aURI)
-{
-  // FUR - might need to implement this - not sure
-  return NS_ERROR_NOT_IMPLEMENTED ;
-}
-
 NS_IMETHODIMP
 nsDiskCacheRecordChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
 {
-  // Not required to be implemented, since it is implemented by cache manager
-  NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
-  return NS_OK ;
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
+      return NS_OK ;
 }
 
 NS_IMETHODIMP
 nsDiskCacheRecordChannel::SetLoadGroup(nsILoadGroup* aLoadGroup)
 {
-  // Not required to be implemented, since it is implemented by cache manager
-  NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
-  return NS_OK;
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
+      return NS_OK;
 }
 
 NS_IMETHODIMP
 nsDiskCacheRecordChannel::GetNotificationCallbacks(nsIInterfaceRequestor* *aNotificationCallbacks)
 {
-  // Not required to be implemented, since it is implemented by cache manager
-  NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
-  return NS_ERROR_NOT_IMPLEMENTED;
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
+      return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsDiskCacheRecordChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aNotificationCallbacks)
 {
-  // Not required to be implemented, since it is implemented by cache manager
-  NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
-  return NS_ERROR_NOT_IMPLEMENTED;
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsDiskCacheRecordChannel method unexpectedly called");
+      return NS_ERROR_NOT_IMPLEMENTED;
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIStreamListener methods:
+////////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::OnStartRequest(nsIChannel* transportChannel, nsISupports* context)
+{
+  NS_ASSERTION(mRealListener, "No listener...");
+  return mRealListener->OnStartRequest(this, context);
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::OnStopRequest(nsIChannel* transportChannel, nsISupports* context,
+                             nsresult aStatus, const PRUnichar* aMsg)
+{
+  nsresult rv;
+
+  rv = mRealListener->OnStopRequest(this, context, aStatus, aMsg);
+
+  if (mLoadGroup) {
+    if (NS_SUCCEEDED(rv)) {
+      mLoadGroup->RemoveChannel(this, context, aStatus, aMsg);
+    }
+  }
+
+  // Release the reference to the consumer stream listener...
+  mRealListener = null_nsCOMPtr();
+  mFileTransport = null_nsCOMPtr();
+  return rv;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::OnDataAvailable(nsIChannel* transportChannel, nsISupports* context,
+                               nsIInputStream *aIStream, PRUint32 aSourceOffset,
+                               PRUint32 aLength)
+{
+  nsresult rv;
+
+  rv = mRealListener->OnDataAvailable(this, context, aIStream,
+                                      aSourceOffset, aLength);
+
+  //
+  // If the connection is being aborted cancel the transport.  This will
+  // insure that the transport will go away even if it is blocked waiting
+  // for the consumer to empty the pipe...
+  //
+  if (NS_FAILED(rv)) {
+    mFileTransport->Cancel();
+  }
+  return rv;
+}
+

mozilla/netwerk/cache/filecache/nsDiskCacheRecordChannel.h

@@ -1,4 +1,5 @@
-/*
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
  * The contents of this file are subject to the Mozilla Public
  * License Version 1.1 (the "License"); you may not use this file
  * except in compliance with the License. You may obtain a copy of
@@ -26,12 +27,14 @@
 #include "nsIChannel.h"
 #include "nsCOMPtr.h"
 #include "nsDiskCacheRecord.h"
+#include "nsIStreamListener.h"
 
 /*
  * This class is plagiarized from nsMemCacheChannel
  */
 
-class nsDiskCacheRecordChannel : public nsIChannel
+class nsDiskCacheRecordChannel : public nsIChannel,
+                                 public nsIStreamListener 
 {
   public:
 
@@ -47,16 +50,24 @@ class nsDiskCacheRecordChannel : public nsIChannel
   // Declare nsIChannel methods
   NS_DECL_NSICHANNEL
 
+  // Declare nsIStreamObserver methods
+  NS_DECL_NSISTREAMOBSERVER
+
+  // Declare nsIStreamListener methods
+  NS_DECL_NSISTREAMLISTENER
+
   nsresult Init(void) ;
 
   private:
 
   nsresult NotifyStorageInUse(PRInt32 aBytesUsed) ;
 
-  nsCOMPtr<nsDiskCacheRecord>           mRecord ;
+  nsDiskCacheRecord*                    mRecord ;
   nsCOMPtr<nsILoadGroup>                mLoadGroup ;
   nsCOMPtr<nsISupports>                 mOwner ;
   nsCOMPtr<nsIChannel>                  mFileTransport ;
+  nsFileSpec                            mSpec ;
+  nsCOMPtr<nsIStreamListener>           mRealListener;
 
   friend class WriteStreamWrapper ;
 } ;

mozilla/netwerk/cache/filecache/nsIDBAccessor.h

@@ -1,4 +1,5 @@
-/*
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
  * The contents of this file are subject to the Mozilla Public
  * License Version 1.1 (the "License"); you may not use this file
  * except in compliance with the License. You may obtain a copy of
@@ -53,6 +54,11 @@ class nsIDBAccessor : public nsISupports
   NS_IMETHOD GetID(const char* key, PRUint32 length, PRInt32* aID) = 0 ;
 
   NS_IMETHOD EnumEntry(void* *anEntry, PRUint32* aLength, PRBool bReset) = 0 ;
+  
+  NS_IMETHOD GetDBFilesize(PRUint32* aSize) = 0 ;
+    
+  NS_IMETHOD GetSpecialEntry(void** anEntry, PRUint32 *aLength) = 0 ;
+  NS_IMETHOD SetSpecialEntry(void* anEntry, PRUint32 aLength) = 0 ;
 
 } ;
 

mozilla/netwerk/cache/filecache/nsNetDiskCache.cpp

@@ -1,4 +1,5 @@
-/*
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
  * The contents of this file are subject to the Mozilla Public
  * License Version 1.1 (the "License"); you may not use this file
  * except in compliance with the License. You may obtain a copy of
@@ -31,6 +32,7 @@
 #include "plhash.h"
 #include "prclist.h"
 #include "prmem.h"
+#include "prlog.h"
 
 #include "nsIComponentManager.h"
 #include "nsIServiceManager.h"
@@ -40,6 +42,23 @@
 #include "nsDBEnumerator.h"
 
 #include "nsDiskCacheRecord.h"
+#include "netCore.h"
+
+#if !defined(IS_LITTLE_ENDIAN) && !defined(IS_BIG_ENDIAN)
+ERROR! Must have a byte order
+#endif
+
+#ifdef IS_LITTLE_ENDIAN
+#define COPY_INT32(_a,_b)  memcpy(_a, _b, sizeof(int32))
+#else
+#define COPY_INT32(_a,_b)  /* swap */                   \
+    do {                                                \
+    ((char *)(_a))[0] = ((char *)(_b))[3];              \
+    ((char *)(_a))[1] = ((char *)(_b))[2];              \
+    ((char *)(_a))[2] = ((char *)(_b))[1];              \
+    ((char *)(_a))[3] = ((char *)(_b))[0];              \
+    } while(0)
+#endif
 
 static NS_DEFINE_CID(kPrefCID, NS_PREF_CID) ;
 static NS_DEFINE_CID(kDBAccessorCID, NS_DBACCESSOR_CID) ;
@@ -57,7 +76,7 @@ nsNetDiskCache::nsNetDiskCache() :
   m_pDiskCacheFolder(0) ,
   m_StorageInUse(0) ,
   m_DB(0) ,
-  m_BaseDirNum(32) 
+  m_DBCorrupted(PR_FALSE) 
 {
   // set it to INF for now 
   m_MaxEntries = (PRUint32)-1 ;
@@ -68,17 +87,10 @@ nsNetDiskCache::nsNetDiskCache() :
 
 nsNetDiskCache::~nsNetDiskCache()
 {
-  printf("~nsNetDiskCache\n") ;
+  SetSpecialEntry() ;
 
   NS_IF_RELEASE(m_DB) ;
-
-  // FUR!!
-  // You shouldn't rely on the value of m_BaseDirNum to diagnose whether or not
-  // a cache corruption has occurred since it's possible that the app does not
-  // shut down cleanly and a corrupted cache has still not been cleaned up from
-  // a previous session.  My suggestion is that you pick a different scheme for
-  // renaming the dirs, e.g. rename them as "trash*" and remove all directories
-  // with this name pattern on shutdown.
+  
 
   // FUR
   // I think that, eventually, we also want a distinguished key in the DB which
@@ -91,88 +103,47 @@ nsNetDiskCache::~nsNetDiskCache()
   //
   // We don't necessarily need all this functionality immediately, though.
 
-  if(m_BaseDirNum > 32)
-    RemoveDirs(32) ;
+
+  if(m_DBCorrupted) {
+    
+    nsFileSpec cacheFolder ;
+    m_pDiskCacheFolder->GetFileSpec(&cacheFolder) ;
+    
+    char nameInt[6] ;
+
+    for(nsDirectoryIterator di(cacheFolder, PR_FALSE); di.Exists(); di++) {
+      char* filename = di.Spec().GetLeafName() ;
+      char* pname = nameInt ;
+      pname = PL_strncpyz(pname, filename, 6) ;
+
+      if(PL_strcmp(pname, "trash") == 0)
+        RemoveFolder(di.Spec()) ;
+      
+      nsCRT::free(filename) ;  
+    }
+  }
 }
 
 NS_IMETHODIMP
 nsNetDiskCache::Init(void) 
 {
   nsresult rv ;
+  
+  // don't initialize if no cache folder is set. 
+  if(!m_pDiskCacheFolder) return NS_OK ;
 
-  // FUR!!
-  // I really don't think prefs belong here, since that breaks modularity.  It
-  // presupposes that the file cache code is embedded in the browser or some
-  // other application that uses the prefs, i.e. the code might be used in a
-  // standalone cache manipulation tool or, someday, in server code.  Pref
-  // reading belongs at a higher level, either in the application itself or
-  // possibly the I/O manager.
-
-
-  // Also, Init() needs to be lazy, since folder name is not set on startup,
-  // i.e. need a call to MaybeInit() at the beginning of every public method
-
-  NS_WITH_SERVICE(nsIPref, pref, kPrefCID, &rv) ;
-  if (NS_FAILED(rv)) 
-    NS_ERROR("Failed to get globle preference!\n") ;
-
-  rv = NS_NewFileSpec(getter_AddRefs(m_pDiskCacheFolder));
-  if (!m_pDiskCacheFolder) {
-    NS_ERROR("ERROR: Could not make a file spec.\n") ;
-    return NS_ERROR_OUT_OF_MEMORY ;
+  if(!m_DB) {
+    m_DB = new nsDBAccessor() ;
+    if(!m_DB)
+      return NS_ERROR_OUT_OF_MEMORY ;
+    else
+      NS_ADDREF(m_DB) ;
   }
 
-  char* tempPref = 0 ;
-  if(pref) {
-    PRInt32 nTemp = 0 ;
-
-    /*
-    rv = pref->CopyCharPref(CACHE_DIR_PREF, &tempPref) ;
-    if (NS_SUCCEEDED(rv)) {
-      printf("cache dir is %s\n", tempPref) ;
-      m_pDiskCacheFolder->SetUnixStyleFilePath(tempPref) ;
-	  PR_Free(tempPref) ;
-    } else */
-    {
-      m_pDiskCacheFolder->SetUnixStyleFilePath("/tmp") ;
-      printf("using default folder, /tmp\n") ;
-    }
-  }
-  else {
-    // temp hack for now. change later for other platform
-    m_pDiskCacheFolder->SetUnixStyleFilePath("/tmp") ;
-  }
-
-  // FUR - suggest you use nsCOMPtr for m_DB - it will eliminate
-  //       manual addref/release and reduce likelihood of bugs
-  NS_IF_RELEASE(m_DB) ;
-  m_DB = new nsDBAccessor() ;
-  if(!m_DB)
-    return NS_ERROR_OUT_OF_MEMORY ;
-  else
-    NS_ADDREF(m_DB) ;
-
-  rv = InitDB() ;
-
-  // try once for recovery
-  if(rv == NS_ERROR_FAILURE) {
-    rv = DBRecovery() ;
-    return rv ;
-  }
-
-  rv = UpdateInfo() ;
-  return rv ;
-}
-
-NS_IMETHODIMP
-nsNetDiskCache::InitDB(void)
-{
   // create cache sub directories
-  nsresult rv ; 
   nsCOMPtr<nsIFileSpec> cacheSubDir;
   rv = NS_NewFileSpec(getter_AddRefs(cacheSubDir));
 
-  // FUR - any way to avoid doing this, if it's already been done ?
   for (int i=0; i < 32; i++) {
     rv = cacheSubDir->FromFileSpec(m_pDiskCacheFolder) ;
     if(NS_FAILED(rv))
@@ -184,8 +155,20 @@ nsNetDiskCache::InitDB(void)
     CreateDir(cacheSubDir);
   }
 
-  NS_NewFileSpec(getter_AddRefs(m_DBFile)) ;
-  // FUR - check for NS_NewFileSpec failure
+  return InitDB() ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::InitDB(void)
+{
+  nsresult rv ; 
+
+  if(!m_DBFile) {
+    NS_NewFileSpec(getter_AddRefs(m_DBFile)) ;
+    if(!m_DBFile)
+      return NS_ERROR_OUT_OF_MEMORY ;
+  }
+
   rv = m_DBFile->FromFileSpec(m_pDiskCacheFolder) ;
   if(NS_FAILED(rv))
     return rv ;
@@ -193,30 +176,28 @@ nsNetDiskCache::InitDB(void)
   m_DBFile->AppendRelativeUnixPath("cache.db") ;
 
   rv = m_DB->Init(m_DBFile) ;
+
+  if(rv == NS_ERROR_FAILURE) {
+    // try recovery if error 
+    DBRecovery() ;
+  }
+
+  rv = GetSpecialEntry() ;
+  if(rv == NS_ERROR_FAILURE) {
+    // try recovery if error 
+    DBRecovery() ;
+  }
+
   return rv ;
 }
 
 //////////////////////////////////////////////////////////////////////////
 // nsISupports methods
 
-// FUR - Suggest you use NS_IMPL_ISUPPORTS3() macro instead
-NS_IMETHODIMP
-nsNetDiskCache::QueryInterface(const nsIID& aIID, void** aInstancePtr)
-{
-  NS_ASSERTION(aInstancePtr, "no instance pointer");
-  if(aIID.Equals(NS_GET_IID(nsINetDataDiskCache)) ||
-     aIID.Equals(NS_GET_IID(nsINetDataCache)) ||
-     aIID.Equals(NS_GET_IID(nsISupports))) {
-    *aInstancePtr = NS_STATIC_CAST(nsINetDataDiskCache*, this);
-    NS_ADDREF_THIS();
-    return NS_OK;
-  }
-  else
-    return NS_NOINTERFACE ;
-}
-
-NS_IMPL_ADDREF(nsNetDiskCache) ;
-NS_IMPL_RELEASE(nsNetDiskCache) ;
+NS_IMPL_ISUPPORTS3(nsNetDiskCache,
+                   nsINetDataDiskCache,
+                   nsINetDataCache,
+                   nsISupports) 
 
 ///////////////////////////////////////////////////////////////////////////
 // nsINetDataCache Method 
@@ -244,17 +225,27 @@ nsNetDiskCache::Contains(const char* key, PRUint32 length, PRBool *_retval)
   NS_ASSERTION(m_DB, "no db.") ;
 
   PRInt32 id = 0 ;
-  m_DB->GetID(key, length, &id) ;
-  // FUR - Check for GetID failure ?
+  nsresult rv = m_DB->GetID(key, length, &id) ;
+
+  if(NS_FAILED(rv)) {
+    // try recovery if error 
+    DBRecovery() ;
+    return rv ;
+  }
 
   void* info = 0 ;
   PRUint32 info_size = 0 ;
 
-  nsresult rv = m_DB->Get(id, &info, &info_size) ;
+  rv = m_DB->Get(id, &info, &info_size) ;
   if(NS_SUCCEEDED(rv) && info) 
     *_retval = PR_TRUE ;
         
-  return NS_OK ;
+  if(NS_FAILED(rv)) {
+    // try recovery if error 
+    DBRecovery() ;
+  }
+
+  return rv ;
 }
 
 /* regardless if it's cached or not, a copy of nsNetDiskCache would 
@@ -275,15 +266,19 @@ nsNetDiskCache::GetCachedNetData(const char* key, PRUint32 length, nsINetDataCac
   *_retval = nsnull ;
 
   PRInt32 id = 0 ;
-  m_DB->GetID(key, length, &id) ;
-  // FUR - Check for GetID failure ?
+  rv = m_DB->GetID(key, length, &id) ;
+  if(NS_FAILED(rv)) {
+    // try recovery if error 
+    DBRecovery() ;
+    return rv ;
+  }
 
   // construct an empty record
   nsDiskCacheRecord* newRecord = new nsDiskCacheRecord(m_DB, this) ;
   if(!newRecord) 
     return NS_ERROR_OUT_OF_MEMORY ;
 
-  rv = newRecord->Init(key, length) ;
+  rv = newRecord->Init(key, length, id) ;
   if(NS_FAILED(rv)) {
     delete newRecord ;
     return rv ;
@@ -298,21 +293,28 @@ nsNetDiskCache::GetCachedNetData(const char* key, PRUint32 length, nsINetDataCac
   rv = m_DB->Get(id, &info, &info_size) ;
   if(NS_SUCCEEDED(rv) && info) {
 
+    // this is a previously cached record 
     nsresult r1 ;
     r1 = newRecord->RetrieveInfo(info, info_size) ;
 
-    // FUR!! need to release and return error if RetrieveInfo() fails
     if(NS_SUCCEEDED(rv)) 
       return NS_OK ;
-    else 
+    else { 
+      // probably a bad one
+      NS_RELEASE(newRecord) ;
+      *_retval = nsnull ;
       return r1;
+    }
     
   } else if (NS_SUCCEEDED(rv) && !info) {
     // this is a new record. 
     m_NumEntries ++ ;
     return NS_OK ;
-  } else 
+  } else {
+    // database error.
+    DBRecovery() ;
     return rv ;
+  }
 }
 
 /* get an nsICachedNetData, mem needs to be de-alloced if not found. */
@@ -353,6 +355,7 @@ nsNetDiskCache::GetCachedNetDataByID(PRInt32 RecordID, nsINetDataCacheRecord **_
     }
   } else {
     NS_ERROR("Error: RecordID not in DB\n") ;
+    DBRecovery() ;
     return rv ;
   }
 }
@@ -395,6 +398,8 @@ nsNetDiskCache::GetMaxEntries(PRUint32 *aMaxEntries)
 NS_IMETHODIMP
 nsNetDiskCache::NewCacheEntryIterator(nsISimpleEnumerator **_retval) 
 {
+  NS_ASSERTION(m_DB, "no db.") ;
+
   if(!_retval)
     return NS_ERROR_NULL_POINTER ;
 
@@ -432,18 +437,16 @@ nsNetDiskCache::SetNextCache(nsINetDataCache *aNextCache)
 NS_IMETHODIMP
 nsNetDiskCache::GetStorageInUse(PRUint32 *aStorageInUse)
 {
-  PRUint32 total_size = m_StorageInUse, len = 0 ;
+  NS_ASSERTION(m_DB, "no db.") ;
 
-  // FUR!!
-  // GetStorageInUse() can be called hundreds of times per second, i.e. every
-  // time a buffer of data is written to the cache, so we can't afford to stat
-  // the db file on every call.  I would suggest caching the size of the db and
-  // invalidating that cached value every time a record is written to the db,
-  // or even every ten written records.
+  PRUint32 total_size = m_StorageInUse ;
 
+  /*
+  PRUint32 len = 0 ;
   // add the size of the db.
-  //  m_DBFile->GetFileSize(&len) ;
-  //  total_size += len ;
+  m_DB->GetDBFilesize(&len) ;
+  total_size += len ;
+  */
 
   // we need size in kB
   total_size = total_size >> 10 ;
@@ -460,9 +463,20 @@ nsNetDiskCache::GetStorageInUse(PRUint32 *aStorageInUse)
 NS_IMETHODIMP
 nsNetDiskCache::RemoveAll(void)
 {
-  nsresult rv = RemoveDirs(0) ;
-  if(NS_FAILED(rv))
-    return rv ;
+  NS_ASSERTION(m_DB, "no db.") ;
+  NS_ASSERTION(m_pDiskCacheFolder, "no cache folder.") ;
+
+  // remove all the sub folders
+  nsFileSpec cacheSubDir;
+
+  for (int i=0; i < 32; i++) {
+    m_pDiskCacheFolder->GetFileSpec(&cacheSubDir) ;
+
+    char dirName[3];
+    PR_snprintf (dirName, 3, "%0.2x", i);
+    cacheSubDir += dirName ;
+    RemoveFolder(cacheSubDir) ;
+  }
 
   // don't forget the db file itself
   m_DB->Shutdown() ;
@@ -471,12 +485,7 @@ nsNetDiskCache::RemoveAll(void)
   dbfile.Delete(PR_TRUE) ;
 
   // reinitilize
-  rv = InitDB() ;
-  if(NS_FAILED(rv))
-    return rv ;
-
-  rv = UpdateInfo() ;
-  return rv ;
+  return Init() ;
 }
 
 //////////////////////////////////////////////////////////////////
@@ -485,6 +494,9 @@ nsNetDiskCache::RemoveAll(void)
 NS_IMETHODIMP
 nsNetDiskCache::GetDiskCacheFolder(nsIFileSpec * *aDiskCacheFolder)
 {
+  *aDiskCacheFolder = nsnull ;
+  NS_ASSERTION(m_pDiskCacheFolder, "no cache folder.") ;
+
   *aDiskCacheFolder = m_pDiskCacheFolder ;
   NS_ADDREF(*aDiskCacheFolder) ;
   return NS_OK ;
@@ -493,22 +505,31 @@ nsNetDiskCache::GetDiskCacheFolder(nsIFileSpec * *aDiskCacheFolder)
 NS_IMETHODIMP
 nsNetDiskCache::SetDiskCacheFolder(nsIFileSpec * aDiskCacheFolder)
 {
-  char *newfolder, *oldfolder ;
-  m_pDiskCacheFolder->GetNativePath(&oldfolder) ;
-  aDiskCacheFolder->GetNativePath(&newfolder) ;
-
-  if(PL_strcmp(newfolder, oldfolder) == 0) {
+  if(!m_pDiskCacheFolder) {
+    NS_NewFileSpec(getter_AddRefs(m_pDiskCacheFolder));
+    if(!m_pDiskCacheFolder) 
+      return NS_ERROR_OUT_OF_MEMORY ;
+    
     m_pDiskCacheFolder = aDiskCacheFolder ;
+    return Init() ;
+  } 
+  else {
+    char *newfolder, *oldfolder ;
+    m_pDiskCacheFolder->GetNativePath(&oldfolder) ;
+    aDiskCacheFolder->GetNativePath(&newfolder) ;
 
-    // should we do this? 
-    // FUR - no
-    nsresult rv = RemoveAll() ;
-    return rv ;
+    if(PL_strcmp(newfolder, oldfolder) != 0) {
+      m_pDiskCacheFolder = aDiskCacheFolder ;
+
+      // do we need to blow away old cache before building a new one?
+      // return RemoveAll() ;
+
+      m_DB->Shutdown() ;
+      return Init() ;
+
+    } else 
+      return NS_OK ;
   }
-  else 
-    // FUR
-    // Need to blow away old cache, build new one
-    return NS_OK ;
 }
 
 //////////////////////////////////////////////////////////////////
@@ -525,76 +546,120 @@ nsNetDiskCache::CreateDir(nsIFileSpec* dir_spec)
   if(does_exist) 
     return NS_OK ;
 
-  dir_spec->GetParent(getter_AddRefs(p_spec)) ;
-  // FUR - check return value
+  nsresult rv = dir_spec->GetParent(getter_AddRefs(p_spec)) ;
+  if(NS_FAILED(rv))
+    return rv ;
+
   p_spec->Exists(&does_exist) ;
   if(!does_exist) {
     CreateDir(p_spec) ;
-    dir_spec->CreateDir() ;
-    // FUR - check return value
+    rv = dir_spec->CreateDir() ;
+    if(NS_FAILED(rv))
+      return rv ;
   }
   else {
-    dir_spec->CreateDir() ;
-    // FUR - check return value
+    rv = dir_spec->CreateDir() ;
+    if(NS_FAILED(rv))
+      return rv ;
   }
   
   return NS_OK ;
 }
 
-// FUR!!
 // We can't afford to make a *separate* pass over the whole db on every
 // startup, just to figure out m_NumEntries and m_StorageInUse.  (This is a
 // several second operation on a large db).  We'll likely need to store
 // distinguished keys in the db that contain these values and update them
 // incrementally, except when failure to shut down the db cleanly is detected.
 
-// this will walk through db and update m_NumEntries and m_StorageInUse
 NS_IMETHODIMP
-nsNetDiskCache::UpdateInfo(void)
+nsNetDiskCache::GetSpecialEntry(void)
 {
-  // count num of entries in db
-//  NS_ADDREF(this) ; // addref before assign to a nsCOMPtr. 
-  nsISimpleEnumerator* dbEnumerator = new nsDBEnumerator(m_DB, this) ;
-  if(dbEnumerator)
-    NS_ADDREF(dbEnumerator) ;
-  else
-    return NS_ERROR_FAILURE ;
+  void* pInfo ;
+  PRUint32 InfoSize ;
 
-  PRUint32 numEntries = 0, storageInUse = 0, len = 0 ;
-  PRBool more = PR_FALSE ;
+  nsresult rv = m_DB->GetSpecialEntry(&pInfo, &InfoSize) ;
+  if(NS_FAILED(rv))
+    return rv ;
 
-  do {
-    dbEnumerator->HasMoreElements(&more) ;
-    if(more) {
-      // update entry number
-      numEntries++ ;
-
-      // update storage in use
-      nsINetDataCacheRecord* record ;
-      dbEnumerator->GetNext((nsISupports**)&record) ;
-      record->GetStoredContentLength(&len) ;
-      storageInUse += len ;
-      NS_IF_RELEASE(record) ;
-    }
-  } while (more) ;
-
-  NS_IF_RELEASE(dbEnumerator) ;
-
-  m_NumEntries = numEntries ;
-  m_StorageInUse = storageInUse ;
-
-  printf(" m_NumEntries = %d, size is %d.\n", m_NumEntries, m_StorageInUse) ;
+  if(!pInfo && InfoSize == 0) {
+    // must be a new DB
+    m_NumEntries = 0 ;
+    m_StorageInUse = 0 ;
+  } 
+  else {
+    char * cur_ptr = NS_STATIC_CAST(char*, pInfo) ;
+    
+    // get m_NumEntries
+    COPY_INT32(&m_NumEntries, cur_ptr) ;
+    cur_ptr += sizeof(PRUint32) ;
+    
+    // get m_StorageInUse
+    COPY_INT32(&m_StorageInUse, cur_ptr) ;
+    cur_ptr += sizeof(PRUint32) ;
+    
+    PR_ASSERT(cur_ptr == NS_STATIC_CAST(char*, pInfo) + InfoSize);
+  }
 
   return NS_OK ;
 }
 
-// this routine will add m_BaseDirNum to current CacheSubDir names. 
-// e.g. 00->20, 1f->5f. and update the m_BaseDirNum to another 32. 
-// the idea is as long as we remember the base number,
-// we know how many dirs needs to be removed during shutdown period
-// it will be from 0x20 to m_BaseDirNum. 
-// also, we assume that this operation will not be performed 3 times more
-// within a single session. it is part of scavenging routine. 
+NS_IMETHODIMP
+nsNetDiskCache::SetSpecialEntry(void)
+{
+  PRUint32 InfoSize ;
+  
+  InfoSize = sizeof m_NumEntries ;
+  InfoSize += sizeof m_StorageInUse ;
+  
+  void* pInfo = nsAllocator::Alloc(InfoSize*sizeof(char)) ;
+  if(!pInfo) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+  
+  char* cur_ptr = NS_STATIC_CAST(char*, pInfo) ;
+
+  COPY_INT32(cur_ptr, &m_NumEntries) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  COPY_INT32(cur_ptr, &m_StorageInUse) ;
+  cur_ptr += sizeof(PRUint32) ;
+  
+  PR_ASSERT(cur_ptr == NS_STATIC_CAST(char*, pInfo) + InfoSize);
+  
+  return m_DB->SetSpecialEntry(pInfo, InfoSize) ;
+}
+
+// this routine will be called everytime we have a db corruption. 
+// m_DB will be re-initialized, m_StorageInUse and m_NumEntries will
+// be reset.
+NS_IMETHODIMP
+nsNetDiskCache::DBRecovery(void)
+{
+  // rename all the sub cache dirs and remove them later during dtor. 
+  nsresult rv = RenameCacheSubDirs() ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  // remove corrupted db file, don't care if db->shutdown fails or not.
+  m_DB->Shutdown() ;
+  
+  nsFileSpec dbfile ;
+  m_DBFile->GetFileSpec(&dbfile) ;
+  dbfile.Delete(PR_TRUE) ;
+
+  // make sure it's not there any more
+  PRBool exists = dbfile.Exists() ;
+  if(exists) {
+    NS_ERROR("can't remove old db.") ;
+    return NS_ERROR_FAILURE ;
+  }
+
+  // reinitilize DB 
+  return InitDB() ;
+}
+
+// this routine will add string "trash" to current CacheSubDir names. 
+// e.g. 00->trash00, 1f->trash1f. and update the m_DBCorrupted. 
 
 NS_IMETHODIMP
 nsNetDiskCache::RenameCacheSubDirs(void) 
@@ -607,85 +672,33 @@ nsNetDiskCache::RenameCacheSubDirs(void)
     if(NS_FAILED(rv))
       return rv ;
 
-    char dirName[3];
-    PR_snprintf(dirName, 3, "%0.2x", i) ;
-    cacheSubDir->AppendRelativeUnixPath(dirName) ;
+    char oldName[3], newName[8];
+    PR_snprintf(oldName, 3, "%0.2x", i) ;
+    cacheSubDir->AppendRelativeUnixPath(oldName) ;
 
     // re-name the directory
-    PR_snprintf(dirName, 3, "%0.2x", i+m_BaseDirNum) ;
-    rv = cacheSubDir->Rename(dirName) ;
+    PR_snprintf(newName, 8, "trash%0.2x", i) ;
+    rv = cacheSubDir->Rename(newName) ;
     if(NS_FAILED(rv))
+      // TODO, error checking
       return NS_ERROR_FAILURE ;
   }
 
-  // update m_BaseDirNum 
-  m_BaseDirNum += 32 ;
+  // update m_DBCorrupted 
+  m_DBCorrupted = PR_TRUE ;
 
   return NS_OK ;
 }
 
-// this routine will be called everytime we have a db corruption. 
-NS_IMETHODIMP
-nsNetDiskCache::DBRecovery(void)
-{
-  nsresult rv = RenameCacheSubDirs() ;
-  if(NS_FAILED(rv))
-    return rv ;
-
-  // remove corrupted db file
-  rv = m_DB->Shutdown() ;
-  
-  // FUR!!
-  // You shouldn't return if this fails.  Otherwise, it might prevent db deletion
-  if(NS_FAILED(rv))
-    return rv ;
-
-  nsFileSpec dbfile ;
-  m_DBFile->GetFileSpec(&dbfile) ;
-  dbfile.Delete(PR_TRUE) ;
-
-  // make sure it's not there any more
-  PRBool exists = dbfile.Exists() ;
-  if(exists) {
-    NS_ERROR("can't remove old db.") ;
-    return NS_ERROR_FAILURE ;
-  }
-
-  // reinitilize
-  rv = InitDB() ;
-  if(NS_FAILED(rv))
-    return rv ;
-
-  rv = UpdateInfo() ;
-  return rv ;
-}
-
 // this routine is used by dtor and RemoveAll() to clean up dirs.
-// All directory named from aNum - m_BasedDirNum will be deleted. 
 NS_IMETHODIMP
-nsNetDiskCache::RemoveDirs(PRUint32 aNum)
+nsNetDiskCache::RemoveFolder(nsFileSpec aFolder)
 {
-  nsCOMPtr<nsIFileSpec> cacheSubDir;
-  nsresult rv = NS_NewFileSpec(getter_AddRefs(cacheSubDir));
-  if(NS_FAILED(rv))
-    return NS_ERROR_FAILURE ;
-
-  for (int i=aNum; i < m_BaseDirNum; i++) {
-    cacheSubDir->FromFileSpec(m_pDiskCacheFolder) ;
-
-    char dirName[3];
-    PR_snprintf (dirName, 3, "%0.2x", i);
-    cacheSubDir->AppendRelativeUnixPath (dirName) ;
-
-    nsFileSpec subdir ;
-    cacheSubDir->GetFileSpec(&subdir) ;
-
-    for(nsDirectoryIterator di(subdir, PR_FALSE); di.Exists(); di++) {
-      di.Spec().Delete(PR_TRUE) ;
-    }
-
-    subdir.Delete(PR_FALSE) ; // recursive delete
+  for(nsDirectoryIterator di(aFolder, PR_FALSE); di.Exists(); di++) {
+    di.Spec().Delete(PR_TRUE) ;
   }
-
+  
+  aFolder.Delete(PR_FALSE) ; // recursive delete
+  
   return NS_OK ;
 }

mozilla/netwerk/cache/filecache/nsNetDiskCache.h

@@ -1,4 +1,5 @@
-/*
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
  * The contents of this file are subject to the Mozilla Public
  * License Version 1.1 (the "License"); you may not use this file
  * except in compliance with the License. You may obtain a copy of
@@ -20,7 +21,13 @@
  *                 Carl Wong <carl.wong@intel.com>
  */
 
-// FUR - Add overall description comment here
+/*
+ * This file is part of filecache implementation.
+ *
+ * nsNetDiskCache is the main disk cache module that will create 
+ * the cache database, and then store and retrieve nsDiskCacheRecord 
+ * objects from it. It also contains some basic error recovery procedure.
+ */
 
 #ifndef __gen_nsNetDiskCache_h__
 #define __gen_nsNetDiskCache_h__
@@ -54,11 +61,12 @@ class nsNetDiskCache : public nsINetDataDiskCache {
 
   NS_IMETHOD InitDB(void) ;
   NS_IMETHOD CreateDir(nsIFileSpec* dir_spec) ;
-  NS_IMETHOD UpdateInfo(void) ;
+  NS_IMETHOD GetSpecialEntry(void) ;
+  NS_IMETHOD SetSpecialEntry(void) ;
 
   NS_IMETHOD RenameCacheSubDirs(void) ;
   NS_IMETHOD DBRecovery(void) ;
-  NS_IMETHOD RemoveDirs(PRUint32 aNum) ;
+  NS_IMETHOD RemoveFolder(nsFileSpec aFolder) ;
 
   private:
 
@@ -72,11 +80,12 @@ class nsNetDiskCache : public nsINetDataDiskCache {
   PRUint32                          m_StorageInUse ;
   nsIDBAccessor*                    m_DB ;
 
-  // this is used to indicate a db corruption
-  PRInt32                           m_BaseDirNum ;
+  // this is used to indicate a db corruption 
+  PRBool                            m_DBCorrupted ;
 
   friend class nsDiskCacheRecord ;
   friend class nsDiskCacheRecordChannel ;
+  friend class nsDBEnumerator ;
 } ;
 
 #endif /* __gen_nsNetDiskCache_h__ */

mozilla/netwerk/cache/memcache/Makefile.in

@@ -29,7 +29,9 @@ LIBRARY_NAME = nkmemcache_s
 
 REQUIRES	= nspr dbm 
 
-EXPORTS=nsMemCacheCID.h
+EXPORTS=nsMemCacheCID.h \
+	nsMemCache.h \
+	$(NULL)
 
 CPPSRCS		= \
         nsMemCache.cpp \

mozilla/netwerk/cache/memcache/nsMemCacheChannel.cpp

@@ -50,7 +50,7 @@ class AsyncReadStreamAdaptor : public nsIInputStream {
 public:
     AsyncReadStreamAdaptor(nsMemCacheChannel* aChannel, nsIInputStream *aSyncStream):
         mSyncStream(aSyncStream), mDataAvailCursor(0),
-        mRemaining(0), mChannel(aChannel), mAvailable(0), mAborted(false), mSuspended(false)
+        mRemaining(0), mAvailable(0), mChannel(aChannel), mAborted(PR_FALSE), mSuspended(PR_FALSE)
         {
             NS_INIT_REFCNT();
             NS_ADDREF(mChannel);
@@ -71,18 +71,18 @@ public:
 
     nsresult
     Cancel(void) {
-        mAborted = true;
+        mAborted = PR_TRUE;
         return mStreamListener->OnStopRequest(mChannel, mContext, NS_BINDING_ABORTED, nsnull);
     }
 
     nsresult
-    Suspend(void) { mSuspended = true; return NS_OK; }
+    Suspend(void) { mSuspended = PR_TRUE; return NS_OK; }
 
     nsresult
     Resume(void) {
         if (!mSuspended)
             return NS_ERROR_FAILURE;
-        mSuspended = false;
+        mSuspended = PR_FALSE;
         return NextListenerEvent();
     }
 
@@ -159,7 +159,7 @@ protected:
 
     nsresult
     Fail(void) {
-        mAborted = true;
+        mAborted = PR_TRUE;
         return mStreamListener->OnStopRequest(mChannel, mContext, NS_BINDING_FAILED, nsnull);
     }
 
@@ -198,8 +198,8 @@ private:
     PRUint32                    mAvailable;      // Number of bytes for which OnDataAvailable fired
     nsMemCacheChannel*          mChannel;        // Associated memory cache channel, strong link
                                                  //   but can not use nsCOMPtr
-    bool                        mAborted;        // Abort() has been called
-    bool                        mSuspended;      // Suspend() has been called
+    PRBool                      mAborted;        // Abort() has been called
+    PRBool                      mSuspended;      // Suspend() has been called
 };
 
 NS_IMPL_ISUPPORTS(AsyncReadStreamAdaptor,  NS_GET_IID(nsIInputStream))
@@ -401,10 +401,8 @@ NS_IMETHODIMP
 nsMemCacheChannel::GetContentType(char* *aContentType)
 {
     // Not required to be implemented, since it is implemented by cache manager
-    // NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
-    // FIXME - lying for the purpose of testing
-    *aContentType = strdup("text/html");
-    return NS_OK;
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP

mozilla/netwerk/cache/memcache/nsMemCacheRecord.h

@@ -23,10 +23,10 @@
 #define _nsMemCacheRecord_h_
 
 #include "nsINetDataCacheRecord.h"
+#include "nsIStorageStream.h"
 #include "nsCOMPtr.h"
 
 class nsMemCache;
-class nsIStorageStream;
 
 class nsMemCacheRecord : public nsINetDataCacheRecord
 {

mozilla/netwerk/cache/mgr/Makefile.in

@@ -31,6 +31,10 @@ LIBRARY_NAME	= nkcachemgr_s
 
 REQUIRES	= nspr
 
+EXPORTS		= \
+		nsCacheManager.h \
+		$(NULL)
+
 CPPSRCS		= \
         nsCacheManager.cpp \
         nsCachedNetData.cpp \

mozilla/netwerk/cache/mgr/nsCacheEntryChannel.cpp

@@ -53,13 +53,14 @@ public:
         mOutputStream(aOutputStream), mCacheEntry(aCacheEntry), mStartTime(PR_Now())
         { NS_INIT_REFCNT(); }
 
-    virtual ~CacheOutputStream() {}
-
+    virtual ~CacheOutputStream() {
+        mCacheEntry->NoteDownloadTime(mStartTime, PR_Now());
+        mCacheEntry->ClearFlag(nsCachedNetData::UPDATE_IN_PROGRESS);
+    }
+    
     NS_DECL_ISUPPORTS
 
     NS_IMETHOD Close() {
-        mCacheEntry->NoteDownloadTime(mStartTime, PR_Now());
-        mCacheEntry->ClearFlag(nsCachedNetData::UPDATE_IN_PROGRESS);
         return mOutputStream->Close();
     }
 
@@ -190,7 +191,7 @@ nsCacheEntryChannel::AsyncRead(PRUint32 aStartPosition, PRInt32 aReadCount,
     CacheManagerStreamListener* cacheManagerStreamListener;
     nsIChannel *channelForListener;
 
-    channelForListener = mProxyChannel ? mProxyChannel : this;
+    channelForListener = mProxyChannel ? mProxyChannel.get() : NS_STATIC_CAST(nsIChannel*, this);
     cacheManagerStreamListener =
         new CacheManagerStreamListener(headListener, mLoadGroup, channelForListener);
     if (!cacheManagerStreamListener) return NS_ERROR_OUT_OF_MEMORY;

mozilla/netwerk/cache/mgr/nsCacheManager.cpp

@@ -38,7 +38,7 @@
 #define MAX_DISK_CACHE_ENTRIES  3200
 
 // Cache capacities in MB, overridable via APIs
-#define DEFAULT_MEMORY_CACHE_CAPACITY  2000
+#define DEFAULT_MEMORY_CACHE_CAPACITY  1024
 #define DEFAULT_DISK_CACHE_CAPACITY   10000
 
 #define CACHE_HIGH_WATER_MARK(capacity) ((PRUint32)(0.98 * (capacity)))
@@ -162,7 +162,8 @@ nsCacheManager::GetCachedNetData(const char *aUriSpec, const char *aSecondaryKey
         if (mDiskCacheCapacity == (PRUint32)-1)
             return NS_ERROR_NOT_AVAILABLE;
 
-    } else if ((aFlags & BYPASS_PERSISTENT_CACHE) || !mDiskCacheCapacity) {
+    } else if ((aFlags & BYPASS_PERSISTENT_CACHE) ||
+               (!mFileCache && !mFlatCache) || !mDiskCacheCapacity) {
         cache = mMemCache;
         spaceManager = mMemSpaceManager;
     } else {
@@ -218,7 +219,7 @@ nsCacheManager::NoteDormant(nsCachedNetData* aEntry)
     
     nsStringKey hashTableKey(nsCString(key, keyLength));
     deletedEntry = (nsCachedNetData*)gCacheManager->mActiveCacheRecords->Remove(&hashTableKey);
-    NS_ASSERTION(deletedEntry == aEntry, "Hash table inconsistency");
+//  NS_ASSERTION(deletedEntry == aEntry, "Hash table inconsistency");
     return NS_OK;
 }
 

mozilla/netwerk/cache/mgr/nsCacheManager.h

@@ -35,6 +35,7 @@
     }
 
 #include "nsINetDataCacheManager.h"
+#include "nsINetDataCache.h"
 #include "nsCOMPtr.h"
 
 class nsHashtable;

mozilla/netwerk/cache/mgr/nsCachedNetData.cpp

@@ -291,8 +291,10 @@ static PRTime
 convertSecondsToPRTime(PRUint32 aSeconds)
 {
     PRInt64 t64;
-    LL_L2I(t64, aSeconds);
-    LL_MUL(t64, t64, 1000000);
+    LL_I2L(t64, aSeconds);
+    PRInt64 mil;
+    LL_I2L(mil, 1000000);
+    LL_MUL(t64, t64, mil);
     return t64;
 }
 
@@ -339,7 +341,7 @@ nsCachedNetData::Init(nsINetDataCacheRecord *aRecord, nsINetDataCache *aCache)
     NS_ADDREF(aRecord);
     mCache = aCache;
     
-    return Deserialize(true);
+    return Deserialize(PR_TRUE);
 }
 
 nsresult
@@ -349,7 +351,7 @@ nsCachedNetData::Resurrect(nsINetDataCacheRecord *aRecord)
     mRecord = aRecord;
     NS_ADDREF(aRecord);
     
-    return Deserialize(true);
+    return Deserialize(PR_TRUE);
 }
 
 // Set a boolean flag for the cache entry
@@ -406,7 +408,7 @@ nsCachedNetData::CommitFlags()
 // extract its components, namely the protocol-specific meta-data and the
 // protocol-independent cache manager meta-data.
 nsresult
-nsCachedNetData::Deserialize(bool aDeserializeFlags)
+nsCachedNetData::Deserialize(PRBool aDeserializeFlags)
 {
     nsresult rv;
     PRUint32 metaDataLength;
@@ -458,19 +460,19 @@ nsCachedNetData::Deserialize(bool aDeserializeFlags)
         if (*tag == 0)
             break;
 
-        CacheMetaData *metaData;
-        metaData = new CacheMetaData(tag);
-        if (!metaData)
+        CacheMetaData *annotation;
+        annotation = new CacheMetaData(tag);
+        if (!annotation)
             return NS_ERROR_OUT_OF_MEMORY;
 
-        rv = binaryStream->Read32(&metaData->mLength);
+        rv = binaryStream->Read32(&annotation->mLength);
         if (NS_FAILED(rv)) return rv;
     
-        rv = binaryStream->ReadBytes(&metaData->mOpaqueBytes, metaData->mLength);
+        rv = binaryStream->ReadBytes(&annotation->mOpaqueBytes, annotation->mLength);
         if (NS_FAILED(rv)) return rv;
 
-        metaData->mNext = mMetaData;
-        mMetaData = metaData;
+        annotation->mNext = mMetaData;
+        mMetaData = annotation;
     }
 
     PRUint16 flags;
@@ -612,7 +614,7 @@ nsCachedNetData::GetLastModifiedTime(PRTime *aLastModifiedTime)
     if (GetFlag(LAST_MODIFIED_KNOWN))
         *aLastModifiedTime = convertSecondsToPRTime(mLastModifiedTime);
     else
-        *aLastModifiedTime = 0;
+        *aLastModifiedTime = LL_ZERO;
     return NS_OK;
 }
 
@@ -634,7 +636,7 @@ nsCachedNetData::GetExpirationTime(PRTime *aExpirationTime)
     if (GetFlag(EXPIRATION_KNOWN))
         *aExpirationTime = convertSecondsToPRTime(mExpirationTime);
     else
-        *aExpirationTime = 0;
+        *aExpirationTime = LL_ZERO;
     return NS_OK;
 }
 
@@ -661,7 +663,7 @@ nsCachedNetData::GetStaleTime(PRTime *aStaleTime)
     if (GetFlag(STALE_TIME_KNOWN)) {
         *aStaleTime = convertSecondsToPRTime(mStaleTime);
     } else {
-        *aStaleTime = 0;
+        *aStaleTime = LL_ZERO;
     }
     return NS_OK;
 }
@@ -719,8 +721,6 @@ nsCachedNetData::Commit(void)
     if (NS_FAILED(rv)) return rv;
 
 #ifdef DEBUG
-    if (GetFlag(EXPIRATION_KNOWN))
-        NS_ASSERTION(GetFlag(LAST_MODIFIED_KNOWN), "Protocol handler error");
     NS_ASSERTION(!GetFlag(UPDATE_IN_PROGRESS),
                  "Protocol handler forgot to clear UPDATE_IN_PROGRESS flag");
 #endif
@@ -748,15 +748,15 @@ nsCachedNetData::Commit(void)
     rv = binaryStream->Write8(CACHE_MANAGER_VERSION);
     if (NS_FAILED(rv)) goto error;
 
-    CacheMetaData *metaData;
-    for (metaData = mMetaData; metaData; metaData = metaData->mNext) {
-        rv = binaryStream->WriteStringZ(metaData->mTag);
+    CacheMetaData *annotation;
+    for (annotation = mMetaData; annotation; annotation = annotation->mNext) {
+        rv = binaryStream->WriteStringZ(annotation->mTag);
         if (NS_FAILED(rv)) return rv;
 
-        rv = binaryStream->Write32(metaData->mLength);
+        rv = binaryStream->Write32(annotation->mLength);
         if (NS_FAILED(rv)) return rv;
     
-        rv = binaryStream->WriteBytes(metaData->mOpaqueBytes, metaData->mLength);
+        rv = binaryStream->WriteBytes(annotation->mOpaqueBytes, annotation->mLength);
         if (NS_FAILED(rv)) return rv;
     }
     // Write terminating null for last meta-data chunk
@@ -1057,7 +1057,9 @@ public:
         mCacheEntry(aCacheEntry), mOriginalListener(aOriginalListener) {
     NS_INIT_REFCNT(); }
     
-    virtual ~InterceptStreamListener() {};
+    virtual ~InterceptStreamListener() {
+        mCacheEntry->ClearFlag(nsCachedNetData::UPDATE_IN_PROGRESS);
+    };
 
     nsresult Init(PRUint32 aStartingOffset) {
         nsresult rv;
@@ -1081,7 +1083,6 @@ public:
         else
             mCacheEntry->ClearFlag(nsCachedNetData::TRUNCATED_CONTENT);
         mCacheEntry->ClearFlag(nsCachedNetData::VESTIGIAL);
-        mCacheEntry->ClearFlag(nsCachedNetData::UPDATE_IN_PROGRESS);
             
         return mOriginalListener->OnStopRequest(channel, ctxt, status, errorMsg);
     }

mozilla/netwerk/cache/mgr/nsCachedNetData.h

@@ -137,7 +137,7 @@ private:
 
     // Initialize internal fields of this nsCachedNetData instance from the
     // underlying raw cache database record.
-    nsresult Deserialize(bool aDeserializeFlags);
+    nsresult Deserialize(PRBool aDeserializeFlags);
 
     // Notify stream-as-file observers about change in cache entry status
     nsresult Notify(PRUint32 aMessage, nsresult aError);

mozilla/netwerk/cache/mgr/nsReplacementPolicy.cpp

@@ -204,16 +204,22 @@ nsCachedNetData::NoteDownloadTime(PRTime start, PRTime end)
     LL_L2D(endFP, end);
 
     duration = endFP - startFP;
-    // Sanity-check
+
+    // If the data arrives so fast that it can not be timed due to the clock
+    // granularity, assume a data arrival duration of 10 ms
     if (!duration)
-        return;
+        duration = 10000;
 
     // Compute download rate in kB/s
-    rate = mLogicalLength / (duration * (1e-6 /1024.0));
+    rate = mLogicalLength / (duration * (1e-6 * 1024.0));
     
-    // Exponentially smooth download rate
-    const double alpha = 0.5;
-    mDownloadRate = (float)(mDownloadRate * alpha + rate * (1.0 - alpha));
+    if (mDownloadRate) {
+        // Exponentially smooth download rate
+        const double alpha = 0.5;
+        mDownloadRate = (float)(mDownloadRate * alpha + rate * (1.0 - alpha));
+    } else {
+        mDownloadRate = (float)rate;
+    }
 }
 
 // 1 hour
@@ -276,7 +282,7 @@ nsCachedNetData::ComputeProfit(PRUint32 aNow)
     //  that it corresponds to the document on the server
     double probabilityFreshness;
     PRInt32 halfLife, age, docTime;
-    bool potentiallyStale;
+    PRBool potentiallyStale;
 
     docTime = GetFlag(LAST_MODIFIED_KNOWN) ? mLastModifiedTime : mLastUpdateTime;
     age = now - docTime;
@@ -287,10 +293,10 @@ nsCachedNetData::ComputeProfit(PRUint32 aNow)
         potentiallyStale = now > mExpirationTime;
         halfLife = mExpirationTime - mLastModifiedTime;
     } else if (GetFlag(STALE_TIME_KNOWN)) {
-        potentiallyStale = true;
+        potentiallyStale = PR_TRUE;
         halfLife = mStaleTime - docTime;
     } else {
-        potentiallyStale = true;
+        potentiallyStale = PR_TRUE;
         halfLife = TYPICAL_HALFLIFE;
     }
     
@@ -301,7 +307,9 @@ nsCachedNetData::ComputeProfit(PRUint32 aNow)
         probabilityFreshness = pow(0.5, (double)age / (double)halfLife);
     }
 
-    mProfit = (float)(frequencyAccess * probabilityFreshness * mDownloadRate);
+    mProfit = (float)(frequencyAccess * probabilityFreshness);
+    if (mDownloadRate)
+        mProfit /= mDownloadRate;
 }
 
 // Number of entries to grow mRankedEntries array when it's full
@@ -312,8 +320,8 @@ nsCachedNetData::ComputeProfit(PRUint32 aNow)
 int
 nsCachedNetData::Compare(const void *a, const void *b, void *unused)
 {
-    nsCachedNetData* entryA = (nsCachedNetData*)a;
-    nsCachedNetData* entryB = (nsCachedNetData*)b;
+    nsCachedNetData* entryA = *(nsCachedNetData**)a;
+    nsCachedNetData* entryB = *(nsCachedNetData**)b;
 
     // Percolate deleted or empty entries to the end of the mRankedEntries
     // array, so that they can be recycled.

mozilla/netwerk/cache/public/Makefile.in

@@ -24,14 +24,18 @@ topsrcdir	= @top_srcdir@
 srcdir		= @srcdir@
 VPATH		= @srcdir@
 
+MODULE		= nkcache
+
 include $(DEPTH)/config/autoconf.mk
 
-EXPORTS		= \
-		nsICacheManager.h \
-		nsICacheObject.h \
-		nsICachePref.h \
-		nsICacheModule.h \
-		$(NULL)
+XPIDLSRCS	= \
+		nsICachedNetData.idl          \
+	        nsINetDataCacheManager.idl    \
+		nsINetDataCache.idl           \
+		nsINetDataCacheRecord.idl     \
+	        nsINetDataDiskCache.idl       \
+		nsIStreamAsFile.idl           \
+	        $(NULL)
 
 EXPORTS		:= $(addprefix $(srcdir)/, $(EXPORTS))
 

mozilla/netwerk/test/TestRawCache.cpp

@@ -29,6 +29,7 @@
 #include <stdio.h>
 
 #include "nsINetDataCache.h"
+#include "nsINetDataDiskCache.h"
 #include "nsINetDataCacheRecord.h"
 #include "nsMemCacheCID.h"
 // file cache include
@@ -730,24 +731,32 @@ main(int argc, char* argv[])
       return -1 ;
     }
 
-    nsCOMPtr<nsINetDataCache> cache;
 
     rv = NS_AutoregisterComponents();
     NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't register XPCOM components");
 
+    nsCOMPtr<nsINetDataCache> cache;
+
     if (PL_strcasecmp(argv[1], "-m") == 0) {
         rv = nsComponentManager::CreateInstance(kMemCacheCID, nsnull,
                                             NS_GET_IID(nsINetDataCache),
                                             getter_AddRefs(cache));
         NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create memory cache factory");
     } else if (PL_strcasecmp(argv[1], "-f") == 0) {
-        // initialize pref
-        initPref() ;
+
+        nsCOMPtr<nsINetDataDiskCache> diskcache ;
 
         rv = nsComponentManager::CreateInstance(kDiskCacheCID, nsnull,
-                                            NS_GET_IID(nsINetDataCache),
-                                             getter_AddRefs(cache));
+                                            NS_GET_IID(nsINetDataDiskCache),
+                                             getter_AddRefs(diskcache));
         NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create disk cache factory") ;
+        
+        nsCOMPtr<nsIFileSpec> folder ;
+        NS_NewFileSpec(getter_AddRefs(folder)) ;
+        folder->SetUnixStyleFilePath("/tmp") ;
+        diskcache->SetDiskCacheFolder(folder) ;
+
+        cache = diskcache ;
 
     } else {
       printf("  %s -f to test filecache\n", argv[0]) ;