This commit was manufactured by cvs2svn to create tag 'CacheMergeWithTrunk'.

git-svn-id: svn://10.0.0.236/tags/CacheMergeWithTrunk@55505 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/netwerk/cache/Makefile.in

@@ -0,0 +1,38 @@
+#
+# The contents of this file are subject to the Netscape 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
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+
+DEPTH		= ../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+DIRS		= \
+        public \
+        memcache \
+        filecache \
+        mgr \
+        build \
+		$(NULL)
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/Makefile.win

@@ -0,0 +1,33 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape 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
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+
+
+DEPTH=..\..
+DIRS= 	\
+	public                  \
+	mgr			\
+	memcache		\
+	filecache		\
+	build                   \
+	$(NULL)
+
+include <$(DEPTH)\config\rules.mak>
+

mozilla/netwerk/cache/build/Makefile.in

@@ -0,0 +1,54 @@
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= nkcache
+LIBRARY_NAME	= nkcache
+IS_COMPONENT	= 1
+
+CPPSRCS		= nsNetDataCacheModule.cpp
+
+SHARED_LIBRARY_LIBS = \
+		$(DIST)/lib/libnkcachemgr_s.a \
+		$(DIST)/lib/libnkfilecache_s.a \
+		$(DIST)/lib/libnkmemcache_s.a \
+        $(DIST)/lib/libmozdbm_s.a     \
+        $(DIST)/lib/libxpcomio_s.a \
+		$(NULL)
+
+LOCAL_INCLUDES	= \
+		-I$(DEPTH)/netwerk/cache/memcache \
+		-I$(DEPTH)/netwerk/cache/filecache \
+		-I$(DEPTH)/netwerk/cache/mgr \
+		$(NULL)
+
+EXTRA_DSO_LDOPTS = \
+		$(MKSHLIB_FORCE_ALL) \
+		$(SHARED_LIBRARY_LIBS) \
+		$(MKSHLIB_UNFORCE_ALL) \
+		$(NULL)
+
+include $(topsrcdir)/config/rules.mk
+
+$(LIBRARY) $(SHARED_LIBRARY): $(SHARED_LIBRARY_LIBS) Makefile
+

mozilla/netwerk/cache/build/makefile.win

@@ -1,3 +1,4 @@
+#!gmake
 #
 # The contents of this file are subject to the Netscape Public
 # License Version 1.1 (the "License"); you may not use this file
@@ -16,54 +17,35 @@
 # Copyright (C) 1998 Netscape Communications Corporation. All
 # Rights Reserved.
 #
-# Contributor(s): 
-#
 
-DEPTH = ..\..\..
-include <$(DEPTH)/config/config.mak>
-
-MODULE = nkcache
-DLLNAME=nkcache
-
-DLL=.\$(OBJDIR)\$(DLLNAME).dll
+DEPTH=..\..\..
+MODULE=nkcache
 
 MAKE_OBJ_TYPE=DLL
+DLLNAME=nkcache
+DLL=.\$(OBJDIR)\$(DLLNAME).dll
 
-LCFLAGS = -DWIN32_LEAN_AND_MEAN -D_IMPL_NS_NET
-
-EXPORTS = \
-		nsCacheService.h \
-		$(NULL)
-
-CPP_OBJS = \
-	.\$(OBJDIR)\nsCache.obj                 \
-	.\$(OBJDIR)\nsCacheEntry.obj			\
-	.\$(OBJDIR)\nsCacheEntryDescriptor.obj  \
-	.\$(OBJDIR)\nsCacheMetaData.obj			\
-	.\$(OBJDIR)\nsCacheModule.obj			\
-	.\$(OBJDIR)\nsCacheService.obj			\
-	.\$(OBJDIR)\nsCacheSession.obj			\
-	.\$(OBJDIR)\nsDiskCacheBinding.obj		\
-	.\$(OBJDIR)\nsDiskCacheBlockFile.obj	\
-	.\$(OBJDIR)\nsDiskCacheDevice.obj		\
-	.\$(OBJDIR)\nsDiskCacheEntry.obj		\
-	.\$(OBJDIR)\nsDiskCacheMap.obj			\
-	.\$(OBJDIR)\nsMemoryCacheDevice.obj		\
+CPP_OBJS=                                    \
+        .\$(OBJDIR)\nsNetDataCacheModule.obj \
 	$(NULL)
 
+LLIBS=                                \
+        $(DIST)\lib\nkcachemgr_s.lib  \
+        $(DIST)\lib\nkfilecache_s.lib \
+        $(DIST)\lib\nkmemcache_s.lib  \
+        $(DIST)\lib\dbm32.lib         \
+        $(DIST)\lib\xpcom.lib         \
+        $(LIBNSPR)  
 
-LLIBS	= \
-	$(LIBNSPR) \
-	$(DIST)\lib\xpcom.lib \
-	$(NULL)
+INCS = $(INCS)                             \
+        -I$(DEPTH)\netwerk\cache\memcache  \
+        -I$(DEPTH)\netwerk\cache\filecache \
+        -I$(DEPTH)\netwerk\cache\mgr       \
+        $(NULL)
 
-include <$(DEPTH)/config/rules.mak>
+include <$(DEPTH)\config\rules.mak>
 
 install:: $(DLL)
 	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).dll $(DIST)\bin\components
 	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib
 
-
-clobber::
-        $(RM) $(DIST)\bin\components\$(DLLNAME).dll
-	$(RM) $(DIST)\lib\$(DLLNAME).lib 

mozilla/netwerk/cache/build/nsNetDataCacheModule.cpp

@@ -0,0 +1,49 @@
+ /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+#include "nsCOMPtr.h"
+#include "nsIModule.h"
+#include "nscore.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsIGenericFactory.h"
+
+#include "nsINetDataCache.h"
+#include "nsINetDataCacheManager.h"
+#include "nsMemCacheCID.h"
+#include "nsMemCache.h"
+#include "nsNetDiskCache.h"
+#include "nsNetDiskCacheCID.h"
+#include "nsCacheManager.h"
+
+// Factory method to create a new nsMemCache instance.  Used
+// by nsNetDataCacheModule
+NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsMemCache, Init)
+NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsNetDiskCache, Init)
+NS_GENERIC_FACTORY_CONSTRUCTOR_INIT(nsCacheManager, Init)
+
+static nsModuleComponentInfo components[] = {
+    { "Memory Cache", NS_MEM_CACHE_FACTORY_CID, NS_NETWORK_MEMORY_CACHE_PROGID, nsMemCacheConstructor },
+    { "File Cache",   NS_NETDISKCACHE_CID,      NS_NETWORK_FILE_CACHE_PROGID,   nsNetDiskCacheConstructor },
+    { "Cache Manager",NS_CACHE_MANAGER_CID,     NS_NETWORK_CACHE_MANAGER_PROGID,nsCacheManagerConstructor }
+};
+
+NS_IMPL_NSGETMODULE("Network Data Cache", components)

mozilla/netwerk/cache/filecache/Makefile.in

@@ -0,0 +1,56 @@
+# 
+# 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
+# the License at http://www.mozilla.org/MPL/
+# 
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+# 
+# The Original Code is Mozilla Communicator.
+# 
+# The Initial Developer of the Original Code is Intel Corp.
+# Portions created by Intel Corp. are
+# Copyright (C) 1999, 1999 Intel Corp.  All
+# Rights Reserved.
+# 
+# Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+#                 Carl Wong <carl.wong@intel.com>
+# 
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+VPATH       = @srcdir@
+srcdir		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE = nkcache
+
+LIBRARY_NAME = nkfilecache_s
+
+REQUIRES	= nspr dbm 
+
+EXTRA_DSO_LDOPTS  +=  -L$(DIST)/lib  -lmozdbm_s
+
+EXPORTS=nsNetDiskCacheCID.h
+
+CPPSRCS		= \
+        nsDBAccessor.cpp\
+        nsDBEnumerator.cpp \
+        nsNetDiskCache.cpp \
+        nsDiskCacheRecord.cpp \
+        nsDiskCacheRecordChannel.cpp \
+		$(NULL)
+
+EXTRA_LIBS	= $(NSPR_LIBS) 
+
+# we don't want the shared lib, but we want to force the creation of a
+# static lib.
+override NO_SHARED_LIB=1
+override NO_STATIC_LIB=
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/filecache/makefile.win

@@ -0,0 +1,44 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+DEPTH=..\..\..
+
+include <$(DEPTH)/config/config.mak>
+
+MODULE = nkcache
+
+LIBRARY_NAME = nkfilecache_s
+
+CPP_OBJS=                                    \
+        .\$(OBJDIR)\nsDBAccessor.obj         \
+        .\$(OBJDIR)\nsDBEnumerator.obj       \
+        .\$(OBJDIR)\nsNetDiskCache.obj       \
+        .\$(OBJDIR)\nsDiskCacheRecord.obj    \
+        .\$(OBJDIR)\nsDiskCacheRecordChannel.obj    \
+	$(NULL)
+
+EXPORTS=nsNetDiskCacheCID.h
+
+include <$(DEPTH)\config\rules.mak> 
+
+install:: $(LIBRARY)
+	$(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
+
+clobber::
+        rm -rf $(OBJDIR)
+        rm -f $(DIST)\lib\$(LIBRARY_NAME).lib
+

mozilla/netwerk/cache/filecache/nsDBAccessor.cpp

@@ -0,0 +1,351 @@
+/*
+ * 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
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+// FUR - Add overall description comment here
+
+#include "nsDBAccessor.h"
+#include "nscore.h"
+
+#include "prtypes.h"
+#include "plhash.h"
+#include "nsCRT.h"
+#include "nsAutoLock.h"
+
+nsDBAccessor::nsDBAccessor() :
+  mDB(0) ,
+  mSessionID(0) ,
+  mSessionCntr(0)
+{
+
+  NS_INIT_REFCNT();
+}
+
+nsDBAccessor::~nsDBAccessor()
+{
+  printf(" ~nsDBAccessor\n") ;
+  Shutdown() ;
+}
+
+//
+// Implement nsISupports methods
+//
+NS_IMPL_ISUPPORTS(nsDBAccessor, NS_GET_IID(nsIDBAccessor))
+
+
+///////////////////////////////////////////////////////////
+// nsIDBAccessor methods 
+
+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) ;
+
+  // FUR - how is page size chosen ?  It's worth putting a comment
+  // in here about the possible usefulness of tuning these parameters
+  HASHINFO hash_info = {
+    16*1024 , /* bucket size */
+    0 ,       /* fill factor */
+    0 ,       /* number of elements */
+    0 ,       /* bytes to cache */
+    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 ?
+
+  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 ;
+
+  int status = (*mDB->get)(mDB, &db_key, &db_data, 0) ;
+  if(status == -1) {
+    NS_ERROR("ERROR: failed get session id in database.") ;
+    return NS_ERROR_FAILURE ;
+  }
+
+  if(status == 0) {
+    // get the last session id
+    PRInt16 *old_ID = NS_STATIC_CAST(PRInt16*, db_data.data) ;
+    if(*old_ID < ini_sessionID) {
+      NS_ERROR("ERROR: Bad Session ID in database, corrupted db.") ;
+      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) {
+    // must be a new db
+    mSessionID = ini_sessionID ;
+  }
+  db_data.data = NS_REINTERPRET_CAST(void*, &mSessionID) ;
+  db_data.size = sizeof(PRInt16) ;
+
+  // store the new session id
+  status = (*mDB->put)(mDB, &db_key, &db_data, 0) ;
+  if(status == 0) {
+    (*mDB->sync)(mDB, 0) ;
+    return NS_OK ;
+  } 
+  else {
+    NS_ERROR("reset session ID failure.") ;
+    return NS_ERROR_FAILURE ;
+  }
+}
+
+NS_IMETHODIMP
+nsDBAccessor::Shutdown(void)
+{
+  if(mDB) {
+    (*mDB->sync)(mDB, 0) ;
+    (*mDB->close)(mDB) ;
+    mDB = nsnull ;
+  }
+
+  // FUR - locks not necessary
+  if(m_Lock) 
+    PR_DestroyLock(m_Lock);
+  return NS_OK ;
+}
+  
+NS_IMETHODIMP
+nsDBAccessor::Get(PRInt32 aID, void** anEntry, PRUint32 *aLength) 
+{
+  if(!anEntry)
+    return NS_ERROR_NULL_POINTER ;
+
+  *anEntry = nsnull ;
+  *aLength = 0 ;
+
+  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) ;
+  db_key.size = sizeof(PRInt32) ;
+  
+  int status = 0 ;
+  status = (*mDB->get)(mDB, &db_key, &db_data, 0) ;
+
+  if(status == 0) {
+    *anEntry = db_data.data ;
+    *aLength = db_data.size ;
+    return NS_OK ;
+  } 
+  else if(status == 1)
+    return NS_OK ;
+  else
+    return NS_ERROR_FAILURE ;
+
+}
+
+NS_IMETHODIMP
+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) ;
+  db_key.size = sizeof(PRInt32) ;
+
+  db_data.data = anEntry ;
+  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 ;
+  }
+  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 ;
+  }
+}
+
+/*
+ * It's more important to remove the id->metadata entry first since
+ * key->id mapping is just a reference
+ */
+NS_IMETHODIMP
+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
+  db_key.data = NS_REINTERPRET_CAST(void*, &aID) ;
+  db_key.size = sizeof(PRInt32) ;
+
+  PRInt32 status = -1 ;
+  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 ;
+  } 
+
+  // delete key->recordID
+  db_key.data = anEntry ;
+  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 ;
+}
+
+NS_IMETHODIMP
+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) ;
+  db_key.size = length ;
+
+  int status = (*mDB->get)(mDB, &db_key, &db_data, 0) ;
+  if(status == 0) {
+    // found recordID
+    *aID = *(NS_REINTERPRET_CAST(PRInt32*, db_data.data)) ;
+    return NS_OK ;
+  }
+  else if(status == 1) {
+    // create a new one
+    PRInt32 id = 0 ;
+    id = mSessionID << 16 | mSessionCntr++ ;
+
+    // add new id into mDB
+    db_data.data = NS_REINTERPRET_CAST(void*, &id) ;
+    db_data.size = sizeof(PRInt32) ;
+
+    status = (*mDB->put)(mDB, &db_key, &db_data, 0) ;
+    if(status != 0) {
+      NS_ERROR("updating db failure.") ;
+      return NS_ERROR_FAILURE ;
+    }
+    // FUR - defer sync ?
+    (*mDB->sync)(mDB, 0) ;
+    *aID = id ;
+    return NS_OK ;
+  } 
+  else {
+    NS_ERROR("ERROR: keydb failure.") ;
+    return NS_ERROR_FAILURE ;
+  }
+}
+
+NS_IMETHODIMP
+nsDBAccessor::EnumEntry(void** anEntry, PRUint32* aLength, PRBool bReset) 
+{
+  if(!anEntry)
+    return NS_ERROR_NULL_POINTER ;
+
+  *anEntry = nsnull ;
+  *aLength = 0 ;
+
+  NS_ASSERTION(mDB, "no database") ;
+
+  PRUint32 flag ;
+
+  if(bReset) 
+    flag = R_FIRST ;
+  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 ;
+
+  int status ;
+
+  do {
+    status = (*mDB->seq)(mDB, &db_key, &db_data, flag) ;
+    flag = R_NEXT ;
+    if(status == -1)
+      return NS_ERROR_FAILURE ;
+    // get next if it's a key->recordID 
+    if(db_key.size > sizeof(PRInt32) && db_data.size == sizeof(PRInt32))
+      continue ;
+    // get next if it's a sessionID entry
+    if(db_key.size == len && db_data.size == sizeof(PRInt16))
+      continue ;
+    // recordID is always 32 bits long
+    if(db_key.size == sizeof(PRInt32))
+      break ;
+  } while(!status) ;
+
+  if (0 == status) {
+    *anEntry = db_data.data ;
+    *aLength = db_data.size ;
+  }
+  return NS_OK ;
+}

mozilla/netwerk/cache/filecache/nsDBAccessor.h

@@ -0,0 +1,68 @@
+/*
+ * 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
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+// FUR - Add overall description comment here
+
+#ifndef _NSIDBACCESSOR_H_
+#define _NSIDBACCESSOR_H_
+
+#include "nsIDBAccessor.h"
+#include "mcom_db.h"
+
+// bogus string for the key of session id 
+// FUR - suggest "SK" instead of "^^"
+static const char * const SessionKey = "^^" ;
+
+// initial session id number 
+static const PRInt16 ini_sessionID = 0xff ;
+
+class nsDBAccessor : public nsIDBAccessor
+{
+  public:
+  NS_DECL_ISUPPORTS
+
+  nsDBAccessor() ;
+  virtual ~nsDBAccessor() ;
+  
+  NS_IMETHOD Init(nsIFileSpec* dbfile) ;
+  NS_IMETHOD Shutdown(void) ; 
+
+  NS_IMETHOD Put(PRInt32 aID, void* anEntry, PRUint32 aLength) ;
+
+  NS_IMETHOD Get(PRInt32 aID, void** anEntry, PRUint32 *aLength) ;
+
+  NS_IMETHOD Del(PRInt32 aID, void* anEntry, PRUint32 aLength) ;
+
+  NS_IMETHOD GetID(const char* key, PRUint32 length, PRInt32* aID) ;
+
+  NS_IMETHOD EnumEntry(void* *anEntry, PRUint32* aLength, PRBool bReset) ;
+
+  protected:
+
+  private:
+  DB *                          mDB ;
+  PRInt16                       mSessionID ;
+  PRInt16                       mSessionCntr ;
+  PRLock *                      m_Lock ;
+} ;
+
+#endif // _NSIDBACCESSOR_H_

mozilla/netwerk/cache/filecache/nsDBEnumerator.cpp

@@ -0,0 +1,97 @@
+/*
+ * 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
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+// FUR - Add overall description comment here
+
+#include "nsDBEnumerator.h"
+#include "nsDiskCacheRecord.h"
+
+nsDBEnumerator::nsDBEnumerator(nsIDBAccessor* aDB, nsNetDiskCache* aCache) :
+  m_DB(aDB) ,
+  m_DiskCache(aCache) ,
+  tempEntry(0) ,
+  tempEntry_length(0) ,
+  m_CacheEntry(0) ,
+  bReset(PR_TRUE) 
+{
+  NS_INIT_REFCNT();
+
+}
+
+nsDBEnumerator::~nsDBEnumerator()
+{
+//  printf(" ~nsDBEnumerator()\n") ;
+  NS_IF_RELEASE(m_CacheEntry) ;
+}
+
+//
+// Implement nsISupports methods
+//
+NS_IMPL_ISUPPORTS(nsDBEnumerator, NS_GET_IID(nsIEnumerator))
+
+/////////////////////////////////////////////////////////////////
+// nsISimpleEnumerator methods
+
+NS_IMETHODIMP
+nsDBEnumerator::HasMoreElements(PRBool *_retval)
+{
+  *_retval = PR_FALSE ;
+
+  m_DB->EnumEntry(&tempEntry, &tempEntry_length, bReset) ;
+  bReset = PR_FALSE ;
+
+  if(tempEntry && tempEntry_length != 0)
+    *_retval = PR_TRUE ;
+
+  return NS_OK ;
+}
+
+// this routine does not create a new item by itself  
+// Rather it reuses the item inside the object. So if you need to use the 
+// item later, you have to
+// create a new item specifically, using copy constructor or some other dup 
+// function. And don't forget to release it after you're done
+//
+NS_IMETHODIMP
+nsDBEnumerator::GetNext(nsISupports **_retval)
+{
+  if(!m_CacheEntry) {
+    m_CacheEntry = new nsDiskCacheRecord(m_DB, m_DiskCache) ;
+    if(m_CacheEntry)
+      NS_ADDREF(m_CacheEntry) ;
+    else
+      return NS_ERROR_OUT_OF_MEMORY ;
+  }
+
+  if(!_retval)
+    return NS_ERROR_NULL_POINTER ;
+  *_retval = nsnull ;
+
+  nsresult rv = m_CacheEntry->RetrieveInfo(tempEntry, tempEntry_length) ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  *_retval = NS_STATIC_CAST(nsISupports*, m_CacheEntry) ;
+  NS_ADDREF(*_retval) ; // all good getter addref 
+
+  return NS_OK ;
+}

mozilla/netwerk/cache/filecache/nsDBEnumerator.h

@@ -0,0 +1,61 @@
+/*
+ * 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
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+// FUR - Add overall description comment here
+
+#ifndef _NS_DBENUMERATOR_H_
+#define _NS_DBENUMERATOR_H_
+
+#include "nsISimpleEnumerator.h"
+#include "nsINetDataCacheRecord.h"
+#include "nsIDBAccessor.h"
+#include "nsCOMPtr.h"
+#include "nsNetDiskCache.h"
+#include "nsDiskCacheRecord.h"
+
+class nsCachedDiskData ; /* forward decl */
+
+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) ;
+
+    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 ;
+};
+
+#endif // _NS_DBENUMERATOR_H_

mozilla/netwerk/cache/filecache/nsDiskCacheRecord.cpp

@@ -0,0 +1,451 @@
+/*
+ * 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
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#include "nsDiskCacheRecord.h"
+#include "nsINetDataDiskCache.h"
+#include "nsNetDiskCacheCID.h"
+#include "nsDiskCacheRecordChannel.h"
+#include "nsFileStream.h"
+
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsIProtocolHandler.h"
+#include "nsIIOService.h"
+#include "nsIAllocator.h"
+
+#include "plstr.h"
+#include "prprf.h"
+#include "prmem.h"
+#include "prlog.h"
+#include "prtypes.h"
+#include "netCore.h"
+
+#include "nsDBAccessor.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
+
+nsDiskCacheRecord::nsDiskCacheRecord(nsIDBAccessor* db, nsNetDiskCache* aCache) :
+  mKey(0) ,
+  mKeyLength(0) ,
+  mRecordID(0) ,
+  mMetaData(0) ,
+  mMetaDataLength(0) ,
+  mDB(db) ,
+  mInfo(0) ,
+  mInfoSize(0) ,
+  mNumChannels(0) ,
+  mDiskCache(aCache) 
+{
+
+  NS_INIT_REFCNT();
+}
+
+// mem alloced. so caller should do free() on key. 
+NS_IMETHODIMP
+nsDiskCacheRecord::Init(const char* key, PRUint32 length) 
+{
+  NS_NewFileSpec(getter_AddRefs(mFile));
+  if(!mFile)
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  // copy key
+  mKeyLength = length ;
+  mKey = NS_STATIC_CAST(char*, nsAllocator::Alloc(mKeyLength*sizeof(char))) ;
+  if(!mKey) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  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
+
+  // setup the file name
+  nsCOMPtr<nsIFileSpec> dbFolder ;
+  mDiskCache->GetDiskCacheFolder(getter_AddRefs(dbFolder)) ;
+
+  nsresult rv = mFile->FromFileSpec(dbFolder) ;
+  if(NS_FAILED(rv))
+    return NS_ERROR_FAILURE ;
+
+  // 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)) ;
+  mFile->AppendRelativeUnixPath(dirName) ;
+
+  // FUR!! - should the format string be "%.08x".  How does this work !?
+  PR_snprintf(filename, 9, "%.8x", mRecordID) ;
+  mFile->AppendRelativeUnixPath(filename) ;
+
+  return NS_OK ;
+}
+
+nsDiskCacheRecord::~nsDiskCacheRecord()
+{
+//  printf(" ~nsDiskCacheRecord()\n") ;
+  if(mKey)
+    nsAllocator::Free(mKey) ;
+  if(mMetaData)
+    nsAllocator::Free(mMetaData) ;
+
+}
+
+//
+// Implement nsISupports methods
+//
+NS_IMPL_ISUPPORTS(nsDiskCacheRecord, NS_GET_IID(nsINetDataCacheRecord))
+
+///////////////////////////////////////////////////////////////////////
+// nsINetDataCacheRecord methods
+
+// yes, mem alloced on *_retval.
+NS_IMETHODIMP
+nsDiskCacheRecord::GetKey(PRUint32 *length, char** _retval) 
+{
+  if(!_retval)
+    return NS_ERROR_NULL_POINTER ;
+
+  *length = mKeyLength ;
+  *_retval = NS_STATIC_CAST(char*, nsAllocator::Alloc(mKeyLength*sizeof(char))) ;
+  if(!*_retval)
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  memcpy(*_retval, mKey, mKeyLength) ;
+
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecord::GetRecordID(PRInt32* aRecordID)
+{
+  *aRecordID = mRecordID ;
+  return NS_OK ;
+}
+
+// yes, mem alloced on *_retval. 
+NS_IMETHODIMP
+nsDiskCacheRecord::GetMetaData(PRUint32 *length, char **_retval) 
+{
+  if(!_retval)
+    return NS_ERROR_NULL_POINTER ;
+
+  // always null the return value first. 
+  *_retval = nsnull ;
+
+  *length = mMetaDataLength ;
+
+  if(mMetaDataLength) {
+    *_retval = NS_STATIC_CAST(char*, nsAllocator::Alloc(mMetaDataLength*sizeof(char))) ;
+    if(!*_retval)
+      return NS_ERROR_OUT_OF_MEMORY ;
+
+    memcpy(*_retval, mMetaData, mMetaDataLength) ;
+  }
+
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecord::SetMetaData(PRUint32 length, const char* data)
+{
+  // set the mMetaData
+  mMetaDataLength = length ;
+  if(mMetaData)
+    nsAllocator::Free(mMetaData) ;
+  mMetaData = NS_STATIC_CAST(char*, nsAllocator::Alloc(mMetaDataLength*sizeof(char))) ;
+  if(!mMetaData) {
+    return NS_ERROR_OUT_OF_MEMORY ;
+  }
+  memcpy(mMetaData, data, length) ;
+
+  // Generate mInfo
+  nsresult rv = GenInfo() ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  // write through into mDB
+  rv = mDB->Put(mRecordID, mInfo, mInfoSize) ;
+
+  // FUR - mInfo leaking ?
+  return rv ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecord::GetStoredContentLength(PRUint32 *aStoredContentLength)
+{
+  return mFile->GetFileSize(aStoredContentLength) ;
+}
+
+// untill nsIFileSpec::Truncate() is in, we have to do all this ugly stuff
+NS_IMETHODIMP
+nsDiskCacheRecord::SetStoredContentLength(PRUint32 aStoredContentLength)
+{
+  PRUint32 len = 0 ;
+  nsresult rv = mFile->GetFileSize(&len) ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  if(len < aStoredContentLength)
+  {
+    NS_ERROR("Error: can not set filesize to something bigger than itself.\n") ;
+    return NS_ERROR_FAILURE ;
+  }
+  else 
+    return mFile->Truncate(aStoredContentLength) ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecord::Delete(void)
+{
+  if(mNumChannels)
+    return NS_ERROR_NOT_AVAILABLE ;
+
+  PRUint32 len ;
+  mFile->GetFileSize(&len) ;
+
+  nsFileSpec cache_file ;
+  nsresult rv = mFile->GetFileSpec(&cache_file) ;
+
+  if(NS_FAILED(rv)) 
+    return NS_ERROR_FAILURE ;
+
+  cache_file.Delete(PR_TRUE) ;
+
+  // updata the storage size
+  mDiskCache->m_StorageInUse -= len ;
+
+  rv = mDB->Del(mRecordID, mKey, mKeyLength) ;
+  if(NS_FAILED(rv)) 
+    return NS_ERROR_FAILURE ;
+  else
+    return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecord::GetFilename(nsIFileSpec * *aFilename) 
+{
+  if(!aFilename)
+    return NS_ERROR_NULL_POINTER ;
+
+  *aFilename = mFile ;
+  NS_ADDREF(*aFilename) ;
+
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecord::NewChannel(nsILoadGroup *loadGroup, nsIChannel **_retval) 
+{
+  nsDiskCacheRecordChannel* channel = new nsDiskCacheRecordChannel(this, loadGroup) ;
+  if(!channel) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  nsresult rv = channel->Init() ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  NS_ADDREF(channel) ;
+  *_retval = NS_STATIC_CAST(nsIChannel*, channel) ;
+  return NS_OK ;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// nsDiskCacheRecord methods
+
+// file name is represented by a url string. I hope this would be more
+// generic
+nsresult
+nsDiskCacheRecord::GenInfo() 
+{
+  if(mInfo)
+    nsAllocator::Free(mInfo) ;
+
+  char* file_url=nsnull ;
+  PRUint32 name_len ;
+  mFile->GetURLString(&file_url) ;
+  name_len = PL_strlen(file_url)+1 ;
+
+  mInfoSize  = sizeof(PRUint32) ;    // checksum for mInfoSize
+  mInfoSize += sizeof(PRInt32) ;     // RecordID
+  mInfoSize += sizeof(PRUint32) ;    // key length
+  mInfoSize += mKeyLength ;          // key 
+  mInfoSize += sizeof(PRUint32) ;    // metadata length
+  mInfoSize += mMetaDataLength ;     // metadata 
+  mInfoSize += sizeof(PRUint32) ;    // filename length
+  mInfoSize += name_len ;            // filename 
+
+  void* newInfo = nsAllocator::Alloc(mInfoSize*sizeof(char)) ;
+  if(!newInfo) {
+    return NS_ERROR_OUT_OF_MEMORY ;
+  }
+
+  // copy the checksum mInfoSize
+  char* cur_ptr = NS_STATIC_CAST(char*, newInfo) ;
+  COPY_INT32(cur_ptr, &mInfoSize) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // copy RecordID
+  COPY_INT32(cur_ptr, &mRecordID) ;
+  cur_ptr += sizeof(PRInt32) ;
+
+  // copy key length
+  COPY_INT32(cur_ptr, &mKeyLength) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // copy key
+  memcpy(cur_ptr, mKey, mKeyLength) ;
+  cur_ptr += mKeyLength ;
+
+  // copy metadata length
+  COPY_INT32(cur_ptr, &mMetaDataLength) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // copy metadata
+  memcpy(cur_ptr, mMetaData, mMetaDataLength) ;
+  cur_ptr += mMetaDataLength ;
+
+  // copy file name length 
+  COPY_INT32(cur_ptr, &name_len) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // copy file name
+  memcpy(cur_ptr, file_url, name_len) ;
+  cur_ptr += name_len ;
+
+  PR_ASSERT(cur_ptr == NS_STATIC_CAST(char*, newInfo) + mInfoSize);
+  mInfo = newInfo ;
+
+  return NS_OK ;
+}
+
+/*
+ * This Method suppose to get all the info from the db record
+ * and set them to accroding members. the original values
+ * will all be overwritten. only minimal error checking is performed.
+ */
+NS_IMETHODIMP
+nsDiskCacheRecord::RetrieveInfo(void* aInfo, PRUint32 aInfoLength) 
+{
+  // reset everything
+  if(mInfo) {
+    nsAllocator::Free(mInfo) ;
+    mInfo = nsnull ;
+  }
+
+  if(mKey) {
+    nsAllocator::Free(mKey) ;
+    mKey = nsnull ;
+  }
+  if(mMetaData) {
+    nsAllocator::Free(mMetaData) ;
+    mMetaData = nsnull ;
+  }
+
+  char * cur_ptr = NS_STATIC_CAST(char*, aInfo) ;
+
+  char* file_url ;
+  PRUint32 name_len ;
+
+  // set mInfoSize 
+  COPY_INT32(&mInfoSize, cur_ptr) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // check this at least
+  if(mInfoSize != aInfoLength) 
+    return NS_ERROR_FAILURE ;
+
+  // set mRecordID 
+  COPY_INT32(&mRecordID, cur_ptr) ;
+  cur_ptr += sizeof(PRInt32) ;
+
+  // set mKeyLength
+  COPY_INT32(&mKeyLength, cur_ptr) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // set mKey
+  mKey = NS_STATIC_CAST(char*, nsAllocator::Alloc(mKeyLength*sizeof(char))) ;
+  if(!mKey) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+  
+  memcpy(mKey, cur_ptr, mKeyLength) ;
+  cur_ptr += mKeyLength ;
+
+  PRInt32 id ;
+  mDB->GetID(mKey, mKeyLength, &id) ;
+  NS_ASSERTION(id==mRecordID, "\t ++++++ bad record, somethings wrong\n") ;
+
+  // set mMetaDataLength
+  COPY_INT32(&mMetaDataLength, cur_ptr) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // set mMetaData
+  mMetaData = NS_STATIC_CAST(char*, nsAllocator::Alloc(mMetaDataLength*sizeof(char))) ;
+  if(!mMetaData) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+  
+  memcpy(mMetaData, cur_ptr, mMetaDataLength) ;
+  cur_ptr += mMetaDataLength ;
+
+  // get mFile name length
+  COPY_INT32(&name_len, cur_ptr) ;
+  cur_ptr += sizeof(PRUint32) ;
+
+  // get mFile native name
+  file_url = NS_STATIC_CAST(char*, nsAllocator::Alloc(name_len*sizeof(char))) ;
+  if(!file_url) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+  
+  memcpy(file_url, cur_ptr, name_len) ;
+  cur_ptr += name_len ;
+
+  PR_ASSERT(cur_ptr == NS_STATIC_CAST(char*, aInfo) + mInfoSize);
+
+  // create mFile if Init() isn't called 
+  if(!mFile) {
+    NS_NewFileSpec(getter_AddRefs(mFile));
+    if(!mFile)
+      return NS_ERROR_OUT_OF_MEMORY ;
+  }
+
+  // setup mFile
+  mFile->SetURLString(file_url) ;
+
+  return NS_OK ;
+}
+

mozilla/netwerk/cache/filecache/nsDiskCacheRecord.h

@@ -0,0 +1,70 @@
+/*
+ * 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
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#ifndef _NET_CACHEDDISKDATA_H_
+#define _NET_CACHEDDISKDATA_H_
+
+#include "nsINetDataCacheRecord.h"
+#include "nsCOMPtr.h"
+#include "nsIDBAccessor.h"
+#include "prtypes.h"
+#include "nsILoadGroup.h"
+#include "nsIFileChannel.h" 
+#include "nsNetDiskCache.h"
+
+class nsDiskCacheRecord : public nsINetDataCacheRecord
+{
+  public:
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSINETDATACACHERECORD
+
+  protected: 
+
+  nsDiskCacheRecord(nsIDBAccessor* db, nsNetDiskCache* aCache) ;
+  virtual ~nsDiskCacheRecord() ;
+
+  NS_IMETHOD RetrieveInfo(void* aInfo, PRUint32 aInfoLength) ;
+  NS_IMETHOD Init(const char* key, PRUint32 length) ;
+
+  nsresult GenInfo(void) ;
+
+  private:
+
+  char*                     mKey ;
+  PRUint32                  mKeyLength ;
+  PRInt32                   mRecordID ;
+  char*                     mMetaData ;
+  PRUint32                  mMetaDataLength ;
+  nsCOMPtr<nsIFileSpec>     mFile ;
+  nsCOMPtr<nsIDBAccessor>            mDB ; 
+  void*                     mInfo ;
+  PRUint32                  mInfoSize ;
+  PRUint32                  mNumChannels ;
+  nsCOMPtr<nsNetDiskCache>           mDiskCache ;
+
+  friend class nsDiskCacheRecordChannel ;
+  friend class nsDBEnumerator ;
+  friend class nsNetDiskCache ;
+} ;
+
+#endif // _NET_CACHEDDISKDATA_H_

mozilla/netwerk/cache/filecache/nsDiskCacheRecordChannel.cpp

@@ -0,0 +1,392 @@
+/* -*- 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
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#include "nsDiskCacheRecordChannel.h"
+//#include "nsFileTransport.h"
+#include "nsIIOService.h"
+#include "nsIServiceManager.h"
+
+#include "nsIOutputStream.h"
+
+static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
+
+// This is copied from nsMemCacheChannel, We should consolidate these two.
+class WriteStreamWrapper : public nsIOutputStream 
+{
+  public:
+  WriteStreamWrapper(nsDiskCacheRecordChannel* aChannel,
+                     nsIOutputStream *aBaseStream) ;
+
+  virtual ~WriteStreamWrapper() ;
+
+  static nsresult
+  Create(nsDiskCacheRecordChannel* aChannel, nsIOutputStream *aBaseStream, nsIOutputStream* *aWrapper) ;
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIBASESTREAM
+  NS_DECL_NSIOUTPUTSTREAM
+
+  private:
+  nsDiskCacheRecordChannel*         mChannel;
+  nsCOMPtr<nsIOutputStream>         mBaseStream;
+} ;
+
+// implement nsISupports
+NS_IMPL_ISUPPORTS(WriteStreamWrapper, NS_GET_IID(nsIOutputStream))
+
+WriteStreamWrapper::WriteStreamWrapper(nsDiskCacheRecordChannel* aChannel, 
+                                       nsIOutputStream *aBaseStream) 
+  : mChannel(aChannel), mBaseStream(aBaseStream)
+{ 
+  NS_INIT_REFCNT(); 
+  NS_ADDREF(mChannel);
+}
+
+WriteStreamWrapper::~WriteStreamWrapper()
+{
+  NS_RELEASE(mChannel);
+}
+
+nsresult 
+WriteStreamWrapper::Create(nsDiskCacheRecordChannel*aChannel, nsIOutputStream *aBaseStream, nsIOutputStream* * aWrapper) 
+{
+  WriteStreamWrapper *wrapper = new WriteStreamWrapper(aChannel, aBaseStream);
+  if (!wrapper) return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(wrapper);
+  *aWrapper = wrapper;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+WriteStreamWrapper::Write(const char *aBuffer, PRUint32 aCount, PRUint32 *aNumWritten) 
+{
+  *aNumWritten = 0;
+  nsresult rv = mBaseStream->Write(aBuffer, aCount, aNumWritten);
+  mChannel->NotifyStorageInUse(*aNumWritten);
+  return rv;
+}
+
+NS_IMETHODIMP
+WriteStreamWrapper::Flush() 
+{ 
+  return mBaseStream->Flush(); 
+}
+
+NS_IMETHODIMP
+WriteStreamWrapper::Close() 
+{ 
+  return mBaseStream->Close(); 
+}
+
+nsDiskCacheRecordChannel::nsDiskCacheRecordChannel(nsDiskCacheRecord *aRecord, 
+                                                   nsILoadGroup *aLoadGroup)
+  : mRecord(aRecord) ,
+    mLoadGroup(aLoadGroup) 
+{
+  NS_INIT_REFCNT() ;
+  mRecord->mNumChannels++ ;
+}
+
+nsDiskCacheRecordChannel::~nsDiskCacheRecordChannel()
+{
+  mRecord->mNumChannels-- ;
+}
+
+// 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:
+//
+//   > I just thought of an argument for the other side of the coin, i.e. the
+//   > benefit of *not* reusing the file protocol handler: On the Mac, it's
+//   > expensive to convert from a string URL to an nsFileSpec, because the Mac
+//   > is brain-dead and scans every directory on the path to the file.  It's
+//   > cheaper to create a nsFileSpec for a cache file by combining a single,
+//   > static nsFileSpec that corresponds to the cache directory with the
+//   > relative path to the cache file (using nsFileSpec's operator +).  This
+//   > operation is optimized on the Mac to avoid the scanning operation.
+//
+//  The Mac guys will eat us alive if we do path string to nsFileSpec
+//  conversions for every cache file we open.
+
+nsresult 
+nsDiskCacheRecordChannel::Init(void) 
+{
+  char* urlStr ;
+  mRecord->mFile->GetURLString(&urlStr) ;
+
+  nsresult rv ;
+  NS_WITH_SERVICE(nsIIOService, serv, kIOServiceCID, &rv);
+  if (NS_FAILED(rv)) return rv;
+
+  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));
+  return rv ;
+}
+
+nsresult 
+nsDiskCacheRecordChannel::NotifyStorageInUse(PRInt32 aBytesUsed)
+{
+  return mRecord->mDiskCache->m_StorageInUse += aBytesUsed ;
+}
+
+// implement nsISupports
+NS_IMPL_ISUPPORTS(nsDiskCacheRecordChannel, NS_GET_IID(nsIChannel))
+
+// implement nsIRequest
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::IsPending(PRBool *aIsPending) 
+{
+  *aIsPending = PR_FALSE ;
+  if(!mFileTransport)
+    return NS_OK ;
+
+  return mFileTransport->IsPending(aIsPending) ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::Cancel(void)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->Cancel() ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::Suspend(void)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->Suspend() ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::Resume(void)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->Resume() ;
+}
+
+// implement nsIChannel
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetURI(nsIURI * *aURI)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->GetURI(aURI) ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::OpenInputStream(PRUint32 aStartPosition, 
+                                          PRInt32 aReadCount,
+                                          nsIInputStream* *aResult)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->OpenInputStream(aStartPosition,
+                                         aReadCount,
+                                         aResult) ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::OpenOutputStream(PRUint32 startPosition, 
+                                           nsIOutputStream* *aResult)
+{
+  nsresult rv ;
+  NS_ENSURE_ARG(aResult) ;
+
+  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)) ;
+  if(NS_FAILED(rv)) 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) ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::AsyncRead(PRUint32 aStartPosition, 
+                                    PRInt32 aReadCount,
+                                    nsISupports *aContext, 
+                                    nsIStreamListener *aListener)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->AsyncRead(aStartPosition , 
+                                   aReadCount , 
+                                   aContext , 
+                                   aListener) ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::AsyncWrite(nsIInputStream *fromStream, 
+                                     PRUint32 startPosition,
+                                     PRInt32 writeCount, 
+                                     nsISupports *ctxt,
+                                     nsIStreamObserver *observer)
+
+{
+  /*
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->AsyncWrite(fromStream, 
+                                    startPosition,
+                                    writeCount,
+                                    ctxt,
+                                    observer) ;
+  */
+
+  // I can't do this since the write is not monitored, and I won't be
+  // able to updata the storage. 
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetLoadAttributes(nsLoadFlags *aLoadAttributes)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->GetLoadAttributes(aLoadAttributes) ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::SetLoadAttributes(nsLoadFlags aLoadAttributes)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->SetLoadAttributes(aLoadAttributes) ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetContentType(char * *aContentType)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->GetContentType(aContentType) ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetContentLength(PRInt32 *aContentLength)
+{
+  if(!mFileTransport)
+    return NS_ERROR_FAILURE ;
+
+  return mFileTransport->GetContentLength(aContentLength) ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetOwner(nsISupports* *aOwner)
+{
+  *aOwner = mOwner.get() ;
+  NS_IF_ADDREF(*aOwner) ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::SetOwner(nsISupports* aOwner) 
+{
+  mOwner = 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 ;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}

mozilla/netwerk/cache/filecache/nsDiskCacheRecordChannel.h

@@ -0,0 +1,65 @@
+/*
+ * 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
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#ifndef _ns_DiskCacheRecordChannel_h_
+#define _ns_DiskCacheRecordChannel_h_
+
+#include "nsIChannel.h"
+#include "nsCOMPtr.h"
+#include "nsDiskCacheRecord.h"
+
+/*
+ * This class is plagiarized from nsMemCacheChannel
+ */
+
+class nsDiskCacheRecordChannel : public nsIChannel
+{
+  public:
+
+  nsDiskCacheRecordChannel(nsDiskCacheRecord *aRecord, nsILoadGroup *aLoadGroup);
+  virtual ~nsDiskCacheRecordChannel() ;
+
+  // Declare nsISupports methods
+  NS_DECL_ISUPPORTS
+
+  // Declare nsIRequest methods
+  NS_DECL_NSIREQUEST
+
+  // Declare nsIChannel methods
+  NS_DECL_NSICHANNEL
+
+  nsresult Init(void) ;
+
+  private:
+
+  nsresult NotifyStorageInUse(PRInt32 aBytesUsed) ;
+
+  nsCOMPtr<nsDiskCacheRecord>           mRecord ;
+  nsCOMPtr<nsILoadGroup>                mLoadGroup ;
+  nsCOMPtr<nsISupports>                 mOwner ;
+  nsCOMPtr<nsIChannel>                  mFileTransport ;
+
+  friend class WriteStreamWrapper ;
+} ;
+
+#endif // _ns_DiskCacheRecordChannel_h_
+

mozilla/netwerk/cache/filecache/nsIDBAccessor.h

@@ -0,0 +1,60 @@
+/*
+ * 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
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#ifndef _NS_IDBACCESSOR_H_
+#define _NS_IDBACCESSOR_H_
+
+#include "nsISupports.h"
+#include "nsIFileSpec.h"
+
+// nsIDBAccessorIID {6AADD4D0-7785-11d3-87FE-000629D01344}
+#define NS_IDBACCESSOR_IID \
+{ 0x6aadd4d0, 0x7785, 0x11d3, \
+ {0x87, 0xfe, 0x0, 0x6, 0x29, 0xd0, 0x13, 0x44}}
+
+// nsDBAccessorCID {6AADD4D1-7785-11d3-87FE-000629D01344}
+#define NS_DBACCESSOR_CID \
+{ 0x6aadd4d1, 0x7785, 0x11d3, \
+  { 0x87, 0xfe, 0x0, 0x6, 0x29, 0xd0, 0x13, 0x44 }} 
+
+class nsIDBAccessor : public nsISupports
+{
+  public:
+  NS_DEFINE_STATIC_IID_ACCESSOR(NS_IDBACCESSOR_IID)
+
+  NS_IMETHOD Init(nsIFileSpec* DBFile) = 0 ;
+  NS_IMETHOD Shutdown(void) = 0 ;
+
+  NS_IMETHOD Put(PRInt32 aID, void* anEntry, PRUint32 aLength) = 0 ;
+
+  NS_IMETHOD Get(PRInt32 aID, void** anEntry, PRUint32 *aLength) = 0 ;
+
+  NS_IMETHOD Del(PRInt32 aID, void* anEntry, PRUint32 aLength) = 0 ;
+
+  NS_IMETHOD GetID(const char* key, PRUint32 length, PRInt32* aID) = 0 ;
+
+  NS_IMETHOD EnumEntry(void* *anEntry, PRUint32* aLength, PRBool bReset) = 0 ;
+
+} ;
+
+#endif // _NS_IDBACCESSOR_H_
+

mozilla/netwerk/cache/filecache/nsNetDiskCache.cpp

@@ -0,0 +1,691 @@
+/*
+ * 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
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#include "nsNetDiskCache.h"
+#include "nscore.h"
+
+#include "plstr.h"
+#include "prprf.h"
+#include "prtypes.h"
+#include "prio.h"
+#include "prsystem.h" // Directory Seperator
+#include "plhash.h"
+#include "prclist.h"
+#include "prmem.h"
+
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+
+#include "nsIPref.h"
+#include "mcom_db.h"
+#include "nsDBEnumerator.h"
+
+#include "nsDiskCacheRecord.h"
+
+static NS_DEFINE_CID(kPrefCID, NS_PREF_CID) ;
+static NS_DEFINE_CID(kDBAccessorCID, NS_DBACCESSOR_CID) ;
+
+static const PRUint32 DISK_CACHE_SIZE_DEFAULT = 5*1024*1024 ; // 5MB
+static const char * const DISK_CACHE_PREF  = "browser.cache.disk_cache_size";
+static const char * const CACHE_DIR_PREF   = "browser.cache.directory";
+
+class nsDiskCacheRecord ;
+
+nsNetDiskCache::nsNetDiskCache() :
+  m_Enabled(PR_TRUE) ,
+  m_NumEntries(0) ,
+  m_pNextCache(0) ,
+  m_pDiskCacheFolder(0) ,
+  m_StorageInUse(0) ,
+  m_DB(0) ,
+  m_BaseDirNum(32) 
+{
+  // set it to INF for now 
+  m_MaxEntries = (PRUint32)-1 ;
+
+  NS_INIT_REFCNT();
+
+}
+
+nsNetDiskCache::~nsNetDiskCache()
+{
+  printf("~nsNetDiskCache\n") ;
+
+  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
+  // means "clean cache shutdown".  You clear this flag when the db is first
+  // opened and set it just before the db is closed.  If the db wasn't shutdown
+  // cleanly in a prior session, i.e. because the app crashed, on startup you
+  // scan all the individual files in directories and look for "orphans",
+  // i.e. cache files which don't have corresponding entries in the db.  That's
+  // also when storage-in-use and number of entries would be recomputed.
+  //
+  // We don't necessarily need all this functionality immediately, though.
+
+  if(m_BaseDirNum > 32)
+    RemoveDirs(32) ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::Init(void) 
+{
+  nsresult rv ;
+
+  // 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 ;
+  }
+
+  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))
+      return rv ;
+
+    char dirName[3];
+    PR_snprintf (dirName, 3, "%0.2x", i);
+    cacheSubDir->AppendRelativeUnixPath (dirName) ;
+    CreateDir(cacheSubDir);
+  }
+
+  NS_NewFileSpec(getter_AddRefs(m_DBFile)) ;
+  // FUR - check for NS_NewFileSpec failure
+  rv = m_DBFile->FromFileSpec(m_pDiskCacheFolder) ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  m_DBFile->AppendRelativeUnixPath("cache.db") ;
+
+  rv = m_DB->Init(m_DBFile) ;
+  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) ;
+
+///////////////////////////////////////////////////////////////////////////
+// nsINetDataCache Method 
+
+NS_IMETHODIMP
+nsNetDiskCache::GetDescription(PRUnichar* *aDescription) 
+{
+  nsAutoString description("Disk Cache") ;
+  *aDescription = description.ToNewUnicode() ;
+  if(!*aDescription)
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  return NS_OK ;
+}
+
+/* don't alloc mem for nsICachedNetData. 
+ * RecordID is generated using the same scheme in nsCacheDiskData,
+ * see GetCachedNetData() for detail.
+ */
+NS_IMETHODIMP
+nsNetDiskCache::Contains(const char* key, PRUint32 length, PRBool *_retval) 
+{
+  *_retval = PR_FALSE ;
+
+  NS_ASSERTION(m_DB, "no db.") ;
+
+  PRInt32 id = 0 ;
+  m_DB->GetID(key, length, &id) ;
+  // FUR - Check for GetID failure ?
+
+  void* info = 0 ;
+  PRUint32 info_size = 0 ;
+
+  nsresult rv = m_DB->Get(id, &info, &info_size) ;
+  if(NS_SUCCEEDED(rv) && info) 
+    *_retval = PR_TRUE ;
+        
+  return NS_OK ;
+}
+
+/* regardless if it's cached or not, a copy of nsNetDiskCache would 
+ * always be returned. so release it appropriately. 
+ * if mem alloced, updata m_NumEntries also.
+ * for now, the new nsCachedNetData is not written into db yet since
+ * we have nothing to write.
+ */
+NS_IMETHODIMP
+nsNetDiskCache::GetCachedNetData(const char* key, PRUint32 length, nsINetDataCacheRecord **_retval) 
+{
+  NS_ASSERTION(m_DB, "no db.") ;
+
+  nsresult rv = 0 ;
+  if (!_retval)
+    return NS_ERROR_NULL_POINTER ;
+
+  *_retval = nsnull ;
+
+  PRInt32 id = 0 ;
+  m_DB->GetID(key, length, &id) ;
+  // FUR - Check for GetID failure ?
+
+  // construct an empty record
+  nsDiskCacheRecord* newRecord = new nsDiskCacheRecord(m_DB, this) ;
+  if(!newRecord) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  rv = newRecord->Init(key, length) ;
+  if(NS_FAILED(rv)) {
+    delete newRecord ;
+    return rv ;
+  }
+
+  NS_ADDREF(newRecord) ; // addref for _retval 
+  *_retval = (nsINetDataCacheRecord*) newRecord ;
+  
+  void* info = 0 ;
+  PRUint32 info_size = 0 ;
+
+  rv = m_DB->Get(id, &info, &info_size) ;
+  if(NS_SUCCEEDED(rv) && info) {
+
+    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 
+      return r1;
+    
+  } else if (NS_SUCCEEDED(rv) && !info) {
+    // this is a new record. 
+    m_NumEntries ++ ;
+    return NS_OK ;
+  } else 
+    return rv ;
+}
+
+/* get an nsICachedNetData, mem needs to be de-alloced if not found. */
+NS_IMETHODIMP
+nsNetDiskCache::GetCachedNetDataByID(PRInt32 RecordID, nsINetDataCacheRecord **_retval) 
+{
+  NS_ASSERTION(m_DB, "no db.") ;
+
+  if (!_retval)
+    return NS_ERROR_NULL_POINTER ;
+
+  *_retval = nsnull ;
+  
+  nsresult rv ;
+
+  void* info = 0 ;
+  PRUint32 info_size = 0 ;
+
+  rv = m_DB->Get(RecordID, &info, &info_size) ;
+  if(NS_SUCCEEDED(rv) && info) {
+
+    // construct an empty record if only found in db
+    nsDiskCacheRecord* newRecord = new nsDiskCacheRecord(m_DB, this) ;
+    if(!newRecord) 
+      return NS_ERROR_OUT_OF_MEMORY ;
+
+    NS_ADDREF(newRecord) ; // addref for _retval
+    rv = newRecord->RetrieveInfo(info, info_size) ;
+
+    if(NS_SUCCEEDED(rv)) {
+      *_retval = (nsINetDataCacheRecord*) newRecord ;
+      return NS_OK ;
+    } 
+    else {
+      // bad record, I guess
+      NS_RELEASE(newRecord) ; // release if bad things happen
+      return rv ;
+    }
+  } else {
+    NS_ERROR("Error: RecordID not in DB\n") ;
+    return rv ;
+  }
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::GetEnabled(PRBool *aEnabled) 
+{
+  *aEnabled = m_Enabled ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::SetEnabled(PRBool aEnabled) 
+{
+  m_Enabled = aEnabled ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::GetFlags(PRUint32 *aFlags) 
+{
+  *aFlags = FILE_PER_URL_CACHE;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::GetNumEntries(PRUint32 *aNumEntries) 
+{
+  *aNumEntries = m_NumEntries ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::GetMaxEntries(PRUint32 *aMaxEntries)
+{
+  *aMaxEntries = m_MaxEntries ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::NewCacheEntryIterator(nsISimpleEnumerator **_retval) 
+{
+  if(!_retval)
+    return NS_ERROR_NULL_POINTER ;
+
+  *_retval = nsnull ;
+
+  nsISimpleEnumerator* enumerator = new nsDBEnumerator(m_DB, this) ;
+  if(enumerator) {
+    NS_ADDREF(enumerator) ;
+    *_retval = enumerator ;
+    return NS_OK ;
+  }
+  else 
+    return NS_ERROR_OUT_OF_MEMORY ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::GetNextCache(nsINetDataCache * *aNextCache)
+{
+  if(!aNextCache)
+    return NS_ERROR_NULL_POINTER ;
+
+  *aNextCache = m_pNextCache ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::SetNextCache(nsINetDataCache *aNextCache)
+{
+  m_pNextCache = aNextCache ;
+  return NS_OK ;
+}
+
+// db size can always be measured at the last minute. Since it's hard
+// to know before hand. 
+NS_IMETHODIMP
+nsNetDiskCache::GetStorageInUse(PRUint32 *aStorageInUse)
+{
+  PRUint32 total_size = m_StorageInUse, len = 0 ;
+
+  // 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.
+
+  // add the size of the db.
+  //  m_DBFile->GetFileSize(&len) ;
+  //  total_size += len ;
+
+  // we need size in kB
+  total_size = total_size >> 10 ;
+
+  *aStorageInUse = total_size ;
+  return NS_OK ;
+}
+
+/*
+ * The whole cache dirs can be whiped clean since all the cache 
+ * files are resides in seperate hashed dirs. It's safe to do so.
+ */
+ 
+NS_IMETHODIMP
+nsNetDiskCache::RemoveAll(void)
+{
+  nsresult rv = RemoveDirs(0) ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  // don't forget the db file itself
+  m_DB->Shutdown() ;
+  nsFileSpec dbfile ;
+  m_DBFile->GetFileSpec(&dbfile) ;
+  dbfile.Delete(PR_TRUE) ;
+
+  // reinitilize
+  rv = InitDB() ;
+  if(NS_FAILED(rv))
+    return rv ;
+
+  rv = UpdateInfo() ;
+  return rv ;
+}
+
+//////////////////////////////////////////////////////////////////
+// nsINetDataDiskCache methods
+
+NS_IMETHODIMP
+nsNetDiskCache::GetDiskCacheFolder(nsIFileSpec * *aDiskCacheFolder)
+{
+  *aDiskCacheFolder = m_pDiskCacheFolder ;
+  NS_ADDREF(*aDiskCacheFolder) ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::SetDiskCacheFolder(nsIFileSpec * aDiskCacheFolder)
+{
+  char *newfolder, *oldfolder ;
+  m_pDiskCacheFolder->GetNativePath(&oldfolder) ;
+  aDiskCacheFolder->GetNativePath(&newfolder) ;
+
+  if(PL_strcmp(newfolder, oldfolder) == 0) {
+    m_pDiskCacheFolder = aDiskCacheFolder ;
+
+    // should we do this? 
+    // FUR - no
+    nsresult rv = RemoveAll() ;
+    return rv ;
+  }
+  else 
+    // FUR
+    // Need to blow away old cache, build new one
+    return NS_OK ;
+}
+
+//////////////////////////////////////////////////////////////////
+// nsNetDiskCache methods
+
+// create a directory (recursively)
+NS_IMETHODIMP
+nsNetDiskCache::CreateDir(nsIFileSpec* dir_spec) 
+{
+  PRBool does_exist ;
+  nsCOMPtr<nsIFileSpec> p_spec ;
+
+  dir_spec->Exists(&does_exist) ;
+  if(does_exist) 
+    return NS_OK ;
+
+  dir_spec->GetParent(getter_AddRefs(p_spec)) ;
+  // FUR - check return value
+  p_spec->Exists(&does_exist) ;
+  if(!does_exist) {
+    CreateDir(p_spec) ;
+    dir_spec->CreateDir() ;
+    // FUR - check return value
+  }
+  else {
+    dir_spec->CreateDir() ;
+    // FUR - check return value
+  }
+  
+  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)
+{
+  // 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 ;
+
+  PRUint32 numEntries = 0, storageInUse = 0, len = 0 ;
+  PRBool more = PR_FALSE ;
+
+  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) ;
+
+  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::RenameCacheSubDirs(void) 
+{
+  nsCOMPtr<nsIFileSpec> cacheSubDir;
+  nsresult rv = NS_NewFileSpec(getter_AddRefs(cacheSubDir)) ;
+
+  for (int i=0; i < 32; i++) {
+    rv = cacheSubDir->FromFileSpec(m_pDiskCacheFolder) ;
+    if(NS_FAILED(rv))
+      return rv ;
+
+    char dirName[3];
+    PR_snprintf(dirName, 3, "%0.2x", i) ;
+    cacheSubDir->AppendRelativeUnixPath(dirName) ;
+
+    // re-name the directory
+    PR_snprintf(dirName, 3, "%0.2x", i+m_BaseDirNum) ;
+    rv = cacheSubDir->Rename(dirName) ;
+    if(NS_FAILED(rv))
+      return NS_ERROR_FAILURE ;
+  }
+
+  // update m_BaseDirNum 
+  m_BaseDirNum += 32 ;
+
+  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)
+{
+  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
+  }
+
+  return NS_OK ;
+}

mozilla/netwerk/cache/filecache/nsNetDiskCache.h

@@ -0,0 +1,82 @@
+/*
+ * 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
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+// FUR - Add overall description comment here
+
+#ifndef __gen_nsNetDiskCache_h__
+#define __gen_nsNetDiskCache_h__
+
+#include "nsINetDataDiskCache.h"
+#include "nsNetDiskCacheCID.h"
+#include "nsCOMPtr.h"
+#include "nsIPref.h"
+#include "nsDBAccessor.h"
+
+class nsIURI; /* forward decl */
+class nsICachedNetData; /* forward decl */
+class nsISimpleEnumerator; /* forward decl */
+class nsIFileSpec; /* forward decl */
+
+/* starting interface:    nsNetDiskCache */
+
+class nsNetDiskCache : public nsINetDataDiskCache {
+  public: 
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSINETDATACACHE
+  NS_DECL_NSINETDATADISKCACHE
+
+  NS_IMETHOD Init(void) ;
+
+  nsNetDiskCache() ;
+  virtual ~nsNetDiskCache() ;
+
+  protected:
+
+  NS_IMETHOD InitDB(void) ;
+  NS_IMETHOD CreateDir(nsIFileSpec* dir_spec) ;
+  NS_IMETHOD UpdateInfo(void) ;
+
+  NS_IMETHOD RenameCacheSubDirs(void) ;
+  NS_IMETHOD DBRecovery(void) ;
+  NS_IMETHOD RemoveDirs(PRUint32 aNum) ;
+
+  private:
+
+  PRBool 			                m_Enabled ;
+  PRUint32 			                m_NumEntries ;
+  nsCOMPtr<nsINetDataCache> 	    m_pNextCache ;
+  nsCOMPtr<nsIFileSpec>   	        m_pDiskCacheFolder ;
+  nsCOMPtr<nsIFileSpec>             m_DBFile ;
+
+  PRUint32                          m_MaxEntries ;
+  PRUint32                          m_StorageInUse ;
+  nsIDBAccessor*                    m_DB ;
+
+  // this is used to indicate a db corruption
+  PRInt32                           m_BaseDirNum ;
+
+  friend class nsDiskCacheRecord ;
+  friend class nsDiskCacheRecordChannel ;
+} ;
+
+#endif /* __gen_nsNetDiskCache_h__ */

mozilla/netwerk/cache/filecache/nsNetDiskCacheCID.h

@@ -0,0 +1,32 @@
+/*
+ * 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
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is Mozilla Communicator.
+ * 
+ * The Initial Developer of the Original Code is Intel Corp.
+ * Portions created by Intel Corp. are
+ * Copyright (C) 1999, 1999 Intel Corp.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): Yixiong Zou <yixiong.zou@intel.com>
+ *                 Carl Wong <carl.wong@intel.com>
+ */
+
+#ifndef _nsNetDiskCacheCID_h_
+#define _nsNetDiskCacheCID_h_
+
+#define NS_NETDISKCACHE_CID_STR "ECFEEA00-7201-11d3-87FE-000629D01344"
+
+#define NS_NETDISKCACHE_CID \
+{ 0xecfeea00, 0x7201, 0x11d3, \
+ { 0x87, 0xfe, 0x0, 0x6, 0x29, 0xd0, 0x13, 0x44 }}
+
+#endif /* _nsNetDiskCacheCID_h_ */

mozilla/netwerk/cache/filecache/test/Makefile.in

@@ -0,0 +1,50 @@
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+
+DEPTH		= ../../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+REQUIRES	= libreg xpcom
+
+CPPSRCS		= \
+         diskcache.cpp \
+		$(NULL)
+
+SIMPLE_PROGRAMS	= $(CPPSRCS:.cpp=)
+
+ifdef NO_LD_ARCHIVE_FLAGS
+LOST_SYM_LIBS	= -lxpcomds_s -lxptinfo -lmozreg_s
+endif
+
+LIBS		= \
+		-lmozjs \
+		-lxpcom \
+        -lmozdbm_s \
+		$(MOZ_NECKO_UTIL_LIBS) \
+		$(LOST_SYM_LIBS) \
+		$(NSPR_LIBS) \
+		$(NULL)
+
+include $(topsrcdir)/config/rules.mk
+
+LOCAL_INCLUDES = -I$(srcdir)/..
+
+DEFINES		+= -DUSE_NSREG -DCACHE

mozilla/netwerk/cache/filecache/test/diskcache.cpp

@@ -0,0 +1,836 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (the "NPL"); you may not use this file except in
+ * compliance with the NPL.  You may obtain a copy of the NPL at
+ * http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the NPL is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+ * for the specific language governing rights and limitations under the
+ * NPL.
+ *
+ * The Initial Developer of this code under the NPL is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+ * Reserved.
+ */
+
+#include "nsIStreamListener.h"
+#include "nsIStreamObserver.h"
+#include "nsIServiceManager.h"
+#include "nsIInputStream.h"
+#include "nsIOutputStream.h"
+#include "nsIEventQueue.h"
+#include "nsIEventQueueService.h"
+#include "nsIChannel.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+#include <stdio.h>
+#include <unistd.h>
+
+#include "nsINetDataCache.h"
+#include "nsINetDataCacheRecord.h"
+//#include "nsMemCacheCID.h"
+#include "nsNetDiskCache.h"
+#include "nsIPref.h"
+#include "prenv.h"
+#include "nsIFileStream.h"
+
+// Number of test entries to be placed in the cache
+#define NUM_CACHE_ENTRIES  250
+
+// Cache content stream length will have random length between zero and
+// MAX_CONTENT_LENGTH bytes
+#define MAX_CONTENT_LENGTH 20000
+
+// Length of random-data cache entry key
+#define CACHE_KEY_LENGTH 15
+
+// Length of random-data cache entry meta-data
+#define CACHE_METADATA_LENGTH 100
+
+//static NS_DEFINE_CID(kMemCacheCID, NS_MEM_CACHE_FACTORY_CID);
+static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
+static NS_DEFINE_CID(kDiskCacheCID, NS_NETDISKCACHE_CID) ;
+static NS_DEFINE_CID(kPrefCID, NS_PREF_CID);
+static NS_DEFINE_IID(kIPrefIID, NS_IPREF_IID);
+
+// Mapping from test case number to RecordID
+static PRInt32 recordID[NUM_CACHE_ENTRIES];
+
+static PRInt32
+mapRecordIdToTestNum(PRInt32 aRecordID)
+{
+    int i;
+    for (i = 0; i < NUM_CACHE_ENTRIES; i++) {
+        if (recordID[i] == aRecordID)
+            return i;
+    }
+    return -1;
+}
+
+// A supply of stream data to either store or compare with
+class nsITestDataStream {
+public:
+    virtual ~nsITestDataStream() {};
+    virtual PRUint32 Next() = 0;
+    virtual void Read(char* aBuf, PRUint32 aCount) = 0;
+
+    virtual PRBool Match(char* aBuf, PRUint32 aCount) = 0;
+    virtual void Skip(PRUint32 aCount) = 0;
+};
+
+// A reproducible stream of random data.
+class RandomStream : public nsITestDataStream {
+public:
+    RandomStream(PRUint32 aSeed) {
+        mStartSeed = mState = aSeed;
+    }
+    
+    PRUint32 GetStartSeed() {
+        return mStartSeed;
+    }
+    
+    PRUint32 Next() {
+        mState = 1103515245 * mState + 12345;
+        return mState;
+    }
+
+    void Read(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            *aBuf++ = Next();
+        }
+    }
+
+    PRBool
+    Match(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            if (*aBuf++ != (char)(Next() & 0xff))
+                return PR_FALSE;
+        }
+        return PR_TRUE;
+    }
+
+    void
+    Skip(PRUint32 aCount) {
+        while (aCount--)
+            Next();
+    }
+
+protected:
+    
+    PRUint32 mState;
+    PRUint32 mStartSeed;
+};
+
+// A stream of data that increments on each byte that is read, modulo 256
+class CounterStream : public nsITestDataStream {
+public:
+    CounterStream(PRUint32 aSeed) {
+        mStartSeed = mState = aSeed;
+    }
+    
+    PRUint32 GetStartSeed() {
+        return mStartSeed;
+    }
+    
+    PRUint32 Next() {
+        mState += 1;
+        mState &= 0xff;
+        return mState;
+    }
+
+    void Read(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            *aBuf++ = Next();
+        }
+    }
+
+    PRBool
+    Match(char* aBuf, PRUint32 aCount) {
+        PRUint32 i;
+        for (i = 0; i < aCount; i++) {
+            if (*aBuf++ != (char)Next())
+                return PR_FALSE;
+        }
+        return PR_TRUE;
+    }
+
+    void
+    Skip(PRUint32 aCount) {
+        mState += aCount;
+        mState &= 0xff;
+    }
+
+protected:
+    
+    PRUint32 mState;
+    PRUint32 mStartSeed;
+};
+
+static int gNumReaders = 0;
+static PRUint32 gTotalBytesRead = 0;
+static PRUint32 gTotalDuration = 0;
+
+class nsReader : public nsIStreamListener {
+public:
+    NS_DECL_ISUPPORTS
+
+    nsReader()
+        : mStartTime(0), mBytesRead(0)
+    {
+        NS_INIT_REFCNT();
+        gNumReaders++;
+    }
+
+    virtual ~nsReader() {
+        delete mTestDataStream;
+        gNumReaders--;
+    }
+
+    nsresult 
+    Init(nsIChannel *aChannel, nsITestDataStream* aRandomStream, PRUint32 aExpectedStreamLength) {
+        mChannel = aChannel;
+        mTestDataStream = aRandomStream;
+        mExpectedStreamLength = aExpectedStreamLength;
+        mRefCnt = 1;
+        return NS_OK;
+    }
+
+    NS_IMETHOD OnStartRequest(nsIChannel* channel,
+                              nsISupports* context) {
+        mStartTime = PR_IntervalNow();
+        return NS_OK;
+    }
+
+    NS_IMETHOD OnDataAvailable(nsIChannel* channel, 
+                               nsISupports* context,
+                               nsIInputStream *aIStream, 
+                               PRUint32 aSourceOffset,
+                               PRUint32 aLength) {
+        char buf[1025];
+        while (aLength > 0) {
+            PRUint32 amt;
+            PRBool match;
+            aIStream->Read(buf, sizeof buf, &amt);
+            if (amt == 0) break;
+            aLength -= amt;
+            mBytesRead += amt;
+            match = mTestDataStream->Match(buf, amt);
+            NS_ASSERTION(match, "Stored data was corrupted on read");
+        }
+        return NS_OK;
+    }
+
+    NS_IMETHOD OnStopRequest(nsIChannel* channel, 
+                             nsISupports* context,
+                             nsresult aStatus,
+                             const PRUnichar* aMsg) {
+        PRIntervalTime endTime;
+        PRIntervalTime duration;
+        
+        endTime = PR_IntervalNow();
+        duration = (endTime - mStartTime);
+
+        if (NS_FAILED(aStatus)) printf("channel failed.\n");
+        //        printf("read %d bytes\n", mBytesRead);
+
+        NS_ASSERTION(mBytesRead == mExpectedStreamLength,
+                     "Stream in cache is wrong length");
+
+        gTotalBytesRead += mBytesRead;
+        gTotalDuration += duration;
+
+        // Release channel
+        mChannel = 0;
+        return NS_OK;
+    }
+
+protected:
+    PRIntervalTime       mStartTime;
+    PRUint32             mBytesRead;
+    nsITestDataStream*   mTestDataStream;
+    PRUint32             mExpectedStreamLength;
+    nsCOMPtr<nsIChannel> mChannel;
+};
+
+NS_IMPL_ISUPPORTS2(nsReader, nsIStreamListener, nsIStreamObserver)
+
+static nsIEventQueue* eventQueue;
+
+nsresult
+InitQueue() {
+    nsresult rv;
+
+    NS_WITH_SERVICE(nsIEventQueueService, eventQService, kEventQueueServiceCID, &rv);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get event queue service");
+
+    rv = eventQService->CreateThreadEventQueue();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create event queue");
+  
+    rv = eventQService->GetThreadEventQueue(PR_CurrentThread(), &eventQueue);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get event queue for main thread");
+
+    return NS_OK;
+}
+
+// Process events until all streams are OnStopRequest'ed
+nsresult
+WaitForEvents() {
+    while (gNumReaders) {
+        eventQueue->ProcessPendingEvents();
+    }
+    return NS_OK;
+}
+
+// Read data for a single cache record and compare against testDataStream
+nsresult
+TestReadStream(nsINetDataCacheRecord *record, nsITestDataStream *testDataStream,
+               PRUint32 expectedStreamLength)
+{
+    nsCOMPtr<nsIChannel> channel;
+    nsresult rv;
+    PRUint32 actualContentLength;
+
+    rv = record->NewChannel(0, getter_AddRefs(channel));
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+    rv = record->GetStoredContentLength(&actualContentLength);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+    NS_ASSERTION(actualContentLength == expectedStreamLength,
+                 "nsINetDataCacheRecord::GetContentLength() busted ?");
+    
+    nsReader *reader = new nsReader;
+    reader->AddRef();
+    rv = reader->Init(channel, testDataStream, expectedStreamLength);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+    
+    rv = channel->AsyncRead(0, -1, 0, reader);
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+    reader->Release();
+
+    return NS_OK;
+}
+
+// Check that records can be retrieved using their record-ID, in addition
+// to using the opaque key.
+nsresult
+TestRecordID(nsINetDataCache *cache)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    RandomStream *randomStream;
+    PRUint32 metaDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char *metaData;
+    PRUint32 testNum;
+    PRBool match;
+
+    for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
+        randomStream = new RandomStream(testNum);
+        randomStream->Read(cacheKey, sizeof cacheKey);
+
+        rv = cache->GetCachedNetDataByID(recordID[testNum], getter_AddRefs(record));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't obtain record using record ID");
+
+        // Match against previously stored meta-data
+        rv = record->GetMetaData(&metaDataLength, &metaData);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get record meta-data");
+        match = randomStream->Match(metaData, metaDataLength);
+        NS_ASSERTION(match, "Meta-data corrupted or incorrect");
+
+        nsAllocator::Free(metaData);
+        delete randomStream;
+    }
+    return NS_OK;
+}
+
+// Check that all cache entries in the database are enumerated and that
+// no duplicates appear.
+nsresult
+TestEnumeration(nsINetDataCache *cache)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsCOMPtr<nsISupports> tempISupports;
+    nsCOMPtr<nsISimpleEnumerator> iterator;
+    RandomStream *randomStream;
+    PRUint32 metaDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char *metaData;
+    PRUint32 testNum;
+    PRBool match;
+    PRInt32 recID;
+
+    int numRecords = 0;
+
+    // Iterate over all records in the cache
+    rv = cache->NewCacheEntryIterator(getter_AddRefs(iterator));
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create new cache entry iterator");
+
+    PRBool notDone;
+    while (1) {
+
+        // Done iterating ?
+        rv = iterator->HasMoreElements(&notDone);
+        if (NS_FAILED(rv)) return rv;
+        if (!notDone)
+            break;
+
+        // Get next record in iteration
+        rv = iterator->GetNext(getter_AddRefs(tempISupports));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "iterator bustage");
+        record = do_QueryInterface(tempISupports);
+
+        numRecords++;
+
+        // Get record ID
+        rv = record->GetRecordID(&recID);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get Record ID");
+        testNum = mapRecordIdToTestNum(recID);
+        NS_ASSERTION(testNum != -1, "Corrupted Record ID ?");
+
+        // Erase mapping from table, so that duplicate enumerations are detected
+        recordID[testNum] = -1;
+
+        // Make sure stream matches test data
+        randomStream = new RandomStream(testNum);
+        randomStream->Read(cacheKey, sizeof cacheKey);
+
+        // Match against previously stored meta-data
+        rv = record->GetMetaData(&metaDataLength, &metaData);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get record meta-data");
+        match = randomStream->Match(metaData, metaDataLength);
+        NS_ASSERTION(match, "Meta-data corrupted or incorrect");
+        nsAllocator::Free(metaData);
+
+        delete randomStream;
+    }
+
+    NS_ASSERTION(numRecords == NUM_CACHE_ENTRIES, "Iteration bug");
+
+    return NS_OK;
+}
+
+// Read the test data that was written in FillCache(), checking for
+// corruption, truncation.
+nsresult
+TestRead(nsINetDataCache *cache)
+{
+    nsresult rv;
+    PRBool inCache;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    RandomStream *randomStream;
+    PRUint32 metaDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char *metaData, *storedCacheKey;
+    PRUint32 testNum, storedCacheKeyLength;
+    PRBool match;
+
+    for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
+        randomStream = new RandomStream(testNum);
+        randomStream->Read(cacheKey, sizeof cacheKey);
+
+        // Ensure that entry is in the cache
+        rv = cache->Contains(cacheKey, sizeof cacheKey, &inCache);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(inCache, "nsINetDataCache::Contains error");
+        
+        rv = cache->GetCachedNetData(cacheKey, sizeof cacheKey, getter_AddRefs(record));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        // Match against previously stored meta-data
+        match = record->GetMetaData(&metaDataLength, &metaData);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        match = randomStream->Match(metaData, metaDataLength);
+        NS_ASSERTION(match, "Meta-data corrupted or incorrect");
+        nsAllocator::Free(metaData);
+
+        // Test GetKey() method
+        rv = record->GetKey(&storedCacheKeyLength, &storedCacheKey);
+        NS_ASSERTION(NS_SUCCEEDED(rv) &&
+                     (storedCacheKeyLength == sizeof cacheKey) &&
+                     !memcmp(storedCacheKey, &cacheKey[0], sizeof cacheKey),
+                     "nsINetDataCacheRecord::GetKey failed");
+        nsAllocator::Free(storedCacheKey);
+
+        PRUint32 expectedStreamLength = randomStream->Next() & 0xffff;
+
+        TestReadStream(record, randomStream, expectedStreamLength);
+    }
+
+    WaitForEvents();
+
+    // Compute rate in MB/s
+    double rate = gTotalBytesRead / PR_IntervalToMilliseconds(gTotalDuration);
+    rate *= NUM_CACHE_ENTRIES;
+    rate *= 1000;
+    rate /= (1024 * 1024);
+    printf("Read %d bytes at a rate of %5.1f MB per second \n",
+           gTotalBytesRead, rate);
+
+    return NS_OK;
+}
+
+// Repeatedly call SetStoredContentLength() on a cache entry and make
+// read the stream's data to ensure that it's not corrupted by the effect
+nsresult
+TestTruncation(nsINetDataCache *cache)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    RandomStream *randomStream;
+    char cacheKey[CACHE_KEY_LENGTH];
+
+    randomStream = new RandomStream(0);
+    randomStream->Read(cacheKey, sizeof cacheKey);
+
+    rv = cache->GetCachedNetData(cacheKey, sizeof cacheKey, getter_AddRefs(record));
+    NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+    randomStream->Skip(CACHE_METADATA_LENGTH);
+    PRUint32 initialStreamLength = randomStream->Next() & 0xffff;
+    delete randomStream;
+
+    PRUint32 i;
+    PRUint32 delta = initialStreamLength / 64;
+    for (i = initialStreamLength; i >= delta; i -= delta) {
+        PRUint32 expectedStreamLength = i;
+
+        // Do the truncation
+        record->SetStoredContentLength(expectedStreamLength);
+        randomStream = new RandomStream(0);
+        randomStream->Skip(CACHE_KEY_LENGTH + CACHE_METADATA_LENGTH + 1);
+
+        TestReadStream(record, randomStream, expectedStreamLength);
+        WaitForEvents();
+    }
+
+    return NS_OK;
+}
+
+// Write known data to random offsets in a single cache entry and test
+// resulting stream for correctness.
+nsresult
+TestOffsetWrites(nsINetDataCache *cache)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsCOMPtr<nsIChannel> channel;
+    nsCOMPtr<nsIOutputStream> outStream;
+    char buf[512];
+    char cacheKey[CACHE_KEY_LENGTH];
+    RandomStream *randomStream;
+
+    randomStream = new RandomStream(0);
+    randomStream->Read(cacheKey, sizeof cacheKey);
+
+    rv = cache->GetCachedNetData(cacheKey, sizeof cacheKey, getter_AddRefs(record));
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't access record via opaque cache key");
+
+
+    nsCOMPtr<nsIFileSpec> file ;
+    record->GetFilename(getter_AddRefs(file)) ;
+    char* name ;
+    file->GetUnixStyleFilePath(&name) ;
+    printf(" file name is %s \n", name) ;
+
+    // Write buffer-fulls of data at random offsets into the cache entry.
+    // Data written is (offset % 0xff)
+    PRUint32 startingOffset;
+    PRUint32 streamLength = 0;
+    PRUint32 len = 0 ;
+    CounterStream *counterStream;
+
+    int i = 0;
+    for (i = 0; i < 257; i++) {
+        rv = record->NewChannel(0, getter_AddRefs(channel));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        startingOffset = streamLength ? streamLength - (randomStream->Next() % sizeof buf): 0;
+        rv = channel->OpenOutputStream(startingOffset, getter_AddRefs(outStream));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        
+        truncate(name, startingOffset) ;
+
+        counterStream = new CounterStream(startingOffset);
+        counterStream->Read(buf, sizeof buf);
+
+      nsresult status ;
+      nsCOMPtr<nsIRandomAccessStore> ras = do_QueryInterface(outStream, &status);
+      if (NS_FAILED(status)) {
+      //        mState = END_WRITE;
+        return NS_ERROR_FAILURE;
+      }
+      PRIntn offset ;
+      ras->Tell(&offset) ;
+//      printf(" offset is %d \n", offset) ;
+
+        PRUint32 numWritten;
+        rv = outStream->Write(buf, sizeof buf, &numWritten);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(numWritten == sizeof buf, "Write() bug?");
+        streamLength = startingOffset + sizeof buf;
+
+        rv = outStream->Close();
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't close channel");
+        delete counterStream;
+
+        record->GetStoredContentLength(&len) ;
+        if(len != streamLength) 
+          printf(" offset = %d is wrong, filesize = %d\n", startingOffset, len) ;
+
+    }
+
+        /*
+        rv = record->NewChannel(0, getter_AddRefs(channel));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        startingOffset = 208;
+        rv = channel->OpenOutputStream(startingOffset, getter_AddRefs(outStream));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        
+        counterStream = new CounterStream(startingOffset);
+        counterStream->Read(buf, sizeof buf);
+
+      nsresult status ;
+      nsCOMPtr<nsIRandomAccessStore> ras = do_QueryInterface(outStream, &status);
+      if (NS_FAILED(status)) {
+      //        mState = END_WRITE;
+        return NS_ERROR_FAILURE;
+      }
+      PRIntn offset = 0 ;
+      ras->Tell(&offset) ;
+      printf(" offset is %d \n", offset) ;
+
+        PRUint32 numWritten;
+        rv = outStream->Write(buf, sizeof buf, &numWritten);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(numWritten == sizeof buf, "Write() bug?");
+        streamLength = startingOffset + sizeof buf;
+
+        rv = outStream->Close();
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't close channel");
+        delete counterStream;
+
+        record->GetStoredContentLength(&len) ;
+        if(len != streamLength) 
+          printf(" offset = %d is wrong, filesize = %d\n", startingOffset, len) ;
+          */
+    
+    delete randomStream;
+
+    counterStream = new CounterStream(0);
+    TestReadStream(record, counterStream, streamLength);
+    WaitForEvents();
+
+    return NS_OK;
+}
+
+// Create entries in the network data cache, using random data for the
+// key, the meta-data and the stored content data.
+nsresult
+FillCache(nsINetDataCache *cache)
+{
+    nsresult rv;
+    PRBool inCache;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsCOMPtr<nsIChannel> channel;
+    nsCOMPtr<nsIOutputStream> outStream;
+    char buf[1000];
+    PRUint32 metaDataLength;
+    char cacheKey[CACHE_KEY_LENGTH];
+    char metaData[CACHE_METADATA_LENGTH];
+    PRUint32 testNum;
+    char *data;
+    RandomStream *randomStream;
+
+    PRIntervalTime startTime = PR_IntervalNow();
+    
+    for (testNum = 0; testNum < NUM_CACHE_ENTRIES; testNum++) {
+        randomStream = new RandomStream(testNum);
+        randomStream->Read(cacheKey, sizeof cacheKey);
+
+        // No entry should be in cache until we add it
+        rv = cache->Contains(cacheKey, sizeof cacheKey, &inCache);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(!inCache, "nsINetDataCache::Contains error");
+        
+        rv = cache->GetCachedNetData(cacheKey, sizeof cacheKey, getter_AddRefs(record));
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't access record via opaque cache key");
+
+        // Test nsINetDataCacheRecord::GetRecordID()
+        rv = record->GetRecordID(&recordID[testNum]);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get Record ID");
+
+        // Test nsINetDataCache::GetNumEntries()
+        PRUint32 numEntries = (PRUint32)-1;
+        rv = cache->GetNumEntries(&numEntries);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
+        NS_ASSERTION(numEntries == testNum + 1, "GetNumEntries failure");
+
+        // Record meta-data should be initially empty
+        rv = record->GetMetaData(&metaDataLength, &data);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        if ((metaDataLength != 0) || (data != 0))
+            return NS_ERROR_FAILURE;
+
+        // Store random data as meta-data
+        randomStream->Read(metaData, sizeof metaData);
+        record->SetMetaData(sizeof metaData, metaData);
+
+        rv = record->NewChannel(0, getter_AddRefs(channel));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+
+        rv = channel->OpenOutputStream(0, getter_AddRefs(outStream));
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        
+        PRUint32 beforeOccupancy;
+        rv = cache->GetStorageInUse(&beforeOccupancy);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache occupancy");
+
+        int streamLength = randomStream->Next() & 0xffff;
+        int remaining = streamLength;
+        while (remaining) {
+            PRUint32 numWritten;
+            int amount = PR_MIN(sizeof buf, remaining);
+            randomStream->Read(buf, amount);
+
+            rv = outStream->Write(buf, amount, &numWritten);
+            NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+            NS_ASSERTION(numWritten == (PRUint32)amount, "Write() bug?");
+            
+            remaining -= amount;
+        }
+        outStream->Close();
+
+        PRUint32 afterOccupancy;
+        rv = cache->GetStorageInUse(&afterOccupancy);
+        NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache occupancy");
+        PRUint32 streamLengthInKB = streamLength >> 10;
+        NS_ASSERTION((afterOccupancy - beforeOccupancy) >= streamLengthInKB,
+                     "nsINetDataCache::GetStorageInUse() is busted");
+        
+
+        // *Now* there should be an entry in the cache
+        rv = cache->Contains(cacheKey, sizeof cacheKey, &inCache);
+        NS_ASSERTION(NS_SUCCEEDED(rv), " ");
+        NS_ASSERTION(inCache, "nsINetDataCache::Contains error");
+
+        delete randomStream;
+    }
+
+    PRIntervalTime endTime = PR_IntervalNow();
+
+    return NS_OK;
+}
+
+nsresult NS_AutoregisterComponents()
+{
+  nsresult rv = nsComponentManager::AutoRegister(nsIComponentManager::NS_Startup,
+                                                 NULL /* default */);
+  return rv;
+}
+
+PRBool initPref ()
+{
+  nsresult rv;
+  NS_WITH_SERVICE(nsIPref, prefPtr, kPrefCID, &rv);
+  if (NS_FAILED(rv))
+    return false;
+
+  nsCOMPtr<nsIFileSpec> fileSpec;
+  rv = NS_NewFileSpec (getter_AddRefs(fileSpec));
+  if (NS_FAILED(rv))
+    return false;
+
+  nsCString defaultPrefFile = PR_GetEnv ("MOZILLA_FIVE_HOME");
+  if (defaultPrefFile.Length())
+    defaultPrefFile += "/";
+  else
+    defaultPrefFile = "./";
+  defaultPrefFile += "default_prefs.js";
+
+  fileSpec->SetUnixStyleFilePath (defaultPrefFile.GetBuffer());
+
+  PRBool exists = false;
+  fileSpec->Exists(&exists);
+  if (exists)
+    prefPtr->ReadUserPrefsFrom(fileSpec);
+  else
+    return false;
+  return true;
+}
+
+int
+main(int argc, char* argv[])
+{
+    initPref() ;
+    nsresult rv;
+    nsCOMPtr<nsINetDataCache> cache;
+
+    rv = NS_AutoregisterComponents();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't register XPCOM components");
+
+    rv = nsComponentManager::CreateInstance(kDiskCacheCID, nsnull,
+                                            NS_GET_IID(nsINetDataCache),
+                                            getter_AddRefs(cache));
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't create memory cache factory");
+
+    InitQueue();
+
+    PRUnichar* description;
+    rv = cache->GetDescription(&description);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache description");
+    nsCAutoString descStr(description);
+    printf("Testing: %s\n", descStr.GetBuffer());
+
+    rv = cache->RemoveAll();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't clear cache");
+
+    PRUint32 startOccupancy;
+    rv = cache->GetStorageInUse(&startOccupancy);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache occupancy");
+
+    PRUint32 numEntries = (PRUint32)-1;
+    rv = cache->GetNumEntries(&numEntries);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
+    NS_ASSERTION(numEntries == 0, "Couldn't clear cache");
+
+    rv = FillCache(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't fill cache with random test data");
+
+    rv = TestRead(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't read random test data from cache");
+
+    rv = TestRecordID(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't index records using record ID");
+
+    rv = TestEnumeration(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't successfully enumerate records");
+
+    rv = TestTruncation(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't successfully truncate records");
+
+    rv = TestOffsetWrites(cache);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't successfully write to records using non-zero offsets");
+
+    rv = cache->RemoveAll();
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't clear cache");
+    rv = cache->GetNumEntries(&numEntries);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get number of cache entries");
+    NS_ASSERTION(numEntries == 0, "Couldn't clear cache");
+
+    PRUint32 endOccupancy;
+    rv = cache->GetStorageInUse(&endOccupancy);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "Couldn't get cache occupancy");
+
+    NS_ASSERTION(startOccupancy == endOccupancy, "Cache occupancy not correctly computed ?");
+
+    return 0;
+}
+

mozilla/netwerk/cache/memcache/Makefile.in

@@ -0,0 +1,46 @@
+# Generated automatically from Makefile.in by configure.
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+#
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+VPATH       = @srcdir@
+srcdir		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE = nkcache
+
+LIBRARY_NAME = nkmemcache_s
+
+REQUIRES	= nspr dbm 
+
+EXPORTS=nsMemCacheCID.h
+
+CPPSRCS		= \
+        nsMemCache.cpp \
+        nsMemCacheRecord.cpp \
+        nsMemCacheChannel.cpp \
+		$(NULL)
+
+# we don't want the shared lib, but we want to force the creation of a
+# static lib.
+override NO_SHARED_LIB=1
+override NO_STATIC_LIB=
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/memcache/makefile.win

@@ -0,0 +1,42 @@
+#!nmake
+#
+# The contents of this file are subject to the Netscape Public License
+# Version 1.0 (the "NPL"); you may not use this file except in
+# compliance with the NPL.  You may obtain a copy of the NPL at
+# http://www.mozilla.org/NPL/
+#
+# Software distributed under the NPL is distributed on an "AS IS" basis,
+# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
+# for the specific language governing rights and limitations under the
+# NPL.
+#
+# The Initial Developer of this code under the NPL is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation.  All Rights
+# Reserved.
+
+DEPTH=..\..\..
+
+include <$(DEPTH)/config/config.mak>
+
+MODULE = nkcache
+
+LIBRARY_NAME = nkmemcache_s
+
+CPP_OBJS =                                \
+ 	.\$(OBJDIR)\nsMemCache.obj        \
+	.\$(OBJDIR)\nsMemCacheRecord.obj  \
+	.\$(OBJDIR)\nsMemCacheChannel.obj \
+	$(NULL)
+
+EXPORTS=nsMemCacheCID.h
+
+include <$(DEPTH)\config\rules.mak>
+
+install:: $(LIBRARY)
+	$(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
+
+clobber::
+        rm -rf $(OBJDIR)
+        rm -f $(DIST)\lib\$(LIBRARY_NAME).lib
+

mozilla/netwerk/cache/memcache/nsMemCache.cpp

@@ -0,0 +1,334 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+/**
+ * nsMemCache is the implementation of an in-memory network-data
+ * cache, used to cache the responses to network retrieval commands.
+ * Each cache entry may contain both content, e.g. GIF image data, and
+ * associated metadata, e.g. HTTP headers.  Each entry is indexed by
+ * two different keys: a record id number and an opaque key, which is
+ * created by the cache manager by combining the URI with a "secondary
+ * key", e.g. HTTP post data.
+ */
+
+#include "nsMemCache.h"
+#include "nsMemCacheRecord.h"
+#include "nsIGenericFactory.h"
+#include "nsString.h"
+#include "nsHashtable.h"
+#include "nsHashtableEnumerator.h"
+#include "nsEnumeratorUtils.h"
+
+PRInt32 nsMemCache::gRecordSerialNumber = 0;
+
+nsMemCache::nsMemCache()
+    : mNumEntries(0), mOccupancy(0), mEnabled(PR_TRUE),
+      mHashTable(0)
+{
+    NS_INIT_REFCNT();
+}
+
+nsMemCache::~nsMemCache()
+{
+    nsresult rv;
+
+    rv = RemoveAll();
+    NS_ASSERTION(NS_SUCCEEDED(rv) && (mNumEntries == 0),
+                 "Failure to shut down memory cache. "
+                 "Somewhere, someone is holding references to at least one cache record");
+    delete mHashTable;
+}
+
+nsresult
+nsMemCache::Init()
+{
+    mHashTable = new nsHashtable(256);
+    if (!mHashTable)
+        return NS_ERROR_OUT_OF_MEMORY;
+    return NS_OK;
+}
+
+NS_IMPL_ISUPPORTS(nsMemCache, NS_GET_IID(nsINetDataCache))
+
+NS_IMETHODIMP
+nsMemCache::GetDescription(PRUnichar * *aDescription)
+{
+    nsAutoString description("Memory Cache");
+    *aDescription = description.ToNewUnicode();
+    if (!*aDescription)
+        return NS_ERROR_OUT_OF_MEMORY;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::Contains(const char *aKey, PRUint32 aKeyLength, PRBool *aFound)
+{
+    nsOpaqueKey *opaqueKey = new nsOpaqueKey(aKey, aKeyLength);
+    if (!opaqueKey)
+        return NS_ERROR_OUT_OF_MEMORY;
+    *aFound = mHashTable->Exists(opaqueKey);
+    delete opaqueKey;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::GetCachedNetData(const char *aKey, PRUint32 aKeyLength,
+                             nsINetDataCacheRecord* *aRecord)
+{
+    nsresult rv;
+    nsMemCacheRecord* record = 0;
+    nsOpaqueKey *opaqueKey2 = 0;
+    nsOpaqueKey *opaqueKey3 = 0;
+    nsOpaqueKey *opaqueKey;
+
+    opaqueKey = new nsOpaqueKey(aKey, aKeyLength);
+    if (!opaqueKey)
+        goto out_of_memory;
+    record = (nsMemCacheRecord*)mHashTable->Get(opaqueKey);
+    delete opaqueKey;
+
+    // No existing cache database entry was found.  Create a new one.
+    // This requires two mappings in the hash table:
+    //    Record ID  ==> record
+    //    Opaque key ==> record
+    if (!record) {
+        record = new nsMemCacheRecord;
+        if (!record)
+            goto out_of_memory;
+        rv = record->Init(aKey, aKeyLength, ++gRecordSerialNumber, this);
+        if (NS_FAILED(rv)) goto out_of_memory;
+
+        // Index the record by opaque key
+        opaqueKey2 = new nsOpaqueKey(record->mKey, record->mKeyLength);
+        if (!opaqueKey2) goto out_of_memory;
+        mHashTable->Put(opaqueKey2, record);
+        
+        // Index the record by it's record ID
+        char *recordIDbytes = NS_REINTERPRET_CAST(char *, &record->mRecordID);
+        opaqueKey3 = new nsOpaqueKey(recordIDbytes,
+                                     sizeof record->mRecordID);
+        if (!opaqueKey3) {
+            // Clean up the first record from the hash table
+            mHashTable->Remove(opaqueKey);
+            goto out_of_memory;
+        }
+        mHashTable->Put(opaqueKey3, record);
+        
+        // The hash table holds on to the record
+        record->AddRef();
+        
+        delete opaqueKey2;
+        delete opaqueKey3;
+        mNumEntries++;
+    }
+
+    record->AddRef();
+    *aRecord = record;
+    return NS_OK;
+
+ out_of_memory:
+    delete opaqueKey2;
+    delete opaqueKey3;
+    delete record;
+    return NS_ERROR_OUT_OF_MEMORY;
+}
+
+NS_IMETHODIMP
+nsMemCache::GetCachedNetDataByID(PRInt32 RecordID,
+                                 nsINetDataCacheRecord* *aRecord)
+{
+    nsOpaqueKey opaqueKey(NS_REINTERPRET_CAST(const char *, &RecordID),
+                          sizeof RecordID);
+    *aRecord = (nsINetDataCacheRecord*)mHashTable->Get(&opaqueKey);
+    if (*aRecord) {
+        NS_ADDREF(*aRecord);
+        return NS_OK;
+    }
+    return NS_ERROR_FAILURE;
+}
+
+NS_METHOD
+nsMemCache::Delete(nsMemCacheRecord* aRecord)
+{
+    nsMemCacheRecord *removedRecord;
+
+    char *recordIDbytes = NS_REINTERPRET_CAST(char *, &aRecord->mRecordID);
+    nsOpaqueKey opaqueRecordIDKey(recordIDbytes,
+                                  sizeof aRecord->mRecordID);
+    removedRecord = (nsMemCacheRecord*)mHashTable->Remove(&opaqueRecordIDKey);
+    NS_ASSERTION(removedRecord == aRecord, "memory cache database inconsistent");
+
+    nsOpaqueKey opaqueKey(aRecord->mKey, aRecord->mKeyLength);
+    removedRecord = (nsMemCacheRecord*)mHashTable->Remove(&opaqueKey);
+    NS_ASSERTION(removedRecord == aRecord, "memory cache database inconsistent");
+
+    aRecord->Release();
+
+    mNumEntries--;
+    
+    return NS_OK;
+}
+    
+
+NS_IMETHODIMP
+nsMemCache::GetEnabled(PRBool *aEnabled)
+{
+    NS_ENSURE_ARG(aEnabled);
+    *aEnabled = mEnabled;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::SetEnabled(PRBool aEnabled)
+{
+    mEnabled = aEnabled;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::GetFlags(PRUint32 *aFlags)
+{
+    NS_ENSURE_ARG(aFlags);
+    *aFlags = MEMORY_CACHE;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::GetNumEntries(PRUint32 *aNumEntries)
+{
+    NS_ENSURE_ARG(aNumEntries);
+    *aNumEntries = mNumEntries;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::GetMaxEntries(PRUint32 *aMaxEntries)
+{
+    NS_ENSURE_ARG(aMaxEntries);
+    *aMaxEntries = MEM_CACHE_MAX_ENTRIES;
+    return NS_OK;
+}
+
+static NS_METHOD
+HashEntryConverter(nsHashKey *aKey, void *aValue,
+                   void *unused, nsISupports **retval)
+{
+    nsMemCacheRecord *record;
+    nsOpaqueKey *opaqueKey;
+
+    record = (nsMemCacheRecord*)aValue;
+    opaqueKey = (nsOpaqueKey*)aKey;
+
+    // Hash table keys that index cache entries by their record ID
+    // shouldn't be enumerated.
+    if ((opaqueKey->GetKeyLength() == sizeof(PRInt32))) {
+
+#ifdef DEBUG
+        PRInt32 recordID;
+        record->GetRecordID(&recordID);
+        NS_ASSERTION(*((PRInt32*)opaqueKey->GetKey()) == recordID,
+                     "Key has incorrect key length");
+#endif
+        return NS_ERROR_FAILURE;
+    }
+
+    NS_IF_ADDREF(record);
+    *retval = NS_STATIC_CAST(nsISupports*, record);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::NewCacheEntryIterator(nsISimpleEnumerator* *aIterator)
+{
+    nsCOMPtr<nsIEnumerator> iterator;
+
+    NS_ENSURE_ARG(aIterator);
+    NS_NewHashtableEnumerator(mHashTable, HashEntryConverter,
+                              mHashTable, getter_AddRefs(iterator));
+    return NS_NewAdapterEnumerator(aIterator, iterator);
+}
+
+NS_IMETHODIMP
+nsMemCache::GetNextCache(nsINetDataCache* *aNextCache)
+{
+    NS_ENSURE_ARG(aNextCache);
+    *aNextCache = mNextCache;
+    NS_ADDREF(*aNextCache);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::SetNextCache(nsINetDataCache* aNextCache)
+{
+    mNextCache = aNextCache;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::GetStorageInUse(PRUint32 *aStorageInUse)
+{
+    NS_ENSURE_ARG(aStorageInUse);
+
+    // Convert from bytes to KB
+    *aStorageInUse = (mOccupancy >> 10);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCache::RemoveAll(void)
+{
+    PRBool failed;
+
+    nsCOMPtr<nsISimpleEnumerator> iterator;
+    nsCOMPtr<nsISupports> recordSupports;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsresult rv;
+
+    failed = PR_FALSE;
+    rv = NewCacheEntryIterator(getter_AddRefs(iterator));
+    if (NS_FAILED(rv))
+        return rv;
+
+    PRBool notDone;
+    while (1) {
+        rv = iterator->HasMoreElements(&notDone);
+        if (NS_FAILED(rv)) return rv;
+        if (!notDone)
+            break;
+        
+        iterator->GetNext(getter_AddRefs(recordSupports));
+        record = do_QueryInterface(recordSupports);
+        recordSupports = 0;
+
+        PRUint32 bytesUsed;
+        record->GetStoredContentLength(&bytesUsed);
+        rv = record->Delete();
+        if (NS_FAILED(rv)) {
+            failed = PR_TRUE;
+            continue;
+        }
+        mOccupancy -= bytesUsed;
+    }
+
+    if (failed)
+        return NS_ERROR_FAILURE;
+    return NS_OK;
+}

mozilla/netwerk/cache/memcache/nsMemCache.h

@@ -0,0 +1,83 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+/**
+ * nsMemCache is the implementation of an in-memory network-data
+ * cache, used to cache the responses to network retrieval commands.
+ * Each cache entry may contain both content, e.g. GIF image data, and
+ * associated metadata, e.g. HTTP headers.  Each entry is indexed by
+ * two different keys: a record id number and an opaque key, which is
+ * created by the cache manager by combining the URI with a "secondary
+ * key", e.g. HTTP post data.
+ */
+
+#ifndef _nsMemCache_h_
+#define _nsMemCache_h_
+
+#include "nsINetDataCache.h"
+
+// Maximum number of URIs that may be resident in the cache
+#define MEM_CACHE_MAX_ENTRIES 1000
+
+#define MEM_CACHE_SEGMENT_SIZE       (1 << 12)
+#define MEM_CACHE_MAX_ENTRY_SIZE     (1 << 20)
+
+class nsHashtable;
+class nsMemCacheRecord;
+
+class nsMemCache : public nsINetDataCache
+{
+public:
+    nsMemCache();
+    virtual ~nsMemCache();
+    nsresult Init();
+
+    // nsISupports methods
+    NS_DECL_ISUPPORTS
+
+    // nsINetDataCache methods
+    NS_DECL_NSINETDATACACHE
+
+    // Factory
+    static NS_METHOD nsMemCacheConstructor(nsISupports *aOuter, REFNSIID aIID,
+                                           void **aResult);
+
+protected:
+
+    PRUint32         mNumEntries;
+    PRUint32         mOccupancy;   // Memory used, in bytes
+    PRBool           mEnabled;     // If false, bypass mem cache
+
+    nsINetDataCache* mNextCache;
+
+    // Mapping from either opaque key or record ID to nsMemCacheRecord
+    nsHashtable*     mHashTable;
+
+    // Used to assign record ID's
+    static PRInt32   gRecordSerialNumber;
+
+    NS_METHOD Delete(nsMemCacheRecord* aRecord);
+
+    friend class nsMemCacheRecord;
+    friend class nsMemCacheChannel;
+};
+
+#endif // _nsMemCache_h_

mozilla/netwerk/cache/memcache/nsMemCacheCID.h

@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+//  XPCOM Class ID for the network data in-memory cache
+
+#ifndef nsMEMCACHECID_h__
+#define nsMEMCACHECID_h__
+
+// {e4710560-7de2-11d3-90cb-0040056a906e}
+#define NS_MEM_CACHE_FACTORY_CID                          \
+    {                                                     \
+        0xe4710560,                                       \
+	    0x7de2,                                           \
+        0x11d3,                                           \
+	    {0x90, 0xcb, 0x00, 0x40, 0x05, 0x6a, 0x90, 0x6e}  \
+    }
+
+#endif // nsMEMCACHECID_h__

mozilla/netwerk/cache/memcache/nsMemCacheChannel.cpp

@@ -0,0 +1,464 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+#include "nsMemCache.h"
+#include "nsMemCacheChannel.h"
+#include "nsIStreamListener.h"
+#include "nsIChannel.h"
+#include "nsIStorageStream.h"
+#include "nsIOutputStream.h"
+#include "nsIServiceManager.h"
+#include "nsIEventQueueService.h"
+#include "nsNetUtil.h"
+#include "nsILoadGroup.h"
+
+static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
+static NS_DEFINE_CID(kEventQueueService, NS_EVENTQUEUESERVICE_CID);
+
+NS_IMPL_ISUPPORTS(nsMemCacheChannel, NS_GET_IID(nsIChannel))
+
+void
+nsMemCacheChannel::NotifyStorageInUse(PRInt32 aBytesUsed)
+{
+    mRecord->mCache->mOccupancy += aBytesUsed;
+}
+
+/**
+ * This class acts as an adaptor around a synchronous input stream to add async
+ * read capabilities.  It adds methods for initiating, suspending, resuming and
+ * cancelling async reads. 
+ */
+class AsyncReadStreamAdaptor : public nsIInputStream {
+public:
+    AsyncReadStreamAdaptor(nsMemCacheChannel* aChannel, nsIInputStream *aSyncStream):
+        mSyncStream(aSyncStream), mDataAvailCursor(0),
+        mRemaining(0), mChannel(aChannel), mAvailable(0), mAborted(false), mSuspended(false)
+        {
+            NS_INIT_REFCNT();
+            NS_ADDREF(mChannel);
+        }
+
+    virtual ~AsyncReadStreamAdaptor() { 
+        mChannel->mAsyncReadStream = 0;
+        NS_RELEASE(mChannel);
+    }
+    
+    NS_DECL_ISUPPORTS
+
+    nsresult
+    IsPending(PRBool* aIsPending) {
+        *aIsPending = (mRemaining != 0) && !mAborted;
+        return NS_OK;
+    }
+
+    nsresult
+    Cancel(void) {
+        mAborted = true;
+        return mStreamListener->OnStopRequest(mChannel, mContext, NS_BINDING_ABORTED, nsnull);
+    }
+
+    nsresult
+    Suspend(void) { mSuspended = true; return NS_OK; }
+
+    nsresult
+    Resume(void) {
+        if (!mSuspended)
+            return NS_ERROR_FAILURE;
+        mSuspended = false;
+        return NextListenerEvent();
+    }
+
+    NS_IMETHOD
+    Available(PRUint32 *aNumBytes) { return mAvailable; }
+
+    NS_IMETHOD
+    Read(char* aBuf, PRUint32 aCount, PRUint32 *aBytesRead) {
+        if (mAborted)
+            return NS_ERROR_ABORT;
+
+        *aBytesRead = 0;
+        aCount = PR_MIN(aCount, mAvailable);
+        nsresult rv = mSyncStream->Read(aBuf, aCount, aBytesRead);
+        mAvailable -= *aBytesRead;
+
+        if (NS_FAILED(rv) && (rv != NS_BASE_STREAM_WOULD_BLOCK)) {
+            Fail();
+            return rv;
+        }
+
+        if (!mSuspended && !mAvailable) {
+            rv = NextListenerEvent();
+            if (NS_FAILED(rv)) {
+                Fail();
+                return rv;
+            }
+        }
+
+        return NS_OK;
+    }
+
+    NS_IMETHOD
+    Close() {
+        nsresult rv = mSyncStream->Close();
+        mSyncStream = 0;
+        mContext = 0;
+        mStreamListener = 0;
+        return rv;
+    }
+
+    nsresult
+    AsyncRead(PRUint32 aStartPosition, PRInt32 aReadCount,
+              nsISupports* aContext, nsIStreamListener* aListener) {
+
+        nsresult rv;
+        nsIEventQueue *eventQ;
+
+        mContext = aContext;
+        mStreamListener = aListener;
+        mRemaining = aReadCount;
+
+        NS_WITH_SERVICE(nsIIOService, serv, kIOServiceCID, &rv);
+        if (NS_FAILED(rv)) return rv;
+
+        NS_WITH_SERVICE(nsIEventQueueService, eventQService, kEventQueueService, &rv);
+        if (NS_FAILED(rv)) return rv;
+
+        rv = eventQService->GetThreadEventQueue(PR_CurrentThread(), &eventQ);
+        if (NS_FAILED(rv)) return rv;
+
+        rv = NS_NewAsyncStreamListener(aListener, eventQ, 
+                                       getter_AddRefs(mStreamListener));
+        NS_RELEASE(eventQ);
+        if (NS_FAILED(rv)) return rv;
+
+        rv = mStreamListener->OnStartRequest(mChannel, aContext);
+        if (NS_FAILED(rv)) return rv;
+
+        return NextListenerEvent();
+    }
+
+protected:
+
+    nsresult
+    Fail(void) {
+        mAborted = true;
+        return mStreamListener->OnStopRequest(mChannel, mContext, NS_BINDING_FAILED, nsnull);
+    }
+
+    nsresult
+    NextListenerEvent() {
+        PRUint32 available;
+        nsresult rv = mSyncStream->Available(&available);
+        if (NS_FAILED(rv)) return rv;
+        available -= mAvailable;
+        available = PR_MIN(available, mRemaining);
+
+        if (available) {
+            PRUint32 size = PR_MIN(available, MEM_CACHE_SEGMENT_SIZE);
+            rv = mStreamListener->OnDataAvailable(mChannel, mContext, this,
+                                                  mDataAvailCursor, size);
+            mDataAvailCursor += size;
+            mRemaining -= size;
+            mAvailable += size;
+            return rv;
+        } else {
+            rv = mStreamListener->OnStopRequest(mChannel, mContext, NS_OK, nsnull);
+            AsyncReadStreamAdaptor* thisAlias = this;
+            NS_RELEASE(thisAlias);
+            return rv;
+        }
+    }
+    
+private:
+    nsCOMPtr<nsISupports>       mContext;        // Opaque context passed to AsyncRead()
+    nsCOMPtr<nsIStreamListener> mStreamListener; // Stream listener that has been proxied
+    nsCOMPtr<nsIInputStream>    mSyncStream;     // Underlying synchronous stream that is
+                                                 //   being converted to an async stream
+    PRUint32                    mDataAvailCursor;
+    PRUint32                    mRemaining;      // Size of AsyncRead request less bytes for
+                                                 //   consumer OnDataAvailable's that were fired
+    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
+};
+
+NS_IMPL_ISUPPORTS(AsyncReadStreamAdaptor,  NS_GET_IID(nsIInputStream))
+
+// The only purpose of this output stream wrapper is to adjust the cache's
+// overall occupancy as new data flows into the cache entry.
+class MemCacheWriteStreamWrapper : public nsIOutputStream {
+public:
+    MemCacheWriteStreamWrapper(nsMemCacheChannel* aChannel, nsIOutputStream *aBaseStream):
+        mBaseStream(aBaseStream), mChannel(aChannel)
+        {
+            NS_INIT_REFCNT();
+            NS_ADDREF(mChannel);
+        }
+
+    virtual ~MemCacheWriteStreamWrapper() { NS_RELEASE(mChannel); };
+    
+    static nsresult
+    Create(nsMemCacheChannel* aChannel, nsIOutputStream *aBaseStream, nsIOutputStream* *aWrapper) {
+        MemCacheWriteStreamWrapper *wrapper =
+            new MemCacheWriteStreamWrapper(aChannel, aBaseStream);
+        if (!wrapper) return NS_ERROR_OUT_OF_MEMORY;
+        NS_ADDREF(wrapper);
+        *aWrapper = wrapper;
+        return NS_OK;
+    }
+    
+    NS_DECL_ISUPPORTS
+
+    NS_IMETHOD
+    Write(const char *aBuffer, PRUint32 aCount, PRUint32 *aNumWritten) {
+        *aNumWritten = 0;
+        nsresult rv = mBaseStream->Write(aBuffer, aCount, aNumWritten);
+        mChannel->NotifyStorageInUse(*aNumWritten);
+        return rv;
+    }
+
+    NS_IMETHOD
+    Flush() { return mBaseStream->Flush(); }
+
+    NS_IMETHOD
+    Close() { return mBaseStream->Close(); }
+
+private:
+    nsCOMPtr<nsIOutputStream>   mBaseStream;
+    nsMemCacheChannel*          mChannel;
+};
+
+NS_IMPL_ISUPPORTS(MemCacheWriteStreamWrapper,  NS_GET_IID(nsIOutputStream))
+
+nsMemCacheChannel::nsMemCacheChannel(nsMemCacheRecord *aRecord, nsILoadGroup *aLoadGroup)
+    : mRecord(aRecord)
+{
+    NS_INIT_REFCNT();
+    mRecord->mNumChannels++;
+}
+
+nsMemCacheChannel::~nsMemCacheChannel()
+{
+    mRecord->mNumChannels--;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::IsPending(PRBool* aIsPending)
+{
+    *aIsPending = PR_FALSE;
+    if (!mAsyncReadStream)
+        return NS_OK;
+    return mAsyncReadStream->IsPending(aIsPending);
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::Cancel(void)
+{
+    if (!mAsyncReadStream)
+        return NS_ERROR_FAILURE;
+    return mAsyncReadStream->Cancel();
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::Suspend(void)
+{
+    if (!mAsyncReadStream)
+        return NS_ERROR_FAILURE;
+    return mAsyncReadStream->Suspend();
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::Resume(void)
+{
+    if (!mAsyncReadStream)
+        return NS_ERROR_FAILURE;
+    return mAsyncReadStream->Resume();
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetOriginalURI(nsIURI * *aURI)
+{
+    // Not required
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetURI(nsIURI * *aURI)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::OpenInputStream(PRUint32 aStartPosition, PRInt32 aReadCount,
+                                   nsIInputStream* *aResult)
+{
+    nsresult rv;
+    NS_ENSURE_ARG(aResult);
+    if (mInputStream)
+        return NS_ERROR_NOT_AVAILABLE;
+
+    rv = mRecord->mStorageStream->NewInputStream(aStartPosition, getter_AddRefs(mInputStream));
+    *aResult = mInputStream;
+    NS_ADDREF(*aResult);
+    return rv;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::OpenOutputStream(PRUint32 startPosition, nsIOutputStream* *aResult)
+{
+    nsresult rv;
+    NS_ENSURE_ARG(aResult);
+
+    nsCOMPtr<nsIOutputStream> outputStream;
+
+    PRUint32 oldLength;
+    mRecord->mStorageStream->GetLength(&oldLength);
+    rv = mRecord->mStorageStream->GetOutputStream(startPosition, getter_AddRefs(outputStream));
+    if (NS_FAILED(rv)) return rv;
+    if (startPosition < oldLength)
+        NotifyStorageInUse(startPosition - oldLength);
+
+    return MemCacheWriteStreamWrapper::Create(this, outputStream, aResult);
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::AsyncOpen(nsIStreamObserver *observer, nsISupports *ctxt)
+{
+    // Not required
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::AsyncRead(PRUint32 aStartPosition, PRInt32 aReadCount,
+                             nsISupports *aContext, nsIStreamListener *aListener)
+{
+    nsCOMPtr<nsIInputStream> inputStream;
+    nsresult rv = OpenInputStream(aStartPosition, aReadCount, getter_AddRefs(inputStream));
+    if (NS_FAILED(rv)) return rv;
+    
+    AsyncReadStreamAdaptor *asyncReadStreamAdaptor;
+    asyncReadStreamAdaptor = new AsyncReadStreamAdaptor(this, inputStream);
+    if (!asyncReadStreamAdaptor)
+        return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(asyncReadStreamAdaptor);
+    mAsyncReadStream = asyncReadStreamAdaptor;
+
+    rv = asyncReadStreamAdaptor->AsyncRead(aStartPosition, aReadCount, aContext, aListener);
+    if (NS_FAILED(rv))
+        delete asyncReadStreamAdaptor;
+    return rv;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::AsyncWrite(nsIInputStream *fromStream, PRUint32 startPosition,
+                              PRInt32 writeCount, nsISupports *ctxt,
+                              nsIStreamObserver *observer)
+{
+    // Not required to be implemented
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetLoadAttributes(nsLoadFlags *aLoadAttributes)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::SetLoadAttributes(nsLoadFlags aLoadAttributes)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+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_IMETHODIMP
+nsMemCacheChannel::GetContentLength(PRInt32 *aContentLength)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetOwner(nsISupports* *aOwner)
+{
+    *aOwner = mOwner.get();
+    NS_IF_ADDREF(*aOwner);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::SetOwner(nsISupports* aOwner)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    mOwner = aOwner;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::SetLoadGroup(nsILoadGroup* aLoadGroup)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::GetNotificationCallbacks(nsIInterfaceRequestor* *aNotificationCallbacks)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheChannel::SetNotificationCallbacks(nsIInterfaceRequestor* aNotificationCallbacks)
+{
+    // Not required to be implemented, since it is implemented by cache manager
+    NS_ASSERTION(0, "nsMemCacheChannel method unexpectedly called");
+    return NS_ERROR_NOT_IMPLEMENTED;
+}

mozilla/netwerk/cache/memcache/nsMemCacheChannel.h

@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+#ifndef _nsMemCacheChannel_h_
+#define _nsMemCacheChannel_h_
+
+#include "nsMemCacheRecord.h"
+#include "nsIChannel.h"
+#include "nsIInputStream.h"
+#include "nsCOMPtr.h"
+
+
+class AsyncReadStreamAdaptor;
+
+class nsMemCacheChannel : public nsIChannel
+{
+public:
+    // Constructors and Destructor
+    nsMemCacheChannel(nsMemCacheRecord *aRecord, nsILoadGroup *aLoadGroup);
+    virtual ~nsMemCacheChannel();
+
+    // Declare nsISupports methods
+    NS_DECL_ISUPPORTS
+
+    // Declare nsIRequest methods
+    NS_DECL_NSIREQUEST
+
+    // Declare nsIChannel methods
+    NS_DECL_NSICHANNEL
+
+protected:
+    void NotifyStorageInUse(PRInt32 aBytesUsed);
+
+    nsCOMPtr<nsMemCacheRecord>   mRecord;
+    nsCOMPtr<nsIInputStream>     mInputStream;
+    nsCOMPtr<nsISupports>        mOwner;
+    AsyncReadStreamAdaptor*      mAsyncReadStream; // non-owning pointer
+
+    friend class MemCacheWriteStreamWrapper;
+    friend class AsyncReadStreamAdaptor;
+};
+
+#endif // _nsMemCacheChannel_h_

mozilla/netwerk/cache/memcache/nsMemCacheRecord.cpp

@@ -0,0 +1,164 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+#include "nsMemCache.h"
+#include "nsMemCacheRecord.h"
+#include "nsMemCacheChannel.h"
+#include "nsIAllocator.h"
+#include "nsStorageStream.h"
+
+static NS_DEFINE_IID(kINetDataCacheRecord, NS_INETDATACACHERECORD_IID);
+
+nsMemCacheRecord::nsMemCacheRecord()
+    : mKey(0), mKeyLength(0), mMetaData(0), mMetaDataLength(0), mNumChannels(0)
+{
+    NS_INIT_REFCNT();
+}
+
+nsMemCacheRecord::~nsMemCacheRecord()
+{
+    if (mMetaData)
+        delete[] mMetaData;
+    if (mKey)
+        delete[] mKey;
+}	
+     
+NS_IMPL_ISUPPORTS(nsMemCacheRecord, NS_GET_IID(nsINetDataCacheRecord))
+
+NS_IMETHODIMP
+nsMemCacheRecord::GetKey(PRUint32 *aLength, char **aResult)
+{
+    NS_ENSURE_ARG(aResult);
+    *aResult = (char *)nsAllocator::Alloc(mKeyLength);
+    if (!*aResult)
+        return NS_ERROR_OUT_OF_MEMORY;
+    memcpy(*aResult, mKey, mKeyLength);
+    *aLength = mKeyLength;
+    return NS_OK;
+}
+
+nsresult
+nsMemCacheRecord::Init(const char *aKey, PRUint32 aKeyLength,
+                       PRUint32 aRecordID, nsMemCache *aCache)
+{
+    nsresult rv;
+
+    NS_ASSERTION(!mKey, "Memory cache record key set multiple times");
+
+    rv = NS_NewStorageStream(MEM_CACHE_SEGMENT_SIZE, MEM_CACHE_MAX_ENTRY_SIZE,
+                             getter_AddRefs(mStorageStream));
+    if (NS_FAILED(rv)) return rv;
+
+    mKey = new char[aKeyLength];
+    if (!mKey)
+        return NS_ERROR_OUT_OF_MEMORY;
+    memcpy(mKey, aKey, aKeyLength);
+    mKeyLength = aKeyLength;
+    mRecordID = aRecordID;
+    mCache = aCache;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::GetRecordID(PRInt32 *aRecordID)
+{
+    NS_ENSURE_ARG(aRecordID);
+    *aRecordID = mRecordID;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::GetMetaData(PRUint32 *aLength, char **aResult)
+{
+    NS_ENSURE_ARG(aResult);
+
+    *aResult = 0;
+    if (mMetaDataLength) {
+        *aResult = (char*)nsAllocator::Alloc(mMetaDataLength);
+        if (!*aResult)
+            return NS_ERROR_OUT_OF_MEMORY;
+        memcpy(*aResult, mMetaData, mMetaDataLength);
+    }
+    *aLength = mMetaDataLength;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::SetMetaData(PRUint32 aLength, const char *aData)
+{
+    if (mMetaData)
+        delete[] mMetaData;
+    mMetaData = new char[aLength];
+    if (!mMetaData)
+        return NS_ERROR_OUT_OF_MEMORY;
+    memcpy(mMetaData, aData, aLength);
+    mMetaDataLength = aLength;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::GetStoredContentLength(PRUint32 *aStoredContentLength)
+{
+    NS_ENSURE_ARG(aStoredContentLength);
+    return mStorageStream->GetLength(aStoredContentLength);
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::SetStoredContentLength(PRUint32 aStoredContentLength)
+{
+    PRUint32 before, after;
+    mStorageStream->GetLength(&before);
+    nsresult rv = mStorageStream->SetLength(aStoredContentLength);
+    if (NS_FAILED(rv)) return rv;
+    mStorageStream->GetLength(&after);
+    mCache->mOccupancy -= (before - after);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::Delete(void)
+{
+    if (mNumChannels)
+        return NS_ERROR_NOT_AVAILABLE;
+  
+    return mCache->Delete(this);
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::GetFilename(nsIFileSpec* *aFilename)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsMemCacheRecord::NewChannel(nsILoadGroup *aLoadGroup, nsIChannel* *aResult)
+{
+    NS_ENSURE_ARG(aResult);
+
+    nsMemCacheChannel* channel = new nsMemCacheChannel(this, aLoadGroup);
+    if (!channel)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF(channel);
+    *aResult = NS_STATIC_CAST(nsIChannel*, channel);
+    return NS_OK;
+
+}

mozilla/netwerk/cache/memcache/nsMemCacheRecord.h

@@ -0,0 +1,65 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ */
+
+#ifndef _nsMemCacheRecord_h_
+#define _nsMemCacheRecord_h_
+
+#include "nsINetDataCacheRecord.h"
+#include "nsCOMPtr.h"
+
+class nsMemCache;
+class nsIStorageStream;
+
+class nsMemCacheRecord : public nsINetDataCacheRecord
+{
+
+public:
+    // Declare interface methods
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSINETDATACACHERECORD
+
+protected:
+    // Constructors and Destructor
+    nsMemCacheRecord();
+    virtual ~nsMemCacheRecord();
+
+    nsresult Init(const char *aKey, PRUint32 aKeyLength,
+                  PRUint32 aRecordID, nsMemCache *aCache);
+
+    char*       mKey;              // opaque database key for this record
+    PRUint32    mKeyLength;        // length, in bytes, of mKey
+
+    PRInt32     mRecordID;         // An alternate key for this record
+
+    char*       mMetaData;         // opaque URI metadata
+    PRUint32    mMetaDataLength;   // length, in bytes, of mMetaData
+
+    nsMemCache* mCache;            // weak pointer to the cache database
+                                   //  that this record inhabits
+
+    nsCOMPtr<nsIStorageStream> mStorageStream;
+    PRUint32    mNumChannels;      // Count un-Release'ed nsIChannels
+
+    friend class nsMemCache;
+    friend class nsMemCacheChannel;
+};
+
+#endif // _nsMemCacheRecord_h_

mozilla/netwerk/cache/mgr/Makefile.in

@@ -13,7 +13,7 @@
 #
 # The Initial Developer of the Original Code is Netscape
 # Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 2001 Netscape Communications Corporation. All
+# Copyright (C) 1998 Netscape Communications Corporation. All
 # Rights Reserved.
 #
 # Contributor(s): 
@@ -26,43 +26,26 @@ VPATH		= @srcdir@
 
 include $(DEPTH)/config/autoconf.mk
 
-MODULE		= nkcache
-LIBRARY_NAME	= nkcache
-EXPORT_LIBRARY = 1
-IS_COMPONENT	= 1
-REQUIRES	= xpcom string necko pref
+MODULE		= nkcache 
+LIBRARY_NAME	= nkcachemgr_s
 
-EXPORTS		= \
-		nsCacheService.h \
-		$(NULL)
+REQUIRES	= nspr
 
 CPPSRCS		= \
-	nsCache.cpp \
-	nsCacheEntry.cpp \
-	nsCacheEntryDescriptor.cpp \
-	nsCacheMetaData.cpp \
-	nsCacheModule.cpp \
-	nsCacheService.cpp \
-	nsCacheSession.cpp \
-	nsDiskCacheBinding.cpp \
-	nsDiskCacheBlockFile.cpp \
-	nsDiskCacheDevice.cpp \
-	nsDiskCacheEntry.cpp \
-	nsDiskCacheMap.cpp \
-	nsMemoryCacheDevice.cpp \
-	$(NULL)
+        nsCacheManager.cpp \
+        nsCachedNetData.cpp \
+        nsReplacementPolicy.cpp \
+        nsCacheEntryChannel.cpp \
+		$(NULL)
 
-include $(topsrcdir)/config/config.mk
-
-EXTRA_DSO_LDOPTS = $(MOZ_COMPONENT_LIBS)
-
-#EXTRA_LIBS	= $(NSPR_LIBS)
+LOCAL_INCLUDES	= -I$(srcdir)/../public -I$(srcdir)/../include
 
+EXTRA_LIBS	= $(NSPR_LIBS)
 
 # we don't want the shared lib, but we want to force the creation of a
 # static lib.
-#override NO_SHARED_LIB=1
-#override NO_STATIC_LIB=
+override NO_SHARED_LIB=1
+override NO_STATIC_LIB=
 
 include $(topsrcdir)/config/rules.mk
 

mozilla/netwerk/cache/mgr/Makefile.win

@@ -0,0 +1,45 @@
+#!gmake
+#
+# The contents of this file are subject to the Netscape 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
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+
+DEPTH=..\..\..
+
+include <$(DEPTH)/config/config.mak>
+
+MODULE = nkcache
+
+LIBRARY_NAME = nkcachemgr_s
+
+CPP_OBJS =                                   \
+	.\$(OBJDIR)\nsCacheManager.obj       \
+	.\$(OBJDIR)\nsCachedNetData.obj      \
+	.\$(OBJDIR)\nsReplacementPolicy.obj  \
+	.\$(OBJDIR)\nsCacheEntryChannel.obj  \
+	$(NULL)
+
+include <$(DEPTH)\config\rules.mak> 
+
+install:: $(LIBRARY)
+	$(MAKE_INSTALL) $(LIBRARY) $(DIST)\lib
+
+clobber::
+        rm -rf $(OBJDIR)
+        rm -f $(DIST)\lib\$(LIBRARY_NAME).lib
+

mozilla/netwerk/cache/mgr/nsCacheEntryChannel.cpp

@@ -0,0 +1,260 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+#include "nsCacheManager.h"
+#include "nsCacheEntryChannel.h"
+#include "nsIOutputStream.h"
+#include "nsIIOService.h"
+#include "nsIServiceManager.h"
+#include "nsIStreamListener.h"
+
+nsCacheEntryChannel::nsCacheEntryChannel(nsCachedNetData* aCacheEntry, nsIChannel* aChannel,
+                                         nsILoadGroup* aLoadGroup):
+    nsChannelProxy(aChannel), mCacheEntry(aCacheEntry), mLoadGroup(aLoadGroup), mLoadAttributes(0)
+{
+    NS_ASSERTION(aCacheEntry->mChannelCount < 0xFF, "Overflowed channel counter");
+    mCacheEntry->mChannelCount++;
+    NS_INIT_REFCNT();
+}
+
+nsCacheEntryChannel::~nsCacheEntryChannel()
+{
+    mCacheEntry->mChannelCount--;
+}
+
+NS_IMPL_ISUPPORTS3(nsCacheEntryChannel, nsISupports, nsIChannel, nsIRequest)
+
+// A proxy for nsIOutputStream
+class CacheOutputStream : public nsIOutputStream {
+
+public:
+    CacheOutputStream(nsIOutputStream *aOutputStream, nsCachedNetData *aCacheEntry):
+        mOutputStream(aOutputStream), mCacheEntry(aCacheEntry), mStartTime(PR_Now())
+        { NS_INIT_REFCNT(); }
+
+    virtual ~CacheOutputStream() {}
+
+    NS_DECL_ISUPPORTS
+
+    NS_IMETHOD Close() {
+        mCacheEntry->NoteDownloadTime(mStartTime, PR_Now());
+        mCacheEntry->ClearFlag(nsCachedNetData::UPDATE_IN_PROGRESS);
+        return mOutputStream->Close();
+    }
+
+    NS_IMETHOD Flush() { return mOutputStream->Flush(); }
+
+    NS_IMETHOD
+    Write(const char *aBuf, PRUint32 aCount, PRUint32 *aActualBytes) {
+        nsresult rv;
+    
+        *aActualBytes = 0;
+        rv = mOutputStream->Write(aBuf, aCount, aActualBytes);
+        mCacheEntry->mLogicalLength += *aActualBytes;
+        if (NS_FAILED(rv)) return rv;
+        nsCacheManager::LimitCacheSize();
+        return rv;
+    }
+    
+protected:
+    nsCOMPtr<nsIOutputStream> mOutputStream;
+    nsCOMPtr<nsCachedNetData> mCacheEntry;
+
+    // Time at which stream was opened
+    PRTime mStartTime;
+};
+
+NS_IMPL_ISUPPORTS(CacheOutputStream, NS_GET_IID(nsIOutputStream))
+
+NS_IMETHODIMP
+nsCacheEntryChannel::OpenOutputStream(PRUint32 aStartPosition, nsIOutputStream* *aOutputStream)
+{
+    nsresult rv;
+    nsCOMPtr<nsIOutputStream> baseOutputStream;
+    
+    rv = mChannel->OpenOutputStream(aStartPosition, getter_AddRefs(baseOutputStream));
+    if (NS_FAILED(rv)) return rv;
+
+    mCacheEntry->NoteUpdate();
+    mCacheEntry->NoteAccess();
+    mCacheEntry->mLogicalLength = aStartPosition;
+
+    *aOutputStream = new CacheOutputStream(baseOutputStream, mCacheEntry);
+    if (!*aOutputStream)
+        return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(*aOutputStream);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheEntryChannel::OpenInputStream(PRUint32 aStartPosition, PRInt32 aReadCount,
+				     nsIInputStream* *aInputStream)
+{
+    mCacheEntry->NoteAccess();
+    return mChannel->OpenInputStream(aStartPosition, aReadCount, aInputStream);
+}
+
+class CacheManagerStreamListener: public nsIStreamListener  {
+
+    public:
+    
+    CacheManagerStreamListener(nsIStreamListener *aListener,
+                               nsILoadGroup *aLoadGroup, nsIChannel *aChannel):
+        mListener(aListener), mLoadGroup(aLoadGroup), mChannel(aChannel)
+        { NS_INIT_REFCNT(); }
+
+    virtual ~CacheManagerStreamListener() {}
+
+    private:
+
+    NS_DECL_ISUPPORTS
+
+    NS_IMETHOD
+    OnDataAvailable(nsIChannel *channel, nsISupports *aContext,
+                    nsIInputStream *inStr, PRUint32 sourceOffset, PRUint32 count) {
+        return mListener->OnDataAvailable(mChannel, aContext, inStr, sourceOffset, count);
+    }
+
+    NS_IMETHOD
+    OnStartRequest(nsIChannel *channel, nsISupports *aContext) {
+        if (mLoadGroup)
+            mLoadGroup->AddChannel(mChannel, aContext);
+        return mListener->OnStartRequest(mChannel, aContext);
+    }
+
+    NS_IMETHOD
+    OnStopRequest(nsIChannel *channel, nsISupports *aContext,
+                  nsresult status, const PRUnichar *errorMsg) {
+        nsresult rv;
+        rv = mListener->OnStopRequest(mChannel, aContext, status, errorMsg);
+        if (mLoadGroup)
+            mLoadGroup->RemoveChannel(mChannel, aContext, status, errorMsg);
+        return rv;
+    }
+
+    private:
+    
+    nsCOMPtr<nsIStreamListener>  mListener;
+    nsCOMPtr<nsILoadGroup>       mLoadGroup;
+    nsCOMPtr<nsIChannel>         mChannel;
+};
+
+NS_IMPL_ISUPPORTS2(CacheManagerStreamListener, nsIStreamListener, nsIStreamObserver)
+
+NS_IMETHODIMP
+nsCacheEntryChannel::AsyncRead(PRUint32 aStartPosition, PRInt32 aReadCount,
+                               nsISupports *aContext, nsIStreamListener *aListener)
+{
+    nsresult rv;
+
+    mCacheEntry->NoteAccess();
+
+    nsCOMPtr<nsIStreamListener> headListener;
+    if (mLoadGroup) {
+        mLoadGroup->GetDefaultLoadAttributes(&mLoadAttributes);
+
+        // Create a load group "proxy" listener...
+        nsCOMPtr<nsILoadGroupListenerFactory> factory;
+        rv = mLoadGroup->GetGroupListenerFactory(getter_AddRefs(factory));
+        if (NS_SUCCEEDED(rv) && factory) {
+            rv = factory->CreateLoadGroupListener(aListener, 
+                                                  getter_AddRefs(headListener));
+            if (NS_FAILED(rv)) return rv;
+        }
+
+    } else {
+        headListener = aListener;
+    }
+
+    CacheManagerStreamListener* cacheManagerStreamListener;
+    nsIChannel *channelForListener;
+
+    channelForListener = mProxyChannel ? mProxyChannel : this;
+    cacheManagerStreamListener =
+        new CacheManagerStreamListener(headListener, mLoadGroup, channelForListener);
+    if (!cacheManagerStreamListener) return NS_ERROR_OUT_OF_MEMORY;
+    
+    NS_ADDREF(cacheManagerStreamListener);
+    rv = mChannel->AsyncRead(aStartPosition, aReadCount, aContext,
+                             cacheManagerStreamListener);
+    NS_RELEASE(cacheManagerStreamListener);
+
+    return rv;
+}
+
+// No async writes allowed to the cache yet
+NS_IMETHODIMP
+nsCacheEntryChannel::AsyncWrite(nsIInputStream *aFromStream, PRUint32 aStartPosition,
+				PRInt32 aWriteCount, nsISupports *aContext,
+				nsIStreamObserver *aObserver)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsCacheEntryChannel::GetLoadGroup(nsILoadGroup* *aLoadGroup)
+{
+    *aLoadGroup = mLoadGroup;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheEntryChannel::GetLoadAttributes(nsLoadFlags *aLoadAttributes)
+{
+    *aLoadAttributes = mLoadAttributes;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheEntryChannel::SetLoadAttributes(nsLoadFlags aLoadAttributes)
+{
+    mLoadAttributes = aLoadAttributes;
+    return NS_OK;
+}
+
+static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID);
+
+NS_IMETHODIMP
+nsCacheEntryChannel::GetURI(nsIURI * *aURI)
+{
+    char* spec;
+    nsresult rv;
+
+    rv = mCacheEntry->GetUriSpec(&spec);
+    if (NS_FAILED(rv)) return rv;
+
+    NS_WITH_SERVICE(nsIIOService, serv, kIOServiceCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+    
+    rv = serv->NewURI(spec, 0, aURI);
+    nsAllocator::Free(spec);
+    return rv;
+}
+
+NS_IMETHODIMP
+nsCacheEntryChannel::GetOriginalURI(nsIURI * *aURI)
+{
+    // FIXME - should return original URI passed into NewChannel() ?
+    return NS_ERROR_NOT_IMPLEMENTED;
+}

mozilla/netwerk/cache/mgr/nsCacheEntryChannel.h

@@ -0,0 +1,82 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+#ifndef _nsCacheEntryChannel_h_
+#define _nsCacheEntryChannel_h_
+
+#include "nsCOMPtr.h"
+#include "nsIChannel.h"
+#include "nsCachedNetData.h"
+#include "nsILoadGroup.h"
+
+class nsIStreamListener;
+
+// A proxy for an nsIChannel, useful when only a few nsIChannel
+// methods must be overridden
+class nsChannelProxy : public nsIChannel {
+
+public:
+    NS_FORWARD_NSICHANNEL(mChannel->)
+    NS_FORWARD_NSIREQUEST(mChannel->)
+
+protected:
+    nsChannelProxy(nsIChannel* aChannel):mChannel(aChannel) {};
+    virtual ~nsChannelProxy() {};
+    nsCOMPtr<nsIChannel>      mChannel;
+};
+
+// Override several nsIChannel methods so that they interact with the cache manager
+class nsCacheEntryChannel : public nsChannelProxy {
+
+public:
+    NS_DECL_ISUPPORTS
+
+    NS_IMETHOD OpenOutputStream(PRUint32 aStartPosition, nsIOutputStream* *aOutputStream);
+    NS_IMETHOD OpenInputStream(PRUint32 aStartPosition, PRInt32 aReadCount,
+			       nsIInputStream* *aInputStream);
+    NS_IMETHOD AsyncRead(PRUint32 aStartPosition, PRInt32 aReadCount,
+			 nsISupports *aContext, nsIStreamListener *aListener);
+    NS_IMETHOD AsyncWrite(nsIInputStream *aFromStream, PRUint32 aStartPosition,
+			  PRInt32 aWriteCount, nsISupports *aContext,
+			  nsIStreamObserver *aObserver);
+    NS_IMETHOD GetLoadAttributes(nsLoadFlags *aLoadAttributes);
+    NS_IMETHOD SetLoadAttributes(nsLoadFlags aLoadAttributes);
+    NS_IMETHOD GetLoadGroup(nsILoadGroup* *aLoadGroup);
+    NS_IMETHOD GetURI(nsIURI * *aURI);
+    NS_IMETHOD GetOriginalURI(nsIURI * *aURI);
+
+protected:
+    nsCacheEntryChannel(nsCachedNetData* aCacheEntry, nsIChannel* aChannel, nsILoadGroup* aLoadGroup);
+    virtual ~nsCacheEntryChannel();
+
+    friend class nsCachedNetData;
+
+private:
+    nsCOMPtr<nsCachedNetData>    mCacheEntry;
+    nsCOMPtr<nsILoadGroup>       mLoadGroup;
+    nsCOMPtr<nsIChannel>         mProxyChannel;
+    nsLoadFlags                  mLoadAttributes;
+};
+
+#endif // _nsCacheEntryChannel_h_

mozilla/netwerk/cache/mgr/nsCacheManager.cpp

@@ -0,0 +1,496 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * 
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+#include "nsINetDataCache.h"
+#include "nsCacheManager.h"
+#include "nsCachedNetData.h"
+#include "nsReplacementPolicy.h"
+#include "nsString.h"
+#include "nsIURI.h"
+#include "nsHashtable.h"
+#include "nsIComponentManager.h"
+#include "nsINetDataDiskCache.h"
+
+// Limit the number of entries in the cache to conserve memory space
+// in the nsReplacementPolicy code
+#define MAX_MEM_CACHE_ENTRIES    800
+#define MAX_DISK_CACHE_ENTRIES  3200
+
+// Cache capacities in MB, overridable via APIs
+#define DEFAULT_MEMORY_CACHE_CAPACITY  2000
+#define DEFAULT_DISK_CACHE_CAPACITY   10000
+
+#define CACHE_HIGH_WATER_MARK(capacity) ((PRUint32)(0.98 * (capacity)))
+#define CACHE_LOW_WATER_MARK(capacity)  ((PRUint32)(0.97 * (capacity)))
+
+nsCacheManager* gCacheManager = 0;
+
+NS_IMPL_ISUPPORTS(nsCacheManager, NS_GET_IID(nsINetDataCacheManager))
+
+nsCacheManager::nsCacheManager()
+    : mActiveCacheRecords(0),
+    mDiskCacheCapacity(DEFAULT_DISK_CACHE_CAPACITY),
+    mMemCacheCapacity(DEFAULT_MEMORY_CACHE_CAPACITY)
+{
+    NS_ASSERTION(!gCacheManager, "Multiple cache managers created");
+    gCacheManager = this;
+    NS_INIT_REFCNT();
+}
+
+nsCacheManager::~nsCacheManager()
+{
+    gCacheManager = 0;
+    delete mActiveCacheRecords;
+    delete mMemSpaceManager;
+    delete mDiskSpaceManager;
+}
+
+nsresult
+nsCacheManager::Init()
+{
+    nsresult rv;
+
+    mActiveCacheRecords = new nsHashtable(64);
+    if (!mActiveCacheRecords)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    // Instantiate the memory cache component
+    rv = nsComponentManager::CreateInstance(NS_NETWORK_MEMORY_CACHE_PROGID,
+                                            nsnull,
+                                            NS_GET_IID(nsINetDataCache),
+                                            getter_AddRefs(mMemCache));
+    if (NS_FAILED(rv))
+        return rv;
+
+    rv = nsComponentManager::CreateInstance(NS_NETWORK_FLAT_CACHE_PROGID,
+                                            nsnull,
+                                            NS_GET_IID(nsINetDataCache),
+
+                                            getter_AddRefs(mFlatCache));
+
+    if (NS_FAILED(rv)) {
+        // For now, we don't require a flat cache module to be present
+        if (rv != NS_ERROR_FACTORY_NOT_REGISTERED)
+            return rv;
+    }
+
+#ifdef FILE_CACHE_IS_READY
+    // Instantiate the file cache component
+    rv = nsComponentManager::CreateInstance(NS_NETWORK_FILE_CACHE_PROGID,
+                                            nsnull,
+                                            NS_GET_IID(nsINetDataCache),
+                                            getter_AddRefs(mFileCache));
+    if (NS_FAILED(rv)) {
+        NS_WARNING("No disk cache present");
+    }
+#endif
+
+    // Set up linked list of caches in search order
+    mCacheSearchChain = mMemCache;
+    if (mFlatCache) {
+        mMemCache->SetNextCache(mFlatCache);
+        mFlatCache->SetNextCache(mFileCache);
+    } else {
+        mMemCache->SetNextCache(mFileCache);
+    }
+
+    // TODO - Load any extension caches here
+
+    // Initialize replacement policy for memory cache module
+    mMemSpaceManager = new nsReplacementPolicy;
+    if (!mMemSpaceManager)
+        return NS_ERROR_OUT_OF_MEMORY;
+    rv = mMemSpaceManager->Init(MAX_MEM_CACHE_ENTRIES);
+    if (NS_FAILED(rv)) return rv;
+    rv = mMemSpaceManager->AddCache(mMemCache);
+
+    // Initialize replacement policy for disk cache modules (file
+    // cache and flat cache)
+    mDiskSpaceManager = new nsReplacementPolicy;
+    if (!mDiskSpaceManager)
+        return NS_ERROR_OUT_OF_MEMORY;
+    rv = mDiskSpaceManager->Init(MAX_DISK_CACHE_ENTRIES);
+    if (NS_FAILED(rv)) return rv;
+    if (mFileCache) {
+        rv = mDiskSpaceManager->AddCache(mFileCache);
+        if (NS_FAILED(rv)) return rv;
+    }
+    if (mFlatCache) {
+        rv = mDiskSpaceManager->AddCache(mFlatCache);
+        if (NS_FAILED(rv)) return rv;
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::GetCachedNetData(const char *aUriSpec, const char *aSecondaryKey,
+                                 PRUint32 aSecondaryKeyLength,
+                                 PRUint32 aFlags, nsICachedNetData* *aResult)
+{
+    nsCachedNetData *cachedData;
+    nsresult rv;
+    nsINetDataCache *cache;
+    nsReplacementPolicy *spaceManager;
+
+    if (aFlags & CACHE_AS_FILE) {
+        cache = mFileCache;
+        spaceManager = mDiskSpaceManager;
+
+        // Ensure that cache is initialized
+        if (mDiskCacheCapacity == (PRUint32)-1)
+            return NS_ERROR_NOT_AVAILABLE;
+
+    } else if ((aFlags & BYPASS_PERSISTENT_CACHE) || !mDiskCacheCapacity) {
+        cache = mMemCache;
+        spaceManager = mMemSpaceManager;
+    } else {
+        cache = mFlatCache ? mFlatCache : mFileCache;
+        spaceManager = mDiskSpaceManager;
+    }
+
+    // Construct the cache key by appending the secondary key to the URI spec
+    nsCAutoString cacheKey(aUriSpec);
+
+    // Insert NUL at end of URI spec
+    cacheKey += '\0';
+    if (aSecondaryKey)
+        cacheKey.Append(aSecondaryKey, aSecondaryKeyLength);
+
+    nsStringKey key(cacheKey);
+    cachedData = (nsCachedNetData*)mActiveCacheRecords->Get(&key);
+
+    // There is no existing instance of nsCachedNetData for this URL.
+    // Make one from the corresponding record in the cache module.
+    if (cachedData) {
+        NS_ASSERTION(cache == cachedData->mCache,
+                     "Cannot yet handle simultaneously active requests for the "
+                     "same URL using different caches");
+        NS_ADDREF(cachedData);
+    } else {
+        rv = spaceManager->GetCachedNetData(cacheKey.GetBuffer(), cacheKey.Length(),
+                                            cache, &cachedData);
+        if (NS_FAILED(rv)) return rv;
+
+        mActiveCacheRecords->Put(&key, cachedData);
+    }
+    
+    *aResult = cachedData;
+    return NS_OK;
+}
+
+// Remove this cache entry from the list of active ones
+nsresult
+nsCacheManager::NoteDormant(nsCachedNetData* aEntry)
+{
+    nsresult rv;
+    PRUint32 keyLength;
+    char* key;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    nsCachedNetData* deletedEntry;
+
+    rv = aEntry->GetRecord(getter_AddRefs(record));
+    if (NS_FAILED(rv)) return rv;
+    
+    rv = record->GetKey(&keyLength, &key);
+    if (NS_FAILED(rv)) return rv;
+    
+    nsStringKey hashTableKey(nsCString(key, keyLength));
+    deletedEntry = (nsCachedNetData*)gCacheManager->mActiveCacheRecords->Remove(&hashTableKey);
+    NS_ASSERTION(deletedEntry == aEntry, "Hash table inconsistency");
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::Contains(const char *aUriSpec, const char *aSecondaryKey,
+                         PRUint32 aSecondaryKeyLength,
+                         PRUint32 aFlags, PRBool *aResult)
+{
+    nsINetDataCache *cache;
+    nsReplacementPolicy *spaceManager;
+    nsCachedNetData *cachedData;
+
+    if (aFlags & CACHE_AS_FILE) {
+        cache = mFileCache;
+        spaceManager = mDiskSpaceManager;
+    } else if ((aFlags & BYPASS_PERSISTENT_CACHE) ||
+               (!mFileCache && !mFlatCache) || !mDiskCacheCapacity) {
+        cache = mMemCache;
+        spaceManager = mMemSpaceManager;
+    } else {
+        cache = mFlatCache ? mFlatCache : mFileCache;
+        spaceManager = mDiskSpaceManager;
+    }
+
+    // Construct the cache key by appending the secondary key to the URI spec
+    nsCAutoString cacheKey(aUriSpec);
+
+    // Insert NUL between URI spec and secondary key
+    cacheKey += '\0';
+    cacheKey.Append(aSecondaryKey, aSecondaryKeyLength);
+
+    // Locate the record using (URI + secondary key)
+    nsStringKey key(cacheKey);
+    cachedData = (nsCachedNetData*)mActiveCacheRecords->Get(&key);
+
+    if (cachedData && (cache == cachedData->mCache)) {
+        *aResult = PR_TRUE;
+        return NS_OK;
+    } else {
+        // No active cache entry, see if there is a dormant one
+        return cache->Contains(cacheKey.GetBuffer(), cacheKey.Length(), aResult);
+    }
+}
+
+NS_IMETHODIMP
+nsCacheManager::GetNumEntries(PRUint32 *aNumEntries)
+{
+    nsresult rv;
+    nsCOMPtr<nsISimpleEnumerator> iterator;
+    nsCOMPtr<nsISupports> cacheSupports;
+    nsCOMPtr<nsINetDataCache> cache;
+
+    PRUint32 totalEntries = 0;
+    
+    rv = NewCacheModuleIterator(getter_AddRefs(iterator));
+    if (NS_FAILED(rv)) return rv;
+    while (1) {
+        PRBool notDone;
+        rv = iterator->HasMoreElements(&notDone);
+        if (NS_FAILED(rv)) return rv;
+        if (!notDone)
+            break;
+        
+        iterator->GetNext(getter_AddRefs(cacheSupports));
+        cache = do_QueryInterface(cacheSupports);
+        
+        PRUint32 numEntries;
+        rv = cache->GetNumEntries(&numEntries);
+        if (NS_FAILED(rv)) return rv;
+        totalEntries += numEntries;
+    }
+    
+    *aNumEntries = totalEntries;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::NewCacheEntryIterator(nsISimpleEnumerator* *aResult)
+{
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+class CacheEnumerator : public nsISimpleEnumerator
+{
+public:
+    CacheEnumerator(nsINetDataCache* aFirstCache):mCache(aFirstCache)
+        { NS_INIT_REFCNT(); }
+
+    virtual ~CacheEnumerator() {};
+    
+    NS_DECL_ISUPPORTS
+
+    NS_IMETHODIMP
+    HasMoreElements(PRBool* aMoreElements) {
+        *aMoreElements = (mCache != 0);
+        return NS_OK;
+    }
+
+    NS_IMETHODIMP
+    GetNext(nsISupports* *aSupports) {
+        *aSupports = mCache;
+        if (!mCache)
+            return NS_ERROR_FAILURE;
+        NS_ADDREF(*aSupports);
+
+        nsCOMPtr<nsINetDataCache> nextCache;
+        nsresult rv = mCache->GetNextCache(getter_AddRefs(nextCache));
+        mCache = nextCache;
+        return rv;
+    }
+
+private:
+    nsCOMPtr<nsINetDataCache> mCache;
+};
+
+NS_IMPL_ISUPPORTS(CacheEnumerator, NS_GET_IID(nsISimpleEnumerator))
+
+NS_IMETHODIMP
+nsCacheManager::NewCacheModuleIterator(nsISimpleEnumerator* *aResult)
+{
+    *aResult = new CacheEnumerator(mCacheSearchChain);
+    if (!*aResult)
+        return NS_ERROR_OUT_OF_MEMORY;
+    NS_ADDREF(*aResult);
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::RemoveAll(void)
+{
+    nsresult rv, result;
+    nsCOMPtr<nsISimpleEnumerator> iterator;
+    nsCOMPtr<nsINetDataCache> cache;
+    nsCOMPtr<nsISupports> iSupports;
+
+    result = NS_OK;
+    rv = NewCacheModuleIterator(getter_AddRefs(iterator));
+    if (NS_FAILED(rv)) return rv;
+    while (1) {
+        PRBool notDone;
+        rv = iterator->HasMoreElements(&notDone);
+        if (NS_FAILED(rv)) return rv;
+        if (!notDone)
+            break;
+        
+        iterator->GetNext(getter_AddRefs(iSupports));
+        cache = do_QueryInterface(iSupports);
+
+        PRUint32 cacheFlags;
+        rv = cache->GetFlags(&cacheFlags);
+        if (NS_FAILED(rv)) return rv;
+        
+        if ((cacheFlags & nsINetDataCache::READ_ONLY) == 0) {
+            rv = cache->RemoveAll();
+            if (NS_FAILED(rv))
+                result = rv;
+        }
+    }
+
+    return result;
+}
+
+nsresult
+nsCacheManager::LimitMemCacheSize()
+{
+    nsresult rv;
+    nsReplacementPolicy* spaceManager;
+
+    NS_ASSERTION(gCacheManager, "No cache manager");
+
+    spaceManager = gCacheManager->mMemSpaceManager;
+
+    PRUint32 occupancy;
+    rv = spaceManager->GetStorageInUse(&occupancy);
+    if (NS_FAILED(rv)) return rv;
+
+    PRUint32 memCacheCapacity = gCacheManager->mMemCacheCapacity;
+    if (occupancy > CACHE_HIGH_WATER_MARK(memCacheCapacity))
+        return spaceManager->Evict(CACHE_LOW_WATER_MARK(memCacheCapacity));
+
+    return NS_OK;
+}
+
+nsresult
+nsCacheManager::LimitDiskCacheSize()
+{
+    nsresult rv;
+    nsReplacementPolicy* spaceManager;
+
+    NS_ASSERTION(gCacheManager, "No cache manager");
+
+    spaceManager = gCacheManager->mDiskSpaceManager;
+
+    PRUint32 occupancy;
+    rv = spaceManager->GetStorageInUse(&occupancy);
+    if (NS_FAILED(rv)) return rv;
+
+    PRUint32 diskCacheCapacity = gCacheManager->mDiskCacheCapacity;
+    if (occupancy > CACHE_HIGH_WATER_MARK(diskCacheCapacity))
+        return spaceManager->Evict(CACHE_LOW_WATER_MARK(diskCacheCapacity));
+
+    return NS_OK;
+}
+
+nsresult
+nsCacheManager::LimitCacheSize()
+{
+    nsresult rv;
+
+    rv = LimitDiskCacheSize();
+    if (NS_FAILED(rv)) return rv;
+
+    rv = LimitMemCacheSize();
+    if (NS_FAILED(rv)) return rv;
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::SetMemCacheCapacity(PRUint32 aCapacity)
+{
+    mMemCacheCapacity = aCapacity;
+    LimitCacheSize();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::GetMemCacheCapacity(PRUint32* aCapacity)
+{
+    NS_ENSURE_ARG_POINTER(aCapacity);
+    *aCapacity = mMemCacheCapacity;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::SetDiskCacheCapacity(PRUint32 aCapacity)
+{
+    mDiskCacheCapacity = aCapacity;
+    LimitCacheSize();
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::GetDiskCacheCapacity(PRUint32* aCapacity)
+{
+    NS_ENSURE_ARG_POINTER(aCapacity);
+    *aCapacity = mDiskCacheCapacity;
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsCacheManager::SetDiskCacheFolder(nsIFileSpec* aFolder)
+{
+    NS_ENSURE_ARG(aFolder);
+
+    if (!mFileCache)
+        return NS_ERROR_NOT_AVAILABLE;
+
+    nsCOMPtr<nsINetDataDiskCache> fileCache;
+    fileCache = do_QueryInterface(mFileCache);
+    return fileCache->SetDiskCacheFolder(aFolder);
+}
+
+NS_IMETHODIMP
+nsCacheManager::GetDiskCacheFolder(nsIFileSpec* *aFolder)
+{
+    NS_ENSURE_ARG(aFolder);
+
+    if (!mFileCache)
+        return NS_ERROR_NOT_AVAILABLE;
+
+    nsCOMPtr<nsINetDataDiskCache> fileCache;
+    fileCache = do_QueryInterface(mFileCache);
+    return fileCache->GetDiskCacheFolder(aFolder);
+}

mozilla/netwerk/cache/mgr/nsCacheManager.h

@@ -0,0 +1,99 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+#ifndef _nsCacheManager_h_
+#define _nsCacheManager_h_
+
+// 2030f0b0-9567-11d3-90d3-0040056a906e
+#define NS_CACHE_MANAGER_CID                              \
+    {                                                     \
+        0x2030f0b0,                                       \
+        0x9567,                                           \
+        0x11d3,                                           \
+        {0x90, 0xd3, 0x00, 0x40, 0x05, 0x6a, 0x90, 0x6e}  \
+    }
+
+#include "nsINetDataCacheManager.h"
+#include "nsCOMPtr.h"
+
+class nsHashtable;
+class nsReplacementPolicy;
+class nsCachedNetData;
+
+class nsCacheManager : public nsINetDataCacheManager {
+
+public:
+    nsCacheManager();
+    virtual ~nsCacheManager();
+
+    NS_METHOD Init();
+
+    // nsISupports methods
+    NS_DECL_ISUPPORTS
+
+    // nsINetDataCacheManager methods
+    NS_DECL_NSINETDATACACHEMANAGER
+
+private:
+	
+    // Mapping from cache key to nsCachedNetData, but only for those cache
+    // entries with external references, i.e. those referred to outside the
+    // cache manager
+    nsHashtable*              mActiveCacheRecords;
+
+    // Memory cache
+    nsCOMPtr<nsINetDataCache> mMemCache;
+
+    // Flat-file database cache; All content aggregated into single disk file
+    nsCOMPtr<nsINetDataCache> mFlatCache;
+
+    // stream-as-file cache
+    nsCOMPtr<nsINetDataCache> mFileCache;
+
+    // Unified replacement policy for flat-cache and file-cache
+    nsReplacementPolicy*      mDiskSpaceManager;
+    
+    // Replacement policy for memory cache
+    nsReplacementPolicy*      mMemSpaceManager;
+
+    // List of caches in search order
+    nsINetDataCache*          mCacheSearchChain;
+
+    // Combined file/flat cache capacity, in KB
+    PRUint32                  mDiskCacheCapacity;
+
+    // Memory cache capacity, in KB
+    PRUint32                  mMemCacheCapacity;
+
+protected:
+    static nsresult NoteDormant(nsCachedNetData* aEntry);
+    static nsresult LimitCacheSize();
+    static nsresult LimitMemCacheSize();
+    static nsresult LimitDiskCacheSize();
+
+    friend class nsCachedNetData;
+    friend class CacheOutputStream;
+};
+
+#endif // _nsCacheManager_h_

mozilla/netwerk/cache/mgr/nsCachedNetData.h

@@ -0,0 +1,242 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+#ifndef _nsCachedNetData_h_
+#define _nsCachedNetData_h_
+
+#include "nsICachedNetData.h"
+#include "nsCOMPtr.h"
+#include "nsINetDataCacheRecord.h"
+
+class nsINetDataCache;
+class nsIStreamAsFileObserver;
+class nsIStreamAsFile;
+class nsIArena;
+class StreamAsFileObserverClosure;
+class CacheMetaData;
+
+// Number of recent access times recorded
+#define MAX_K  3
+
+/**
+ * FIXME - add comment.  There are a lot of these data structures resident in
+ * memory, so be careful about adding members unnecessarily.
+ */
+class nsCachedNetData : public nsICachedNetData {
+
+public:
+    NS_DECL_ISUPPORTS
+
+    // nsICachedNetData methods
+    NS_DECL_NSICACHEDNETDATA
+
+    NS_METHOD Init(nsINetDataCacheRecord *aRecord, nsINetDataCache *aCache);
+
+protected:
+
+    // Bits for mFlags, below
+    typedef enum {
+        DIRTY               = 1 << 0, // Cache entry data needs to be flushed to database
+
+    // ==== Flags that can be set by the protocol handler ====
+        ALLOW_PARTIAL       = 1 << 1, // Protocol handler supports partial fetching
+        UPDATE_IN_PROGRESS  = 1 << 2, // Protocol handler now modifying cache data
+
+    // ==== Cache-entry state flags.  At most one of these flags can be set ====
+        TRUNCATED_CONTENT   = 1 << 4, // Entry contains valid content, but it has
+                                      //   been truncated by cache manager
+
+        // A previously-used cache entry, which has been purged of all cached
+        // content and protocol-private data.  This cache entry can be refilled
+        // with new content or it may be retained in this vestigial state
+        // because the usage statistics it contains will be used by the
+        // replacement policy if the same URI is ever cached again.
+        VESTIGIAL           = 1 << 5,
+
+    // ==== Memory usage status bits.  At most one of these flags can be set ====
+        RECYCLED            = 1 << 8, // Previously associated database record has
+                                      //   been deleted; This cache entry is available
+                                      //   for recycling.
+
+        DORMANT             = 1 << 9, // No references to this cache entry, except by
+                                      //   the cache manager itself
+        
+    // ==== Setter bits ====
+        LAST_MODIFIED_KNOWN = 1 <<12, // Protocol handler called SetLastModifiedTime()
+        EXPIRATION_KNOWN    = 1 <<13, // Protocol handler called SetExpirationTime()
+        STALE_TIME_KNOWN    = 1 <<14, // Protocol handler called SetStaleTime()
+
+    // ==== Useful flag combinations ====
+        // Cache entry not eligible for eviction
+        UNEVICTABLE         = VESTIGIAL | RECYCLED | UPDATE_IN_PROGRESS,
+        
+        // State flags that are in-memory only, i.e. not persistent 
+        TRANSIENT_FLAGS     = DIRTY | RECYCLED | DORMANT
+    } Flag;
+
+    PRBool GetFlag(Flag aFlag) { return (mFlags & aFlag) != 0; }
+    nsresult GetFlag(PRBool *aResult, Flag aFlag) { *aResult = GetFlag(aFlag); return NS_OK; }
+
+    // Set a boolean flag for the cache entry
+    nsresult SetFlag(PRBool aValue, Flag aFlag);
+    nsresult SetFlag(Flag aFlag)   { return SetFlag(PR_TRUE,  aFlag); }
+    nsresult ClearFlag(Flag aFlag) { return SetFlag(PR_FALSE, aFlag); }
+
+    void ComputeProfit(PRUint32 aCurrentTime);
+    static int Compare(const void *a, const void *b, void *unused);
+
+    void NoteAccess();
+    void NoteUpdate();
+
+    // Get underlying raw cache database record.
+    nsresult GetRecord(nsINetDataCacheRecord* *aRecord);
+
+    nsresult GetRecordID(PRInt32 *aRecordID);
+
+    nsresult Evict(PRUint32 aTruncatedContentLength);
+    
+    nsresult GetFileSpec(nsIFileSpec* *aFileSpec);
+
+    void NoteDownloadTime(PRTime start, PRTime end);
+
+    // placement new for arena-allocation
+    void *operator new (size_t aSize, nsIArena *aArena);
+
+    friend class nsReplacementPolicy;
+    friend class nsCacheManager;
+    friend class StreamAsFile;
+    friend class nsCacheEntryChannel;
+    friend class CacheOutputStream;
+    friend class InterceptStreamListener;
+
+private:
+
+    nsCachedNetData() {};
+    virtual ~nsCachedNetData() {};
+
+    // Initialize internal fields of this nsCachedNetData instance from the
+    // underlying raw cache database record.
+    nsresult Deserialize(bool aDeserializeFlags);
+
+    // Notify stream-as-file observers about change in cache entry status
+    nsresult Notify(PRUint32 aMessage, nsresult aError);
+
+    // Add/Remove stream-as-file observers
+    nsresult AddObserver(nsIStreamAsFile *aStreamAsFile, nsIStreamAsFileObserver* aObserver);
+    nsresult RemoveObserver(nsIStreamAsFileObserver* aObserver);
+
+    // Mark cache entry to indicate a write out to the cache database is required
+    void SetDirty() { mFlags |= DIRTY; }
+
+    nsresult Resurrect(nsINetDataCacheRecord *aRecord);
+
+    nsresult CommitFlags();
+
+    CacheMetaData* FindTaggedMetaData(const char* aTag, PRBool aCreate);
+
+private:
+    
+    // List of nsIStreamAsFileObserver's that will receive notification events
+    // when the cache manager or a client desires to delete/truncate a cache
+    // entry file.
+    StreamAsFileObserverClosure* mObservers;
+
+    // Protocol-specific meta-data, opaque to the cache manager
+    CacheMetaData *mMetaData;
+
+    // Next in chain for a single bucket in the replacement policy hash table
+    // that maps from record ID to nsCachedNetData
+    nsCachedNetData* mNext;
+    
+    // See flag bits, above
+    // NOTE: 16 bit member is combined with members below for
+    //       struct packing efficiency.  Do not change order of members!
+    PRUint16    mFlags;
+
+protected:
+
+    // Number of nsCacheEntryChannels referring to this record
+    PRUint8     mChannelCount;
+
+    // Below members are statistics kept per cache-entry, used to decide how
+    // profitable it will be to evict a record from the cache relative to other
+    // existing records.  Note: times are measured in *seconds* since the
+    // 1/1/70 epoch, same as a unix time_t.
+
+    // Number of accesses for this cache record
+    // NOTE: 8 bit member is combined with members above for
+    //       struct packing efficiency.  Do not change order of members!
+    PRUint8     mNumAccesses;
+
+    // A reference to the underlying, raw cache database record, either as a
+    // pointer to an in-memory object or as a database record identifier
+    union {
+        nsINetDataCacheRecord* mRecord;
+
+        // Database record ID of associated cache record.  See
+        // nsINetDataCache::GetRecordByID().
+        PRInt32  mRecordID;
+    };
+
+    // Weak link to parent cache
+    nsINetDataCache* mCache;
+
+    // Length of stored content, which may be less than storage consumed if
+    // compression is used
+    PRUint32 mLogicalLength;
+
+    // Most recent cache entry access times, used to compute access frequency
+    PRUint32 mAccessTime[MAX_K];
+    
+    // We use modification time of the original document for replacement policy
+    // computations, i.e. to compute a document's age, but if we don't know it,
+    // we use the time that the document was last written to the cache.
+    union {
+        // Document modification time, if known.
+        PRUint32 mLastModifiedTime;
+
+        // Time of last cache update for this doc
+        PRUint32 mLastUpdateTime;
+    };
+
+    union {
+      // Time until which document is fresh, i.e. does not have to be validated
+      // with server and, therefore, data in cache is guaranteed usable
+      PRUint32 mExpirationTime;
+
+      // Heuristic time at which cached document is likely to be out-of-date
+      // with respect to canonical copy on server.  Used for cache replacement
+      // policy, not for validation.
+      PRUint32 mStaleTime;
+    };
+
+    // Download time per byte, measure roughly in units of KB/s
+    float mDownloadRate;
+    
+    // Heuristic estimate of cache entry future benefits, based on above values
+    float mProfit;
+};
+
+#endif // _nsCachedNetData_h_
+

mozilla/netwerk/cache/mgr/nsReplacementPolicy.cpp

@@ -0,0 +1,658 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+#include "nsReplacementPolicy.h"
+#include "nsCachedNetData.h"
+
+#include "nsQuickSort.h"
+#include "nsIAllocator.h"
+#include "nsIEnumerator.h"
+#include "prtime.h"
+#include "prbit.h"
+#include "nsCOMPtr.h"
+#include <math.h>
+
+// Constant used to estimate frequency of access to a document based on size
+#define CACHE_CONST_B   1.35
+
+// A cache whose space is managed by this replacement policy
+class nsReplacementPolicy::CacheInfo {
+public:
+    CacheInfo(nsINetDataCache* aCache):mCache(aCache),mNext(0) {}
+
+    nsINetDataCache* mCache;
+    CacheInfo*       mNext;
+};
+
+nsReplacementPolicy::nsReplacementPolicy()
+    : mRankedEntries(0), mCaches(0), mRecordsRemovedSinceLastRanking(0),
+      mNumEntries(0), mCapacityRankedEntriesArray(0), mLastRankTime(0) {}
+
+nsReplacementPolicy::~nsReplacementPolicy()
+{
+    if (mRankedEntries)
+        nsAllocator::Free(mRankedEntries);
+    if (mMapRecordIdToEntry)
+        nsAllocator::Free(mMapRecordIdToEntry);
+}
+
+nsresult
+nsReplacementPolicy::Init(PRUint32 aMaxCacheEntries)
+{
+    nsresult rv;
+
+    rv = NS_NewHeapArena(getter_AddRefs(mArena), sizeof(nsCachedNetData) * 32);
+    if (NS_FAILED(rv)) return rv;
+
+    mMaxEntries = aMaxCacheEntries;
+
+    mHashArrayLength = PR_CeilingLog2(aMaxCacheEntries) >> 3;
+    size_t numBytes = mHashArrayLength * sizeof(*mMapRecordIdToEntry);
+    mMapRecordIdToEntry = (nsCachedNetData**)nsAllocator::Alloc(numBytes);
+    if (!mMapRecordIdToEntry)
+        return NS_ERROR_OUT_OF_MEMORY;
+
+    nsCRT::zero(mMapRecordIdToEntry, numBytes);
+
+    return NS_OK;
+}
+
+nsresult
+nsReplacementPolicy::AddCache(nsINetDataCache *aCache)
+{
+    CacheInfo *cacheInfo = new CacheInfo(aCache);
+    if (!cacheInfo)
+        return NS_ERROR_OUT_OF_MEMORY;
+    cacheInfo->mNext = mCaches;
+    mCaches = cacheInfo;
+    return NS_OK;
+}
+
+PRUint32
+nsReplacementPolicy::HashRecordID(PRInt32 aRecordID)
+{
+    return ((aRecordID >> 16) ^ aRecordID) & (mHashArrayLength - 1);
+}
+
+nsCachedNetData*
+nsReplacementPolicy::FindCacheEntryByRecordID(PRInt32 aRecordID, nsINetDataCache *aCache)
+{
+    nsresult rv;
+    nsCachedNetData* cacheEntry;
+    PRUint32 bucket = HashRecordID(aRecordID);
+
+    cacheEntry = mMapRecordIdToEntry[bucket];
+    for (;cacheEntry; cacheEntry = cacheEntry->mNext) {
+
+        PRInt32 recordID;
+        rv = cacheEntry->GetRecordID(&recordID);
+        if (NS_FAILED(rv))
+            continue;
+
+        if ((recordID == aRecordID) && (cacheEntry->mCache == aCache))
+            return cacheEntry;
+    }
+
+    return 0;
+}
+
+// Add a cache entry to the hash table that maps record ID to entries
+void
+nsReplacementPolicy::AddCacheEntry(nsCachedNetData* aCacheEntry, PRInt32 aRecordID)
+{
+    nsCachedNetData** cacheEntryp;
+    PRUint32 bucket = HashRecordID(aRecordID);
+
+    cacheEntryp = &mMapRecordIdToEntry[bucket];
+    while (*cacheEntryp)
+        cacheEntryp = &(*cacheEntryp)->mNext;
+    *cacheEntryp = aCacheEntry;
+    aCacheEntry->mNext = 0;
+}
+
+// Delete a cache entry from the hash table that maps record ID to entries
+nsresult
+nsReplacementPolicy::DeleteCacheEntry(nsCachedNetData* aCacheEntry)
+{
+    nsresult rv;
+    PRInt32 recordID;
+    rv = aCacheEntry->GetRecordID(&recordID);
+    if (NS_FAILED(rv)) return rv;
+
+    PRUint32 bucket = HashRecordID(recordID);
+
+    nsCachedNetData** cacheEntryp;
+    cacheEntryp = &mMapRecordIdToEntry[bucket];
+    while (*cacheEntryp) {
+        if (*cacheEntryp == aCacheEntry) {
+            *cacheEntryp = aCacheEntry->mNext;
+            return NS_OK;
+        }
+        cacheEntryp = &(*cacheEntryp)->mNext;
+    }
+    
+    NS_ASSERTION(0, "hash table inconsistency");
+    return NS_ERROR_FAILURE;
+}
+
+nsresult
+nsReplacementPolicy::AddAllRecordsInCache(nsINetDataCache *aCache)
+{
+    nsresult rv;
+    nsCOMPtr<nsISimpleEnumerator> iterator;
+    nsCOMPtr<nsISupports> iSupports;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+    rv = aCache->NewCacheEntryIterator(getter_AddRefs(iterator));
+    if (!NS_SUCCEEDED(rv)) return rv;
+
+    while (1) {
+        PRBool notDone;
+
+        rv = iterator->HasMoreElements(&notDone);
+        if (NS_FAILED(rv)) return rv;
+        if (!notDone)
+            break;
+
+        rv = iterator->GetNext(getter_AddRefs(iSupports));
+        if (!NS_SUCCEEDED(rv)) return rv;
+        record = do_QueryInterface(iSupports);
+        
+        rv = AssociateCacheEntryWithRecord(record, aCache, 0);
+        if (!NS_SUCCEEDED(rv)) return rv;
+    }
+
+    return NS_OK;
+}
+
+// Get current time and convert to seconds since the epoch
+static PRUint32
+now32()
+{
+    double nowFP;
+    PRInt64 now64 = PR_Now();
+    LL_L2D(nowFP, now64);
+    PRUint32 now = (PRUint32)(nowFP * 1e-6);
+    return now;
+}
+
+void
+nsCachedNetData::NoteDownloadTime(PRTime start, PRTime end)
+{
+    double startFP, endFP, rate, duration;
+
+    LL_L2D(startFP, start);
+    LL_L2D(endFP, end);
+
+    duration = endFP - startFP;
+    // Sanity-check
+    if (!duration)
+        return;
+
+    // Compute download rate in kB/s
+    rate = mLogicalLength / (duration * (1e-6 /1024.0));
+    
+    // Exponentially smooth download rate
+    const double alpha = 0.5;
+    mDownloadRate = (float)(mDownloadRate * alpha + rate * (1.0 - alpha));
+}
+
+// 1 hour
+#define MIN_HALFLIFE (60 * 60)
+
+// 1 week
+#define TYPICAL_HALFLIFE (7 * 24 * 60 * 60)
+
+/**
+ * Estimate the profit that would be lost if the given cache entry was evicted
+ * from the cache.  Profit is defined as the future expected download delay per
+ * byte of cached content.  The profit computation is made based on projected
+ * frequency of access, prior download performance and a heuristic staleness
+ * criteria.  The technique used is a variation of that described in the
+ * following paper:
+ *
+ *    "A Case for Delay-Conscious Caching of Web Documents"
+ *    http://www.bell-labs.com/user/rvingral/www97.html
+ *
+ * Briefly, expected profit is:
+ *
+ *   (projected frequency of access) * (download time per byte) * (probability freshness)
+ */
+void
+nsCachedNetData::ComputeProfit(PRUint32 aNow)
+{
+    PRUint32 K, now;
+
+    if (aNow)
+        now = aNow;
+    else
+        now = now32();
+    
+    K = PR_MIN(MAX_K, mNumAccesses);
+    if (!K) {
+        mProfit = 0;
+        return;
+    }
+
+    // Compute time, in seconds, since k'th most recent access
+    double timeSinceKthAccess = now - mAccessTime[K - 1];
+    if (timeSinceKthAccess <= 0.0)    // Sanity check
+        timeSinceKthAccess = 1.0;
+
+    // Estimate frequency of future document access based on past
+    //  access frequency
+    double frequencyAccess = K / timeSinceKthAccess;
+
+    // If we don't have much historical data on access frequency
+    //   use a heuristic based on document size as an estimate
+    if (mLogicalLength) {
+        if (K == 1) {
+            frequencyAccess /= pow(mLogicalLength, CACHE_CONST_B);
+        } else if (K == 2) {
+            frequencyAccess /= pow(mLogicalLength, CACHE_CONST_B / 2);
+        }
+    }
+
+    // Estimate likelihood that data in cache is fresh, i.e.
+    //  that it corresponds to the document on the server
+    double probabilityFreshness;
+    PRInt32 halfLife, age, docTime;
+    bool potentiallyStale;
+
+    docTime = GetFlag(LAST_MODIFIED_KNOWN) ? mLastModifiedTime : mLastUpdateTime;
+    age = now - docTime;
+
+    probabilityFreshness = 1.0; // Optimistic
+
+    if (GetFlag(EXPIRATION_KNOWN)) {
+        potentiallyStale = now > mExpirationTime;
+        halfLife = mExpirationTime - mLastModifiedTime;
+    } else if (GetFlag(STALE_TIME_KNOWN)) {
+        potentiallyStale = true;
+        halfLife = mStaleTime - docTime;
+    } else {
+        potentiallyStale = true;
+        halfLife = TYPICAL_HALFLIFE;
+    }
+    
+    if (potentiallyStale) {
+        if (halfLife < MIN_HALFLIFE)
+            halfLife = MIN_HALFLIFE;
+
+        probabilityFreshness = pow(0.5, (double)age / (double)halfLife);
+    }
+
+    mProfit = (float)(frequencyAccess * probabilityFreshness * mDownloadRate);
+}
+
+// Number of entries to grow mRankedEntries array when it's full
+#define STATS_GROWTH_INCREMENT  256
+
+
+// Sorting predicate for NS_Quicksort
+int
+nsCachedNetData::Compare(const void *a, const void *b, void *unused)
+{
+    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.
+    if (!entryA || entryA->GetFlag(RECYCLED)) {
+        if (!entryB || entryB->GetFlag(RECYCLED))
+            return 0;
+        else 
+            return +1;
+    } 
+    if (!entryB || entryB->GetFlag(RECYCLED))
+        return -1;
+
+    // Evicted entries (those with no content data) and active entries (those
+    // currently being updated) are collected towards the end of the sorted
+    // array just prior to the deleted cache entries, since evicted entries
+    // can't be re-evicted.
+    if (entryA->GetFlag(UPDATE_IN_PROGRESS)) {
+        if (entryB->GetFlag(UPDATE_IN_PROGRESS))
+            return 0;
+        else 
+            return +1;
+    } 
+    if (entryB->GetFlag(UPDATE_IN_PROGRESS))
+        return -1;
+
+    PRUint16 Ka = PR_MIN(MAX_K, entryA->mNumAccesses);
+    PRUint16 Kb = PR_MIN(MAX_K, entryB->mNumAccesses);
+
+    // Order cache entries by the number of times they've been accessed
+    if (Ka < Kb)
+        return -1;
+    if (Ka > Kb)
+        return +1;
+
+    /*
+     * Among records that have been accessed an equal number of times, order
+     * them by profit.
+     */
+    if (entryA->mProfit > entryB->mProfit)
+        return +1;
+    if (entryA->mProfit < entryB->mProfit)
+        return -1;
+    return 0;
+}
+
+/**
+ * Rank cache entries in terms of their elegibility for eviction.
+ */
+nsresult
+nsReplacementPolicy::RankRecords()
+{
+    PRUint32 i, now;
+
+    // Add all cache records if this is the first ranking
+    if (!mLastRankTime) {
+        nsresult rv;
+        CacheInfo *cacheInfo;
+
+        cacheInfo = mCaches;
+        while (cacheInfo) {
+            rv = AddAllRecordsInCache(cacheInfo->mCache);
+            if (NS_FAILED(rv)) return rv;
+
+            cacheInfo = cacheInfo->mNext;
+        }
+    }
+
+    // Get current time and convert to seconds since the epoch
+    now = now32();
+
+    // Recompute profit for every known cache record, except deleted ones
+    for (i = 0; i < mNumEntries; i++) {
+        nsCachedNetData* entry = mRankedEntries[i];
+        if (entry && !entry->GetFlag(nsCachedNetData::RECYCLED))
+            entry->ComputeProfit(now);
+    }
+    NS_QuickSort(mRankedEntries, mNumEntries, sizeof *mRankedEntries, 
+                 nsCachedNetData::Compare, 0);
+
+    mNumEntries -= mRecordsRemovedSinceLastRanking;
+    mRecordsRemovedSinceLastRanking = 0;
+    mLastRankTime = now;
+    return NS_OK;
+}
+
+// A heuristic policy to avoid the cost of re-ranking cache records by
+// profitability every single time space must be made available in the cache.
+void
+nsReplacementPolicy::MaybeRerankRecords()
+{
+    // Rank at most once per minute
+    PRUint32 now = now32();
+    if ((now - mLastRankTime) >= 60)
+        RankRecords();
+}
+
+void
+nsReplacementPolicy::CompactRankedEntriesArray()
+{
+    if (mRecordsRemovedSinceLastRanking || !mLastRankTime)
+        RankRecords();
+}
+
+nsresult
+nsReplacementPolicy::CheckForTooManyCacheEntries()
+{
+    if (mCapacityRankedEntriesArray == mMaxEntries) {
+        return DeleteOneEntry(0);
+    } else {
+        nsresult rv;
+        CacheInfo *cacheInfo;
+
+        cacheInfo = mCaches;
+        while (cacheInfo) {
+            PRUint32 numEntries, maxEntries;
+
+            rv = cacheInfo->mCache->GetNumEntries(&numEntries);
+            if (NS_FAILED(rv)) return rv;
+
+            rv = cacheInfo->mCache->GetMaxEntries(&maxEntries);
+            if (NS_FAILED(rv)) return rv;
+
+            if (numEntries == maxEntries)
+                return DeleteOneEntry(cacheInfo->mCache);
+
+            cacheInfo = cacheInfo->mNext;
+        }
+    }
+    return NS_OK;
+}
+
+
+/** 
+ * Create a new association between a low-level cache database record and a
+ * cache entry.  Add the entry to the set of entries eligible for eviction from
+ * the cache.  This would typically be done when the cache entry is created.
+ */
+nsresult
+nsReplacementPolicy::AssociateCacheEntryWithRecord(nsINetDataCacheRecord *aRecord,
+                                                   nsINetDataCache* aCache,
+                                                   nsCachedNetData** aResult)
+{
+    nsCachedNetData* cacheEntry;
+    nsresult rv;
+
+    // First, see if the record is already known to the replacement policy
+    PRInt32 recordID;
+    rv = aRecord->GetRecordID(&recordID);
+    if (NS_FAILED(rv)) return rv;
+    cacheEntry = FindCacheEntryByRecordID(recordID, aCache);
+    if (cacheEntry) {
+        if (aResult) {
+            if (cacheEntry->GetFlag(nsCachedNetData::DORMANT))
+                cacheEntry->Resurrect(aRecord);
+            NS_ADDREF(cacheEntry);
+            *aResult = cacheEntry;
+        }
+        return NS_OK;
+    }
+
+    // Compact the array of cache entry statistics, so that free entries appear
+    // at the end, for possible reuse.
+    if (mNumEntries && (mNumEntries == mCapacityRankedEntriesArray))
+        CompactRankedEntriesArray();
+
+    // If compaction doesn't yield available entries in the
+    // mRankedEntries array, then extend the array.
+    if (mNumEntries == mCapacityRankedEntriesArray) {
+        PRUint32 newCapacity;
+
+        rv = CheckForTooManyCacheEntries();
+        if (NS_FAILED(rv)) return rv;
+
+        newCapacity = mCapacityRankedEntriesArray + STATS_GROWTH_INCREMENT;
+        if (newCapacity > mMaxEntries)
+            newCapacity = mMaxEntries;
+
+        nsCachedNetData** newRankedEntriesArray; 
+        PRUint32 numBytes = sizeof(nsCachedNetData*) * newCapacity;
+        newRankedEntriesArray = 
+            (nsCachedNetData**)nsAllocator::Realloc(mRankedEntries, numBytes);
+        if (!newRankedEntriesArray)
+            return NS_ERROR_OUT_OF_MEMORY;
+        
+        mRankedEntries = newRankedEntriesArray;
+        mCapacityRankedEntriesArray = newCapacity;
+
+        PRUint32 i;
+        for (i = mNumEntries; i < newCapacity; i++)
+            mRankedEntries[i] = 0;
+    }
+
+    // Recycle the record after the last in-use record in the array
+    nsCachedNetData *entry = mRankedEntries[mNumEntries];
+    NS_ASSERTION(!entry || !entry->GetFlag(nsCachedNetData::RECYCLED),
+                 "Only deleted cache entries should appear at end of array");
+
+    if (!entry) {
+        entry = new(mArena) nsCachedNetData;
+        if (!entry)
+            return NS_ERROR_OUT_OF_MEMORY;
+        mRankedEntries[mNumEntries] = entry;
+    } else {
+        // Clear out recycled data structure
+        nsCRT::zero(entry, sizeof(*entry));
+    }
+
+    entry->Init(aRecord, aCache);
+    AddCacheEntry(entry, recordID);
+    
+    // Add one reference to the cache entry from the cache manager
+    NS_ADDREF(entry);
+
+    if (aResult) {
+        // And one reference from our caller
+        NS_ADDREF(entry);
+        *aResult = entry;
+    }
+
+    mNumEntries++;
+    return NS_OK;
+}
+
+nsresult
+nsReplacementPolicy::GetCachedNetData(const char* cacheKey, PRUint32 cacheKeyLength,
+                                      nsINetDataCache* aCache,
+                                      nsCachedNetData** aResult)
+{
+    nsresult rv;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+
+    rv = aCache->GetCachedNetData(cacheKey, cacheKeyLength,
+                                  getter_AddRefs(record));
+    if (NS_FAILED(rv)) return rv;
+    return AssociateCacheEntryWithRecord(record, aCache, aResult);
+}
+
+/**
+ * Delete the least desirable record from the cache database.  This is used
+ * when the addition of another record would exceed either the cache manager or
+ * the cache's maximum permitted number of records.
+ */
+nsresult
+nsReplacementPolicy::DeleteOneEntry(nsINetDataCache *aCache)
+{
+    PRUint32 i;
+    nsresult rv;
+    nsCachedNetData *entry;
+
+    i = 0;
+    while (1) {
+        MaybeRerankRecords();
+        for (; i < mNumEntries; i++) {
+            entry = mRankedEntries[i];
+            if (!entry || entry->GetFlag(nsCachedNetData::RECYCLED))
+                continue;
+            if (!aCache || (entry->mCache == aCache))
+                break;
+        }
+
+        // Report error if no record found to delete
+        if (i == mNumEntries)
+            return NS_ERROR_FAILURE;
+        rv = entry->Delete();
+        if (NS_SUCCEEDED(rv)) {
+            rv = DeleteCacheEntry(entry);
+            return rv;
+        }
+    }
+}
+
+nsresult
+nsReplacementPolicy::GetStorageInUse(PRUint32* aStorageInUse)
+{
+    nsresult rv;
+    CacheInfo *cacheInfo;
+
+    *aStorageInUse = 0;
+    cacheInfo = mCaches;
+    while (cacheInfo) {
+        PRUint32 cacheStorage;
+        rv = cacheInfo->mCache->GetStorageInUse(&cacheStorage);
+        if (NS_FAILED(rv)) return rv;
+
+        *aStorageInUse += cacheStorage;
+        cacheInfo = cacheInfo->mNext;
+    }
+    return NS_OK;
+}
+
+/**
+ * Delete the least desirable records from the cache until the occupancy of the
+ * cache has been reduced by the given number of KB.  This is used when the
+ * addition of more cache data would exceed the cache's capacity. 
+ */
+nsresult
+nsReplacementPolicy::Evict(PRUint32 aTargetOccupancy)
+{
+    PRUint32 i;
+    nsCachedNetData *entry;
+    nsresult rv;
+    PRUint32 occupancy;
+    PRInt32 truncatedLength;
+    nsCOMPtr<nsINetDataCacheRecord> record;
+
+    MaybeRerankRecords();
+    for (i = 0; i < mNumEntries; i++) {
+        rv = GetStorageInUse(&occupancy);
+        if (!NS_SUCCEEDED(rv)) return rv;
+        
+        if (occupancy <= aTargetOccupancy)
+            return NS_OK;
+
+        entry = mRankedEntries[i];
+
+        // Skip deleted/empty cache entries and ones that have already been evicted
+        if (!entry || entry->GetFlag(nsCachedNetData::UNEVICTABLE))
+            continue;
+
+        if (entry->GetFlag(nsCachedNetData::ALLOW_PARTIAL)) {
+            rv = entry->GetRecord(getter_AddRefs(record));
+            if (NS_FAILED(rv))
+                continue;
+
+            PRUint32 contentLength;
+            rv = record->GetStoredContentLength(&contentLength);
+            if (NS_FAILED(rv))
+                continue;
+            
+            // Additional cache storage required, in KB
+            PRUint32 storageToReclaim = (occupancy - aTargetOccupancy) << 10;
+            
+            truncatedLength = (PRInt32)(contentLength - storageToReclaim);
+            if (truncatedLength < 0)
+                truncatedLength = 0;
+        } else {
+            truncatedLength = 0;
+        }
+        rv = entry->Evict(truncatedLength);
+    }
+    return NS_ERROR_FAILURE;
+}

mozilla/netwerk/cache/mgr/nsReplacementPolicy.h

@@ -0,0 +1,136 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape 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
+ * the License at http://www.mozilla.org/NPL/
+ *  
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *  
+ * The Original Code is Mozilla Communicator client code, released
+ * March 31, 1998.
+ * 
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation. Portions created by Netscape are
+ * Copyright (C) 1998-1999 Netscape Communications Corporation. All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *   Scott Furman, fur@netscape.com
+ */
+
+/**
+ * This class manages one or more caches that share a storage resource, e.g. a
+ * file cache and a flat-database cache might each occupy space on the disk and
+ * they would share a single instance of nsReplacementPolicy.  The replacement
+ * policy heuristically chooses which cache entries to evict when storage is
+ * required to accommodate incoming cache data.
+ */
+
+#ifndef _nsReplacementPolicy_h_
+#define _nsReplacementPolicy_h_
+
+#include "nscore.h"
+#include "nsISupportsUtils.h"
+#include "nsINetDataCache.h"
+#include "nsICachedNetData.h"
+#include "nsIArena.h"
+#include "nsCOMPtr.h"
+#include "nsHashtable.h"
+
+class nsCachedNetData;
+struct PL_HashTable;
+
+/**
+ * This private class is responsible for implementing the network data cache's
+ * replacement policy, i.e. it decides which cache data should be evicted to
+ * make room for new incoming data.
+ */
+class nsReplacementPolicy {
+
+public:
+
+    nsReplacementPolicy();
+    ~nsReplacementPolicy();
+
+protected:
+
+    nsresult Init(PRUint32 aMaxCacheEntries);
+    nsresult AddCache(nsINetDataCache *aCache);
+    nsresult GetCachedNetData(const char* cacheKey, PRUint32 cacheKeyLength,
+                              nsINetDataCache* aCache,
+                              nsCachedNetData** aResult);
+    nsresult GetStorageInUse(PRUint32* aNumKBytes);
+
+    friend class nsCacheManager;
+
+private:
+    nsresult RankRecords();
+    void MaybeRerankRecords();
+    void CompactRankedEntriesArray();
+    nsresult DeleteOneEntry(nsINetDataCache* aCache);
+    nsresult Evict(PRUint32 aTargetOccupancy);
+
+    nsCachedNetData* FindCacheEntryByRecordID(PRInt32 aRecordID, nsINetDataCache *aCache);
+    void AddCacheEntry(nsCachedNetData* aCacheEntry, PRInt32 aRecordID);
+    nsresult DeleteCacheEntry(nsCachedNetData* aCacheEntry);
+    PRUint32 HashRecordID(PRInt32 aRecordID);
+    nsresult AssociateCacheEntryWithRecord(nsINetDataCacheRecord *aRecord,
+                                           nsINetDataCache* aCache,
+                                           nsCachedNetData** aResult);
+
+    nsresult AddAllRecordsInCache(nsINetDataCache *aCache);
+    nsresult CheckForTooManyCacheEntries();
+
+    class CacheInfo;
+
+private:
+
+    // Growable array of pointers to individual cache entries; It is sorted by
+    // profitability, such that low-numbered array indices refer to cache
+    // entries that are the least profitable to retain.  New cache entries are
+    // added to the end of the array.  Deleted cache entries are specially
+    // marked and percolate to the end of the array for recycling whenever
+    // mRankedEntries is sorted.  Evicted cache entries (those with no
+    // associated content data) are retained for the purpose of improving the
+    // replacement policy efficacy, and are percolated towards the end of the
+    // array, just prior to the deleted cache entries.
+    //
+    // The array is not in sorted order 100% of the time; For efficiency
+    // reasons, sorting is only done when heuristically deemed necessary.
+    nsCachedNetData**   mRankedEntries;
+
+    // Hash table buckets to map Record ID to cache entry.  We use this instead
+    // of a PL_HashTable to reduce storage requirements
+    nsCachedNetData**   mMapRecordIdToEntry;
+
+    // Length of mMapRecordIdToEntry array
+    PRUint32            mHashArrayLength;
+
+    // Linked list of caches that share this replacement policy
+    CacheInfo*          mCaches;
+
+    // Allocation area for cache entry (nsCachedNetData) instances
+    nsCOMPtr<nsIArena>  mArena;
+
+    // Bookkeeping
+    PRUint32            mRecordsRemovedSinceLastRanking;
+
+    // Maximum permitted length of mRankedEntries array
+    PRUint32            mMaxEntries;
+
+    // Number of occupied slots in mRankedEntries array
+    PRUint32            mNumEntries;
+
+    // Capacity of mRankedEntries array
+    PRUint32            mCapacityRankedEntriesArray;
+
+    // Time at which cache entries were last ranked by profitability
+    PRUint32            mLastRankTime;
+};
+
+
+#endif // _nsReplacementPolicy_h_

mozilla/netwerk/cache/public/MANIFEST

@@ -1,6 +0,0 @@
-nsICachedNetData.idl
-nsINetDataCache.idl
-nsINetDataCacheManager.idl
-nsINetDataCacheRecord.idl
-nsINetDataDiskCache.idl
-nsIStreamAsFile.idl

mozilla/netwerk/cache/public/Makefile.in

@@ -24,35 +24,14 @@ topsrcdir	= @top_srcdir@
 srcdir		= @srcdir@
 VPATH		= @srcdir@
 
-MODULE		= nkcache
-XPIDL_MODULE	= necko_cache
-
 include $(DEPTH)/config/autoconf.mk
 
-XPIDLSRCS	= $(NULL)
-
-ifdef OLD_CACHE
-XPIDLSRCS	+= \
-		nsICachedNetData.idl          \
-	        nsINetDataCacheManager.idl    \
-		nsINetDataCache.idl           \
-		nsINetDataCacheRecord.idl     \
-	        nsINetDataDiskCache.idl       \
-		nsIStreamAsFile.idl           \
+EXPORTS		= \
+		nsICacheManager.h \
+		nsICacheObject.h \
+		nsICachePref.h \
+		nsICacheModule.h \
 		$(NULL)
-endif
-
-
-ifdef MOZ_NEW_CACHE
-XPIDLSRCS	+= \
-		nsICache.idl		      \
-		nsICacheEntryDescriptor.idl   \
-		nsICacheListener.idl	      \
-		nsICacheService.idl           \
-		nsICacheSession.idl           \
-		nsICacheVisitor.idl           \
-	        $(NULL)
-endif
 
 EXPORTS		:= $(addprefix $(srcdir)/, $(EXPORTS))
 

mozilla/netwerk/cache/public/Makefile.win

@@ -19,8 +19,7 @@
 #
 # Contributor(s): 
 
-MODULE = necko
-XPIDL_MODULE = necko_cache
+MODULE = nkcache
 
 DEPTH = ..\..\..
 include <$(DEPTH)/config/config.mak>
@@ -30,24 +29,13 @@ EXPORTS =                   \
         $(NULL)
 
 XPIDLSRCS =                             \
-!ifdef MOZ_OLD_CACHE
         .\nsICachedNetData.idl          \
         .\nsINetDataCacheManager.idl    \
         .\nsINetDataCache.idl           \
         .\nsINetDataCacheRecord.idl     \
         .\nsINetDataDiskCache.idl       \
         .\nsIStreamAsFile.idl           \
-!endif
-!ifdef MOZ_NEW_CACHE
-	.\nsICache.idl		        \
-	.\nsICacheEntryDescriptor.idl   \
-	.\nsICacheListener.idl		\
-	.\nsICacheService.idl		\
-	.\nsICacheSession.idl           \
-	.\nsICacheVisitor.idl           \
-!endif
         $(NULL)
 
 include <$(DEPTH)/config/rules.mak>
 
-

mozilla/netwerk/cache/public/nsICache.idl

@@ -1,170 +0,0 @@
-/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsICache.idl, released February 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan <gordon@netscape.com>
- *    Patrick Beard <beard@netscape.com>
- *    Darin Fisher <darin@netscape.com>
- */
-
-#include "nsISupports.idl"
-
-typedef long nsCacheStoragePolicy;
-typedef long nsCacheAccessMode;
-
-/**
- * nsICache is a namespace for various cache constants.  It does not represent
- * an actual object.
- */
-[scriptable, uuid(ec1c0063-197d-44bb-84ba-7525d50fc937)]
-interface nsICache
-{
-    /**
-     * Access Modes
-     *
-     *
-     * Mode Requested | Not Cached          | Cached
-     * ------------------------------------------------------------------------
-     * READ           | KEY_NOT_FOUND       | NS_OK
-     *                | Mode = NONE         | Mode = READ
-     *                | No Descriptor       | Descriptor
-     * ------------------------------------------------------------------------
-     * WRITE          | NS_OK               | NS_OK            (Cache service
-     *                | Mode = WRITE        | Mode = WRITE      dooms existing
-     *                | Descriptor          | Descriptor        cache entry)
-     * ------------------------------------------------------------------------
-     * READ_WRITE     | NS_OK               | NS_OK
-     * (1st req.)     | Mode = WRITE        | Mode = READ_WRITE
-     *                | Descriptor          | Descriptor
-     * ------------------------------------------------------------------------
-     * READ_WRITE     | N/A                 | NS_OK
-     * (Nth req.)     |                     | Mode = READ
-     *                |                     | Descriptor
-     * ------------------------------------------------------------------------
-     *
-     *
-     * Access Requested:
-     *
-     * READ	       - I only want to READ, if there isn't an entry just fail
-     * WRITE       - I have something new I want to write into the cache, make
-     *               me a new entry and doom the old one, if any.
-     * READ_WRITE  - I want to READ, but I'm willing to update an existing
-     *               entry if necessary, or create a new one if none exists.
-     *
-     *
-     * Access Granted:
-     *
-     * NONE        - No descriptor is provided. You get zilch. Nada. Nothing.
-     * READ		   - You can READ from this descriptor.
-     * WRITE	   - You must WRITE to this descriptor because the cache entry
-     *               was just created for you.
-     * READ_WRITE  - You can READ the descriptor to determine if it's valid,
-     *               you may WRITE if it needs updating.
-     *
-     *
-     * Comments:
-     *
-     * If you think that you might need to modify cached data or meta data,
-     * then you must open a cache entry requesting WRITE access.  Only one
-     * cache entry descriptor, per cache entry, will be granted WRITE access.
-     * 
-     * Usually, you will request READ_WRITE access in order to first test the
-     * meta data and informational fields to determine if a write (ie. going
-     * to the net) may actually be necessary.  If you determine that it is 
-     * not, then you would mark the cache entry as valid (using MarkValid) and
-     * then simply read the data from the cache.
-     *
-     * A descriptor granted WRITE access has exclusive access to the cache
-     * entry up to the point at which it marks it as valid.  Once the cache
-     * entry has been "validated", other descriptors with READ access may be
-     * opened to the cache entry.
-     *
-     * If you make a request for READ_WRITE access to a cache entry, the cache
-     * service will downgrade your access to READ if there is already a
-     * cache entry descriptor open with WRITE access.
-     *
-     * If you make a request for only WRITE access to a cache entry and another
-     * descriptor with WRITE access is currently open, then the existing cache
-     * entry will be 'doomed', and you will be given a descriptor (with WRITE
-     * access only) to a new cache entry.
-     *
-     */
-    const nsCacheAccessMode ACCESS_NONE       = 0;
-    const nsCacheAccessMode ACCESS_READ       = 1;
-    const nsCacheAccessMode ACCESS_WRITE      = 2;
-    const nsCacheAccessMode ACCESS_READ_WRITE = 3;
-
-    /**
-     * Storage Policy
-     *
-     * The storage policy of a cache entry determines the device(s) to which
-     * it belongs.  See nsICacheSession and nsICacheEntryDescriptor for more
-     * details.
-     *
-     * STORE_ANYWHERE        - Allows the cache entry to be stored in any device.
-     *                         The cache service decides which cache device to use
-     *                         based on "some resource management calculation."
-     * STORE_IN_MEMORY       - Requires the cache entry to reside in non-persistent
-     *                         storage (ie. typically in system RAM).
-     * STORE_ON_DISK         - Requires the cache entry to reside in persistent
-     *                         storage (ie. typically on a system's hard disk).
-     * STORE_ON_DISK_AS_DISK - Requires the cache entry to reside in persistent
-     *                         storage, and in a specific file.
-     */
-    const nsCacheStoragePolicy STORE_ANYWHERE        = 0;
-    const nsCacheStoragePolicy STORE_IN_MEMORY       = 1;
-    const nsCacheStoragePolicy STORE_ON_DISK         = 2;
-    const nsCacheStoragePolicy STORE_ON_DISK_AS_FILE = 3;
-
-    /**
-     * All entries for a cache session are stored as streams of data or
-     * as objects.  These constant my be used to specify the type of entries
-     * when calling nsICacheService::CreateSession().
-     */
-    const long NOT_STREAM_BASED = 0;
-    const long STREAM_BASED     = 1;
-    
-    /**
-     * The synchronous OpenCacheEntry() may be blocking or non-blocking.  If a cache entry is
-     * waiting to be validated by another cache descriptor (so no new cache descriptors for that
-     * key can be created, OpenCacheEntry() will return NS_ERROR_CACHE_WAIT_FOR_VALIDATION in
-     * non-blocking mode.  In blocking mode, it will wait until the cache entry for the key has
-     * been validated or doomed.  If the cache entry is validated, then a descriptor for that
-     * entry will be created and returned.  If the cache entry was doomed, then a descriptor
-     * will be created for a new cache entry for the key. 
-     */
-    const long NON_BLOCKING = 0;
-    const long BLOCKING     = 1;
-};
-
-
-%{C++
-
-/**
- * Cache specific nsresult error codes
- */
-#define NS_ERROR_CACHE_KEY_NOT_FOUND        NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 61)
-#define NS_ERROR_CACHE_DATA_IS_STREAM       NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 62)
-#define NS_ERROR_CACHE_DATA_IS_NOT_STREAM   NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 63)
-#define NS_ERROR_CACHE_WAIT_FOR_VALIDATION  NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 64)
-#define NS_ERROR_CACHE_ENTRY_DOOMED         NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 65)
-#define NS_ERROR_CACHE_READ_ACCESS_DENIED   NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 66)
-#define NS_ERROR_CACHE_WRITE_ACCESS_DENIED  NS_ERROR_GENERATE_FAILURE(NS_ERROR_MODULE_NETWORK, 67)
-
-%}

mozilla/netwerk/cache/public/nsICacheEntryDescriptor.idl

@@ -1,137 +0,0 @@
-/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsICacheEntryDescriptor.idl, released
- * February 10, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan <gordon@netscape.com>
- *    Patrick Beard   <beard@netscape.com>
- *    Darin Fisher    <darin@netscape.com>
- */
-
-#include "nsICacheVisitor.idl"
-#include "nsICache.idl"
-
-interface nsISimpleEnumerator;
-interface nsICacheListener;
-interface nsITransport;
-interface nsIFile;
-interface nsICacheMetaDataVisitor;
-
-
-[scriptable, uuid(49c1a11d-f5d2-4f09-8262-551e64908ada)]
-interface nsICacheEntryDescriptor : nsICacheEntryInfo
-{
-    /**
-     * Set the time at which the cache entry should be considered invalid (in
-     * seconds since the Epoch).
-     */
-    void setExpirationTime(in PRUint32 expirationTime);
-
-    /**
-     * Set the cache entry data size.  This will fail if the cache entry
-     * IS stream based.
-     */
-    void setDataSize(in unsigned long size);
-
-    /**
-     * Get a transport to the cache data.  This will fail if the cache entry
-     * IS NOT stream based.
-     */
-    readonly attribute nsITransport transport;
-
-    /**
-     * Get/set the cache data element.  This will fail if the cache entry
-     * IS stream based.  The cache entry holds a strong reference to this
-     * object.  The object will be released when the cache entry is destroyed.
-     */
-    attribute nsISupports cacheElement;
-     
-    /**
-     * Get the access granted to this descriptor.  See nsICache.idl for the
-     * definitions of the access modes and a thorough description of their
-     * corresponding meanings.
-     */
-    readonly attribute nsCacheAccessMode accessGranted;
-    
-    /**
-     * Get/set the storage policy of the cache entry.  See nsICache.idl for
-     * the definitions of the storage policies.
-     */
-    attribute nsCacheStoragePolicy storagePolicy;
-
-    /**
-     * Get the disk file associated with the cache entry.
-     */
-    readonly attribute nsIFile file;
-
-    /**
-     * Get/set security info on the cache entry for this descriptor.  This fails
-     * if the storage policy is not STORE_IN_MEMORY.
-     */
-    attribute nsISupports securityInfo;
-    
-    /**
-     * Doom the cache entry this descriptor references in order to slate it for 
-     * removal.  Once doomed a cache entry cannot be undoomed.
-     *
-     * A descriptor with WRITE access can doom the cache entry and choose to
-     * fail pending requests.  This means that pending requests will not get
-     * a cache descriptor.  This is meant as a tool for clients that wish to
-     * instruct pending requests to skip the cache.
-     */
-    void doom();
-    void doomAndFailPendingRequests(in nsresult status);
-    
-    /**
-     * A writer must validate this cache object before any readers are given
-     * a descriptor to the object.
-     */
-    void markValid();
-
-    /**
-     *  Explicitly close the descriptor (optional).
-     */
-    
-    void close();
-
-    /**
-     * Methods for accessing meta data.  Meta data is a table of key/value
-     * string pairs.  The strings do not have to conform to any particular
-     * charset, but they must be null terminated.
-     */
-    string getMetaDataElement(in string key);
-    void   setMetaDataElement(in string key, in string value);
-    
-    /**
-     * Visitor will be called with key/value pair for each meta data element.
-     */
-    void   visitMetaData(in nsICacheMetaDataVisitor  visitor);
-};
-
-
-
-[scriptable, uuid(22f9a49c-3cf8-4c23-8006-54efb11ac562)]
-interface nsICacheMetaDataVisitor : nsISupports
-{
-    /**
-     * Called for each key/value pair in the meta data for a cache entry
-     */
-    boolean visitMetaDataElement(in string  key,
-                                 in string  value);
-};

mozilla/netwerk/cache/public/nsICacheListener.idl

@@ -1,44 +0,0 @@
-/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsICacheListener.idl, released January 19, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan <gordon@netscape.com>
- *    Patrick Beard   <beard@netscape.com>
- *    Darin Fisher    <darin@netscape.com>
- */
-
-
-#include "nsISupports.idl"
-#include "nsICache.idl"
-
-
-interface nsICacheEntryDescriptor;
-
-[scriptable, uuid(638c3848-778b-4851-8ff3-9400f65b8773)]
-interface nsICacheListener : nsISupports
-{
-    /**
-     * Called when the requested access (or appropriate subset) is
-     * acquired.  The status parameter equals NS_OK on success.
-     * See nsICacheService.idl for accessGranted values.
-     */
-    void onCacheEntryAvailable(in nsICacheEntryDescriptor descriptor,
-                               in nsCacheAccessMode       accessGranted,
-                               in nsresult                status);
-};

mozilla/netwerk/cache/public/nsICacheService.idl

@@ -1,80 +0,0 @@
-/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsICacheService.idl, released February 10, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan <gordon@netscape.com>
- *    Patrick Beard   <beard@netscape.com>
- *    Darin Fisher    <darin@netscape.com>
- */
-
-#include "nsISupports.idl"
-#include "nsICache.idl"
-
-interface nsISimpleEnumerator;
-interface nsICacheListener;
-interface nsICacheSession;
-interface nsICacheVisitor;
-
-[scriptable, uuid(0ebec4c7-742f-4f27-8e7b-7c8a0cc76348)]
-interface nsICacheService : nsISupports
-{
-    /**
-     * Initialize the cache service.
-     */
-    void init();
-
-    /**
-     * Shutdown the cache service.
-     */
-    void shutdown();
-
-    /**
-     * Create a cache session
-     *
-     * A cache session represents a client's access into the cache.  The cache
-     * session is not "owned" by the cache service.  Hence, it is possible to
-     * create duplicate cache sessions.  Entries created by a cache session
-     * are invisible to other cache sessions, unless the cache sessions are
-     * equivalent.
-     *
-     * @param clientID - Specifies the name of the client using the cache.
-     * @param storagePolicy - Limits the storage policy for all entries
-     *   accessed via the returned session.  As a result, devices excluded
-     *   by the storage policy will not be searched when opening entries
-     *   from the returned session.
-     * @param streamBased - Indicates whether or not the data being cached
-     *   can be represented as a stream.  The storagePolicy must be 
-     *   consistent with the value of this field.  For example, a non-stream-
-     *   based cache entry can only have a storage policy of STORE_IN_MEMORY.
-     * @return new cache session.
-     */
-    nsICacheSession createSession(in string                 clientID,
-                                  in nsCacheStoragePolicy   storagePolicy,
-                                  in boolean                streamBased);
-
-    /**
-     * Visit entries stored in the cache.  Used to implement about:cache.
-     */
-    void visitEntries(in nsICacheVisitor visitor);
-
-    /**
-     * Evicts all entries in all devices implied by the storage policy.
-     */
-    void evictEntries(in nsCacheStoragePolicy  storagePolicy);
-};

mozilla/netwerk/cache/public/nsICacheSession.idl

@@ -1,72 +0,0 @@
-/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsICacheSession.idl, released February 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan <gordon@netscape.com>
- *    Patrick Beard   <beard@netscape.com>
- *    Darin Fisher    <darin@netscape.com>
- */
-
-#include "nsISupports.idl"
-#include "nsICache.idl"
-
-interface nsICacheEntryDescriptor;
-interface nsICacheListener;
-
-[scriptable, uuid(b4b419ad-28b7-4d25-9988-20fa98505a19)]
-interface nsICacheSession : nsISupports
-{
-    /**
-     * Expired entries will be doomed or evicted if this attribute is set to
-     * true.  If false, expired entries will be returned (useful for offline-
-     * mode and clients, such as HTTP, that can update the valid lifetime of
-     * cached content).  This attribute defaults to true.
-     */
-    attribute PRBool doomEntriesIfExpired;
-
-    /**
-     * A cache session can only give out one descriptor with WRITE access
-     * to a given cache entry at a time.  Until the client calls MarkValid on
-     * its descriptor, other attempts to open the same cache entry will block.
-     */
-
-    /**
-     * Synchronous cache access.  This returns a unique descriptor each
-     * time it is called, even if the same key is specified.  When
-     * called by multiple threads for write access, only one writable
-     * descriptor will be granted.  If 'blocking' is set to false, 
-     */
-    nsICacheEntryDescriptor openCacheEntry(in string            key,
-                                           in nsCacheAccessMode accessRequested,
-                                           in boolean           blockingMode);
-
-    /**
-     * Asynchronous cache access. Does not block the calling thread.
-     * Instead, the listener will be notified when the descriptor is
-     * available.
-     */
-    void asyncOpenCacheEntry(in string            key,
-                             in nsCacheAccessMode accessRequested,
-                             in nsICacheListener  listener);
-
-    /**
-     * Evict all entries for this session's clientID according to its storagePolicy.
-     */
-    void evictEntries();
-};

mozilla/netwerk/cache/public/nsICacheVisitor.idl

@@ -1,142 +0,0 @@
-/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsICacheVisitor.idl, released February 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan <gordon@netscape.com>
- *    Patrick Beard   <beard@netscape.com>
- *    Darin Fisher    <darin@netscape.com>
- */
-
-#include "nsISupports.idl"
-
-/* XXX we should define device and entry info as well (stats, etc) */
-
-interface nsICacheDeviceInfo;
-interface nsICacheEntryInfo;
-
-
-[scriptable, uuid(f8c08c4b-d778-49d1-a59b-866fdc500d95)]
-interface nsICacheVisitor : nsISupports
-{
-    /**
-     * Called to provide information about a cache device.
-     *
-     * @param deviceID - specifies the device being visited.
-     * @param deviceInfo - specifies information about this device.
-     *
-     * @return true to start visiting all entries for this device.
-     * @return false to advance to the next device.
-     */
-    boolean visitDevice(in string               deviceID,
-                        in nsICacheDeviceInfo   deviceInfo);
-
-    /**
-     * Called to provide information about a cache entry.
-     *
-     * @param deviceID - specifies the device being visited.
-     * @param entryInfo - specifies information about this entry.
-     * 
-     * @return true to visit the next entry on the current device, or if the
-     *   end of the device has been reached, advance to the next device.
-     * @return false to advance to the next device.
-     */
-    boolean visitEntry(in string                deviceID,
-                       in nsICacheEntryInfo     entryInfo);
-};
-
-
-[scriptable, uuid(31d1c294-1dd2-11b2-be3a-c79230dca297)]
-interface nsICacheDeviceInfo : nsISupports
-{
-    /**
-     * Get a human readable description of the cache device.
-     */
-    readonly attribute string  description;
-    
-    /**
-     * Get a usage report, statistics, miscellaneous data about
-     * the cache device.
-     */
-    readonly attribute string  usageReport;
-    
-    /**
-     * Get the number of stored cache entries.
-     */
-    readonly attribute unsigned long  entryCount;
-    
-    /**
-     * Get the total size of the stored cache entries.
-     */
-    readonly attribute unsigned long  totalSize;
-
-    /**
-     * Get the upper limit of the size of the data the cache can store.
-     */
-    readonly attribute unsigned long  maximumSize;
-};
-
-
-[scriptable, uuid(72c64022-1dd2-11b2-b3a5-b8b859e0a1b2)]
-interface nsICacheEntryInfo : nsISupports
-{
-    /**
-     * Get the client id associated with this cache entry.
-     */
-    readonly attribute string  clientID;
-
-    /**
-     * Get the id for the device that stores this cache entry.
-     */
-    readonly attribute string deviceID;
-
-    /**
-     * Get the key identifying the cache entry.
-     */
-    readonly attribute string  key;
-    
-    /**
-     * Get the number of times the cache entry has been opened.
-     */
-    readonly attribute long  fetchCount;
-
-    /**
-     * Get the last time the cache entry was opened (in seconds since the Epoch).
-     */
-    readonly attribute PRUint32  lastFetched;
-
-    /**
-     * Get the last time the cache entry was modified (in seconds since the Epoch).
-     */
-    readonly attribute PRUint32  lastModified;
-
-    /**
-     * Get the expiration time of the cache entry (in seconds since the Epoch).
-     */
-    readonly attribute PRUint32  expirationTime;
-
-    /**
-     * Get the cache entry data size.
-     */
-    readonly attribute unsigned long  dataSize;
-
-    /**
-     * Find out whether or not the cache entry is stream based.
-     */
-    boolean  isStreamBased();
-};

mozilla/netwerk/cache/public/nsICachedNetData.idl

@@ -23,7 +23,7 @@
 #include "nsrootidl.idl"
 #include "nsISupports.idl"
 
-
+interface nsIFileSpec;
 interface nsIURI;
 interface nsIObserver;
 interface nsIChannel;
@@ -139,8 +139,6 @@ interface nsICachedNetData : nsISupports
      */
     readonly attribute PRTime lastAccessTime;
 
-    readonly attribute PRTime lastUpdateTime;
-
     /**
      * Number of times this record has been accessed since it was first stored.
      */
@@ -180,18 +178,6 @@ interface nsICachedNetData : nsISupports
      */
     attribute PRUint32 storedContentLength;
 
-	/**
-	 * Length of stored content, which may be less than storage consumed if
-     * compression is used
-	 */
-	readonly attribute PRUint32 logicalLength;
-
-	/**
-	 * Opaque security info associated with the cache entry; it can't be serialized
-	 * to disk, so it'll only make sense with memory cache
-	 */
-	attribute nsISupports securityInfo;
-
     /** 
      * Notify any observers associated with this cache entry of the deletion
      * request.  If all observers drop their reference to the cache entry,
@@ -224,9 +210,12 @@ interface nsICachedNetData : nsISupports
      *
      * Though nsIChannel provides for both async and synchronous I/O APIs, both
      * may not be implemented.  Only AsyncRead() and OpenOutputStream() is
-     * required.  
+     * required.  The aProxyChannel argument allows another channel to be
+     * specified as the proffered argument to nsIStreamListener methods rather
+     * than the cache's own channel.
      */
-    nsIChannel newChannel(in nsILoadGroup aLoadGroup);
+    nsIChannel newChannel(in nsILoadGroup aLoadGroup,
+                          in nsIChannel aProxyChannel);
 
     /**
      * This method can be used by a caching protocol handler to store data in

mozilla/netwerk/cache/public/nsINetDataCache.idl

@@ -25,6 +25,7 @@
 interface nsIURI;
 interface nsINetDataCacheRecord;
 interface nsISimpleEnumerator;
+interface nsIFileSpec;
 
 /**
  * The nsINetDataCache defines the low-level API for a network-data
@@ -134,9 +135,9 @@ interface nsINetDataCache : nsISupports
 };
 
 %{ C++
-// ContractID prefix for Components that implement this interface
-#define NS_NETWORK_CACHE_CONTRACTID "@mozilla.org/network/cache;1"
-#define NS_NETWORK_MEMORY_CACHE_CONTRACTID NS_NETWORK_CACHE_CONTRACTID "?name=memory-cache"
-#define NS_NETWORK_FLAT_CACHE_CONTRACTID   NS_NETWORK_CACHE_CONTRACTID "?name=flat-cache"
-#define NS_NETWORK_FILE_CACHE_CONTRACTID   NS_NETWORK_CACHE_CONTRACTID "?name=file-cache"
+// ProgID prefix for Components that implement this interface
+#define NS_NETWORK_CACHE_PROGID "component://netscape/network/cache"
+#define NS_NETWORK_MEMORY_CACHE_PROGID NS_NETWORK_CACHE_PROGID "?name=memory-cache"
+#define NS_NETWORK_FLAT_CACHE_PROGID   NS_NETWORK_CACHE_PROGID "?name=flat-cache"
+#define NS_NETWORK_FILE_CACHE_PROGID   NS_NETWORK_CACHE_PROGID "?name=file-cache"
 %}

mozilla/netwerk/cache/public/nsINetDataCacheManager.idl

@@ -21,12 +21,13 @@
  */
 
 #include "nsISupports.idl"
-#include "nsINetDataCache.idl"
 
 interface nsISimpleEnumerator;
 interface nsICachedNetData;
+interface nsINetDataCache;
 interface nsINetDataDiskCache;
 interface nsIURI;
+interface nsIFileSpec;
 
 /**
  * The network-response cache manager is partly responsible for the caching of
@@ -71,13 +72,6 @@ interface nsINetDataCacheManager : nsISupports
      */
     const unsigned long CACHE_AS_FILE             = 1 << 2;
 
-	/**
-		These enum's are used for the ClearCache calls. 
-	*/
-	const unsigned long ALL_CACHES = 1;
-	const unsigned long MEM_CACHE = 1<<1;
-	const unsigned long FILE_CACHE = 1<<2;
-	const unsigned long FLAT_CACHE = 1<<3;
     /**
      * Fetch the cache entry record for the given URI.  If one does not exist,
      * create a new, empty record.  The normal search order for caches is:
@@ -137,12 +131,7 @@ interface nsINetDataCacheManager : nsISupports
      * even those in active use, will be deleted.  Also, any global cache
      * database files will be deleted.
      */
-    void removeAll();
-    
-    /**
-      *	Clears the specified cache
-      */
-    void clear( in PRUint32 aCacheToClear );
+    void RemoveAll();
 
     /**
      * The disk cache is made up of the file cache (for stream-as-file
@@ -161,9 +150,14 @@ interface nsINetDataCacheManager : nsISupports
      * accomodate the requested capacity.
      */
     attribute PRUint32 memCacheCapacity;
+
+	/**
+	 * This attribute must be set before attempting to store into the disk cache.
+	 */
+    attribute nsIFileSpec diskCacheFolder;
 };
 
 %{ C++
-// ContractID prefix for Components that implement this interface
-#define NS_NETWORK_CACHE_MANAGER_CONTRACTID NS_NETWORK_CACHE_CONTRACTID "?name=manager"
+// ProgID prefix for Components that implement this interface
+#define NS_NETWORK_CACHE_MANAGER_PROGID NS_NETWORK_CACHE_PROGID "?name=manager"
 %}

mozilla/netwerk/cache/public/nsINetDataCacheRecord.idl

@@ -23,7 +23,7 @@
 #include "nsISupports.idl"
 #include "nsrootidl.idl"
 
-interface nsIFile;
+interface nsIFileSpec;
 interface nsIChannel;
 interface nsINetDataCache;
 
@@ -96,12 +96,6 @@ interface nsINetDataCacheRecord : nsISupports
      */
     attribute PRUint32 storedContentLength;
 
-	/**
-	 * Opaque security info associated with the cache entry; it can't be serialized
-	 * to disk, so it'll only make sense with memory cache
-	 */
-	attribute nsISupports securityInfo;
-
     /** 
      * Delete this cache entry and its associated content.
      */
@@ -127,5 +121,5 @@ interface nsINetDataCacheRecord : nsISupports
      * from each URI in an individual file, so it is acceptable for an
      * implementation of this method to signal NS_NOT_IMPLEMENTED.
      */
-    readonly attribute nsIFile file;
+    readonly attribute nsIFileSpec filename;
 };

mozilla/netwerk/cache/public/nsINetDataDiskCache.idl

@@ -22,8 +22,9 @@
 
 #include "nsINetDataCache.idl"
 
-interface nsIFile;
+interface nsIFileSpec;
 
+/**
 /**
  * A network-data disk cache is used to persistently cache the responses to
  * network retrieval commands.  Each cache entry may contain both content,
@@ -36,6 +37,6 @@ interface nsINetDataDiskCache : nsINetDataCache
 	 * This attribute must be set before calling any other methods of this
 	 * interface.
 	 */
-    attribute nsIFile diskCacheFolder;
+    attribute nsIFileSpec diskCacheFolder;
 };
 

mozilla/netwerk/cache/public/nsIStreamAsFile.idl

@@ -24,7 +24,7 @@
 #include "nsrootidl.idl"
 #include "nsISupports.idl"
 
-interface nsIFile;
+interface nsIFileSpec;
 interface nsIStreamAsFileObserver;
 
 /**
@@ -41,7 +41,7 @@ interface nsIStreamAsFile : nsISupports
     /**
      * Filename containing stream-as-file
      */
-    readonly attribute nsIFile file;
+    readonly attribute nsIFileSpec fileSpec;
 
     /**
      * Add an observer for this cache record.  When the cache wants to delete
@@ -71,7 +71,7 @@ interface nsIStreamAsFile : nsISupports
 interface nsIStreamAsFileObserver : nsISupports
 {
     /**
-     * Flag bits for argument to observeStreamAsFile() method.
+     * Flag bits for argument to Observe() method.
      */
     const long NOTIFY_AVAILABLE    = 1 << 0; // Stream-as-file now available for reading
     const long NOTIFY_ERROR        = 1 << 1; // Error while loading stream / creating file
@@ -100,7 +100,7 @@ interface nsIStreamAsFileObserver : nsISupports
      * as the cache manager will effectively relinquished ownership of the
      * file.
      */
-    void observeStreamAsFile(in nsIStreamAsFile aStreamAsFile,
-                             in PRUint32 aMessage,
-                             in nsresult aError);
+    void ObserveStreamAsFile(in nsIStreamAsFile aStreamAsFile,
+			     in PRUint32 aMessage,
+			     in nsresult aError);
 };

mozilla/netwerk/cache/src/nsANSIFileStreams.cpp

@@ -1,388 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsANSIFileStreams.cpp, released March 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Patrick C. Beard <beard@netscape.com>
- */
-
-#include "nsANSIFileStreams.h"
-
-NS_IMPL_ISUPPORTS2(nsANSIInputStream, nsIInputStream, nsISeekableStream);
-
-nsANSIInputStream::nsANSIInputStream() : mFile(nsnull), mSize(0)
-{
-    NS_INIT_ISUPPORTS();
-}
-
-nsANSIInputStream::~nsANSIInputStream()
-{
-    Close();
-}
-
-nsresult nsANSIInputStream::Open(nsILocalFile* file)
-{
-    nsresult rv;
-    rv = file->OpenANSIFileDesc("rb", &mFile);
-    if (NS_FAILED(rv)) return rv;
-
-    if (::fseek(mFile, 0, SEEK_END) != 0) return NS_ERROR_FAILURE;
-    mSize = ::ftell(mFile);
-    ::fseek(mFile, 0, SEEK_SET);
-    rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-    return rv;
-}
-
-NS_IMETHODIMP nsANSIInputStream::Close()
-{
-    if (mFile) {
-        ::fclose(mFile);
-        mFile = nsnull;
-        return NS_OK;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIInputStream::Available(PRUint32 * result)
-{
-    if (mFile) {
-        *result = (mSize - ::ftell(mFile));
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIInputStream::Read(char * buf, PRUint32 count, PRUint32 *result)
-{
-    if (mFile) {
-        *result = ::fread(buf, 1, count, mFile);
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIInputStream::ReadSegments(nsWriteSegmentFun writer, void * closure, PRUint32 count, PRUint32 *_retval)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIInputStream::GetNonBlocking(PRBool *aNonBlocking)
-{
-    *aNonBlocking = PR_FALSE;
-    return NS_OK;
-}
-
-NS_IMETHODIMP nsANSIInputStream::GetObserver(nsIInputStreamObserver * *aObserver)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIInputStream::SetObserver(nsIInputStreamObserver * aObserver)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIInputStream::Seek(PRInt32 whence, PRInt32 offset)
-{
-    if (mFile) {
-        ::fseek(mFile, offset, whence);
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIInputStream::Tell(PRUint32 * result)
-{
-    if (mFile) {
-        *result = ::ftell(mFile);
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMPL_ISUPPORTS2(nsANSIOutputStream, nsIOutputStream, nsISeekableStream);
-
-nsANSIOutputStream::nsANSIOutputStream() : mFile(nsnull)
-{
-    NS_INIT_ISUPPORTS();
-}
-
-nsANSIOutputStream::~nsANSIOutputStream()
-{
-    Close();
-}
-
-nsresult nsANSIOutputStream::Open(nsILocalFile* file)
-{
-    nsresult rv = file->OpenANSIFileDesc("wb", &mFile);
-    return rv;
-}
-
-NS_IMETHODIMP nsANSIOutputStream::Close()
-{
-    if (mFile) {
-        ::fclose(mFile);
-        mFile = nsnull;
-        return NS_OK;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIOutputStream::Flush()
-{
-    if (mFile) {
-        ::fflush(mFile);
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIOutputStream::Write(const char *buffer, PRUint32 count, PRUint32 *result)
-{
-    if (mFile) {
-        *result = ::fwrite(buffer, 1, count, mFile);
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIOutputStream::WriteFrom(nsIInputStream *input, PRUint32 count, PRUint32 *actualCount)
-{
-    nsresult rv;
-    char buffer[BUFSIZ];
-    PRUint32 totalCount = count;
-    *actualCount = 0;
-    while (totalCount > 0) {
-        count = (totalCount < BUFSIZ ? totalCount : BUFSIZ);
-        rv = input->Read(buffer, count, &count);
-        if (NS_FAILED(rv)) break;
-        rv = Write(buffer, count, &count);
-        if (NS_FAILED(rv)) break;
-        totalCount -= count;
-        *actualCount += count;
-    }
-    return rv;
-}
-
-NS_IMETHODIMP nsANSIOutputStream::WriteSegments(nsReadSegmentFun reader, void * closure, PRUint32 count, PRUint32 *_retval)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIOutputStream::GetNonBlocking(PRBool *aNonBlocking)
-{
-    *aNonBlocking = PR_FALSE;
-    return NS_OK;
-}
-NS_IMETHODIMP nsANSIOutputStream::SetNonBlocking(PRBool aNonBlocking)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIOutputStream::GetObserver(nsIOutputStreamObserver * *aObserver)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-NS_IMETHODIMP nsANSIOutputStream::SetObserver(nsIOutputStreamObserver * aObserver)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIOutputStream::Seek(PRInt32 whence, PRInt32 offset)
-{
-    if (mFile) {
-        ::fseek(mFile, offset, whence);
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIOutputStream::Tell(PRUint32 * result)
-{
-    if (mFile) {
-        *result = ::ftell(mFile);
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-///////
-
-NS_IMPL_ISUPPORTS3(nsANSIFileStream, nsIInputStream, nsIOutputStream, nsISeekableStream);
-
-nsANSIFileStream::nsANSIFileStream() : mFile(nsnull), mSize(0)
-{
-    NS_INIT_ISUPPORTS();
-}
-
-nsANSIFileStream::~nsANSIFileStream()
-{
-    Close();
-}
-
-NS_IMETHODIMP nsANSIFileStream::Open(nsILocalFile* file)
-{
-    nsresult rv;
-    rv = file->OpenANSIFileDesc("rb+", &mFile);
-    if (NS_FAILED(rv)) {
-        rv = rv = file->OpenANSIFileDesc("wb+", &mFile);
-        if (NS_FAILED(rv)) return rv;
-    }
-    
-    // compute size of file.
-    if (::fseek(mFile, 0, SEEK_END) != 0) return NS_ERROR_FAILURE;
-    mSize = ::ftell(mFile);
-    ::fseek(mFile, 0, SEEK_SET);
-    rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-    return rv;
-}
-
-NS_IMETHODIMP nsANSIFileStream::Close()
-{
-    if (mFile) {
-        ::fclose(mFile);
-        mFile = nsnull;
-        return NS_OK;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::Available(PRUint32 * result)
-{
-    if (mFile) {
-        *result = (mSize - ::ftell(mFile));
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::Read(char * buf, PRUint32 count, PRUint32 *result)
-{
-    if (mFile) {
-        *result = ::fread(buf, 1, count, mFile);
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::ReadSegments(nsWriteSegmentFun writer, void * closure, PRUint32 count, PRUint32 *_retval)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::GetNonBlocking(PRBool *aNonBlocking)
-{
-    *aNonBlocking = PR_FALSE;
-    return NS_OK;
-}
-
-NS_IMETHODIMP nsANSIFileStream::GetObserver(nsIInputStreamObserver * *aObserver)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::SetObserver(nsIInputStreamObserver * aObserver)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::Flush()
-{
-    if (mFile) {
-        ::fflush(mFile);
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::Write(const char *buffer, PRUint32 count, PRUint32 *result)
-{
-    if (mFile) {
-        *result = ::fwrite(buffer, 1, count, mFile);
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::WriteFrom(nsIInputStream *input, PRUint32 count, PRUint32 *actualCount)
-{
-    char buffer[BUFSIZ];
-    PRUint32 totalCount = count;
-    *actualCount = 0;
-    while (totalCount > 0) {
-        count = (totalCount < BUFSIZ ? totalCount : BUFSIZ);
-        nsresult rv = input->Read(buffer, count, &count);
-        if (NS_FAILED(rv)) return rv;
-        rv = Write(buffer, count, &count);
-        totalCount -= count;
-        *actualCount += count;
-    }
-    return NS_OK;
-}
-
-NS_IMETHODIMP nsANSIFileStream::WriteSegments(nsReadSegmentFun reader, void * closure, PRUint32 count, PRUint32 *_retval)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::SetNonBlocking(PRBool aNonBlocking)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::GetObserver(nsIOutputStreamObserver * *aObserver)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::SetObserver(nsIOutputStreamObserver * aObserver)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::Seek(PRInt32 whence, PRInt32 offset)
-{
-    if (mFile) {
-        ::fseek(mFile, offset, whence);
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}
-
-NS_IMETHODIMP nsANSIFileStream::Tell(PRUint32 * result)
-{
-    if (mFile) {
-        *result = ::ftell(mFile);
-        nsresult rv = (ferror(mFile) ? NS_ERROR_FAILURE : NS_OK);
-        return rv;
-    }
-    return NS_BASE_STREAM_CLOSED;
-}

mozilla/netwerk/cache/src/nsANSIFileStreams.h

@@ -1,80 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsANSIFileStreams.h, released March 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Patrick C. Beard <beard@netscape.com>
- */
-
-#ifndef _nsANSIFileStreams_h_
-#define _nsANSIFileStreams_h_
-
-#include <stdio.h>
-
-#include "nsIFileStreams.h"
-
-class nsANSIInputStream : public nsIInputStream, public nsISeekableStream {
-    FILE*       mFile;
-    PRUint32    mSize;
-public:
-    NS_DECL_ISUPPORTS
-    NS_DECL_NSIINPUTSTREAM
-    NS_DECL_NSISEEKABLESTREAM
-    
-    nsANSIInputStream();
-    virtual ~nsANSIInputStream();
-    nsresult Open(nsILocalFile* file);
-};
-
-class nsANSIOutputStream : public nsIOutputStream, public nsISeekableStream {
-    FILE*       mFile;
-public:
-    NS_DECL_ISUPPORTS
-    NS_DECL_NSIOUTPUTSTREAM
-    NS_DECL_NSISEEKABLESTREAM
-    
-    nsANSIOutputStream();
-    virtual ~nsANSIOutputStream();
-    nsresult Open(nsILocalFile* file);
-};
-
-class nsANSIFileStream : public nsIInputStream, public nsIOutputStream, public nsISeekableStream {
-    FILE*       mFile;
-    PRUint32    mSize;
-public:
-    NS_DECL_ISUPPORTS
-    NS_DECL_NSIINPUTSTREAM
-
-    // NS_DECL_NSIOUTPUTSTREAM
-    // XXX must only declare additional methods introduced by nsIOutputStream.
-    NS_IMETHOD Flush(void);
-    NS_IMETHOD Write(const char *buf, PRUint32 count, PRUint32 *_retval);
-    NS_IMETHOD WriteFrom(nsIInputStream *inStr, PRUint32 count, PRUint32 *_retval);
-    NS_IMETHOD WriteSegments(nsReadSegmentFun reader, void * closure, PRUint32 count, PRUint32 *_retval);
-    NS_IMETHOD SetNonBlocking(PRBool aNonBlocking);
-    NS_IMETHOD GetObserver(nsIOutputStreamObserver * *aObserver);
-    NS_IMETHOD SetObserver(nsIOutputStreamObserver * aObserver);
-
-    NS_DECL_NSISEEKABLESTREAM
-
-    NS_EXPORT nsANSIFileStream();
-    virtual ~nsANSIFileStream();
-    NS_IMETHOD Open(nsILocalFile* file);
-};
-
-#endif // _nsANSIFileStreams_h_

mozilla/netwerk/cache/src/nsCache.cpp

@@ -1,119 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCache.cpp, released March 18, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan  <gordon@netscape.com>
- *    Patrick C. Beard <beard@netscape.com>
- *    Darin Fisher     <darin@netscape.com>
- */
-
-#include "nsCache.h"
-#include "nsReadableUtils.h"
-
-
-/**
- * Cache Service Utility Functions
- */
-
-#if defined(PR_LOGGING)
-PRLogModuleInfo * gCacheLog = nsnull;
-
-void
-CacheLogInit()
-{
-    if (gCacheLog) return;
-    gCacheLog = PR_NewLogModule("cache");
-    NS_ASSERTION(gCacheLog, "\n### failed to allocate cache log.\n");
-}
-#endif
-
-PRUint32
-SecondsFromPRTime(PRTime prTime)
-{
-  PRInt64  microSecondsPerSecond, intermediateResult;
-  PRUint32 seconds;
-
-  LL_I2L(microSecondsPerSecond, PR_USEC_PER_SEC);
-  LL_DIV(intermediateResult, prTime, microSecondsPerSecond);
-  LL_L2UI(seconds, intermediateResult);
-  return seconds;
-}
-
-
-PRTime
-PRTimeFromSeconds(PRUint32 seconds)
-{
-  PRInt64 microSecondsPerSecond, intermediateResult;
-  PRTime  prTime;
-
-  LL_I2L(microSecondsPerSecond, PR_USEC_PER_SEC);
-  LL_UI2L(intermediateResult, seconds);
-  LL_MUL(prTime, intermediateResult, microSecondsPerSecond);
-  return prTime;
-}
-
-
-nsresult
-ClientIDFromCacheKey(const nsAReadableCString&  key, char ** result)
-{
-    nsresult  rv = NS_OK;
-    *result = nsnull;
-
-    nsReadingIterator<char> colon;
-    key.BeginReading(colon);
-        
-    nsReadingIterator<char> start;
-    key.BeginReading(start);
-        
-    nsReadingIterator<char> end;
-    key.EndReading(end);
-        
-    if (FindCharInReadable(':', colon, end)) {
-        *result = ToNewCString( Substring(start, colon));
-        if (!*result) rv = NS_ERROR_OUT_OF_MEMORY;
-    } else {
-        NS_ASSERTION(PR_FALSE, "FindCharInRead failed to find ':'");
-        rv = NS_ERROR_UNEXPECTED;
-    }
-    return rv;
-}
-
-
-nsresult
-ClientKeyFromCacheKey(const nsAReadableCString& key, char ** result)
-{
-    nsresult  rv = NS_OK;
-    *result = nsnull;
-
-    nsReadingIterator<char> start;
-    key.BeginReading(start);
-        
-    nsReadingIterator<char> end;
-    key.EndReading(end);
-        
-    if (FindCharInReadable(':', start, end)) {
-        ++start;  // advance past clientID ':' delimiter
-        *result = ToNewCString( Substring(start, end));
-        if (!*result) rv = NS_ERROR_OUT_OF_MEMORY;
-    } else {
-        NS_ASSERTION(PR_FALSE, "FindCharInRead failed to find ':'");
-        rv = NS_ERROR_UNEXPECTED;
-    }
-    return rv;
-}

mozilla/netwerk/cache/src/nsCache.h

@@ -1,63 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCache.h, released March 18, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan  <gordon@netscape.com>
- *    Patrick C. Beard <beard@netscape.com>
- *    Darin Fisher     <darin@netscape.com>
- */
-
-/**
- * Cache Service Utility Functions
- */
-
-#ifndef _nsCache_h_
-#define _nsCache_h_
-
-#include "nsAReadableString.h"
-#include "prtime.h"
-#include "nsError.h"
-#include "prlog.h"
-
-// PR_LOG args = "format string", arg, arg, ...
-#if defined(PR_LOGGING)
-extern PRLogModuleInfo * gCacheLog;
-void   CacheLogInit();
-#define CACHE_LOG_INIT()        CacheLogInit()
-#define CACHE_LOG_ALWAYS(args)  PR_LOG(gCacheLog, PR_LOG_ALWAYS, args)
-#define CACHE_LOG_ERROR(args)   PR_LOG(gCacheLog, PR_LOG_ERROR, args)
-#define CACHE_LOG_WARNING(args) PR_LOG(gCacheLog, PR_LOG_WARNING, args)
-#define CACHE_LOG_DEBUG(args)   PR_LOG(gCacheLog, PR_LOG_DEBUG, args)
-#else
-#define CACHE_LOG_INIT()        {}
-#define CACHE_LOG_ALWAYS(args)  {}
-#define CACHE_LOG_ERROR(args)   {}
-#define CACHE_LOG_WARNING(args) {}
-#define CACHE_LOG_DEBUG(args)   {}
-#endif
-
-
-extern PRUint32  SecondsFromPRTime(PRTime prTime);
-extern PRTime    PRTimeFromSeconds(PRUint32 seconds);
-
-
-extern nsresult  ClientIDFromCacheKey(const nsAReadableCString&  key, char ** result);
-extern nsresult  ClientKeyFromCacheKey(const nsAReadableCString& key, char ** result);
-
-#endif // _nsCache_h

mozilla/netwerk/cache/src/nsCacheDevice.h

@@ -1,72 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheDevice.h, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-#ifndef _nsCacheDevice_h_
-#define _nsCacheDevice_h_
-
-#include "nspr.h"
-#include "nsError.h"
-#include "nsICache.h"
-
-class nsIFile;
-class nsCString;
-class nsCacheEntry;
-class nsICacheVisitor;
-class nsITransport;
-
-/******************************************************************************
-* nsCacheDevice
-*******************************************************************************/
-class nsCacheDevice {
-public:
-    virtual ~nsCacheDevice() {}
-
-    virtual nsresult Init() = 0;
-    virtual nsresult Shutdown() = 0;
-
-    virtual const char *   GetDeviceID(void) = 0;
-    virtual nsCacheEntry * FindEntry( nsCString * key ) = 0;
-
-    virtual nsresult DeactivateEntry( nsCacheEntry * entry ) = 0;
-    virtual nsresult BindEntry( nsCacheEntry * entry ) = 0;
-    virtual void     DoomEntry( nsCacheEntry * entry ) = 0;
-
-    virtual nsresult GetTransportForEntry( nsCacheEntry * entry,
-                                           nsCacheAccessMode mode,
-                                           nsITransport **result ) = 0;
-
-    virtual nsresult GetFileForEntry( nsCacheEntry *    entry,
-                                      nsIFile **        result ) = 0;
-
-    virtual nsresult OnDataSizeChange( nsCacheEntry * entry, PRInt32 deltaSize ) = 0;
-
-    virtual nsresult Visit(nsICacheVisitor * visitor) = 0;
-
-    /**
-     * Device must evict entries associated with clientID.  If clientID == nsnull, all
-     * entries must be evicted.  Active entries must be doomed, rather than evicted.
-     */
-    virtual nsresult EvictEntries(const char * clientID) = 0;
-};
-
-#endif // _nsCacheDevice_h_

mozilla/netwerk/cache/src/nsCacheEntry.cpp

@@ -1,663 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheEntry.cpp, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-
-#include "nspr.h"
-#include "nsCacheEntry.h"
-#include "nsCacheEntryDescriptor.h"
-#include "nsCacheMetaData.h"
-#include "nsCacheRequest.h"
-#include "nsError.h"
-#include "nsICacheService.h"
-#include "nsCache.h"
-#include "nsCacheDevice.h"
-
-
-nsCacheEntry::nsCacheEntry(nsCString *          key,
-                           PRBool               streamBased,
-                           nsCacheStoragePolicy storagePolicy)
-    : mKey(key),
-      mFetchCount(0),
-      mLastFetched(0),
-      mExpirationTime(0),
-      mFlags(0),
-      mDataSize(0),
-      mMetaSize(0),
-      mCacheDevice(nsnull),
-      mData(nsnull),
-      mMetaData(nsnull)
-{
-    PR_INIT_CLIST(this);
-    PR_INIT_CLIST(&mRequestQ);
-    PR_INIT_CLIST(&mDescriptorQ);
-
-    if (streamBased) MarkStreamBased();
-    SetStoragePolicy(storagePolicy);
-}
-
-
-static void* PR_CALLBACK
-CacheElementReleaseEventHandler(PLEvent *self)
-{
-    nsISupports * element = (nsISupports *)PL_GetEventOwner(self);
-    NS_RELEASE(element);
-    return 0;
-}
-
-
-static void PR_CALLBACK
-CacheElementReleaseDestroyHandler(PLEvent *self)
-{
-    delete self;
-}
-
-
-nsCacheEntry::~nsCacheEntry()
-{
-    delete mKey;
-    delete mMetaData;
-    
-    if (IsStreamData()) return;
-
-    // proxy release of of memory cache nsISupports objects
-    if (!mData) {
-        NS_ASSERTION(!mEventQ, "### ~nsCacheEntry: mEventQ but no mData");
-        return;
-    }
-    
-    if (!mEventQ) {
-        NS_ASSERTION(!mData, "### ~nsCacheEntry: mData, but no eventQ");
-        return;
-    }
-    
-    PLEvent * event = new PLEvent;
-    if (!event) {
-        // XXX warning
-        return;
-    }
-    
-    nsISupports * data = mData;
-    NS_ADDREF(data);    // this reference will be owned by the event
-    mData = nsnull;     // release our reference before switching threads
-
-    PL_InitEvent(event,
-                 data,
-                 CacheElementReleaseEventHandler,
-                 CacheElementReleaseDestroyHandler);
-    
-    mEventQ->PostEvent(event);
-}
-
-
-nsresult
-nsCacheEntry::Create( const char *          key,
-                      PRBool                streamBased,
-                      nsCacheStoragePolicy  storagePolicy,
-                      nsCacheDevice *       device,
-                      nsCacheEntry **       result)
-{
-    nsCString* newKey = new nsCString(key);
-    if (!newKey) return NS_ERROR_OUT_OF_MEMORY;
-    
-    nsCacheEntry* entry = new nsCacheEntry(newKey, streamBased, storagePolicy);
-    if (!entry) { delete newKey; return NS_ERROR_OUT_OF_MEMORY; }
-    
-    entry->SetCacheDevice(device);
-    
-    *result = entry;
-    return NS_OK;
-}
-
-void
-nsCacheEntry::Fetched()
-{
-    mLastFetched = SecondsFromPRTime(PR_Now());
-    ++mFetchCount;
-    MarkEntryDirty();
-}
-
-
-const char *
-nsCacheEntry::GetDeviceID()
-{
-    if (mCacheDevice)  return mCacheDevice->GetDeviceID();
-    return nsnull;
-}
-
-
-nsresult
-nsCacheEntry::GetData(nsISupports **result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    NS_IF_ADDREF(*result = mData);
-    return NS_OK;
-}
-
-
-void
-nsCacheEntry::TouchData()
-{
-    mLastModified = SecondsFromPRTime(PR_Now());
-    MarkDataDirty();
-}
-
-
-
-nsresult
-nsCacheEntry::GetMetaDataElement( const nsAReadableCString&  key,
-                                  nsAReadableCString **      value)
-{
-    *value = mMetaData ? mMetaData->GetElement(&key) : nsnull;
-    return NS_OK;
-}
-
-
-nsresult
-nsCacheEntry::SetMetaDataElement( const nsAReadableCString& key, 
-                                  const nsAReadableCString& value)
-{
-    if (!mMetaData) {
-        mMetaData = nsCacheMetaData::Create();
-        if (!mMetaData)
-            return NS_ERROR_OUT_OF_MEMORY;
-    }
-    nsresult rv = mMetaData->SetElement(key, value);
-    if (NS_FAILED(rv))
-        return rv;
-
-    mMetaSize = mMetaData->Size();                // calc new meta data size
-    return rv;
-}
-
-
-nsresult
-nsCacheEntry::VisitMetaDataElements( nsICacheMetaDataVisitor * visitor)
-{
-    NS_ENSURE_ARG_POINTER(visitor);
-
-    if (mMetaData)
-        mMetaData->VisitElements(visitor);
-
-    return NS_OK;
-}
-
-
-nsresult
-nsCacheEntry::FlattenMetaData(char ** data, PRUint32 * size)
-{
-    NS_ENSURE_ARG_POINTER(size);
-
-    if (mMetaData)
-        return mMetaData->FlattenMetaData(data, size);
-
-    if (data) *data = nsnull;
-    *size = 0;
-
-    return NS_OK;
-}
-
-nsresult
-nsCacheEntry::UnflattenMetaData(char * data, PRUint32 size)
-{
-    delete mMetaData;
-    mMetaData = nsCacheMetaData::Create();
-    if (!mMetaData)
-        return NS_ERROR_OUT_OF_MEMORY;
-    nsresult rv = mMetaData->UnflattenMetaData(data, size);
-    if (NS_SUCCEEDED(rv))
-        mMetaSize = mMetaData->Size();
-    return rv;
-}
-
-
-void
-nsCacheEntry::TouchMetaData()
-{
-    mLastModified = SecondsFromPRTime(PR_Now());
-    MarkMetaDataDirty();
-}
-
-#if 0
-nsresult
-nsCacheEntry::GetKeyValueArray(nsCacheMetaDataKeyValuePair ** array,
-                               PRUint32 *                     count)
-{
-    if (!array || !count)  return NS_ERROR_NULL_POINTER;
-
-    if (!mMetaData) {
-        *array = nsnull;
-        *count = 0;
-        return NS_OK;
-    }
-    return mMetaData->GetKeyValueArray(array, count);
-}
-#endif
-
-
-nsresult
-nsCacheEntry::GetSecurityInfo( nsISupports ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    NS_IF_ADDREF(*result = mSecurityInfo);
-    return NS_OK;
-}
-
-
-/**
- *  cache entry states
- *      0 descriptors (new entry)
- *      0 descriptors (existing, bound entry)
- *      n descriptors (existing, bound entry) valid
- *      n descriptors (existing, bound entry) not valid (wait until valid or doomed)
- */
-
-nsresult
-nsCacheEntry::RequestAccess(nsCacheRequest * request, nsCacheAccessMode *accessGranted)
-{
-    nsresult  rv = NS_OK;
-    
-    if (!IsInitialized()) {
-        // brand new, unbound entry
-        request->mKey = nsnull;  // steal ownership of the key string
-        if (request->IsStreamBased())  MarkStreamBased();
-        MarkInitialized();
-
-        *accessGranted = request->AccessRequested() & nsICache::ACCESS_WRITE;
-        NS_ASSERTION(*accessGranted, "new cache entry for READ-ONLY request");
-        PR_APPEND_LINK(request, &mRequestQ);
-        return rv;
-    }
-    
-    if (IsDoomed()) return NS_ERROR_CACHE_ENTRY_DOOMED;
-
-    if (IsStreamData() != request->IsStreamBased()) {
-        *accessGranted = nsICache::ACCESS_NONE;
-        return request->IsStreamBased() ?
-            NS_ERROR_CACHE_DATA_IS_NOT_STREAM : NS_ERROR_CACHE_DATA_IS_STREAM;
-    }
-
-    if (PR_CLIST_IS_EMPTY(&mDescriptorQ)) {
-        // 1st descriptor for existing bound entry
-        *accessGranted = request->AccessRequested();
-        if (*accessGranted & nsICache::ACCESS_WRITE) {
-            MarkInvalid();
-        } else {
-            MarkValid();
-        }
-    } else {
-        // nth request for existing, bound entry
-        *accessGranted = request->AccessRequested() & ~nsICache::ACCESS_WRITE;
-        if (!IsValid())
-            rv = NS_ERROR_CACHE_WAIT_FOR_VALIDATION;
-    }
-    PR_APPEND_LINK(request,&mRequestQ);
-
-    return rv;
-}
-
-
-nsresult
-nsCacheEntry::CreateDescriptor(nsCacheRequest *           request,
-                               nsCacheAccessMode          accessGranted,
-                               nsICacheEntryDescriptor ** result)
-{
-    NS_ENSURE_ARG_POINTER(request && result);
-
-    nsCacheEntryDescriptor * descriptor =
-        new nsCacheEntryDescriptor(this, accessGranted);
-
-    // XXX check request is on q
-    PR_REMOVE_AND_INIT_LINK(request); // remove request regardless of success
-
-    if (descriptor == nsnull)
-        return NS_ERROR_OUT_OF_MEMORY;
-
-    PR_APPEND_LINK(descriptor, &mDescriptorQ);
-
-    NS_ADDREF(*result = descriptor);
-    return NS_OK;
-}
-
-
-PRBool
-nsCacheEntry::RemoveRequest(nsCacheRequest * request)
-{
-    // XXX if debug: verify this request belongs to this entry
-    PR_REMOVE_AND_INIT_LINK(request);
-
-    // return true if this entry should stay active
-    return !((PR_CLIST_IS_EMPTY(&mRequestQ)) &&
-             (PR_CLIST_IS_EMPTY(&mDescriptorQ)));
-}
-
-
-PRBool
-nsCacheEntry::RemoveDescriptor(nsCacheEntryDescriptor * descriptor)
-{
-    // XXX if debug: verify this descriptor belongs to this entry
-    PR_REMOVE_AND_INIT_LINK(descriptor);
-
-    if (!PR_CLIST_IS_EMPTY(&mDescriptorQ))
-        return PR_TRUE;  // stay active if we still have open descriptors
-
-    if (PR_CLIST_IS_EMPTY(&mRequestQ))
-        return PR_FALSE; // no descriptors or requests, we can deactivate
-
-    return PR_TRUE;     // find next best request to give a descriptor to
-}
-
-
-void
-nsCacheEntry::DetachDescriptors(void)
-{
-    nsCacheEntryDescriptor * descriptor =
-        (nsCacheEntryDescriptor *)PR_LIST_HEAD(&mDescriptorQ);
-
-    while (descriptor != &mDescriptorQ) {
-        nsCacheEntryDescriptor * nextDescriptor =
-            (nsCacheEntryDescriptor *)PR_NEXT_LINK(descriptor);
-        
-        descriptor->ClearCacheEntry();
-        PR_REMOVE_AND_INIT_LINK(descriptor);
-        descriptor = nextDescriptor;
-    }
-}
-
-
-/******************************************************************************
- * nsCacheEntryInfo - for implementing about:cache
- *****************************************************************************/
-
-NS_IMPL_ISUPPORTS1(nsCacheEntryInfo, nsICacheEntryInfo);
-
-
-NS_IMETHODIMP
-nsCacheEntryInfo::GetClientID(char ** clientID)
-{
-    NS_ENSURE_ARG_POINTER(clientID);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    return ClientIDFromCacheKey(*mCacheEntry->Key(), clientID);
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryInfo::GetDeviceID(char ** deviceID)
-{
-    NS_ENSURE_ARG_POINTER(deviceID);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-    
-    *deviceID = nsCRT::strdup(mCacheEntry->GetDeviceID());
-    return *deviceID ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryInfo::GetKey(char ** key)
-{
-    NS_ENSURE_ARG_POINTER(key);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    return ClientKeyFromCacheKey(*mCacheEntry->Key(), key);
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryInfo::GetFetchCount(PRInt32 * fetchCount)
-{
-    NS_ENSURE_ARG_POINTER(fetchCount);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    *fetchCount = mCacheEntry->FetchCount();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryInfo::GetLastFetched(PRUint32 * lastFetched)
-{
-    NS_ENSURE_ARG_POINTER(lastFetched);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    *lastFetched = mCacheEntry->LastFetched();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryInfo::GetLastModified(PRUint32 * lastModified)
-{
-    NS_ENSURE_ARG_POINTER(lastModified);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    *lastModified = mCacheEntry->LastModified();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryInfo::GetExpirationTime(PRUint32 * expirationTime)
-{
-    NS_ENSURE_ARG_POINTER(expirationTime);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    *expirationTime = mCacheEntry->ExpirationTime();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryInfo::GetDataSize(PRUint32 * dataSize)
-{
-    NS_ENSURE_ARG_POINTER(dataSize);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    *dataSize = mCacheEntry->DataSize();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryInfo::IsStreamBased(PRBool * result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-    
-    *result = mCacheEntry->IsStreamData();
-    return NS_OK;
-}
-
-
-/******************************************************************************
- *  nsCacheEntryHashTable
- *****************************************************************************/
-
-PLDHashTableOps
-nsCacheEntryHashTable::ops =
-{
-    PL_DHashAllocTable,
-    PL_DHashFreeTable,
-    GetKey,
-    HashKey,
-    MatchEntry,
-    MoveEntry,
-    ClearEntry,
-    PL_DHashFinalizeStub
-};
-
-
-nsCacheEntryHashTable::nsCacheEntryHashTable()
-    : initialized(PR_FALSE)
-{
-}
-
-
-nsCacheEntryHashTable::~nsCacheEntryHashTable()
-{
-    if (initialized)
-        Shutdown();
-}
-
-
-nsresult
-nsCacheEntryHashTable::Init()
-{
-    nsresult rv = NS_OK;
-    initialized = PL_DHashTableInit(&table, &ops, nsnull,
-                                           sizeof(nsCacheEntryHashTableEntry), 512);
-
-    if (!initialized) rv = NS_ERROR_OUT_OF_MEMORY;
-    
-    return rv;
-}
-
-void
-nsCacheEntryHashTable::Shutdown()
-{
-    if (initialized) {
-        PL_DHashTableFinish(&table);
-        initialized = PR_FALSE;
-    }
-}
-
-
-nsCacheEntry *
-nsCacheEntryHashTable::GetEntry( const nsCString * key)
-{
-    PLDHashEntryHdr *hashEntry;
-    nsCacheEntry    *result = nsnull;
-
-    NS_ASSERTION(initialized, "nsCacheEntryHashTable not initialized");
-    if (!initialized)  return nsnull;
-    
-    hashEntry = PL_DHashTableOperate(&table, key, PL_DHASH_LOOKUP);
-    if (PL_DHASH_ENTRY_IS_BUSY(hashEntry)) {
-        result = ((nsCacheEntryHashTableEntry *)hashEntry)->cacheEntry;
-    }
-    return result;
-}
-
-
-nsresult
-nsCacheEntryHashTable::AddEntry( nsCacheEntry *cacheEntry)
-{
-    PLDHashEntryHdr    *hashEntry;
-
-    NS_ASSERTION(initialized, "nsCacheEntryHashTable not initialized");
-    if (!initialized)  return NS_ERROR_NOT_INITIALIZED;
-    if (!cacheEntry)   return NS_ERROR_NULL_POINTER;
-
-    hashEntry = PL_DHashTableOperate(&table, cacheEntry->mKey, PL_DHASH_ADD);
-#ifndef DEBUG_dougt
-    NS_ASSERTION(((nsCacheEntryHashTableEntry *)hashEntry)->cacheEntry == 0,
-                 "### nsCacheEntryHashTable::AddEntry - entry already used");
-#endif
-    ((nsCacheEntryHashTableEntry *)hashEntry)->cacheEntry = cacheEntry;
-
-    return NS_OK;
-}
-
-
-void
-nsCacheEntryHashTable::RemoveEntry( nsCacheEntry *cacheEntry)
-{
-    NS_ASSERTION(initialized, "nsCacheEntryHashTable not initialized");
-    NS_ASSERTION(cacheEntry, "### cacheEntry == nsnull");
-
-    if (!initialized)  return; // NS_ERROR_NOT_INITIALIZED
-
-#if DEBUG
-    // XXX debug code to make sure we have the entry we're trying to remove
-    nsCacheEntry *check = GetEntry(cacheEntry->mKey);
-    NS_ASSERTION(check == cacheEntry, "### Attempting to remove unknown cache entry!!!");
-#endif
-    (void) PL_DHashTableOperate(&table, cacheEntry->mKey, PL_DHASH_REMOVE);
-}
-
-
-void
-nsCacheEntryHashTable::VisitEntries( nsCacheEntryHashTable::Visitor *visitor)
-{
-    NS_ASSERTION(initialized, "nsCacheEntryHashTable not initialized");
-    if (!initialized)  return; // NS_ERROR_NOT_INITIALIZED
-    PL_DHashTableEnumerate(&table, VisitEntry, visitor);
-}
-
-
-PLDHashOperator PR_CALLBACK
-nsCacheEntryHashTable::VisitEntry(PLDHashTable *table,
-                                  PLDHashEntryHdr *hashEntry,
-                                  PRUint32 number,
-                                  void *arg)
-{
-    nsCacheEntry *cacheEntry = ((nsCacheEntryHashTableEntry *)hashEntry)->cacheEntry;
-    nsCacheEntryHashTable::Visitor *visitor = (nsCacheEntryHashTable::Visitor*) arg;
-    return (visitor->VisitEntry(cacheEntry) ? PL_DHASH_NEXT : PL_DHASH_STOP);
-}
-
-/**
- *  hash table operation callback functions
- */
-const void * PR_CALLBACK
-nsCacheEntryHashTable::GetKey( PLDHashTable * /*table*/, PLDHashEntryHdr *hashEntry)
-{
-    nsCacheEntry *cacheEntry = ((nsCacheEntryHashTableEntry *)hashEntry)->cacheEntry;
-    return cacheEntry->mKey;
-}
-
-
-PLDHashNumber PR_CALLBACK
-nsCacheEntryHashTable::HashKey( PLDHashTable *table, const void *key)
-{
-    return PL_DHashStringKey(table,((nsCString *)key)->get());
-}
-
-PRBool PR_CALLBACK
-nsCacheEntryHashTable::MatchEntry(PLDHashTable *       /* table */,
-                                  const PLDHashEntryHdr * hashEntry,
-                                  const void *            key)
-{
-    NS_ASSERTION(key !=  nsnull, "### nsCacheEntryHashTable::MatchEntry : null key");
-    nsCacheEntry *cacheEntry = ((nsCacheEntryHashTableEntry *)hashEntry)->cacheEntry;
-
-    return nsStr::StrCompare(*cacheEntry->mKey, *(nsCString *)key, -1, PR_FALSE) == 0;
-}
-
-
-void PR_CALLBACK
-nsCacheEntryHashTable::MoveEntry(PLDHashTable * /* table */,
-                                 const PLDHashEntryHdr *from,
-                                 PLDHashEntryHdr       *to)
-{
-    ((nsCacheEntryHashTableEntry *)to)->cacheEntry =
-        ((nsCacheEntryHashTableEntry *)from)->cacheEntry;
-}
-
-
-void PR_CALLBACK
-nsCacheEntryHashTable::ClearEntry(PLDHashTable * /* table */,
-                                  PLDHashEntryHdr * hashEntry)
-{
-    ((nsCacheEntryHashTableEntry *)hashEntry)->cacheEntry = 0;
-}
-

mozilla/netwerk/cache/src/nsCacheEntry.h

@@ -1,330 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheEntry.h, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-#ifndef _nsCacheEntry_h_
-#define _nsCacheEntry_h_
-
-#include "nsICache.h"
-#include "nsICacheEntryDescriptor.h"
-#include "nsCacheMetaData.h"
-
-#include "nspr.h"
-#include "pldhash.h"
-#include "nscore.h"
-#include "nsCOMPtr.h"
-#include "nsString.h"
-#include "nsAReadableString.h"
-#include "nsIEventQueue.h"
-
-
-class nsCacheDevice;
-class nsCacheMetaData;
-class nsCacheRequest;
-class nsCacheEntryDescriptor;
-
-/******************************************************************************
-* nsCacheEntry
-*******************************************************************************/
-class nsCacheEntry : public PRCList
-{
-public:
-
-    nsCacheEntry(nsCString *          key,
-                 PRBool               streamBased,
-                 nsCacheStoragePolicy storagePolicy);
-    ~nsCacheEntry();
-
-
-    static nsresult  Create( const char *          key,
-                             PRBool                streamBased,
-                             nsCacheStoragePolicy  storagePolicy,
-                             nsCacheDevice *       device,
-                             nsCacheEntry **       result);
-                                      
-    nsCString *  Key()  { return mKey; }
-
-    PRInt32  FetchCount()                              { return mFetchCount;}
-    void     SetFetchCount( PRInt32   count)           { mFetchCount = count;}
-    void     Fetched();
-
-    PRUint32 LastFetched()                             { return mLastFetched;}
-    void     SetLastFetched( PRUint32  lastFetched)    { mLastFetched = lastFetched;}
-
-    PRUint32 LastModified()                            { return mLastModified;}
-    void     SetLastModified( PRUint32 lastModified)   { mLastModified = lastModified;}
-
-    PRUint32 ExpirationTime()                     { return mExpirationTime;}
-    void     SetExpirationTime( PRUint32 expires) { mExpirationTime = expires;}
-
-    PRUint32 Size()                               { return mDataSize + mMetaSize; }
-
-    nsCacheDevice * CacheDevice()                            { return mCacheDevice;}
-    void            SetCacheDevice( nsCacheDevice * device)  { mCacheDevice = device;}
-    const char *    GetDeviceID();
-
-    /**
-     * Data accessors
-     */
-    nsresult GetData( nsISupports ** result);
-    void     SetData( nsISupports *  data)        { mData = data;}
-
-    PRUint32 DataSize()                           { return mDataSize;}
-    void     SetDataSize( PRUint32  size)         { mDataSize = size;}
-
-    void     TouchData();
-    
-    nsIEventQueue * GetEventQ()                         { return mEventQ;}
-    void            SetEventQ(nsIEventQueue * eventQ)   { mEventQ = dont_AddRef(eventQ);}
-
-    /**
-     * Meta data accessors
-     */
-    nsresult GetMetaDataElement( const nsAReadableCString&  key,
-                                 nsAReadableCString **      value);
-    nsresult SetMetaDataElement( const nsAReadableCString&  key,
-                                 const nsAReadableCString&  value);
-
-    nsresult VisitMetaDataElements( nsICacheMetaDataVisitor * visitor);
-
-    nsresult FlattenMetaData( char ** data,  PRUint32 * size);
-    nsresult UnflattenMetaData( char * data, PRUint32   size);
-
-    PRUint32 MetaDataSize()                       { return mMetaSize;}
-
-    void     TouchMetaData();
-
-
-    /**
-     * Security Info accessors
-     */
-    nsresult GetSecurityInfo( nsISupports ** result);
-    void     SetSecurityInfo( nsISupports *  info) { mSecurityInfo = info; }
-
-
-    // XXX enumerate MetaData method
-
-
-    enum CacheEntryFlags {
-        eStoragePolicyMask   = 0x000000FF,
-        eDoomedMask          = 0x00000100,
-        eEntryDirtyMask      = 0x00000200,
-        eDataDirtyMask       = 0x00000400,
-        eMetaDataDirtyMask   = 0x00000800,
-        eStreamDataMask      = 0x00001000,
-        eActiveMask          = 0x00002000,
-        eInitializedMask     = 0x00004000,
-        eValidMask           = 0x00008000,
-        eBindingMask         = 0x00010000
-    };
-    
-    void MarkBinding()         { mFlags |=  eBindingMask; }
-    void ClearBinding()        { mFlags &= ~eBindingMask; }
-    PRBool IsBinding()         { return (mFlags & eBindingMask) != 0; }
-
-    void MarkEntryDirty()      { mFlags |=  eEntryDirtyMask; }
-    void MarkEntryClean()      { mFlags &= ~eEntryDirtyMask; }
-    void MarkDataDirty()       { mFlags |=  eDataDirtyMask; }
-    void MarkDataClean()       { mFlags &= ~eDataDirtyMask; }
-    void MarkMetaDataDirty()   { mFlags |=  eMetaDataDirtyMask; }
-    void MarkMetaDataClean()   { mFlags &= ~eMetaDataDirtyMask; }
-    void MarkStreamData()      { mFlags |=  eStreamDataMask; }
-    void MarkValid()           { mFlags |=  eValidMask; }
-    void MarkInvalid()         { mFlags &= ~eValidMask; }
-    //    void MarkAllowedInMemory() { mFlags |=  eAllowedInMemoryMask; }
-    //    void MarkAllowedOnDisk()   { mFlags |=  eAllowedOnDiskMask; }
-
-    PRBool IsDoomed()          { return (mFlags & eDoomedMask) != 0; }
-    PRBool IsEntryDirty()      { return (mFlags & eEntryDirtyMask) != 0; }
-    PRBool IsDataDirty()       { return (mFlags & eDataDirtyMask) != 0; }
-    PRBool IsMetaDataDirty()   { return (mFlags & eMetaDataDirtyMask) != 0; }
-    PRBool IsStreamData()      { return (mFlags & eStreamDataMask) != 0; }
-    PRBool IsActive()          { return (mFlags & eActiveMask) != 0; }
-    PRBool IsInitialized()     { return (mFlags & eInitializedMask) != 0; }
-    PRBool IsValid()           { return (mFlags & eValidMask) != 0; }
-    PRBool IsInvalid()         { return (mFlags & eValidMask) == 0; }
-    PRBool IsInUse()           { return !(PR_CLIST_IS_EMPTY(&mRequestQ) &&
-                                          PR_CLIST_IS_EMPTY(&mDescriptorQ)); }
-    PRBool IsNotInUse()        { return (PR_CLIST_IS_EMPTY(&mRequestQ) &&
-                                         PR_CLIST_IS_EMPTY(&mDescriptorQ)); }
-
-
-    PRBool IsAllowedInMemory()
-    {
-        return (StoragePolicy() ==  nsICache::STORE_ANYWHERE) ||
-            (StoragePolicy() == nsICache::STORE_IN_MEMORY);
-    }
-
-    PRBool IsAllowedOnDisk()
-    {
-        return (StoragePolicy() == nsICache::STORE_ANYWHERE) ||
-            (StoragePolicy() == nsICache::STORE_ON_DISK) ||
-            (StoragePolicy() == nsICache::STORE_ON_DISK_AS_FILE);
-    }
-
-    nsCacheStoragePolicy  StoragePolicy()
-    {
-        return (nsCacheStoragePolicy)(mFlags & eStoragePolicyMask);
-    }
-
-    void SetStoragePolicy(nsCacheStoragePolicy policy)
-    {
-        NS_ASSERTION(policy <= 0xFF, "too many bits in nsCacheStoragePolicy");
-        mFlags &= ~eStoragePolicyMask; // clear storage policy bits
-        mFlags |= policy;
-    }
-
-
-    // methods for nsCacheService
-    nsresult RequestAccess( nsCacheRequest * request, nsCacheAccessMode *accessGranted);
-    nsresult CreateDescriptor( nsCacheRequest *           request,
-                               nsCacheAccessMode          accessGranted,
-                               nsICacheEntryDescriptor ** result);
-
-    //    nsresult Open(nsCacheRequest *request, nsICacheEntryDescriptor ** result);
-    //    nsresult AsyncOpen(nsCacheRequest *request);
-    PRBool   RemoveRequest( nsCacheRequest * request);
-    PRBool   RemoveDescriptor( nsCacheEntryDescriptor * descriptor);
-    
-private:
-    friend class nsCacheEntryHashTable;
-    friend class nsCacheService;
-
-    void     DetachDescriptors(void);
-
-    // internal methods
-    void MarkDoomed()          { mFlags |=  eDoomedMask; }
-    void MarkStreamBased()     { mFlags |=  eStreamDataMask; }
-    void MarkInitialized()     { mFlags |=  eInitializedMask; }
-    void MarkActive()          { mFlags |=  eActiveMask; }
-    void MarkInactive()        { mFlags &= ~eActiveMask; }
-
-    nsCString *             mKey;            // 4  // XXX ask scc about const'ness
-    PRUint32                mFetchCount;     // 4
-    PRUint32                mLastFetched;    // 4
-    PRUint32                mLastModified;   // 4
-    PRUint32                mLastValidated;  // 4
-    PRUint32                mExpirationTime; // 4
-    PRUint32                mFlags;          // 4
-    PRUint32                mDataSize;       // 4
-    PRUint32                mMetaSize;       // 4
-    nsCacheDevice *         mCacheDevice;    // 4
-    nsCOMPtr<nsISupports>   mSecurityInfo;   // 
-    nsCOMPtr<nsISupports>   mData;           // 
-    nsCOMPtr<nsIEventQueue> mEventQ;         // event queue for mData (for mem object cache)
-    nsCacheMetaData *       mMetaData;       // 4
-    PRCList                 mRequestQ;       // 8
-    PRCList                 mDescriptorQ;    // 8
-};
-
-
-/******************************************************************************
-* nsCacheEntryInfo
-*******************************************************************************/
-class nsCacheEntryInfo : public nsICacheEntryInfo {
-public:
-    NS_DECL_ISUPPORTS
-    NS_DECL_NSICACHEENTRYINFO
-
-    nsCacheEntryInfo(nsCacheEntry* entry)
-        :   mCacheEntry(entry)
-    {
-        NS_INIT_ISUPPORTS();
-    }
-
-    virtual ~nsCacheEntryInfo() {}
-    void    DetachEntry() { mCacheEntry = nsnull; }
-    
-private:
-    nsCacheEntry * mCacheEntry;
-};
-
-
-/******************************************************************************
-* nsCacheEntryHashTable
-*******************************************************************************/
-typedef struct {
-    PLDHashNumber  keyHash;
-    nsCacheEntry  *cacheEntry;
-} nsCacheEntryHashTableEntry;
-
-
-class nsCacheEntryHashTable
-{
-public:
-    nsCacheEntryHashTable();
-    ~nsCacheEntryHashTable();
-
-    nsresult      Init();
-    void          Shutdown();
-
-    nsCacheEntry *GetEntry( const nsCString * key);
-    nsresult      AddEntry( nsCacheEntry *entry);
-    void          RemoveEntry( nsCacheEntry *entry);
-    
-    // XXX enumerate entries?
-    class Visitor {
-    public:
-        virtual PRBool VisitEntry( nsCacheEntry *entry) = 0;
-    };
-    
-    void          VisitEntries( Visitor *visitor);
-    
-private:
-    friend class nsCacheService; // XXX redefine interface so this isn't necessary
-
-    // PLDHashTable operation callbacks
-    static const void *   PR_CALLBACK GetKey( PLDHashTable *table, PLDHashEntryHdr *entry);
-
-    static PLDHashNumber  PR_CALLBACK HashKey( PLDHashTable *table, const void *key);
-
-    static PRBool         PR_CALLBACK MatchEntry( PLDHashTable *           table,
-                                                  const PLDHashEntryHdr *  entry,
-                                                  const void *             key);
-
-    static void           PR_CALLBACK MoveEntry( PLDHashTable *table,
-                                                 const PLDHashEntryHdr *from,
-                                                 PLDHashEntryHdr       *to);
-
-    static void           PR_CALLBACK ClearEntry( PLDHashTable *table, PLDHashEntryHdr *entry);
-
-    static void           PR_CALLBACK Finalize( PLDHashTable *table);
-
-    static
-    PLDHashOperator       PR_CALLBACK FreeCacheEntries(PLDHashTable *    table,
-                                                       PLDHashEntryHdr * hdr,
-                                                       PRUint32          number,
-                                                       void *            arg);
-    static
-    PLDHashOperator       PR_CALLBACK VisitEntry(PLDHashTable *         table,
-                                                 PLDHashEntryHdr *      hdr,
-                                                 PRUint32               number,
-                                                 void *                 arg);
-                                     
-    // member variables
-    static PLDHashTableOps ops;
-    PLDHashTable           table;
-    PRBool                 initialized;
-};
-
-#endif // _nsCacheEntry_h_
-

mozilla/netwerk/cache/src/nsCacheEntryDescriptor.cpp

@@ -1,647 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheEntryDescriptor.cpp, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-#include "nsICache.h"
-#include "nsCache.h"
-#include "nsCacheService.h"
-#include "nsCacheEntryDescriptor.h"
-#include "nsCacheEntry.h"
-#include "nsReadableUtils.h"
-#include "nsIOutputStream.h"
-
-NS_IMPL_THREADSAFE_ISUPPORTS1(nsCacheEntryDescriptor, nsICacheEntryDescriptor)
-
-
-nsCacheEntryDescriptor::nsCacheEntryDescriptor(nsCacheEntry * entry,
-                                               nsCacheAccessMode accessGranted)
-    : mCacheEntry(entry),
-      mAccessGranted(accessGranted)
-{
-  NS_INIT_ISUPPORTS();
-  PR_INIT_CLIST(this);
-}
-
-
-nsCacheEntryDescriptor::~nsCacheEntryDescriptor()
-{
-    if (mCacheEntry)
-        Close();
-}
-
-
-nsresult
-nsCacheEntryDescriptor::Create(nsCacheEntry * entry, nsCacheAccessMode  accessGranted,
-                               nsICacheEntryDescriptor ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    nsresult rv = nsnull;
-    
-    nsCacheEntryDescriptor * descriptor =
-        new nsCacheEntryDescriptor(entry, accessGranted);
-
-    if (descriptor == nsnull)
-        return NS_ERROR_OUT_OF_MEMORY;
-
-    NS_ADDREF(descriptor);
-    rv = descriptor->QueryInterface(NS_GET_IID(nsICacheEntryDescriptor), (void**)result);
-    NS_RELEASE(descriptor);
-    return rv;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetClientID(char ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    return ClientIDFromCacheKey(*(mCacheEntry->Key()), result);
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetDeviceID(char ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    *result = nsCRT::strdup(mCacheEntry->GetDeviceID());
-    return *result ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetKey(char ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    return ClientKeyFromCacheKey(*(mCacheEntry->Key()), result);
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetFetchCount(PRInt32 *result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    *result = mCacheEntry->FetchCount();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetLastFetched(PRUint32 *result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    *result = mCacheEntry->LastFetched();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetLastModified(PRUint32 *result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    *result = mCacheEntry->LastModified();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetExpirationTime(PRUint32 *result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    *result = mCacheEntry->ExpirationTime();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::SetExpirationTime(PRUint32 expirationTime)
-{
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    mCacheEntry->SetExpirationTime(expirationTime);
-    mCacheEntry->MarkEntryDirty();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP nsCacheEntryDescriptor::IsStreamBased(PRBool *result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    *result = mCacheEntry->IsStreamData();  // XXX which name is better?
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP nsCacheEntryDescriptor::GetDataSize(PRUint32 *result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    *result = mCacheEntry->DataSize();
-    return NS_OK;
-}
-
-
-nsresult
-nsCacheEntryDescriptor::RequestDataSizeChange(PRInt32 deltaSize)
-{
-    nsresult  rv;
-    rv = nsCacheService::GlobalInstance()->OnDataSizeChange(mCacheEntry, deltaSize);
-    if (NS_SUCCEEDED(rv)) {
-        // XXX review for signed/unsigned math errors
-        PRUint32  newDataSize = mCacheEntry->DataSize() + deltaSize;
-        mCacheEntry->SetDataSize(newDataSize);
-        mCacheEntry->TouchData();
-    }
-    return rv;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::SetDataSize(PRUint32 dataSize)
-{
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    // XXX review for signed/unsigned math errors
-    PRInt32  deltaSize = dataSize - mCacheEntry->DataSize();
-
-    // this had better be NS_OK, this call instance is advisory
-    nsresult  rv = RequestDataSizeChange(deltaSize);
-    NS_ASSERTION(NS_SUCCEEDED(rv), "failed SetDataSize() on memory cache object!");
-    return rv;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetTransport(nsITransport ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)                  return NS_ERROR_NOT_AVAILABLE;
-    if (!mCacheEntry->IsStreamData())  return NS_ERROR_CACHE_DATA_IS_NOT_STREAM;
-
-    NS_ADDREF(*result = &mTransportWrapper);
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetCacheElement(nsISupports ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)                 return NS_ERROR_NOT_AVAILABLE;
-    if (mCacheEntry->IsStreamData())  return NS_ERROR_CACHE_DATA_IS_STREAM;
-
-    return mCacheEntry->GetData(result);
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::SetCacheElement(nsISupports * cacheElement)
-{
-    if (!mCacheEntry)                 return NS_ERROR_NOT_AVAILABLE;
-    if (mCacheEntry->IsStreamData())  return NS_ERROR_CACHE_DATA_IS_STREAM;
-
-    mCacheEntry->SetData(cacheElement);
-    mCacheEntry->TouchData();
-
-    return nsCacheService::GlobalInstance()->SetCacheElement(mCacheEntry, cacheElement);
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetAccessGranted(nsCacheAccessMode *result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    *result = mAccessGranted;
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetStoragePolicy(nsCacheStoragePolicy *result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-    
-    return mCacheEntry->StoragePolicy();
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::SetStoragePolicy(nsCacheStoragePolicy policy)
-{
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-    // XXX validate policy against session?
-    mCacheEntry->SetStoragePolicy(policy);
-    mCacheEntry->MarkEntryDirty();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetFile(nsIFile ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-    
-    return nsCacheService::GlobalInstance()->GetFileForEntry(mCacheEntry, result);
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetSecurityInfo(nsISupports ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    return mCacheEntry->GetSecurityInfo(result);
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::SetSecurityInfo(nsISupports * securityInfo)
-{
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    mCacheEntry->SetSecurityInfo(securityInfo);
-    mCacheEntry->MarkEntryDirty();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::Doom()
-{
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    return nsCacheService::GlobalInstance()->DoomEntry(mCacheEntry);
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::DoomAndFailPendingRequests(nsresult status)
-{
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::MarkValid()
-{
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    nsresult  rv;
-    rv = nsCacheService::GlobalInstance()->ValidateEntry(mCacheEntry);
-    return rv;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::Close()
-{
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    // tell nsCacheService we're going away
-    nsCacheService::GlobalInstance()->CloseDescriptor(this);
-    mCacheEntry = nsnull;
-
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::GetMetaDataElement(const char *key, char ** result)
-{
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    if (!key | !result) return NS_ERROR_NULL_POINTER;
-    nsAReadableCString *value;
-    *result = nsnull;
-
-    // XXX not thread safe    
-    nsresult rv = mCacheEntry->GetMetaDataElement(nsLiteralCString(key), &value);
-    if (NS_FAILED(rv)) return rv;
-
-    if (!value) return NS_ERROR_NOT_AVAILABLE;
-
-    *result = ToNewCString(*value);
-    if (!*result) return NS_ERROR_OUT_OF_MEMORY;
-
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::SetMetaDataElement(const char *key, const char *value)
-{
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    if (!key) return NS_ERROR_NULL_POINTER;
-    // XXX not thread safe
-    // XXX allow null value, for clearing key?
-    nsresult rv = mCacheEntry->SetMetaDataElement(nsLiteralCString(key),
-                                                  nsLiteralCString(value));
-    if (NS_SUCCEEDED(rv))
-        mCacheEntry->TouchMetaData();
-    return rv;
-}
-
-
-NS_IMETHODIMP
-nsCacheEntryDescriptor::VisitMetaData(nsICacheMetaDataVisitor * visitor)
-{
-    NS_ENSURE_ARG_POINTER(visitor);
-    if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    return mCacheEntry->VisitMetaDataElements(visitor);
-}
-
-
-/******************************************************************************
- * nsCacheTransportWrapper
- ******************************************************************************/
-
-// XXX NS_IMPL_ISUPPORTS1(nsCacheEntryDescriptor::nsTransportWrapper, nsITransport);
-NS_IMPL_QUERY_INTERFACE1(nsCacheEntryDescriptor::nsTransportWrapper, nsITransport)
-
-
-//  special AddRef and Release, because we are part of the descriptor
-#define GET_DESCRIPTOR_FROM_TRANSPORT_WRAPPER(_this) \
-        ((nsCacheEntryDescriptor*)((char*)(_this) - \
-                                   offsetof(nsCacheEntryDescriptor, mTransportWrapper)))
-
-NS_IMETHODIMP_(nsrefcnt) nsCacheEntryDescriptor::
-nsTransportWrapper::AddRef(void)
-{
-    return GET_DESCRIPTOR_FROM_TRANSPORT_WRAPPER(this)->AddRef();
-}
-
-NS_IMETHODIMP_(nsrefcnt) nsCacheEntryDescriptor::
-nsTransportWrapper::Release(void)
-{
-    return GET_DESCRIPTOR_FROM_TRANSPORT_WRAPPER(this)->Release();
-}
-
-
-nsresult nsCacheEntryDescriptor::
-nsTransportWrapper::EnsureTransportWithAccess(nsCacheAccessMode  mode)
-{
-    nsresult  rv = NS_OK;
-
-    nsCacheEntryDescriptor * descriptor = GET_DESCRIPTOR_FROM_TRANSPORT_WRAPPER(this);
-    if (!descriptor->mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-    if (!descriptor->mAccessGranted & mode) {
-        rv = (mode == nsICache::ACCESS_READ) ?
-            NS_ERROR_CACHE_READ_ACCESS_DENIED : NS_ERROR_CACHE_WRITE_ACCESS_DENIED;
-        return rv;
-    }
-
-    if (!mTransport) {
-        rv = nsCacheService::GlobalInstance()->
-            GetTransportForEntry(descriptor->mCacheEntry,
-                                 descriptor->mAccessGranted,
-                                 getter_AddRefs(mTransport));
-        if (NS_FAILED(rv))  return rv;
-    }
-    return NS_OK;
-}
-
-
-nsresult 
-nsCacheEntryDescriptor::NewOutputStreamWrapper(nsIOutputStream **       result,
-                                               nsCacheEntryDescriptor * descriptor,
-                                               nsIOutputStream *        output)
-{
-    nsOutputStreamWrapper* cacheOutput =
-        new nsOutputStreamWrapper(descriptor, output);
-    if (!cacheOutput) return NS_ERROR_OUT_OF_MEMORY;
-
-    nsCOMPtr<nsISupports> ref(cacheOutput);
-    nsresult              rv = cacheOutput->Init();
-    if (NS_FAILED(rv)) return rv;
-
-    NS_ADDREF(*result = cacheOutput);
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP nsCacheEntryDescriptor::
-nsTransportWrapper::GetSecurityInfo(nsISupports ** securityInfo)
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-NS_IMETHODIMP nsCacheEntryDescriptor::
-nsTransportWrapper::GetNotificationCallbacks(nsIInterfaceRequestor ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    // if (!mCacheEntry)  return NS_ERROR_NOT_AVAILABLE;
-
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-NS_IMETHODIMP nsCacheEntryDescriptor::
-nsTransportWrapper::SetNotificationCallbacks(nsIInterfaceRequestor * requestor,
-                                             PRUint32                flags)
-{
-    //    if (!mCacheEntry)       return NS_ERROR_NOT_AVAILABLE;
-
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-NS_IMETHODIMP nsCacheEntryDescriptor::
-nsTransportWrapper::OpenInputStream(PRUint32           offset,
-                                    PRUint32           count,
-                                    PRUint32           flags,
-                                    nsIInputStream  ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-
-    nsresult  rv = EnsureTransportWithAccess(nsICache::ACCESS_READ);
-    if (NS_FAILED(rv)) return rv;
-    
-    return mTransport->OpenInputStream(offset, count, flags, result);
-}
-
-
-NS_IMETHODIMP nsCacheEntryDescriptor::
-nsTransportWrapper::OpenOutputStream(PRUint32            offset,
-                                     PRUint32            count,
-                                     PRUint32            flags,
-                                     nsIOutputStream  ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-
-    nsresult  rv = EnsureTransportWithAccess(nsICache::ACCESS_WRITE);
-    if (NS_FAILED(rv))  return rv;
-
-    // XXX allow more than one output stream at a time on a descriptor?  Why?  
-
-    // Create the underlying output stream using the wrapped transport.
-    nsCOMPtr<nsIOutputStream> output;    
-    rv = mTransport->OpenOutputStream(offset, count, flags, getter_AddRefs(output));
-    if (NS_FAILED(rv)) return rv;    
-
-    // Wrap this output stream with a stream that monitors how much data gets written,
-    // maintains the cache entry's size, and informs the cache device.
-    // This mechanism provides a way for the cache device to enforce space limits,
-    // and to drive cache entry eviction.
-    nsCacheEntryDescriptor * descriptor = GET_DESCRIPTOR_FROM_TRANSPORT_WRAPPER(this);
-    
-    // reset datasize of entry based on offset so OnWrite calculates delta changes correctly.
-    rv = descriptor->SetDataSize(offset);
-    if (NS_FAILED(rv)) return rv;
-    
-    return NewOutputStreamWrapper(result, descriptor, output);
-}
-
-
-NS_IMETHODIMP nsCacheEntryDescriptor::
-nsTransportWrapper::AsyncRead(nsIStreamListener * listener,
-                              nsISupports *       ctxt,
-                              PRUint32            offset,
-                              PRUint32            count,
-                              PRUint32            flags,
-                              nsIRequest       ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-
-    nsresult  rv = EnsureTransportWithAccess(nsICache::ACCESS_READ);
-    if (NS_FAILED(rv))  return rv;
-    
-    return mTransport->AsyncRead(listener, ctxt, offset, count, flags, result);
-}
-
-
-NS_IMETHODIMP nsCacheEntryDescriptor::
-nsTransportWrapper::AsyncWrite(nsIStreamProvider * provider,
-                               nsISupports *       ctxt,
-                               PRUint32            offset, 
-                               PRUint32            count, 
-                               PRUint32            flags, 
-                               nsIRequest       ** result)
-{
-    // we're not planning on implementing this
-    return NS_ERROR_NOT_IMPLEMENTED;
-
-#if 0
-    NS_ENSURE_ARG_POINTER(result);
-
-    nsresult rv = EnsureTransportWithAccess(nsICache::ACCESS_WRITE);
-    if (NS_FAILED(rv)) return rv;
-    
-    return mTransport->AsyncWrite(provider, ctxt, offset, count, flags, result);
-#endif
-}
-
-
-/******************************************************************************
- * nsCacheOutputStream - a wrapper for nsIOutputstream to track the amount of
- *                       data written to a cache entry.
- ******************************************************************************/
-
-NS_IMPL_ISUPPORTS1(nsCacheEntryDescriptor::nsOutputStreamWrapper, nsIOutputStream);
-
-nsresult nsCacheEntryDescriptor::
-nsOutputStreamWrapper::Init()
-{
-    nsCacheAccessMode mode;
-    nsresult rv = mDescriptor->GetAccessGranted(&mode);
-    if (NS_FAILED(rv)) return rv;
-
-    if (mode == nsICache::ACCESS_WRITE) {
-        nsCacheEntry* cacheEntry = mDescriptor->CacheEntry();
-        if (!cacheEntry) return NS_ERROR_NOT_AVAILABLE;
-
-        nsCacheDevice* device = cacheEntry->CacheDevice();
-        if (!device) return NS_ERROR_NOT_AVAILABLE;
-
-        // the entry has been truncated to zero bytes, inform the device.
-        PRInt32 delta = -cacheEntry->DataSize();
-        rv = device->OnDataSizeChange(cacheEntry, delta);
-        cacheEntry->SetDataSize(0);
-    }
-    return rv;
-}
-
-
-NS_IMETHODIMP nsCacheEntryDescriptor::
-nsOutputStreamWrapper::Write(const char * buf,
-                             PRUint32     count,
-                             PRUint32 *   result)
-{
-    nsresult rv = OnWrite(count);
-    if (NS_FAILED(rv)) return rv;
-    return mOutput->Write(buf, count, result);
-}
-
-
-NS_IMETHODIMP nsCacheEntryDescriptor::
-nsOutputStreamWrapper::WriteFrom(nsIInputStream * inStr,
-                                 PRUint32         count,
-                                 PRUint32 *       result)
-{
-    nsresult rv = OnWrite(count);
-    if (NS_FAILED(rv)) return rv;
-    return mOutput->WriteFrom(inStr, count, result);
-}
-
-
-NS_IMETHODIMP nsCacheEntryDescriptor::
-nsOutputStreamWrapper::WriteSegments(nsReadSegmentFun  reader,
-                                    void *            closure,
-                                    PRUint32          count,
-                                    PRUint32 *        result)
-{
-    nsresult rv = OnWrite(count);
-    if (NS_FAILED(rv)) return rv;
-    return mOutput->WriteSegments(reader, closure, count, result);
-}
-
-
-nsresult nsCacheEntryDescriptor::
-nsOutputStreamWrapper::OnWrite(PRUint32 count)
-{
-    // XXX if count > 2^31 error_write_too_big
-    return mDescriptor->RequestDataSizeChange((PRInt32)count);
-}
-
-

mozilla/netwerk/cache/src/nsCacheEntryDescriptor.h

@@ -1,167 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheEntryDescriptor.h, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-
-#ifndef _nsCacheEntryDescriptor_h_
-#define _nsCacheEntryDescriptor_h_
-
-#include "nsICacheEntryDescriptor.h"
-#include "nsCacheEntry.h"
-#include "nsIOutputStream.h"
-#include "nsITransport.h"
-
-/******************************************************************************
-* nsCacheEntryDescriptor
-*******************************************************************************/
-class nsCacheEntryDescriptor :
-    public PRCList,
-    public nsICacheEntryDescriptor
-{
-public:
-    NS_DECL_ISUPPORTS
-    NS_DECL_NSICACHEENTRYDESCRIPTOR
-    NS_DECL_NSICACHEENTRYINFO
-    
-    nsCacheEntryDescriptor(nsCacheEntry * entry, nsCacheAccessMode  mode);
-    virtual ~nsCacheEntryDescriptor();
-    
-    static nsresult Create(nsCacheEntry * entry, nsCacheAccessMode  accessGranted,
-                           nsICacheEntryDescriptor ** result);
-
-
-    /**
-     * utility method to attempt changing data size of associated entry
-     */
-    nsresult  RequestDataSizeChange(PRInt32 deltaSize);
-    
-    /**
-     * methods callbacks for nsCacheService
-     */
-    nsCacheEntry * CacheEntry(void)      { return mCacheEntry; }
-    void           ClearCacheEntry(void) { mCacheEntry = nsnull; }
-
-private:
-
-     /*************************************************************************
-      * transport wrapper class - 
-      *
-      * we want the transport wrapper to have the same lifetime as the
-      * descriptor, but since they each need to reference the other, we have the
-      * descriptor include the transport wrapper as a member, rather than just
-      * pointing to it, which avoids circular AddRefs.
-      *************************************************************************/
-     class nsTransportWrapper : public nsITransport
-     {
-     public:
-         NS_DECL_ISUPPORTS_INHERITED
-         NS_DECL_NSITRANSPORT
-
-         nsTransportWrapper() : mTransport(nsnull) {}
-         virtual ~nsTransportWrapper() {}
-
-         nsresult EnsureTransportWithAccess(nsCacheAccessMode  mode);
-
-         nsCOMPtr<nsITransport>   mTransport;
-     }; // end of class nsTransportWrapper
-     friend class nsTransportWrapper;
-
-
-     /*************************************************************************
-      * output stream wrapper class -
-      *
-      * The output stream wrapper references the descriptor, but the descriptor
-      * doesn't need any references to the stream wrapper, so we don't need the
-      * same kind of tricks that we're using for the transport wrapper.
-      *************************************************************************/
-     class nsOutputStreamWrapper : public nsIOutputStream {
-     private:
-         nsCacheEntryDescriptor *  mDescriptor;
-         nsCOMPtr<nsIOutputStream> mOutput;
-     public:
-         NS_DECL_ISUPPORTS
-         // NS_DECL_NSIOUTPUTSTREAM
-         NS_IMETHOD Close(void) { return mOutput->Close(); }
-         NS_IMETHOD Flush(void) { return mOutput->Flush(); }
-
-         NS_IMETHOD Write(const char * buf,
-                          PRUint32     count,
-                          PRUint32 *   result);
-
-         NS_IMETHOD WriteFrom(nsIInputStream * inStr,
-                              PRUint32         count,
-                              PRUint32 *       result);
-
-         NS_IMETHOD WriteSegments(nsReadSegmentFun reader,
-                                  void *           closure,
-                                  PRUint32         count,
-                                  PRUint32 *       result);
-
-         NS_IMETHOD GetNonBlocking(PRBool * nonBlocking)
-         { return mOutput->GetNonBlocking(nonBlocking); }
-
-         NS_IMETHOD SetNonBlocking(PRBool nonBlocking)
-         { return mOutput->SetNonBlocking(nonBlocking); }
-
-         NS_IMETHOD GetObserver(nsIOutputStreamObserver ** observer)
-         { return mOutput->GetObserver(observer); }
-
-         NS_IMETHOD SetObserver(nsIOutputStreamObserver * observer)
-         { return mOutput->SetObserver(observer); }
-
-         nsOutputStreamWrapper(nsCacheEntryDescriptor * descriptor,
-                               nsIOutputStream *        output)
-             : mDescriptor(nsnull), mOutput(output)
-         {
-             NS_INIT_ISUPPORTS();
-             NS_ADDREF(mDescriptor = descriptor);
-         }
-    
-         virtual ~nsOutputStreamWrapper()
-         {
-             NS_RELEASE(mDescriptor);
-         }
-    
-         nsresult Init();
-
-
-     private:
-         nsresult OnWrite(PRUint32 count);
-     }; // end of class nsOutputStreamWrapper
-     friend class nsOutputStreamWrapper;
-
-
-
-     static nsresult NewOutputStreamWrapper(nsIOutputStream **       result,
-                                            nsCacheEntryDescriptor * descriptor,
-                                            nsIOutputStream *        output);
- private:
-     /**
-      * nsCacheEntryDescriptor data members
-      */
-     nsCacheEntry          * mCacheEntry; // we are a child of the entry
-     nsCacheAccessMode       mAccessGranted;
-     nsTransportWrapper      mTransportWrapper;
-};
-
-
-#endif // _nsCacheEntryDescriptor_h_

mozilla/netwerk/cache/src/nsCacheMetaData.cpp

@@ -1,327 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheMetaData.cpp, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-#include "nsCacheMetaData.h"
-#include "nsString.h"
-#include "nsICacheEntryDescriptor.h"
-
-
-/*
- *  nsCacheClientHashTable
- */
-
-PLDHashTableOps
-nsCacheMetaData::ops =
-{
-    PL_DHashAllocTable,
-    PL_DHashFreeTable,
-    GetKey,
-    HashKey,
-    MatchEntry,
-    MoveEntry,
-    ClearEntry,
-    Finalize
-};
-
-
-nsCacheMetaData::nsCacheMetaData()
-    : initialized(PR_FALSE)
-{
-}
-
-nsCacheMetaData::~nsCacheMetaData()
-{
-    if (initialized)
-        PL_DHashTableFinish(&table);
-}
-
-
-nsresult
-nsCacheMetaData::Init()
-{
-    nsresult rv = NS_OK;
-    initialized = PL_DHashTableInit(&table, &ops, nsnull,
-                                    sizeof(nsCacheMetaDataHashTableEntry), 16);
-
-    if (!initialized) rv = NS_ERROR_OUT_OF_MEMORY;
-    return rv;
-}
-
-
-nsCacheMetaData *
-nsCacheMetaData::Create()
-{
-    nsCacheMetaData * metaData = new nsCacheMetaData();
-    if (!metaData)
-        return nsnull;
-
-    nsresult rv = metaData->Init();
-    if (NS_FAILED(rv)) {
-        delete metaData;
-        return nsnull;
-    }
-
-    return metaData;
-}
-
-
-nsAReadableCString *
-nsCacheMetaData::GetElement(const nsAReadableCString * key)
-{
-    PLDHashEntryHdr * hashEntry;
-    nsCString *       result = nsnull;
-
-    // XXX need to copy string until we have scc's new flat string abstract class
-    // XXX see nsCacheMetaData::HashKey below (bug 70075)
-    nsCString * tempKey = new nsCString(*key);
-    if (!tempKey) return result;
-
-    NS_ASSERTION(initialized, "nsCacheMetaDataHashTable not initialized");
-    hashEntry = PL_DHashTableOperate(&table, tempKey, PL_DHASH_LOOKUP);
-    if (PL_DHASH_ENTRY_IS_BUSY(hashEntry)) {
-        result = ((nsCacheMetaDataHashTableEntry *)hashEntry)->value;
-    }
-
-    delete tempKey;
-    return result;
-}
-
-
-nsresult
-nsCacheMetaData::SetElement(const nsAReadableCString& key,
-                            const nsAReadableCString& value)
-{
-    nsCacheMetaDataHashTableEntry * metaEntry;
-    nsresult  rv = NS_ERROR_OUT_OF_MEMORY;  // presume the worst
-
-    NS_ASSERTION(initialized, "nsCacheMetaDataHashTable not initialized");
-
-    // XXX need to copy string until we have scc's new flat string abstract class
-    // XXX see nsCacheMetaData::HashKey below (bug 70075)
-    nsCString * tempKey = new nsCString(key);
-    if (!tempKey) return rv;
-
-    // XXX should empty value remove the key?
-
-    metaEntry = (nsCacheMetaDataHashTableEntry *)
-        PL_DHashTableOperate(&table, tempKey, PL_DHASH_ADD);
-    if (!metaEntry) goto error_exit;
-
-
-    if (metaEntry->key == nsnull) {
-        metaEntry->key = new nsCString(key);
-        if (metaEntry->key == nsnull) {
-            goto error_exit;
-        }
-    }
-    if (metaEntry->value != nsnull)
-        delete metaEntry->value;  // clear the old value
-
-    metaEntry->value = new nsCString(value);
-    if (metaEntry->value == nsnull) {
-        // XXX remove key?
-        goto error_exit;
-    }
-
-    rv = NS_OK;
- error_exit:
-    delete tempKey;
-    return rv;
-}
-
-
-PRUint32
-nsCacheMetaData::Size(void)
-{
-    PRUint32 size = 0;
-    (void) PL_DHashTableEnumerate(&table, CalculateSize, &size);
-    return size;
-}
-
-
-nsresult
-nsCacheMetaData::FlattenMetaData(char ** data, PRUint32 * size)
-{
-    *size = 0;
-
-    if (PL_DHashTableEnumerate(&table, CalculateSize, size) != 0 && data) {
-        *data = new char[*size];
-        if (*data == nsnull) return NS_ERROR_OUT_OF_MEMORY;
-        char* state = *data;
-        PL_DHashTableEnumerate(&table, AccumulateElement, &state);
-    }
-
-    return NS_OK;
-}
-
-nsresult
-nsCacheMetaData::UnflattenMetaData(char * data, PRUint32 size)
-{
-    nsresult rv = NS_ERROR_UNEXPECTED;
-    char* limit = data + size;
-    while (data < limit) {
-        const char* name = data;
-        PRUint32 nameSize = nsCRT::strlen(name);
-        data += 1 + nameSize;
-        if (data < limit) {
-            const char* value = data;
-            PRUint32 valueSize = nsCRT::strlen(value);
-            data += 1 + valueSize;
-            rv = SetElement(nsLocalCString(name, nameSize),
-                                   nsLocalCString(value, valueSize));
-            if (NS_FAILED(rv)) break;
-        }
-    }
-    return rv;
-}
-
-
-nsresult
-nsCacheMetaData::VisitElements(nsICacheMetaDataVisitor * visitor)
-{
-    (void) PL_DHashTableEnumerate(&table, VisitElement, visitor);
-    return NS_OK;
-}
-
-
-/*
- *  hash table operation callback functions
- */
-
-const void * PR_CALLBACK
-nsCacheMetaData::GetKey( PLDHashTable * /* table */, PLDHashEntryHdr *hashEntry)
-{
-    return ((nsCacheMetaDataHashTableEntry *)hashEntry)->key;
-}
-
-
-PLDHashNumber PR_CALLBACK
-nsCacheMetaData::HashKey( PLDHashTable * table, const void *key)
-{
-    // XXX need scc's new flat string abstract class here (bug 70075)
-    return PL_DHashStringKey(table, ((nsCString *)key)->get());
-}
-
-
-PRBool PR_CALLBACK
-nsCacheMetaData::MatchEntry(PLDHashTable *       /* table */,
-				     const PLDHashEntryHdr * hashEntry,
-				     const void *            key)
-{
-    NS_ASSERTION(key !=  nsnull, "### nsCacheMetaDataHashTable::MatchEntry : null key");
-    nsCString * entryKey = ((nsCacheMetaDataHashTableEntry *)hashEntry)->key;
-    NS_ASSERTION(entryKey, "### hashEntry->key == nsnull");
-
-    return entryKey->Equals(*NS_STATIC_CAST(const nsAReadableCString*,key));
-}
-
-
-void PR_CALLBACK
-nsCacheMetaData::MoveEntry(PLDHashTable * /* table */,
-				    const PLDHashEntryHdr *from,
-				    PLDHashEntryHdr       *to)
-{
-    ((nsCacheMetaDataHashTableEntry *)to)->key =
-        ((nsCacheMetaDataHashTableEntry *)from)->key;
-    ((nsCacheMetaDataHashTableEntry *)to)->value =
-        ((nsCacheMetaDataHashTableEntry *)from)->value;
-}
-
-
-void PR_CALLBACK
-nsCacheMetaData::ClearEntry(PLDHashTable * /* table */,
-                            PLDHashEntryHdr * hashEntry)
-{
-    ((nsCacheMetaDataHashTableEntry *)hashEntry)->key      = 0;
-    ((nsCacheMetaDataHashTableEntry *)hashEntry)->value    = 0;
-}
-
-
-void PR_CALLBACK
-nsCacheMetaData::Finalize(PLDHashTable * table)
-{
-    (void) PL_DHashTableEnumerate(table, FreeElement, nsnull);   
-}
-
-
-/**
- * hash table enumeration callback functions
- */
-
-PLDHashOperator PR_CALLBACK
-nsCacheMetaData::CalculateSize(PLDHashTable *table,
-                               PLDHashEntryHdr *hdr,
-                               PRUint32 number,
-                               void *arg)
-{
-    nsCacheMetaDataHashTableEntry* hashEntry = (nsCacheMetaDataHashTableEntry *)hdr;
-    *(PRUint32*)arg += (2 + hashEntry->key->Length() + hashEntry->value->Length());
-    return PL_DHASH_NEXT;
-}
-
-PLDHashOperator PR_CALLBACK
-nsCacheMetaData::AccumulateElement(PLDHashTable *table,
-                                 PLDHashEntryHdr *hdr,
-                                 PRUint32 number,
-                                 void *arg)
-{
-    char** bufferPtr = (char**) arg;
-    nsCacheMetaDataHashTableEntry* hashEntry = (nsCacheMetaDataHashTableEntry *)hdr;
-    PRUint32 size = 1 + hashEntry->key->Length();
-    nsCRT::memcpy(*bufferPtr, hashEntry->key->get(), size);
-    *bufferPtr += size;
-    size = 1 + hashEntry->value->Length();
-    nsCRT::memcpy(*bufferPtr, hashEntry->value->get(), size);
-    *bufferPtr += size;
-    return PL_DHASH_NEXT;
-}
-
-PLDHashOperator PR_CALLBACK
-nsCacheMetaData::FreeElement(PLDHashTable *table,
-                              PLDHashEntryHdr *hdr,
-                              PRUint32 number,
-                              void *arg)
-{
-    nsCacheMetaDataHashTableEntry *entry = (nsCacheMetaDataHashTableEntry *)hdr;
-    delete entry->key;
-    delete entry->value;
-    return PL_DHASH_NEXT;
-}
-
-
-PLDHashOperator PR_CALLBACK
-nsCacheMetaData::VisitElement(PLDHashTable *table,
-                              PLDHashEntryHdr *hdr,
-                              PRUint32 number,
-                              void *arg)
-{
-    nsCacheMetaDataHashTableEntry *entry   = (nsCacheMetaDataHashTableEntry *)hdr;
-    nsICacheMetaDataVisitor       *visitor = (nsICacheMetaDataVisitor *)arg;
-    const char * key   = entry->key   ? entry->key->get()   : nsnull;
-    const char * value = entry->value ? entry->value->get() : nsnull;
-    
-    PRBool keepGoing;
-    nsresult rv = visitor->VisitMetaDataElement(key, value, &keepGoing);
-
-    return NS_SUCCEEDED(rv) && keepGoing ? PL_DHASH_NEXT : PL_DHASH_STOP;
-}

mozilla/netwerk/cache/src/nsCacheMetaData.h

@@ -1,119 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheMetaData.h, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-#ifndef _nsCacheMetaData_h_
-#define _nsCacheMetaData_h_
-
-#include "nspr.h"
-#include "pldhash.h"
-#include "nscore.h"
-// #include "nsCOMPtr.h"
-#include "nsString.h"
-// #include "nsAReadableString.h"
-
-class nsICacheMetaDataVisitor;
-
-typedef struct {
-    nsCString *  key;
-    nsCString *  value;
-} nsCacheMetaDataKeyValuePair;
-
-
-typedef struct {
-  PLDHashNumber  keyHash;
-  nsCString *    key;
-  nsCString *    value;
-} nsCacheMetaDataHashTableEntry;
-
-
-class nsCacheMetaData {
-public:
-    nsCacheMetaData();
-    ~nsCacheMetaData();
-
-    static
-    nsCacheMetaData *     Create(void);
-
-    nsresult              Init(void);
-
-    nsAReadableCString *  GetElement(const nsAReadableCString * key);
-
-    nsresult              SetElement(const nsAReadableCString& key,
-                                     const nsAReadableCString& value);
-
-    PRUint32              Size(void);
-
-    nsresult              FlattenMetaData(char ** data, PRUint32 * size);
-    
-    nsresult              UnflattenMetaData(char * data, PRUint32 size);
-
-    nsresult              VisitElements(nsICacheMetaDataVisitor * visitor);
-
-private:
-    // PLDHashTable operation callbacks
-    static const void *   PR_CALLBACK GetKey( PLDHashTable *table, PLDHashEntryHdr *entry);
-
-    static PLDHashNumber  PR_CALLBACK HashKey( PLDHashTable *table, const void *key);
-
-    static PRBool         PR_CALLBACK MatchEntry( PLDHashTable *           table,
-                                                  const PLDHashEntryHdr *  entry,
-                                                  const void *             key);
-
-    static void           PR_CALLBACK MoveEntry( PLDHashTable *table,
-                                                 const PLDHashEntryHdr *from,
-                                                 PLDHashEntryHdr       *to);
-
-    static void           PR_CALLBACK ClearEntry( PLDHashTable *table, PLDHashEntryHdr *entry);
-
-    static void           PR_CALLBACK Finalize( PLDHashTable *table);
-
-    static
-    PLDHashOperator       PR_CALLBACK CalculateSize(PLDHashTable *table,
-                                                    PLDHashEntryHdr *hdr,
-                                                    PRUint32 number,
-                                                    void *arg);
-
-    static
-    PLDHashOperator       PR_CALLBACK AccumulateElement(PLDHashTable *table,
-                                                         PLDHashEntryHdr *hdr,
-                                                         PRUint32 number,
-                                                         void *arg);
-
-    static
-    PLDHashOperator       PR_CALLBACK FreeElement(PLDHashTable *table,
-                                                   PLDHashEntryHdr *hdr,
-                                                   PRUint32 number,
-                                                   void *arg);
-    static
-    PLDHashOperator       PR_CALLBACK VisitElement(PLDHashTable *table,
-                                                    PLDHashEntryHdr *hdr,
-                                                    PRUint32 number,
-                                                    void *arg);
-
-    // member variables
-    static PLDHashTableOps ops;
-    PLDHashTable           table;
-    PRBool                 initialized;
-};
-
-#endif // _nsCacheMetaData_h

mozilla/netwerk/cache/src/nsCacheModule.cpp

@@ -1,41 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheModule.cpp, released February 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *  Patrick C. Beard <beard@netscape.com>
- *  Gordon Sheridan  <gordon@netscape.com>
- */
-
-#include "nsIGenericFactory.h"
-#include "nsCacheService.h"
-#include "nsNetCID.h"
-
-// nsCacheService
-//
-
-static nsModuleComponentInfo gResComponents[] = {
-    {
-        NS_CACHESERVICE_CLASSNAME,
-        NS_CACHESERVICE_CID,
-        NS_CACHESERVICE_CONTRACTID,
-        nsCacheService::Create
-    }
-};
-
-NS_IMPL_NSGETMODULE(cacheservice, gResComponents)

mozilla/netwerk/cache/src/nsCacheRequest.h

@@ -1,178 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheRequest.h, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-#ifndef _nsCacheRequest_h_
-#define _nsCacheRequest_h_
-
-#include "nspr.h"
-#include "nsCOMPtr.h"
-#include "nsICache.h"
-#include "nsICacheListener.h"
-#include "nsIEventQueue.h"
-#include "nsCacheSession.h"
-
-
-class nsCacheRequest : public PRCList
-{
-private:
-    friend class nsCacheService;
-    friend class nsCacheEntry;
-
-    nsCacheRequest( nsCString *           key, 
-                    nsICacheListener *    listener,
-                    nsCacheAccessMode     accessRequested,
-                    PRBool                blockingMode,
-                    nsCacheSession *      session)
-        : mKey(key),
-          mInfo(0),
-          mListener(listener),
-          mEventQ(nsnull),
-          mLock(nsnull),
-          mCondVar(nsnull)
-    {
-        PR_INIT_CLIST(this);
-        SetAccessRequested(accessRequested);
-        SetStoragePolicy(session->StoragePolicy());
-        if (session->IsStreamBased())             MarkStreamBased();
-        if (session->WillDoomEntriesIfExpired())  MarkDoomEntriesIfExpired();
-        if (blockingMode == nsICache::BLOCKING)    MarkBlockingMode();
-        MarkWaitingForValidation();
-    }
-    
-    ~nsCacheRequest()
-    {
-        delete mKey;
-        if (mLock)    PR_DestroyLock(mLock);
-        if (mCondVar) PR_DestroyCondVar(mCondVar);
-        NS_ASSERTION(PR_CLIST_IS_EMPTY(this), "request still on a list");
-    }
-    
-    /**
-     * Simple Accessors
-     */
-    enum CacheRequestInfo {
-        eStoragePolicyMask         = 0x000000FF,
-        eStreamBasedMask           = 0x00000100,
-        eDoomEntriesIfExpiredMask  = 0x00001000,
-        eBlockingModeMask          = 0x00010000,
-        eWaitingForValidationMask  = 0x00100000,
-        eAccessRequestedMask       = 0xFF000000
-    };
-
-    void SetAccessRequested(nsCacheAccessMode mode)
-    {
-        NS_ASSERTION(mode <= 0xFF, "too many bits in nsCacheAccessMode");
-        mInfo &= ~eAccessRequestedMask;
-        mInfo |= mode << 24;
-    }
-
-    nsCacheAccessMode AccessRequested()
-    {
-        return (nsCacheAccessMode)((mInfo >> 24) & 0xFF);
-    }
-
-    void MarkStreamBased()      { mInfo |=  eStreamBasedMask; }
-    PRBool IsStreamBased()      { return (mInfo & eStreamBasedMask) != 0; }
-
-
-    void   MarkDoomEntriesIfExpired()   { mInfo |=  eDoomEntriesIfExpiredMask; }
-    PRBool WillDoomEntriesIfExpired()   { return (mInfo & eDoomEntriesIfExpiredMask); }
-    
-    void   MarkBlockingMode()           { mInfo |= eBlockingModeMask; }
-    PRBool IsBlocking()                 { return  (mInfo & eBlockingModeMask); }
-    PRBool IsNonBlocking()              { return !(mInfo & eBlockingModeMask); }
-
-    void SetStoragePolicy(nsCacheStoragePolicy policy)
-    {
-        NS_ASSERTION(policy <= 0xFF, "too many bits in nsCacheStoragePolicy");
-        mInfo &= ~eStoragePolicyMask;  // clear storage policy bits
-        mInfo |= policy;         // or in new bits
-    }
-
-    nsCacheStoragePolicy StoragePolicy()
-    {
-        return (nsCacheStoragePolicy)(mInfo & 0xFF);
-    }
-
-    void   MarkWaitingForValidation() { mInfo |=  eWaitingForValidationMask; }
-    void   DoneWaitingForValidation() { mInfo &= ~eWaitingForValidationMask; }
-    PRBool WaitingForValidation()
-    {
-        return (mInfo & eWaitingForValidationMask) != 0;
-    }
-
-    nsresult
-    WaitForValidation(void)
-    {
-        if (!WaitingForValidation()) {   // flag already cleared
-            MarkWaitingForValidation();  // set up for next time
-            return NS_OK;                // early exit;
-        }
-
-        if (!mLock) {
-            mLock = PR_NewLock();
-            if (!mLock) return NS_ERROR_OUT_OF_MEMORY;
-
-            NS_ASSERTION(!mCondVar,"we have mCondVar, but didn't have mLock?");
-            mCondVar = PR_NewCondVar(mLock);
-            if (!mCondVar) {
-                PR_DestroyLock(mLock);
-                return NS_ERROR_OUT_OF_MEMORY;
-            }
-        }
-        PRStatus status = PR_SUCCESS;
-        PR_Lock(mLock);
-        while (WaitingForValidation() && (status == PR_SUCCESS) ) {
-            status = PR_WaitCondVar(mCondVar, PR_INTERVAL_NO_TIMEOUT);
-        }
-        MarkWaitingForValidation();  // set up for next time
-        PR_Unlock(mLock);
-        
-        NS_ASSERTION(status == PR_SUCCESS, "PR_WaitCondVar() returned PR_FAILURE?");
-        if (status == PR_FAILURE)
-            return NS_ERROR_UNEXPECTED;
-
-        return NS_OK;
-    }
-
-    void WakeUp(void) {
-        DoneWaitingForValidation();
-        if (mLock) {
-        PR_Lock(mLock);
-        PR_NotifyCondVar(mCondVar);
-        PR_Unlock(mLock);
-        }
-    }
-
-    /**
-     * Data members
-     */
-    nsCString *                mKey;
-    PRUint32                   mInfo;
-    nsCOMPtr<nsICacheListener> mListener;
-    nsCOMPtr<nsIEventQueue>    mEventQ;
-    PRLock *                   mLock;
-    PRCondVar *                mCondVar;
-};
-
-#endif // _nsCacheRequest_h_

mozilla/netwerk/cache/src/nsCacheService.h

@@ -1,194 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheService.h, released February 10, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan  <gordon@netscape.com>
- *    Patrick C. Beard <beard@netscape.com>
- *    Darin Fisher     <darin@netscape.com>
- */
-
-
-#ifndef _nsCacheService_h_
-#define _nsCacheService_h_
-
-#include "nsICacheService.h"
-#include "nsCacheSession.h"
-#include "nsCacheDevice.h"
-#include "nsCacheEntry.h"
-
-#include "nspr.h"
-#include "nsIObserver.h"
-#include "nsString.h"
-#include "nsIEventQueueService.h"
-#include "nsProxiedService.h"
-
-class nsCacheRequest;
-
-
-/******************************************************************************
- *  nsCacheService
- ******************************************************************************/
-
-class nsCacheService : public nsICacheService, public nsIObserver
-{
-public:
-    NS_DECL_ISUPPORTS
-    NS_DECL_NSICACHESERVICE
-    NS_DECL_NSIOBSERVER
-    
-    nsCacheService();
-    virtual ~nsCacheService();
-
-    // Define a Create method to be used with a factory:
-    static NS_METHOD
-    Create(nsISupports* outer, const nsIID& iid, void* *result);
-
-
-    /**
-     * Methods called by nsCacheSession
-     */
-    nsresult         OpenCacheEntry(nsCacheSession *           session,
-                                    const char *               key,
-                                    nsCacheAccessMode          accessRequested,
-                                    PRBool                     blockingMode,
-                                    nsICacheListener *         listener,
-                                    nsICacheEntryDescriptor ** result);
-
-    nsresult         EvictEntriesForSession(nsCacheSession *   session);
-
-    nsresult         EvictEntriesForClient(const char *          clientID,
-                                           nsCacheStoragePolicy  storagePolicy);
-
-    /**
-     * Methods called by nsCacheEntryDescriptor
-     */
-    nsresult         SetCacheElement(nsCacheEntry * entry, nsISupports * element);
-
-    nsresult         OnDataSizeChange(nsCacheEntry * entry, PRInt32 deltaSize);
-
-    nsresult         ValidateEntry(nsCacheEntry * entry);
-
-    nsresult         GetTransportForEntry(nsCacheEntry *     entry,
-                                          nsCacheAccessMode  mode,
-                                          nsITransport **    result);
-
-    void             CloseDescriptor(nsCacheEntryDescriptor * descriptor);
-
-    nsresult         GetFileForEntry(nsCacheEntry *         entry,
-                                     nsIFile **             result);
-
-    /**
-     * Methods called by any cache classes
-     */
-
-    static
-    nsCacheService * GlobalInstance(void) { return gService; };
-
-    nsresult         DoomEntry(nsCacheEntry * entry);
-
-    nsresult         DoomEntry_Locked(nsCacheEntry * entry);
-
-    /**
-     * Methods called by nsCachePrefObserver
-     */
-    void             SetCacheDevicesEnabled(PRBool  disk, PRBool  memory);
-
-private:
-
-    /**
-     * Internal Methods
-     */
-
-    nsresult         CreateDiskDevice();
-    nsresult         CreateMemoryDevice();
-
-    nsresult         CreateRequest(nsCacheSession *   session,
-                                   const char *       clientKey,
-                                   nsCacheAccessMode  accessRequested,
-                                   PRBool             blockingMode,
-                                   nsICacheListener * listener,
-                                   nsCacheRequest **  request);
-
-    nsresult         NotifyListener(nsCacheRequest *          request,
-                                    nsICacheEntryDescriptor * descriptor,
-                                    nsCacheAccessMode         accessGranted,
-                                    nsresult                  error);
-
-    nsresult         ActivateEntry(nsCacheRequest * request, nsCacheEntry ** entry);
-
-    nsCacheDevice *  EnsureEntryHasDevice(nsCacheEntry * entry);
-
-    nsCacheEntry *   SearchCacheDevices(nsCString * key, nsCacheStoragePolicy policy);
-
-    void             DeactivateEntry(nsCacheEntry * entry);
-
-    nsresult         ProcessRequest(nsCacheRequest *           request,
-                                    PRBool                     calledFromOpenCacheEntry,
-                                    nsICacheEntryDescriptor ** result);
-
-    nsresult         ProcessPendingRequests(nsCacheEntry * entry);
-
-    void             ClearPendingRequests(nsCacheEntry * entry);
-    void             ClearDoomList(void);
-    void             ClearActiveEntries(void);
-
-    static
-    PLDHashOperator PR_CALLBACK  DeactivateAndClearEntry(PLDHashTable *    table,
-                                                         PLDHashEntryHdr * hdr,
-                                                         PRUint32          number,
-                                                         void *            arg);
-#if defined(PR_LOGGING)
-    void LogCacheStatistics();
-#endif
-
-    /**
-     *  Data Members
-     */
-
-    static nsCacheService *             gService;  // there can be only one...
-    nsCOMPtr<nsIEventQueueService>      mEventQService;
-    nsCOMPtr<nsIProxyObjectManager>     mProxyObjectManager;
-    
-    PRLock*                 mCacheServiceLock;
-    
-    PRBool                  mEnableMemoryDevice;
-    PRBool                  mEnableDiskDevice;
-
-    nsCacheDevice *         mMemoryDevice;
-    nsCacheDevice *         mDiskDevice;
-
-    nsCacheEntryHashTable   mActiveEntries;
-    PRCList                 mDoomedEntries;
-
-    // stats
-    
-    PRUint32                mTotalEntries;
-    PRUint32                mCacheHits;
-    PRUint32                mCacheMisses;
-    PRUint32                mMaxKeyLength;
-    PRUint32                mMaxDataSize;
-    PRUint32                mMaxMetaSize;
-
-    // Unexpected error totals
-    PRUint32                mDeactivateFailures;
-    PRUint32                mDeactivatedUnboundEntries;
-};
-
-
-#endif // _nsCacheService_h_

mozilla/netwerk/cache/src/nsCacheSession.cpp

@@ -1,104 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheSession.h, released February 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan <gordon@netscape.com>
- *    Patrick Beard   <beard@netscape.com>
- *    Darin Fisher    <darin@netscape.com>
- */
-
-#include "nsCacheSession.h"
-#include "nsCacheService.h"
-
-
-NS_IMPL_ISUPPORTS1(nsCacheSession, nsICacheSession)
-
-nsCacheSession::nsCacheSession(const char *         clientID,
-                               nsCacheStoragePolicy storagePolicy,
-                               PRBool               streamBased)
-    : mClientID(clientID),
-      mInfo(0)
-{
-  NS_INIT_ISUPPORTS();
-  SetStoragePolicy(storagePolicy);
-
-  if (streamBased) MarkStreamBased();
-  else SetStoragePolicy(nsICache::STORE_IN_MEMORY);
-}
-
-nsCacheSession::~nsCacheSession()
-{
-  /* destructor code */
-    // notify service we are going away?
-}
-
-
-NS_IMETHODIMP nsCacheSession::GetDoomEntriesIfExpired(PRBool *result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    *result = WillDoomEntriesIfExpired();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP nsCacheSession::SetDoomEntriesIfExpired(PRBool doomEntriesIfExpired)
-{
-    if (doomEntriesIfExpired)  MarkDoomEntriesIfExpired();
-    else                       ClearDoomEntriesIfExpired();
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsCacheSession::OpenCacheEntry(const char *               key, 
-                               nsCacheAccessMode          accessRequested,
-                               PRBool                     blockingMode,
-                               nsICacheEntryDescriptor ** result)
-{
-    nsresult rv;
-    rv =  nsCacheService::GlobalInstance()->OpenCacheEntry(this,
-                                                           key,
-                                                           accessRequested,
-                                                           blockingMode,
-                                                           nsnull, // no listener
-                                                           result);
-    return rv;
-}
-
-
-NS_IMETHODIMP nsCacheSession::AsyncOpenCacheEntry(const char *key,
-                                                  nsCacheAccessMode accessRequested,
-                                                  nsICacheListener *listener)
-{
-    nsresult rv;
-    rv = nsCacheService::GlobalInstance()->OpenCacheEntry(this,
-                                                          key,
-                                                          accessRequested,
-                                                          nsICache::BLOCKING,
-                                                          listener,
-                                                          nsnull); // no result
-
-    if (rv == NS_ERROR_CACHE_WAIT_FOR_VALIDATION) rv = NS_OK;
-    return rv;
-}
-
-NS_IMETHODIMP nsCacheSession::EvictEntries()
-{
-    return nsCacheService::GlobalInstance()->EvictEntriesForSession(this);
-}

mozilla/netwerk/cache/src/nsCacheSession.h

@@ -1,76 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheSession.h, released February 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan <gordon@netscape.com>
- *    Patrick Beard   <beard@netscape.com>
- *    Darin Fisher    <darin@netscape.com>
- */
-
-#ifndef _nsCacheSession_h_
-#define _nsCacheSession_h_
-
-#include "nspr.h"
-#include "nsError.h"
-#include "nsICacheSession.h"
-#include "nsString.h"
-
-class nsCacheSession : public nsICacheSession
-{
-public:
-    NS_DECL_ISUPPORTS
-    NS_DECL_NSICACHESESSION
-    
-    nsCacheSession(const char * clientID, nsCacheStoragePolicy storagePolicy, PRBool streamBased);
-    virtual ~nsCacheSession();
-    
-    nsCString *           ClientID()      { return &mClientID; }
-
-    enum SessionInfo {
-        eStoragePolicyMask        = 0x000000FF,
-        eStreamBasedMask          = 0x00000100,
-        eDoomEntriesIfExpiredMask = 0x00001000
-    };
-
-    void   MarkStreamBased()  { mInfo |=  eStreamBasedMask; }
-    void   ClearStreamBased() { mInfo &= ~eStreamBasedMask; }
-    PRBool IsStreamBased()    { return (mInfo & eStreamBasedMask) != 0; }
-
-    void   MarkDoomEntriesIfExpired()  { mInfo |=  eDoomEntriesIfExpiredMask; }
-    void   ClearDoomEntriesIfExpired() { mInfo &= ~eDoomEntriesIfExpiredMask; }
-    PRBool WillDoomEntriesIfExpired()  { return (mInfo & eDoomEntriesIfExpiredMask); }
-
-    nsCacheStoragePolicy  StoragePolicy()
-    {
-        return (nsCacheStoragePolicy)(mInfo & eStoragePolicyMask);
-    }
-
-    void SetStoragePolicy(nsCacheStoragePolicy policy)
-    {
-        NS_ASSERTION(policy <= 0xFF, "too many bits in nsCacheStoragePolicy");
-        mInfo &= ~eStoragePolicyMask; // clear storage policy bits
-        mInfo |= policy;
-    }
-
-private:
-    nsCString               mClientID;
-    PRUint32                mInfo;
-};
-
-#endif // _nsCacheSession_h_

mozilla/netwerk/cache/src/nsDiskCache.h

@@ -1,43 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheDevice.h, released March 9, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Patrick Beard   <beard@netscape.com>
- *    Gordon Sheridan <gordon@netscape.com>
- */
-
-
-#ifndef _nsDiskCache_h_
-#define _nsDiskCache_h_
-
-#include "nsCacheEntry.h"
-
-
-class nsDiskCache {
-public:
-    enum {
-            kCurrentVersion = 0x00010003      // XXX whats the format?
-    };
-
-    enum { kData, kMetaData };
-
-    static PLDHashNumber    Hash(const char* key);
-};
-
-#endif // _nsDiskCache_h_

mozilla/netwerk/cache/src/nsDiskCacheBinding.cpp

@@ -1,348 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsDiskCacheBinding.cpp, released May 10, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Patrick C. Beard <beard@netscape.com>
- *    Gordon Sheridan  <gordon@netscape.com>
- */
-
-#include <limits.h>
-
-#include "nsDiskCacheBinding.h"
-
-
-
-/******************************************************************************
- *  static hash table callback functions
- *
- *****************************************************************************/
-#ifdef XP_MAC
-#pragma mark -
-#pragma mark HASHTABLE CALLBACKS
-#endif
-
-struct HashTableEntry : PLDHashEntryHdr {
-    nsDiskCacheBinding *  mBinding;
-};
-
-
-static const void * PR_CALLBACK
-GetKey(PLDHashTable * /*table*/, PLDHashEntryHdr * header)
-{
-    return (void*) ((HashTableEntry *)header)->mBinding->mRecord.HashNumber();
-}
-
-
-static PLDHashNumber PR_CALLBACK
-HashKey( PLDHashTable *table, const void *key)
-{
-    return (PLDHashNumber) key;
-}
-
-
-static PRBool PR_CALLBACK
-MatchEntry(PLDHashTable *              /* table */,
-            const PLDHashEntryHdr *       header,
-            const void *                  key)
-{
-    HashTableEntry * hashEntry = (HashTableEntry *) header;
-    return (hashEntry->mBinding->mRecord.HashNumber() == (PLDHashNumber) key);
-}
-
-static void PR_CALLBACK
-MoveEntry(PLDHashTable *           /* table */,
-          const PLDHashEntryHdr *     src,
-          PLDHashEntryHdr       *     dst)
-{
-    ((HashTableEntry *)dst)->mBinding = ((HashTableEntry *)src)->mBinding;
-}
-
-
-static void PR_CALLBACK
-ClearEntry(PLDHashTable *      /* table */,
-           PLDHashEntryHdr *      header)
-{
-    ((HashTableEntry *)header)->mBinding = nsnull;
-}
-
-
-/******************************************************************************
- *  Utility Functions
- *****************************************************************************/
-#ifdef XP_MAC
-#pragma mark -
-#pragma mark DISK CACHE BINDERY
-#endif
-
-nsDiskCacheBinding *
-GetCacheEntryBinding(nsCacheEntry * entry)
-{
-    nsCOMPtr<nsISupports> data;
-    nsresult rv = entry->GetData(getter_AddRefs(data));
-    if (NS_FAILED(rv))  return nsnull;
-    
-    return (nsDiskCacheBinding *)data.get();
-}
-
-
-/******************************************************************************
- *  nsDiskCacheBinding
- *****************************************************************************/
-
-NS_IMPL_THREADSAFE_ISUPPORTS0(nsDiskCacheBinding);
-
-nsDiskCacheBinding::nsDiskCacheBinding(nsCacheEntry* entry, nsDiskCacheRecord * record)
-    :   mCacheEntry(entry)
-{
-    NS_ASSERTION(record->ValidRecord(), "bad record");
-    NS_INIT_ISUPPORTS();
-    PR_INIT_CLIST(this);
-    mRecord     = *record;
-    mDoomed     = entry->IsDoomed();
-    mGeneration = record->Generation();    // 0 == uninitialized, or data & meta using block files
-}
-
-nsDiskCacheBinding::~nsDiskCacheBinding()
-{
-    NS_ASSERTION(PR_CLIST_IS_EMPTY(this), "binding deleted while still on list");
-    if (!PR_CLIST_IS_EMPTY(this))
-        PR_REMOVE_LINK(this);       // XXX why are we still on a list?
-}
-
-
-/******************************************************************************
- *  nsDiskCacheBindery
- *
- *  Keeps track of bound disk cache entries to detect for collisions.
- *
- *****************************************************************************/
-
-PLDHashTableOps nsDiskCacheBindery::ops =
-{
-    PL_DHashAllocTable,
-    PL_DHashFreeTable,
-    GetKey,
-    HashKey,
-    MatchEntry,
-    MoveEntry,
-    ClearEntry,
-    PL_DHashFinalizeStub
-};
-
-
-nsDiskCacheBindery::nsDiskCacheBindery()
-    : initialized(PR_FALSE)
-{
-}
-
-
-nsDiskCacheBindery::~nsDiskCacheBindery()
-{
-    if (initialized)
-        PL_DHashTableFinish(&table);
-}
-
-
-nsresult
-nsDiskCacheBindery::Init()
-{
-    nsresult rv = NS_OK;
-    initialized = PL_DHashTableInit(&table, &ops, nsnull, sizeof(HashTableEntry), 0);
-
-    if (!initialized) rv = NS_ERROR_OUT_OF_MEMORY;
-    
-    return rv;
-}
-
-
-nsDiskCacheBinding *
-nsDiskCacheBindery::CreateBinding(nsCacheEntry *       entry,
-                                  nsDiskCacheRecord *  record)
-{
-    NS_ASSERTION(initialized, "nsDiskCacheBindery not initialized");
-    nsCOMPtr<nsISupports> data;
-    nsresult rv = entry->GetData(getter_AddRefs(data));
-    if (NS_FAILED(rv) || data) {
-        NS_ASSERTION(!data, "cache entry already has bind data");
-        return nsnull;
-    }
-    
-    nsDiskCacheBinding * binding = new nsDiskCacheBinding(entry, record);
-    if (!binding)  return nsnull;
-        
-    // give ownership of the binding to the entry
-    entry->SetData(binding);
-    
-    // add binding to collision detection system
-    rv = AddBinding(binding);
-    if (NS_FAILED(rv)) {
-        entry->SetData(nsnull);
-        return nsnull;
-    }
-
-    return binding;
-}
-
-
-/**
- *  FindActiveEntry :  to find active colliding entry so we can doom it
- */
-nsDiskCacheBinding *
-nsDiskCacheBindery::FindActiveBinding(PRUint32  hashNumber)
-{
-    NS_ASSERTION(initialized, "nsDiskCacheBindery not initialized");
-    // find hash entry for key
-    HashTableEntry * hashEntry;
-    hashEntry = (HashTableEntry *) PL_DHashTableOperate(&table, (void*) hashNumber, PL_DHASH_LOOKUP);
-    if (PL_DHASH_ENTRY_IS_FREE(hashEntry)) return nsnull;
-    
-    // walk list looking for active entry
-    NS_ASSERTION(hashEntry->mBinding, "hash entry left with no binding");
-    nsDiskCacheBinding * binding = hashEntry->mBinding;    
-    while (binding->mCacheEntry->IsDoomed()) {
-        binding = (nsDiskCacheBinding *)PR_NEXT_LINK(binding);
-        if (binding == hashEntry->mBinding)  return nsnull;
-    }
-    return binding;
-}
-
-
-/**
- *  FindBinding :  to identify whether a record is 'in use' so we don't evict it
- */
-nsDiskCacheBinding *
-nsDiskCacheBindery::FindBinding(nsDiskCacheRecord * record)
-{    
-    NS_ASSERTION(initialized, "nsDiskCacheBindery not initialized");
-    // find hash entry for key
-    HashTableEntry * hashEntry;
-    hashEntry = (HashTableEntry *) PL_DHashTableOperate(&table, (void*) record->HashNumber(), PL_DHASH_LOOKUP);
-    if (PL_DHASH_ENTRY_IS_FREE(hashEntry)) return nsnull;
-
-    // walk list looking for matching record (match on MetaLocation)
-    NS_ASSERTION(hashEntry->mBinding, "hash entry left with no binding");
-    nsDiskCacheBinding * binding = hashEntry->mBinding;    
-    while (binding->mRecord.MetaLocation() != record->MetaLocation()) {
-        binding = (nsDiskCacheBinding *)PR_NEXT_LINK(binding);
-        if (binding == hashEntry->mBinding)  return nsnull;
-    }
-    return binding;
-}
-
-
-
-/**
- *  AddBinding
- *
- *  Called from FindEntry() if we read an entry off of disk
- *      - it may already have a generation number
- *      - a generation number conflict is an error
- *
- *  Called from BindEntry()
- *      - a generation number needs to be assigned
- */
-nsresult
-nsDiskCacheBindery::AddBinding(nsDiskCacheBinding * binding)
-{
-    NS_ENSURE_ARG_POINTER(binding);
-    NS_ASSERTION(initialized, "nsDiskCacheBindery not initialized");
-
-    // find hash entry for key
-    HashTableEntry * hashEntry;
-    hashEntry = (HashTableEntry *) PL_DHashTableOperate(&table,
-                                                        (void*) binding->mRecord.HashNumber(),
-                                                        PL_DHASH_ADD);
-    if (!hashEntry) return NS_ERROR_OUT_OF_MEMORY;
-    
-    if (hashEntry->mBinding == nsnull) {
-        hashEntry->mBinding = binding;
-        if (binding->mGeneration == 0)
-            binding->mGeneration = 1;   // if generation uninitialized, set it to 1
-            
-        return NS_OK;
-    }
-    
-    
-    // insert binding in generation order
-    nsDiskCacheBinding * p  = hashEntry->mBinding;
-    PRBool   calcGeneration = (binding->mGeneration == 0);  // do we need to calculate generation?
-    if (calcGeneration)  binding->mGeneration = 1;          // initialize to 1 if uninitialized
-    while (1) {
-    
-        if (binding->mGeneration < p->mGeneration) {
-            // here we are
-            PR_INSERT_BEFORE(binding, p);
-            if (hashEntry->mBinding == p)
-                hashEntry->mBinding = binding;
-        }
-        
-        if (binding->mGeneration == p->mGeneration) {
-            if (calcGeneration)  ++binding->mGeneration;    // try the next generation
-            else {
-                NS_ASSERTION(binding->mGeneration != p->mGeneration,  "generations collide!");
-                return NS_ERROR_UNEXPECTED;
-            }
-        }
-
-        p = (nsDiskCacheBinding *)PR_NEXT_LINK(p);
-        if (p == hashEntry->mBinding) {
-            // end of line: insert here or die
-            p = (nsDiskCacheBinding *)PR_PREV_LINK(p);  // back up and check generation
-            if (p->mGeneration == 255) {
-                NS_ASSERTION(p->mGeneration < 255, "generation capacity at full, the engines canna take it cap'n");
-                return NS_ERROR_UNEXPECTED;
-            }
-            PR_INSERT_BEFORE(binding, hashEntry->mBinding);
-        }
-    }
-    return NS_OK;
-}
-
-
-/**
- *  RemoveBinding :  remove binding from collision detection on deactivation
- */
-void
-nsDiskCacheBindery::RemoveBinding(nsDiskCacheBinding * binding)
-{
-    NS_ASSERTION(initialized, "nsDiskCacheBindery not initialized");
-    if (!initialized)   return;
-    
-    HashTableEntry * hashEntry;
-    void *           key = (void *)binding->mRecord.HashNumber();
-
-    hashEntry = (HashTableEntry*) PL_DHashTableOperate(&table, (void*) key, PL_DHASH_LOOKUP);
-    if (!PL_DHASH_ENTRY_IS_BUSY(hashEntry)) {
-        NS_ASSERTION(PL_DHASH_ENTRY_IS_BUSY(hashEntry), "binding not in disk cache hashtable!");
-        return;
-    }
-    
-    if (binding == hashEntry->mBinding) {
-        if (PR_CLIST_IS_EMPTY(binding)) {
-            // remove this hash entry
-            (void) PL_DHashTableOperate(&table, (void*) binding->mRecord.HashNumber(), PL_DHASH_REMOVE);
-            return;
-            
-        } else {
-            // promote next binding to head, and unlink this binding
-            hashEntry->mBinding = (nsDiskCacheBinding *)PR_NEXT_LINK(binding);
-        }
-    }
-    PR_REMOVE_AND_INIT_LINK(binding);
-}

mozilla/netwerk/cache/src/nsDiskCacheBinding.h

@@ -1,143 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsDiskCacheBinding.h, released May 10, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan  <gordon@netscape.com>
- *    Patrick C. Beard <beard@netscape.com>
- */
-
-
-#ifndef _nsDiskCacheBinding_h_
-#define _nsDiskCacheBinding_h_
-
-#include "nspr.h"
-#include "pldhash.h"
-
-#include "nsISupports.h"
-#include "nsCacheEntry.h"
-
-#ifdef MOZ_NEW_CACHE_REUSE_TRANSPORTS
-#include "nsITransport.h"
-#endif
-
-#include "nsDiskCacheMap.h"
-
-
-/******************************************************************************
- *  nsDiskCacheBinding
- *
- *  Created for disk cache specific data and stored in nsCacheEntry.mData as
- *  an nsISupports.  Also stored in nsDiskCacheHashTable, with collisions
- *  linked by the PRCList.
- *
- *****************************************************************************/
-
-class nsDiskCacheBinding : public nsISupports, public PRCList {
-public:
-    NS_DECL_ISUPPORTS
-
-    nsDiskCacheBinding(nsCacheEntry* entry, nsDiskCacheRecord * record);
-    virtual ~nsDiskCacheBinding();
-
-#ifdef MOZ_NEW_CACHE_REUSE_TRANSPORTS
-    /**
-     * Maps a cache access mode to a cached nsITransport for that access
-     * mode. We keep these cached to avoid repeated trips to the
-     * file transport service.
-     */
-    nsCOMPtr<nsITransport>& getTransport(nsCacheAccessMode mode)
-    {
-        return mTransports[mode - 1];
-    }
-#endif
-
-
-// XXX make friends
-public:
-    nsCacheEntry*           mCacheEntry;    // back pointer to parent nsCacheEntry
-    nsDiskCacheRecord       mRecord;
-    PRBool                  mDoomed;        // record is not stored in cache map
-    PRUint8                 mGeneration;    // possibly just reservation
-
-private:
-#ifdef MOZ_NEW_CACHE_REUSE_TRANSPORTS
-    nsCOMPtr<nsITransport>  mTransports[3];
-#endif
-};
-
-
-/******************************************************************************
- *  Utility Functions
- *****************************************************************************/
-
-nsDiskCacheBinding *   GetCacheEntryBinding(nsCacheEntry * entry);
-
-
-
-/******************************************************************************
- *  nsDiskCacheBindery
- *
- *  Used to keep track of nsDiskCacheBinding associated with active/bound (and
- *  possibly doomed) entries.  Lookups on 4 byte disk hash to find collisions
- *  (which need to be doomed, instead of just evicted.  Collisions are linked
- *  using a PRCList to keep track of current generation number.
- *
- *  Used to detect hash number collisions, and find available generation numbers.
- *
- *  Not all nsDiskCacheBinding have a generation number.
- *
- *  Generation numbers may be aquired late, or lost (when data fits in block file)
- *
- *  Collisions can occur:
- *      BindEntry()       - hashnumbers collide (possibly different keys)
- *
- *  Generation number required:
- *      DeactivateEntry() - metadata written to disk, may require file
- *      GetFileForEntry() - force data to require file
- *      writing to stream - data size may require file
- *
- *  Binding can be kept in PRCList in order of generation numbers.
- *  Binding with no generation number can be Appended to PRCList (last).
- *
- *****************************************************************************/
-
-class nsDiskCacheBindery {
-public:
-    nsDiskCacheBindery();
-    ~nsDiskCacheBindery();
-
-    nsresult                Init();
-
-    nsDiskCacheBinding *   CreateBinding(nsCacheEntry *       entry,
-                                         nsDiskCacheRecord *  record);
-
-    nsDiskCacheBinding *    FindActiveBinding(PRUint32  hashNumber);
-    nsDiskCacheBinding *    FindBinding(nsDiskCacheRecord * record);
-    nsresult                AddBinding(nsDiskCacheBinding * binding);
-    void                    RemoveBinding(nsDiskCacheBinding * binding);
-
-    
-private:
-    // member variables
-    static PLDHashTableOps ops;
-    PLDHashTable           table;
-    PRBool                 initialized;
-};
-
-#endif /* _nsDiskCacheBinding_h_ */

mozilla/netwerk/cache/src/nsDiskCacheBlockFile.cpp

@@ -1,422 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsDiskCacheBlockFile.cpp, released April 12, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan  <gordon@netscape.com>
- */
-
-#include "nsCRT.h"
-#include "nsDiskCacheBlockFile.h"
-
-/******************************************************************************
- * nsDiskCacheBlockFile - 
- *****************************************************************************/
-
-
-/******************************************************************************
- *  Open
- *****************************************************************************/
-nsresult
-nsDiskCacheBlockFile::Open( nsILocalFile *  blockFile, PRUint32  blockSize)
-{
-    PRStatus  err = PR_SUCCESS;
-    PRInt32   fileSize;
-
-    mBlockSize = blockSize;
-    
-    // open the file
-    nsresult rv = blockFile->OpenNSPRFileDesc(PR_RDWR | PR_CREATE_FILE, 00666, &mFD);
-    if (NS_FAILED(rv))  return rv;  // unable to open or create file
-    
-    // allocate bit map buffer
-    mBitMap = new PRUint8[kBitMapBytes];
-    if (!mBitMap) {
-        rv = NS_ERROR_OUT_OF_MEMORY;
-        goto error_exit;
-    }
-    
-    // check if we just creating the file
-    fileSize = PR_Available(mFD);
-    if (fileSize < 0) {
-        // XXX an error occurred. We could call PR_GetError(), but how would that help?
-        rv = NS_ERROR_UNEXPECTED;
-        goto error_exit;
-    }
-    mEndOfFile = fileSize;
-    if (mEndOfFile == 0) {
-        // initialize bit map and write it
-        nsCRT::zero(mBitMap, kBitMapBytes);
-        PRInt32 bytesWritten = PR_Write(mFD, mBitMap, kBitMapBytes);
-        if (bytesWritten < kBitMapBytes) goto error_exit;
-        mEndOfFile = kBitMapBytes;
-        
-    } else if (mEndOfFile < kBitMapBytes) {
-        rv = NS_ERROR_UNEXPECTED;  // XXX NS_ERROR_CACHE_INVALID;
-        goto error_exit;
-        
-    } else {
-        // read the bit map
-        PRInt32 bytesRead = PR_Read(mFD, mBitMap, kBitMapBytes);
-        if (bytesRead < kBitMapBytes) {
-            rv = NS_ERROR_UNEXPECTED;
-            goto error_exit;
-        }
-        
-        // validate block file
-        rv = ValidateFile();
-        if (NS_FAILED(rv)) goto error_exit;
-    }
-    
-    return NS_OK;
-
-error_exit:
-    if (mFD) {
-        (void) PR_Close(mFD);
-        mFD = nsnull;
-    }
-    
-    if (mBitMap) {
-        delete [] mBitMap;
-        mBitMap = nsnull;
-    }
-    return rv;
-}
-
-
-/******************************************************************************
- *  Close
- *****************************************************************************/
-nsresult
-nsDiskCacheBlockFile::Close()
-{
-    if (!mFD)  return NS_OK;
-    
-    nsresult rv  = FlushBitMap();
-    PRStatus err = PR_Close(mFD);
-    mFD = nsnull;
-    
-    if (mBitMap) {
-        delete [] mBitMap;
-        mBitMap = nsnull;
-    }
-    
-    if (NS_SUCCEEDED(rv) && (err != PR_SUCCESS))
-        rv = NS_ERROR_UNEXPECTED;
-        
-    return rv;
-}
-
-
-/******************************************************************************
- *  Trim
- *
- *  Truncate the block file to the end of the last allocated block.
- *
- *****************************************************************************/
-nsresult
-nsDiskCacheBlockFile::Trim()
-{
-    return NS_OK;
-}
-
-
-/******************************************************************************
- *  AllocateBlocks
- *
- *  Allocates 1-4 blocks, using a first fit strategy,
- *  so that no group of blocks spans a quad block boundary.
- *
- *  Returns block number of first block allocated or -1 on failure.
- *
- *****************************************************************************/
-PRInt32
-nsDiskCacheBlockFile::AllocateBlocks(PRInt32 numBlocks)
-{
-    if (!mFD)  return -1;  // NS_ERROR_NOT_AVAILABLE;
-    // return -1 if unable to allocate blocks
-    // PRUint8  mask = (0x01 << numBlocks) - 1;    
-    int     i = 0;
-    PRUint8 mapByte;
-    PRUint8 mask;
-    
-    // presume allocation will succeed
-    PRBool oldValue = mBitMapDirty;
-    mBitMapDirty = PR_TRUE;
-    
-    while ((mBitMap[i] == 0xFF) && (i < kBitMapBytes)) ++i;     // find first block with a free bit
-    
-    if (numBlocks == 1) {
-        if (i < kBitMapBytes) {
-            // don't need a while loop, because we know there's at least 1 free bit in this byte
-            mapByte = ~mBitMap[i]; // flip bits so free bits are 1
-/*
- *          // Linear search for first free bit in byte
- *          mask = 0x01;
- *          for (int j=0; j<8; ++j, mask <<= 1)
- *              if (mask & mapByte) {mBitMap[i] |= mask; return (i * 8 + j); }
- */
-            // Binary search for first free bit in byte
-            PRUint8 bit = 0;
-            if ((mapByte & 0x0F) == 0) { bit |= 4; mapByte >>= 4; }
-            if ((mapByte & 0x03) == 0) { bit |= 2; mapByte >>= 2; }
-            if ((mapByte & 0x01) == 0) { bit |= 1; mapByte >>= 1; }
-            mBitMap[i] |= (PRUint8)1 << bit;
-            return i * 8 + bit;
-        }
-    } else if (numBlocks == 2) {
-        while (i < kBitMapBytes) {
-            mapByte = ~mBitMap[i]; // flip bits so free bits are 1
-            mask = 0x03;
-            // check for fit in lower quad bits
-            if ((mask & mapByte) == mask) { mBitMap[i] |= mask; return (i * 8); }       mask <<= 1;
-            if ((mask & mapByte) == mask) { mBitMap[i] |= mask; return (i * 8 + 1); }   mask <<= 1;
-            if ((mask & mapByte) == mask) { mBitMap[i] |= mask; return (i * 8 + 2); }   mask <<= 2;
-            // check for fit in upper quad bits
-            if ((mask & mapByte) == mask) { mBitMap[i] |= mask; return (i * 8 + 4); }   mask <<= 1;
-            if ((mask & mapByte) == mask) { mBitMap[i] |= mask; return (i * 8 + 5); }   mask <<= 1;
-            if ((mask & mapByte) == mask) { mBitMap[i] |= mask; return (i * 8 + 6); }
-            ++i;
-        }
-    } else if (numBlocks == 3) {
-        while (i < kBitMapBytes) {
-            mapByte = ~mBitMap[i]; // flip bits so free bits are 1
-            mask = 0x07;
-            // check for fit in lower quad bits
-            if ((mask & mapByte) == mask) { mBitMap[i] |= mask; return (i * 8); }       mask <<= 1;
-            if ((mask & mapByte) == mask) { mBitMap[i] |= mask; return (i * 8 + 1); }   mask <<= 3;
-            // check for fit in upper quad bits
-            if ((mask & mapByte) == mask) { mBitMap[i] |= mask; return (i * 8 + 4); }   mask <<= 1;
-            if ((mask & mapByte) == mask) { mBitMap[i] |= mask; return (i * 8 + 5); }
-            ++i;
-        }
-    } else if (numBlocks == 4) {
-        while (i < kBitMapBytes) {
-            mapByte = ~mBitMap[i]; // flip bits so free bits are 1
-            mask = 0x0F;
-            // check for fit in lower quad bits
-            if ((mask & mapByte) == mask) { mBitMap[i] |= mask; return (i * 8); }      mask <<= 4;
-            // check for fit in upper quad bits
-            if ((mask & mapByte) == mask) { mBitMap[i] |= mask; return (i * 8 + 4); }
-            ++i;
-        }
-    }
-    
-    mBitMapDirty = oldValue;
-    return -1;
-}
-
-
-/******************************************************************************
- *  DeallocateBlocks
- *****************************************************************************/
-nsresult
-nsDiskCacheBlockFile::DeallocateBlocks( PRInt32  startBlock, PRInt32  numBlocks)
-{
-    if (!mFD)  return NS_ERROR_NOT_AVAILABLE;
-    if ((startBlock < 0) || (startBlock > kBitMapBytes * 8 - 1) ||
-        (numBlocks < 1)  || (numBlocks > 4))
-       return NS_ERROR_ILLEGAL_VALUE;
-           
-    PRInt32 startByte = startBlock / 8;
-    PRUint8 startBit  = startBlock % 8;
-    
-    // make sure requested deallocation doesn't span a byte boundary
-    if ((startBlock + numBlocks - 1) / 8 != startByte)  return NS_ERROR_UNEXPECTED;
-    PRUint8 mask = ((0x01 << numBlocks) - 1) << startBit;
-    
-    PRUint8 mapByte = ~mBitMap[startByte]; // flip so allocated bits are zero
-    
-    // make sure requested deallocation is currently allocated
-    if (mapByte & mask)  return NS_ERROR_ABORT;
-    
-    mBitMap[startByte] ^= mask;    // flips the bits off;
-    mBitMapDirty = PR_TRUE;
-    // XXX rv = FlushBitMap();  // coherency vs. performance
-    return NS_OK;
-}
-
-
-/******************************************************************************
- *  WriteBlocks
- *****************************************************************************/
-nsresult
-nsDiskCacheBlockFile::WriteBlocks( void *   buffer,
-                                   PRInt32  startBlock,
-                                   PRInt32  numBlocks)
-{
-    // presume buffer != nsnull
-    if (!mFD)  return NS_ERROR_NOT_AVAILABLE;
-    nsresult rv = VerifyAllocation(startBlock, numBlocks);
-    if (NS_FAILED(rv))  return rv;
-    
-    // seek to block position
-    PRInt32 blockPos = kBitMapBytes + startBlock * mBlockSize;
-    PRInt32 filePos = PR_Seek(mFD, blockPos, PR_SEEK_SET);
-    if (filePos != blockPos)  return NS_ERROR_UNEXPECTED;
-    
-    if (mEndOfFile < (blockPos + numBlocks * mBlockSize))
-        mEndOfFile = (blockPos + numBlocks * mBlockSize);
-    
-    // write the blocks
-    PRInt32 bytesToWrite = numBlocks * mBlockSize;
-    PRInt32 bytesWritten = PR_Write(mFD, buffer, bytesToWrite);
-    if (bytesWritten < bytesToWrite)  return NS_ERROR_UNEXPECTED;
-    
-    // write the bit map and flush the file
-    // XXX rv = FlushBitMap();
-    return rv;
-}
-
-
-/******************************************************************************
- *  ReadBlocks
- *****************************************************************************/
-nsresult
-nsDiskCacheBlockFile::ReadBlocks(  void *    buffer,
-                                   PRInt32   startBlock,
-                                   PRInt32   numBlocks)
-{
-    // presume buffer != nsnull
-    if (!mFD)  return NS_ERROR_NOT_AVAILABLE;
-    nsresult rv = VerifyAllocation(startBlock, numBlocks);
-    if (NS_FAILED(rv))  return rv;
-    
-    // seek to block position
-    PRInt32 blockPos = kBitMapBytes + startBlock * mBlockSize;
-    PRInt32 filePos = PR_Seek(mFD, blockPos, PR_SEEK_SET);
-    if (filePos != blockPos)  return NS_ERROR_UNEXPECTED;
-
-    // read the blocks
-    PRInt32 bytesToRead = numBlocks * mBlockSize;
-    PRInt32 bytesRead = PR_Read(mFD, buffer, bytesToRead);
-    if (bytesRead < bytesToRead)  return NS_ERROR_UNEXPECTED;
-    
-    return rv;
-}
-
-
-/******************************************************************************
- *  FlushBitMap
- *****************************************************************************/
-nsresult
-nsDiskCacheBlockFile::FlushBitMap()
-{
-    if (!mBitMapDirty)  return NS_OK;
-
-    // seek to bitmap
-    PRInt32 filePos = PR_Seek(mFD, 0, PR_SEEK_SET);
-    if (filePos != 0)  return NS_ERROR_UNEXPECTED;
-    
-    // write bitmap
-    PRInt32 bytesWritten = PR_Write(mFD, mBitMap, kBitMapBytes);
-    if (bytesWritten < kBitMapBytes)  return NS_ERROR_UNEXPECTED;
-
-    PRStatus err = PR_Sync(mFD);
-    if (err != PR_SUCCESS)  return NS_ERROR_UNEXPECTED;
-
-    mBitMapDirty = PR_FALSE;
-    return NS_OK;
-}
-
-
-/******************************************************************************
- *  ValidateFile
- *
- *  Check size of file against last bit allocated for mBlockSize.
- *
- *****************************************************************************/
-nsresult
-nsDiskCacheBlockFile::ValidateFile()
-{
-    PRInt32  estimatedSize = kBitMapBytes;
-    PRInt32  lastBlock = LastBlock();
-    if (lastBlock >= 0)
-        estimatedSize += (lastBlock + 1) * mBlockSize;
-        
-    // seek to beginning
-    PRInt32 filePos = PR_Seek(mFD, 0, PR_SEEK_SET);
-    if (filePos != 0)  return NS_ERROR_UNEXPECTED;
-    
-    PRInt32 fileSize = PR_Available(mFD);
-
-    if (estimatedSize > fileSize)
-        return NS_ERROR_UNEXPECTED;
-
-    return NS_OK;
-}
-
-
-/******************************************************************************
- *  VerfiyAllocation
- *
- *  Return values:
- *      NS_OK if all bits are marked allocated
- *      NS_ERROR_ILLEGAL_VALUE if parameters don't obey constraints
- *      NS_ERROR_FAILURE if some or all the bits are marked unallocated
- *
- *****************************************************************************/
-nsresult
-nsDiskCacheBlockFile::VerifyAllocation( PRInt32  startBlock, PRInt32  numBlocks)
-{
-    if ((startBlock < 0) || (startBlock > kBitMapBytes * 8 - 1) ||
-        (numBlocks < 1)  || (numBlocks > 4))
-       return NS_ERROR_ILLEGAL_VALUE;
-    
-    PRInt32 startByte = startBlock / 8;
-    PRUint8 startBit  = startBlock % 8;
-    
-    // make sure requested deallocation doesn't span a byte boundary
-    if ((startBlock + numBlocks - 1) / 8 != startByte)  return NS_ERROR_ILLEGAL_VALUE;
-    PRUint8 mask = ((0x01 << numBlocks) - 1) << startBit;
-    
-    // check if all specified blocks are currently allocated
-    if ((mBitMap[startByte] & mask) != mask)    return NS_ERROR_FAILURE;
-    
-    return NS_OK;
-}
-
-
-/******************************************************************************
- *  LastBlock
- *
- *  Return last block allocated or -1 if no blocks are allocated.
- *
- *****************************************************************************/
-PRInt32
-nsDiskCacheBlockFile::LastBlock()
-{
-    // search for last byte in mBitMap with allocated bits
-    PRInt32 i = kBitMapBytes;
-    while (--i >= 0) {
-        if (mBitMap[i]) break;
-    }
-
-    if (i >= 0) {
-        // binary search to find last allocated bit in byte
-        PRUint8 mapByte = mBitMap[i];
-        PRUint8 lastBit = 7;
-        if ((mapByte & 0xF0) == 0) { lastBit ^= 4; mapByte <<= 4; }
-        if ((mapByte & 0xC0) == 0) { lastBit ^= 2; mapByte <<= 2; }
-        if ((mapByte & 0x80) == 0) { lastBit ^= 1; mapByte <<= 1; }
-        return i * 8 + lastBit;
-    }
-    
-    return -1;
-
-}

mozilla/netwerk/cache/src/nsDiskCacheBlockFile.h

@@ -1,76 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsDiskCacheBlockFile.h, released April 12, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan  <gordon@netscape.com>
- */
-
-#ifndef _nsDiskCacheBlockFile_h_
-#define _nsDiskCacheBlockFile_h_
-
-#include "nsILocalFile.h"
-#include "nspr.h"
-
-enum { kBitMapBytes = 4096 };
-
-
-/******************************************************************************
- *  nsDiskCacheBlockFile
- *
- *  The structure of a cache block file is a 4096 bytes bit map, followed by
- *  some number of blocks of mBlockSize.  The creator of a
- *  nsDiskCacheBlockFile object must provide the block size for a given file.
- *
- *****************************************************************************/
-class nsDiskCacheBlockFile {
-public:
-    nsDiskCacheBlockFile()
-           : mFD(nsnull)
-           , mBlockSize(0)
-           , mEndOfFile(0)
-           , mBitMap(nsnull)
-           , mBitMapDirty(PR_FALSE)
-            {}
-    ~nsDiskCacheBlockFile() { (void) Close(); }
-    
-    nsresult  Open( nsILocalFile *  blockFile, PRUint32  blockSize);
-    nsresult  Close();
-    nsresult  Trim();
-    PRInt32   AllocateBlocks( PRInt32  numBlocks);
-    nsresult  DeallocateBlocks( PRInt32  startBlock, PRInt32  numBlocks);
-    nsresult  WriteBlocks( void * buffer, PRInt32  startBlock, PRInt32  numBlocks);
-    nsresult  ReadBlocks(  void * buffer, PRInt32  startBlock, PRInt32  numBlocks);
-    
-private:
-    nsresult  FlushBitMap();
-    nsresult  ValidateFile();   // called by Open()
-    nsresult  VerifyAllocation( PRInt32 startBlock, PRInt32 numBLocks);
-    PRInt32   LastBlock();
-
-/**
- *  Data members
- */
-    PRFileDesc *                mFD;
-    PRUint32                    mBlockSize;
-    PRUint32                    mEndOfFile;
-    PRUint8 *                   mBitMap;      // XXX future: array of bit map blocks
-    PRBool                      mBitMapDirty;
-};
-
-#endif // _nsDiskCacheBlockFile_h_

mozilla/netwerk/cache/src/nsDiskCacheDevice.h

@@ -1,96 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsDiskCacheDevice.h, released February 20, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan <gordon@netscape.com>
- *    Patrick C. Beard <beard@netscape.com>
- */
-
-#ifndef _nsDiskCacheDevice_h_
-#define _nsDiskCacheDevice_h_
-
-#include "nsCacheDevice.h"
-#include "nsDiskCacheBinding.h"
-#include "nsDiskCacheBlockFile.h"
-#include "nsDiskCacheEntry.h"
-
-#include "nsILocalFile.h"
-#include "nsIObserver.h"
-
-class nsDiskCacheMap;
-
-class nsDiskCacheDevice : public nsCacheDevice {
-public:
-    nsDiskCacheDevice();
-    virtual ~nsDiskCacheDevice();
-
-    static nsresult         Create(nsCacheDevice **result);
-
-    virtual nsresult        Init();
-    virtual nsresult        Shutdown();
-
-    virtual const char *    GetDeviceID(void);
-    virtual nsCacheEntry *  FindEntry(nsCString * key);
-    virtual nsresult        DeactivateEntry(nsCacheEntry * entry);
-    virtual nsresult        BindEntry(nsCacheEntry * entry);
-    virtual void            DoomEntry( nsCacheEntry * entry );
-
-    virtual nsresult        GetTransportForEntry(nsCacheEntry * entry,
-                                          nsCacheAccessMode mode,
-                                          nsITransport ** result);
-
-    virtual nsresult        GetFileForEntry(nsCacheEntry *    entry,
-                                            nsIFile **        result);
-
-    virtual nsresult        OnDataSizeChange(nsCacheEntry * entry, PRInt32 deltaSize);
-    
-    virtual nsresult        Visit(nsICacheVisitor * visitor);
-
-    virtual nsresult        EvictEntries(const char * clientID);
-
-/* private: */
-    void                    setPrefsObserver(nsIObserver *  observer);
-    void                    getPrefsObserver(nsIObserver ** result);
-    void                    setCacheDirectory(nsILocalFile *  directory);
-    void                    getCacheDirectory(nsILocalFile ** result);
-    void                    setCacheCapacity(PRUint32 capacity);
-    PRUint32                getCacheCapacity();
-    PRUint32                getCacheSize();
-    PRUint32                getEntryCount();
-    
-private:    
-    /**
-     *  Private methods
-     */
-    nsresult    InitializeCacheDirectory();
-    nsresult    GetCacheTrashDirectory(nsIFile ** result);
-    nsresult    EvictDiskCacheEntries();
-    
-    /**
-     *  Member variables
-     */
-    PRBool                  mInitialized;
-    nsCOMPtr<nsIObserver>   mPrefsObserver;     // XXX ?
-    nsCOMPtr<nsILocalFile>  mCacheDirectory;
-    nsDiskCacheBindery      mBindery;
-    PRUint32                mCacheCapacity;     // XXX need soft/hard limits, currentTotal
-    nsDiskCacheMap *        mCacheMap;
-};
-
-#endif // _nsDiskCacheDevice_h_

mozilla/netwerk/cache/src/nsDiskCacheEntry.cpp

@@ -1,211 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsDiskCacheEntry.cpp, released May 10, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan  <gordon@netscape.com>
- *    Patrick C. Beard <beard@netscape.com>
- */
-
-#include "nsDiskCache.h"
-#include "nsDiskCacheEntry.h"
-#include "nsDiskCacheBinding.h"
-#include "nsDiskCacheMap.h"
-
-#include "nsCache.h"
-
-
-/******************************************************************************
- *  nsDiskCacheEntry
- *****************************************************************************/
-
-/**
- *  CreateCacheEntry()
- *
- *  Creates an nsCacheEntry and sets all fields except for the binding.
- */
-nsCacheEntry *
-nsDiskCacheEntry::CreateCacheEntry(nsCacheDevice *  device)
-{
-    nsCacheEntry * entry = nsnull;
-    nsresult       rv = nsCacheEntry::Create(mKeyStart,
-                                             nsICache::STREAM_BASED,
-                                             nsICache::STORE_ON_DISK,
-                                             device,
-                                             &entry);
-    if (NS_FAILED(rv) || !entry) return nsnull;
-    
-    entry->SetFetchCount(mFetchCount);
-    entry->SetLastFetched(mLastFetched);
-    entry->SetLastModified(mLastModified);
-    entry->SetExpirationTime(mExpirationTime);
-    entry->SetCacheDevice(device);
-    // XXX why does nsCacheService have to fill out device in BindEntry()?
-    entry->SetDataSize(mDataSize);
-    
-    rv = entry->UnflattenMetaData(&mKeyStart[mKeySize], mMetaDataSize);
-    if (NS_FAILED(rv)) {
-        delete entry;
-        return nsnull;
-    }
-    
-    return entry;                      
-}
-
-
-/**
- *  CheckConsistency()
- *
- *  Perform a few simple checks to verify the data looks reasonable.
- */
-PRBool
-nsDiskCacheEntry::CheckConsistency(PRUint32  size)
-{
-    if ((mHeaderVersion != nsDiskCache::kCurrentVersion) ||
-        (Size() > size) ||
-        (mKeySize == 0) ||
-        (mKeyStart[mKeySize - 1] != 0)) // key is null terminated
-        return PR_FALSE;
-    
-    return PR_TRUE;
-}
-
-
-/**
- *  CreateDiskCacheEntry(nsCacheEntry * entry)
- *
- *  Prepare an nsCacheEntry for writing to disk
- */
-nsDiskCacheEntry *
-CreateDiskCacheEntry(nsDiskCacheBinding *  binding)
-{
-    nsCacheEntry * entry = binding->mCacheEntry;
-    if (!entry)  return nsnull;
-    
-    PRUint32  keySize = entry->Key()->Length() + 1;
-    PRUint32  size = sizeof(nsDiskCacheEntry) +
-                     keySize + entry->MetaDataSize();
-    
-    // pad size so we can write to block files without overrunning buffer
-    PRInt32 pad = size;
-    if      (pad <  1024) pad =  1024;
-    else if (pad <  4096) pad =  4096;
-    else if (pad < 16384) pad = 16384;
-    // XXX be more precise
-    
-    nsDiskCacheEntry * diskEntry = (nsDiskCacheEntry *)new char[pad];
-    if (!diskEntry)  return nsnull;
-    
-    diskEntry->mHeaderVersion   = nsDiskCache::kCurrentVersion;
-    diskEntry->mMetaLocation    = binding->mRecord.MetaLocation();
-    diskEntry->mFetchCount      = entry->FetchCount();
-    diskEntry->mLastFetched     = entry->LastFetched();
-    diskEntry->mLastModified    = entry->LastModified();
-    diskEntry->mExpirationTime  = entry->ExpirationTime();
-    diskEntry->mDataSize        = entry->DataSize();
-    diskEntry->mKeySize         = keySize;
-    diskEntry->mMetaDataSize    = entry->MetaDataSize();
-    
-    nsCRT::memcpy(diskEntry->mKeyStart, entry->Key()->get(),keySize);
-    
-    // XXX FIXME FlattenMetaData should not allocate a buffer
-    char *    metaData = nsnull;
-    PRUint32  metaSize = 0;
-    nsresult rv = entry->FlattenMetaData(&metaData, &metaSize);
-    if (NS_FAILED(rv)) {
-        delete diskEntry;
-        return nsnull;
-    }
-    
-    diskEntry->mMetaDataSize    = metaSize;
-    if (metaSize)
-        nsCRT::memcpy(&diskEntry->mKeyStart[keySize], metaData, metaSize);
-    
-    delete metaData;
-    return  diskEntry;
-}
-
-
-/******************************************************************************
- *  nsDiskCacheEntryInfo
- *****************************************************************************/
-
-NS_IMPL_ISUPPORTS1(nsDiskCacheEntryInfo, nsICacheEntryInfo);
-
-NS_IMETHODIMP nsDiskCacheEntryInfo::GetClientID(char ** clientID)
-{
-    NS_ENSURE_ARG_POINTER(clientID);
-    return ClientIDFromCacheKey(nsLiteralCString(mDiskEntry->mKeyStart), clientID);
-}
-
-extern const char DISK_CACHE_DEVICE_ID[];
-NS_IMETHODIMP nsDiskCacheEntryInfo::GetDeviceID(char ** deviceID)
-{
-    NS_ENSURE_ARG_POINTER(deviceID);
-    *deviceID = nsCRT::strdup(mDeviceID);
-    return *deviceID ? NS_OK : NS_ERROR_OUT_OF_MEMORY;
-}
-
-
-NS_IMETHODIMP nsDiskCacheEntryInfo::GetKey(char ** clientKey)
-{
-    NS_ENSURE_ARG_POINTER(clientKey);
-    return ClientKeyFromCacheKey(nsLiteralCString(mDiskEntry->mKeyStart), clientKey);
-}
-
-NS_IMETHODIMP nsDiskCacheEntryInfo::GetFetchCount(PRInt32 *aFetchCount)
-{
-    NS_ENSURE_ARG_POINTER(aFetchCount);
-    *aFetchCount = mDiskEntry->mFetchCount;
-    return NS_OK;
-}
-
-NS_IMETHODIMP nsDiskCacheEntryInfo::GetLastFetched(PRUint32 *aLastFetched)
-{
-    NS_ENSURE_ARG_POINTER(aLastFetched);
-    *aLastFetched = mDiskEntry->mLastFetched;
-    return NS_OK;
-}
-
-NS_IMETHODIMP nsDiskCacheEntryInfo::GetLastModified(PRUint32 *aLastModified)
-{
-    NS_ENSURE_ARG_POINTER(aLastModified);
-    *aLastModified = mDiskEntry->mLastModified;
-    return NS_OK;
-}
-
-NS_IMETHODIMP nsDiskCacheEntryInfo::GetExpirationTime(PRUint32 *aExpirationTime)
-{
-    NS_ENSURE_ARG_POINTER(aExpirationTime);
-    *aExpirationTime = mDiskEntry->mExpirationTime;
-    return NS_OK;
-}
-
-NS_IMETHODIMP nsDiskCacheEntryInfo::IsStreamBased(PRBool *aStreamBased)
-{
-    NS_ENSURE_ARG_POINTER(aStreamBased);
-    *aStreamBased = PR_TRUE;
-    return NS_OK;
-}
-
-NS_IMETHODIMP nsDiskCacheEntryInfo::GetDataSize(PRUint32 *aDataSize)
-{
-    NS_ENSURE_ARG_POINTER(aDataSize);
-    *aDataSize = mDiskEntry->mDataSize;
-    return NS_OK;
-}

mozilla/netwerk/cache/src/nsDiskCacheEntry.h

@@ -1,126 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsMemoryCacheDevice.cpp, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s):
- *    Gordon Sheridan  <gordon@netscape.com>
- *    Patrick C. Beard <beard@netscape.com>
- */
-
-#ifndef _nsDiskCacheEntry_h_
-#define _nsDiskCacheEntry_h_
-
-#include "nsDiskCacheMap.h"
-
-#include "nsCacheEntry.h"
-
-#include "nsICacheVisitor.h"
-
-#include "nspr.h"
-#include "nscore.h"
-#include "nsError.h"
-
-
-
-/******************************************************************************
- *  nsDiskCacheEntry
- *****************************************************************************/
-struct nsDiskCacheEntry {
-    PRUint32        mHeaderVersion; // useful for stand-alone metadata files
-    PRUint32        mMetaLocation;  // for verification
-    PRInt32         mFetchCount;
-    PRUint32        mLastFetched;
-    PRUint32        mLastModified;
-    PRUint32        mExpirationTime;
-    PRUint32        mDataSize;
-    PRUint32        mKeySize;       // includes terminating null byte
-    PRUint32        mMetaDataSize;  // includes terminating null byte
-    char            mKeyStart[1];   // start of key data
-    //              mMetaDataStart = mKeyStart[mKeySize];
-
-    PRUint32        Size()    { return sizeof(nsDiskCacheEntry)
-                                     - sizeof(char) // subtract default key size
-                                     + mKeySize     // plus actual key size
-                                     + mMetaDataSize;
-                              }
-
-    nsCacheEntry *  CreateCacheEntry(nsCacheDevice *  device);
-                                     
-    PRBool          CheckConsistency(PRUint32  size);
-
-    void Swap()         // host to network (memory to disk)
-    {
-#if defined(IS_LITTLE_ENDIAN)   
-        mHeaderVersion      = ::PR_htonl(mHeaderVersion);
-        mMetaLocation       = ::PR_htonl(mMetaLocation);
-        mFetchCount         = ::PR_htonl(mFetchCount);
-        mLastFetched        = ::PR_htonl(mLastFetched);
-        mLastModified       = ::PR_htonl(mLastModified);
-        mExpirationTime     = ::PR_htonl(mExpirationTime);
-        mDataSize           = ::PR_htonl(mDataSize);
-        mKeySize            = ::PR_htonl(mKeySize);
-        mMetaDataSize       = ::PR_htonl(mMetaDataSize);
-#endif
-    }
-    
-    void Unswap()       // network to host (disk to memory)
-    {
-#if defined(IS_LITTLE_ENDIAN)
-        mHeaderVersion      = ::PR_ntohl(mHeaderVersion);
-        mMetaLocation       = ::PR_ntohl(mMetaLocation);
-        mFetchCount         = ::PR_ntohl(mFetchCount);
-        mLastFetched        = ::PR_ntohl(mLastFetched);
-        mLastModified       = ::PR_ntohl(mLastModified);
-        mExpirationTime     = ::PR_ntohl(mExpirationTime);
-        mDataSize           = ::PR_ntohl(mDataSize);
-        mKeySize            = ::PR_ntohl(mKeySize);
-        mMetaDataSize       = ::PR_ntohl(mMetaDataSize);
-#endif
-    }
-};
-
-nsDiskCacheEntry *  CreateDiskCacheEntry(nsDiskCacheBinding *  binding);
-
-
-
-/******************************************************************************
- *  nsDiskCacheEntryInfo
- *****************************************************************************/
-class nsDiskCacheEntryInfo : public nsICacheEntryInfo {
-public:
-    NS_DECL_ISUPPORTS
-    NS_DECL_NSICACHEENTRYINFO
-
-    nsDiskCacheEntryInfo(const char * deviceID, nsDiskCacheEntry * diskEntry)
-        : mDeviceID(deviceID)
-        , mDiskEntry(diskEntry)
-    {
-        NS_INIT_ISUPPORTS();
-    }
-
-    virtual ~nsDiskCacheEntryInfo() {}
-    
-    const char* Key() { return mDiskEntry->mKeyStart; }
-    
-private:
-    const char *        mDeviceID;
-    nsDiskCacheEntry *  mDiskEntry;
-};
-
-
-#endif /* _nsDiskCacheEntry_h_ */

mozilla/netwerk/cache/src/nsDiskCacheMap.cpp

@@ -1,836 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsDiskCacheMap.cpp, released March 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Patrick C. Beard <beard@netscape.com>
- *    Gordon Sheridan  <gordon@netscape.com>
- */
-
-#include "nsDiskCacheMap.h"
-#include "nsDiskCacheBinding.h"
-#include "nsDiskCacheEntry.h"
-
-#include "nsCache.h"
-
-#include "nsCRT.h"
-
-#include <string.h>
-
-
-/******************************************************************************
- *  nsDiskCacheBucket
- *****************************************************************************/
-
-void
-nsDiskCacheBucket::Swap()
-{
-    nsDiskCacheRecord * record = &mRecords[0];
-    for (int i = 0; i < kRecordsPerBucket; ++i) {
-        if (record->HashNumber() == 0)
-            break;
-        record->Swap();
-    }
-}
-
-void
-nsDiskCacheBucket::Unswap()
-{
-    nsDiskCacheRecord * record = &mRecords[0];
-    for (int i = 0; i < kRecordsPerBucket; ++i) {
-        if (record->HashNumber() == 0)
-            break;
-        record->Unswap();
-    }
-}
-
-
-PRUint32
-nsDiskCacheBucket::CountRecords()
-{
-    if (mRecords[0].HashNumber() == 0)  return 0;
-    
-    PRUint32 i      = kRecordsPerBucket >> 1;
-    PRUint32 offset = kRecordsPerBucket >> 2;
-    
-    while (offset > 0) {
-        if (mRecords[i].HashNumber())  i += offset;
-        else                           i -= offset;
-        offset >>= 1;
-    }
-    
-    if (mRecords[i].HashNumber() != 0)
-        ++i;
-    
-    return i;
-}
-
-
-PRUint32
-nsDiskCacheBucket::EvictionRank()
-{
-    PRUint32  rank = 0;
-    for (int i = CountRecords() - 1; i >= 0; --i) {
-        if (rank < mRecords[i].EvictionRank())
-            rank = mRecords[i].EvictionRank();
-    }
-    return rank;
-}
-
-
-PRInt32
-nsDiskCacheBucket::VisitEachRecord(nsDiskCacheRecordVisitor *  visitor,
-                                   PRUint32                    evictionRank,
-                                   PRUint32 *                  result)
-{
-    PRUint32 recordsDeleted = 0;
-    PRInt32  rv = kVisitNextRecord;
-    PRInt32  last  = CountRecords() - 1;
-    
-    // call visitor for each entry (equal or greater than evictionRank)
-    for (int i = last; i >= 0; i--) {
-        if (evictionRank > mRecords[i].EvictionRank())  continue;
-    
-        rv = visitor->VisitRecord(&mRecords[i]);
-        if (rv == kVisitNextRecord) continue;
-        
-        if (rv == kDeleteRecordAndContinue) {
-            mRecords[i] = mRecords[last];
-            mRecords[last].SetHashNumber(0);
-            --last;
-            ++recordsDeleted;
-            continue;
-        }
-
-        *result = recordsDeleted;
-        return kStopVisitingRecords;  // rv == kStopVisitingRecords
-    }
-    
-    *result = recordsDeleted;
-    return rv;
-}
-
-
-/******************************************************************************
- *  nsDiskCacheMap
- *****************************************************************************/
-
-/**
- *  File operations
- */
-
-nsresult
-nsDiskCacheMap::Open(nsILocalFile *  cacheDirectory)
-{
-    NS_ENSURE_ARG_POINTER(cacheDirectory);
-    if (mMapFD)  return NS_ERROR_ALREADY_INITIALIZED;
-
-    mCacheDirectory = cacheDirectory;   // save a reference for ourselves
-    
-    // create nsILocalFile for _CACHE_MAP_
-    nsresult rv;
-    nsCOMPtr<nsIFile> file;
-    rv = cacheDirectory->Clone(getter_AddRefs(file));
-    nsCOMPtr<nsILocalFile> localFile(do_QueryInterface(file, &rv));
-    if (NS_FAILED(rv))  return rv;
-    rv = localFile->Append("_CACHE_MAP_");
-    if (NS_FAILED(rv))  return rv;
-    
-    // open the file
-    rv = localFile->OpenNSPRFileDesc(PR_RDWR | PR_CREATE_FILE, 00666, &mMapFD);
-    if (NS_FAILED(rv))  return rv;  // unable to open or create file
-    
-    // check size of map file
-    PRUint32  mapSize = PR_Available(mMapFD);
-    if (mapSize < 0) {
-        rv = NS_ERROR_UNEXPECTED;
-        goto error_exit;
-    }
-    
-    if (mapSize == 0) {
-        // create the file - initialize in memory
-        mHeader.mVersion    = nsDiskCache::kCurrentVersion;
-        mHeader.mDataSize   = 0;
-        mHeader.mEntryCount = 0;
-        mHeader.mIsDirty = PR_TRUE;
-        for (int i = 0; i < kBucketsPerTable; ++i) {
-            mHeader.mEvictionRank[i] = 0;
-        }
-
-        nsCRT::zero(mHeader.reserved, nsDiskCacheHeader::kReservedBytes);
-        nsCRT::zero(mBuckets, sizeof(nsDiskCacheBucket) * kBucketsPerTable);
-        
-    } else if (mapSize == kCacheMapSize) {
-        // read it in
-        PRUint32 bytesRead = PR_Read(mMapFD, &mHeader, kCacheMapSize);
-        if (kCacheMapSize != bytesRead) {
-            rv = NS_ERROR_UNEXPECTED;
-            goto error_exit;
-        }
-        mHeader.Unswap();
-        if (mHeader.mIsDirty || mHeader.mVersion != nsDiskCache::kCurrentVersion) {
-            rv = NS_ERROR_FILE_CORRUPTED;
-            goto error_exit;
-        }
-        
-        // Unswap each bucket
-        for (PRUint32 i = 0; i < kBucketsPerTable; ++i) {
-            mBuckets[i].Unswap();
-        }
-        
-        // XXX verify entry count, check size(?)
-        
-    } else {
-        rv = NS_ERROR_FILE_CORRUPTED;
-        goto error_exit;
-    }
-
-    rv = OpenBlockFiles();
-    if (NS_FAILED(rv))  goto error_exit;
-
-    // set dirty bit and flush header
-    mHeader.mIsDirty    = PR_TRUE;
-    rv = FlushHeader();
-    if (NS_FAILED(rv))  goto error_exit;
-    
-    return NS_OK;
-    
-error_exit:
-    (void) CloseBlockFiles();
-    
-    if (mMapFD) {
-        (void) PR_Close(mMapFD);
-        mMapFD = nsnull;
-    }
-    
-    return rv;
-}
-
-
-nsresult
-nsDiskCacheMap::Close()
-{
-    if (!mMapFD)  return NS_OK;
-
-    // close block files
-    nsresult  rv = CloseBlockFiles();
-    if (NS_FAILED(rv)) goto exit;  // this is going to be a mess...
-    
-    // write map record buckets
-    rv = FlushBuckets(PR_FALSE);   // don't bother swapping buckets back
-    if (NS_FAILED(rv))  goto exit;
-    
-    // clear dirty bit
-    mHeader.mIsDirty    = PR_FALSE;
-
-    rv = FlushHeader();
-
-exit:
-    PRStatus err = PR_Close(mMapFD);
-    mMapFD = nsnull;
-    
-    if (NS_FAILED(rv))  return rv;
-    return err == PR_SUCCESS ? NS_OK : NS_ERROR_UNEXPECTED;
-}
-
-
-nsresult
-nsDiskCacheMap::FlushHeader()
-{
-    if (!mMapFD)  return NS_ERROR_NOT_AVAILABLE;
-    
-    // seek to beginning of cache map
-    PRInt32 filePos = PR_Seek(mMapFD, 0, PR_SEEK_SET);
-    if (filePos != 0)  return NS_ERROR_UNEXPECTED;
-    
-    // write the header
-    mHeader.Swap();
-    PRInt32 bytesWritten = PR_Write(mMapFD, &mHeader, sizeof(nsDiskCacheHeader));
-    mHeader.Unswap();
-    if (sizeof(nsDiskCacheHeader) != bytesWritten) {
-        return NS_ERROR_UNEXPECTED;
-    }
-    
-    return NS_OK;
-}
-
-
-nsresult
-nsDiskCacheMap::FlushBuckets(PRBool unswap)
-{
-    if (!mMapFD)  return NS_ERROR_NOT_AVAILABLE;
-    
-    // seek to beginning of buckets
-    PRInt32 filePos = PR_Seek(mMapFD, sizeof(nsDiskCacheHeader), PR_SEEK_SET);
-    if (filePos != sizeof(nsDiskCacheHeader))  return NS_ERROR_UNEXPECTED;
-    
-    // Swap each bucket
-    for (PRUint32 i = 0; i < kBucketsPerTable; ++i) {
-        mBuckets[i].Swap();
-    }
-    
-    PRInt32 bytesWritten = PR_Write(mMapFD, &mBuckets, sizeof(nsDiskCacheBucket) * kBucketsPerTable);
-
-    if (unswap) {
-        // Unswap each bucket
-        for (PRUint32 i = 0; i < kBucketsPerTable; ++i) {
-            mBuckets[i].Unswap();
-        }
-    }
-
-    if ( sizeof(nsDiskCacheBucket) * kBucketsPerTable != bytesWritten) {
-        return NS_ERROR_UNEXPECTED;
-    }
-    
-    return NS_OK;
-}
-
-
-/**
- *  Record operations
- */
-
-nsresult
-nsDiskCacheMap::AddRecord( nsDiskCacheRecord *  mapRecord,
-                           nsDiskCacheRecord *  oldRecord)
-{
-    nsresult            rv;
-    PRUint32            hashNumber = mapRecord->HashNumber();
-    nsDiskCacheBucket * bucket;
-    PRUint32            bucketIndex = GetBucketIndex(hashNumber);
-    int                 i;
-
-   oldRecord->SetHashNumber(0);  // signify no record
-
-    rv = GetBucketForHashNumber(hashNumber, &bucket);
-    if (NS_FAILED(rv))  return rv;
-    
-    nsDiskCacheRecord * mostEvictable = &bucket->mRecords[0];
-    for (i = 0; i < kRecordsPerBucket; ++i) {
-        if (bucket->mRecords[i].HashNumber() == 0) {
-            // stick the new record here
-            bucket->mRecords[i] = *mapRecord;
-            ++mHeader.mEntryCount;
-            
-            // update eviction rank in header if necessary
-            if (mHeader.mEvictionRank[bucketIndex] < mapRecord->EvictionRank())
-                mHeader.mEvictionRank[bucketIndex] = mapRecord->EvictionRank();
-
-NS_ASSERTION(mHeader.mEvictionRank[bucketIndex] == bucket->EvictionRank(), "whao!");
-            return NS_OK;
-        }
-        
-        if (bucket->mRecords[i].EvictionRank() > mostEvictable->EvictionRank())
-            mostEvictable = &bucket->mRecords[i];
-    }
-    
-    *oldRecord     = *mostEvictable;    // i == kRecordsPerBucket, so evict the mostEvictable
-    *mostEvictable = *mapRecord;        // replace it with the new record
-    
-    // check if we need to update mostEvictable entry in header
-    if ((oldRecord->HashNumber() != 0) ||
-         (mapRecord->EvictionRank() > mHeader.mEvictionRank[bucketIndex])) {
-         
-        mHeader.mEvictionRank[bucketIndex] = bucket->EvictionRank();
-    }
-
-NS_ASSERTION(mHeader.mEvictionRank[bucketIndex] == bucket->EvictionRank(), "whao!");    
-    return NS_OK;
-}
-
-
-nsresult
-nsDiskCacheMap::UpdateRecord( nsDiskCacheRecord *  mapRecord)
-{
-    PRUint32            hashNumber = mapRecord->HashNumber();
-    nsDiskCacheBucket * bucket;
-    nsresult            rv = GetBucketForHashNumber(hashNumber, &bucket);
-    if (NS_FAILED(rv))  return rv;
-
-    for (int i = 0; i < kRecordsPerBucket; ++i) {
-        if (bucket->mRecords[i].HashNumber() == mapRecord->HashNumber()) {
-            PRUint32 oldRank = bucket->mRecords[i].EvictionRank();
-
-            // stick the new record here            
-            bucket->mRecords[i] = *mapRecord;
-
-            // update eviction rank in header if necessary
-            PRUint32  bucketIndex = GetBucketIndex(mapRecord->HashNumber());
-            if (mHeader.mEvictionRank[bucketIndex] < mapRecord->EvictionRank())
-                mHeader.mEvictionRank[bucketIndex] = mapRecord->EvictionRank();
-            else if (mHeader.mEvictionRank[bucketIndex] == oldRank)
-                mHeader.mEvictionRank[bucketIndex] = bucket->EvictionRank();
-
-NS_ASSERTION(mHeader.mEvictionRank[bucketIndex] == bucket->EvictionRank(), "whao!");
-            return NS_OK;
-        }
-    }
-    return NS_ERROR_UNEXPECTED;
-}
-
-
-nsresult
-nsDiskCacheMap::FindRecord( PRUint32  hashNumber, nsDiskCacheRecord *  result)
-{
-    nsDiskCacheBucket * bucket;
-    nsresult rv = GetBucketForHashNumber(hashNumber, &bucket);
-    if (NS_FAILED(rv))  return rv;
-    
-    for (int i = 0; i < kRecordsPerBucket; ++i) {
-        if (bucket->mRecords[i].HashNumber() == 0)  break;
-            
-        if (bucket->mRecords[i].HashNumber() == hashNumber) {
-            *result = bucket->mRecords[i];    // copy the record
-            NS_ASSERTION(result->ValidRecord(), "bad cache map record");
-            return NS_OK;
-        }
-    }
-    return NS_ERROR_CACHE_KEY_NOT_FOUND;
-}
-
-
-nsresult
-nsDiskCacheMap::DeleteRecord( nsDiskCacheRecord *  mapRecord)
-{
-    nsDiskCacheBucket * bucket;
-    nsresult rv = GetBucketForHashNumber(mapRecord->HashNumber(), &bucket);
-    if (NS_FAILED(rv))  return rv;
-    
-    PRUint32 count = bucket->CountRecords();
-    for (PRUint32 i = 0; i < count; ++i) {        
-        if (bucket->mRecords[i].HashNumber() == mapRecord->HashNumber()) {
-            // found it, now delete it.
-            PRUint32  evictionRank = bucket->mRecords[i].EvictionRank();
-            NS_ASSERTION(evictionRank == mapRecord->EvictionRank(), "evictionRank out of sync");
-            if (i != (count - 1)) { // if not the last record, shift last record into opening
-                bucket->mRecords[i] = bucket->mRecords[count - 1];
-            }
-            bucket->mRecords[count - 1].SetHashNumber(0);   // clear last record
-            mHeader.mEntryCount--;
-            // update eviction rank
-            PRUint32  bucketIndex = GetBucketIndex(mapRecord->HashNumber());
-            if (mHeader.mEvictionRank[bucketIndex] <= evictionRank) {
-                mHeader.mEvictionRank[bucketIndex] = bucket->EvictionRank();
-            }
-
-NS_ASSERTION(mHeader.mEvictionRank[bucketIndex] == bucket->EvictionRank(), "whao!");
-            return NS_OK;
-        }
-    }
-    return NS_ERROR_UNEXPECTED;
-}
-
-
-/**
- *  VisitRecords
- *
- *  Visit every record in cache map in the most convenient order
- */
-nsresult
-nsDiskCacheMap::VisitRecords( nsDiskCacheRecordVisitor *  visitor)
-{
-    for (PRUint32 i = 0; i < kBucketsPerTable; ++i) {
-        // get bucket
-        PRUint32 recordsDeleted;
-        PRBool continueFlag = mBuckets[i].VisitEachRecord(visitor, 0, &recordsDeleted);
-        if (recordsDeleted) {
-            // recalc eviction rank
-            mHeader.mEvictionRank[i] = mBuckets[i].EvictionRank();
-            mHeader.mEntryCount -= recordsDeleted;
-            // XXX write bucket
-        }
-NS_ASSERTION(mHeader.mEvictionRank[i] == mBuckets[i].EvictionRank(), "whao!");
-        if (!continueFlag)  break;
-    }
-    
-    return NS_OK;
-}
-
-
-/**
- *  EvictRecords
- *
- *  Just like VisitRecords, but visits the records in order of their eviction rank
- */
-nsresult
-nsDiskCacheMap::EvictRecords( nsDiskCacheRecordVisitor * visitor)
-{
-    while (1) {
-    
-        // find bucket with highest eviction rank
-        PRUint32    rank  = 0;
-        PRUint32    index = 0;
-        for (int i = 0; i < kBucketsPerTable; ++i) {
-            if (rank < mHeader.mEvictionRank[i]) {
-                rank = mHeader.mEvictionRank[i];
-                index = i;
-            }
-        }
-        
-NS_ASSERTION(mHeader.mEvictionRank[index] == mBuckets[index].EvictionRank(),
-    "header eviction rank out of sync");
-            
-        // visit records in bucket with eviction ranks >= target eviction rank
-        PRUint32 recordsDeleted;
-        PRBool continueFlag = mBuckets[index].VisitEachRecord(visitor, rank, &recordsDeleted);
-        if (recordsDeleted) {
-            // recalc eviction rank
-            mHeader.mEvictionRank[index] = mBuckets[index].EvictionRank();
-            mHeader.mEntryCount -= recordsDeleted;
-            // XXX write bucket
-        }
-        if (!continueFlag)  break;
-        
-        // break if visitor returned stop
-        
-    }
-    return NS_OK;
-}
-
-
-
-nsresult
-nsDiskCacheMap::OpenBlockFiles()
-{
-    // create nsILocalFile for block file
-    nsCOMPtr<nsILocalFile> blockFile;
-    nsresult rv;
-    
-    for (int i = 0; i < 3; ++i) {
-        rv = GetBlockFileForIndex(i, getter_AddRefs(blockFile));
-        if (NS_FAILED(rv))  goto error_exit;
-    
-        PRUint32 blockSize = GetBlockSizeForIndex(i);
-        rv = mBlockFile[i].Open(blockFile, blockSize);
-        if (NS_FAILED(rv)) goto error_exit;
-    }
-    return NS_OK;
-
-error_exit:
-    (void)CloseBlockFiles();        // we already have an error to report
-    return rv;
-}
-
-
-nsresult
-nsDiskCacheMap::CloseBlockFiles()
-{
-    nsresult rv, rv2 = NS_OK;
-    for (int i=0; i < 3; ++i) {
-        rv = mBlockFile[i].Close();
-        if (NS_FAILED(rv))  rv2 = rv;   // if one or more errors, report at least one
-    }
-    return rv2;
-}
-
-
-nsresult
-nsDiskCacheMap::ReadDiskCacheEntry(nsDiskCacheRecord * record, nsDiskCacheEntry ** result)
-{
-    nsresult            rv;
-    nsDiskCacheEntry *  diskEntry  = nsnull;
-    PRUint32            metaFile   = record->MetaFile();
-    PRFileDesc *        fd         = nsnull;
-    *result = nsnull;
-    
-    if (metaFile == 0) {  // entry/metadata stored in separate file
-        // open and read the file
-        nsCOMPtr<nsILocalFile> file;
-        rv = GetLocalFileForDiskCacheRecord(record, nsDiskCache::kMetaData, getter_AddRefs(file));
-        if (NS_FAILED(rv))  return rv;
-
-        PRFileDesc * fd = nsnull;
-        nsresult rv = file->OpenNSPRFileDesc(PR_RDONLY, 00666, &fd);
-        if (NS_FAILED(rv))  return rv;
-        
-        PRInt32 fileSize = PR_Available(fd);
-        if (fileSize < 0) {
-            // XXX an error occurred. We could call PR_GetError(), but how would that help?
-            rv = NS_ERROR_UNEXPECTED;
-            goto exit;
-        }
-
-        diskEntry = (nsDiskCacheEntry *) new char[fileSize];
-        if (!diskEntry) {
-            rv = NS_ERROR_OUT_OF_MEMORY;
-            goto exit;
-        }
-        
-        PRInt32 bytesRead = PR_Read(fd, diskEntry, fileSize);
-        if (bytesRead < fileSize) {
-            rv = NS_ERROR_UNEXPECTED;
-            goto exit;
-        }
-
-    } else if (metaFile < 4) {  // XXX magic number: use constant
-        // entry/metadata stored in cache block file
-        
-        // allocate buffer
-        PRUint32 blockSize  = GetBlockSizeForIndex(metaFile - 1);
-        PRUint32 blockCount = record->MetaBlockCount();
-        diskEntry = (nsDiskCacheEntry *) new char[blockSize * blockCount];
-        
-        // read diskEntry
-        rv = mBlockFile[metaFile - 1].ReadBlocks((char *)diskEntry,
-                                                 record->MetaStartBlock(),
-                                                 blockCount);
-        if (NS_FAILED(rv))  goto exit;
-    }
-    
-    diskEntry->Unswap();    // disk to memory
-    // pass ownership to caller
-    *result = diskEntry;
-    diskEntry = nsnull;
-
-exit:
-    // XXX auto ptr would be nice
-    if (fd) (void) PR_Close(fd);
-    delete diskEntry;
-    return rv;
-}
-
-
-nsresult
-nsDiskCacheMap::WriteDiskCacheEntry(nsDiskCacheBinding *  binding)
-{
-    nsresult            rv        = NS_OK;
-    nsDiskCacheEntry *  diskEntry =  CreateDiskCacheEntry(binding);
-    if (!diskEntry)  return NS_ERROR_UNEXPECTED;
-    
-    binding->mRecord.SetEvictionRank(ULONG_MAX - SecondsFromPRTime(PR_Now()));
-    
-    PRUint32    size = diskEntry->Size();
-    PRUint32    fileIndex;
-    PRUint32    blocks;
-    
-    if (size < 1024) {             // block size 256
-        fileIndex = 1;
-        blocks    = size / 256 + 1;
-    } else if (size < 4096) {      // block size 1024
-        fileIndex = 2;
-        blocks    = size / 1024 + 1;
-    } else if (size < 16384) {     // block size 4096
-        fileIndex = 3;
-        blocks    = size / 4096 + 1;
-    } else {                       // separate file
-        fileIndex = 0;
-    }
-    
-    PRUint32  metaFile   = binding->mRecord.MetaFile();
-
-    // Deallocate old storage if necessary    
-    if (binding->mRecord.MetaLocationInitialized()) {
-        // we have existing storage
-
-        if ((metaFile == 0) && (fileIndex == 0)) {  // keeping the separate file
-            // just decrement total
-            // XXX if bindRecord.MetaFileSize == USHRT_MAX, stat the file to see how big it is
-            DecrementTotalSize(binding->mRecord.MetaFileSize() * 1024);
-            NS_ASSERTION(binding->mRecord.MetaFileGeneration() == binding->mGeneration,
-                         "generations out of sync");
-        } else {
-            rv = DeleteStorage(&binding->mRecord, nsDiskCache::kMetaData);
-            if (NS_FAILED(rv))  return rv;
-        }
-    }
-        
-    if (fileIndex == 0) {
-        // Write entry data to separate file
-        PRUint32 metaFileSizeK = ((size + 0x0399) >> 10); // round up to nearest 1k
-        nsCOMPtr<nsILocalFile> localFile;
-        
-        // XXX handle metaFileSizeK > USHRT_MAX
-        binding->mRecord.SetMetaFileGeneration(binding->mGeneration);
-        binding->mRecord.SetMetaFileSize(metaFileSizeK);
-        rv = UpdateRecord(&binding->mRecord);
-        if (NS_FAILED(rv))  goto exit;
-
-        rv = GetLocalFileForDiskCacheRecord(&binding->mRecord,
-                                            nsDiskCache::kMetaData,
-                                            getter_AddRefs(localFile));
-        if (NS_FAILED(rv))  goto exit;
-        
-        // open the file
-        PRFileDesc * fd;
-        rv = localFile->OpenNSPRFileDesc(PR_RDWR | PR_TRUNCATE | PR_CREATE_FILE, 00666, &fd);
-        if (NS_FAILED(rv))  goto exit;  // unable to open or create file
-
-        // write the file
-        diskEntry->Swap();
-        PRInt32 bytesWritten = PR_Write(fd, diskEntry, size);
-        
-        PRStatus err = PR_Close(mMapFD);
-        if ((bytesWritten != size) || (err != PR_SUCCESS)) {
-            rv = NS_ERROR_UNEXPECTED;
-            goto exit;
-        }
-        // XXX handle metaFileSizeK == USHRT_MAX
-        IncrementTotalSize(metaFileSizeK * 1024);
-        
-    } else {
-        // write entry data to disk cache block file
-        PRInt32 startBlock = mBlockFile[fileIndex - 1].AllocateBlocks(blocks);
-        if (startBlock < 0) {
-            rv = NS_ERROR_UNEXPECTED;
-            goto exit;
-        }
-        
-        // update binding and cache map record
-        binding->mRecord.SetMetaBlocks(fileIndex, startBlock, blocks);
-        rv = UpdateRecord(&binding->mRecord);
-        if (NS_FAILED(rv))  goto exit;
-        // XXX we should probably write out bucket ourselves
-
-        // write data
-        diskEntry->Swap();
-        rv = mBlockFile[fileIndex - 1].WriteBlocks(diskEntry, startBlock, blocks);
-        if (NS_FAILED(rv))  goto exit;
-        
-        IncrementTotalSize(blocks * GetBlockSizeForIndex(fileIndex - 1));
-    }
-
-exit:
-
-    return rv;
-}
-
-
-nsresult
-nsDiskCacheMap::DoomRecord(nsDiskCacheRecord * record)
-{
-    nsresult  rv = DeleteRecord(record);
-    // XXX future: add record to doomed record journal
-
-    return rv;
-}
-
-
-nsresult
-nsDiskCacheMap::DeleteStorage(nsDiskCacheRecord * record)
-{
-    nsresult  rv1 = DeleteStorage(record, nsDiskCache::kData);
-    nsresult  rv2 = DeleteStorage(record, nsDiskCache::kMetaData);
-    return NS_FAILED(rv1) ? rv1 : rv2;
-}
-
-
-nsresult
-nsDiskCacheMap::DeleteStorage(nsDiskCacheRecord * record, PRBool metaData)
-{
-    nsresult    rv;
-    PRUint32    fileIndex = metaData ? record->MetaFile() : record->DataFile();
-    nsCOMPtr<nsIFile> file;
-    
-    if (fileIndex == 0) {
-        // delete the file
-        PRUint32  sizeK = metaData ? record->MetaFileSize() : record->DataFileSize();
-        // XXX if sizeK == USHRT_MAX, stat file for actual size
-
-        rv = GetFileForDiskCacheRecord(record, metaData, getter_AddRefs(file));
-        if (NS_SUCCEEDED(rv)) {
-            rv = file->Delete(PR_FALSE);    // false == non-recursive
-        }
-        DecrementTotalSize(sizeK * 1024);
-        
-    } else if (fileIndex < 4) {
-        // deallocate blocks
-        PRInt32  startBlock = metaData ? record->MetaStartBlock() : record->DataStartBlock();
-        PRInt32  blockCount = metaData ? record->MetaBlockCount() : record->DataBlockCount();
-        
-        rv = mBlockFile[fileIndex - 1].DeallocateBlocks(startBlock, blockCount);
-        DecrementTotalSize(blockCount * GetBlockSizeForIndex(fileIndex - 1));
-    }
-    
-    return rv;
-}
-
-
-nsresult
-nsDiskCacheMap::DeleteRecordAndStorage(nsDiskCacheRecord * record)
-{
-    nsresult  rv1 = DeleteStorage(record);
-    nsresult  rv2 = DeleteRecord(record);
-    return NS_FAILED(rv1) ? rv1 : rv2;
-}
-
-
-nsresult
-nsDiskCacheMap::GetFileForDiskCacheRecord(nsDiskCacheRecord * record,
-                                             PRBool              meta,
-                                             nsIFile **          result)
-{
-    if (!mCacheDirectory)  return NS_ERROR_NOT_AVAILABLE;
-    
-    nsCOMPtr<nsIFile> file;
-    nsresult rv = mCacheDirectory->Clone(getter_AddRefs(file));
-    if (NS_FAILED(rv))  return rv;
-    
-    PRInt16 generation = record->Generation();
-    char name[32];
-    ::sprintf(name, "%08X%c%02X", record->HashNumber(),  (meta ? 'm' : 'd'), generation);
-    rv = file->Append(name);
-    if (NS_FAILED(rv))  return rv;
-    
-    NS_IF_ADDREF(*result = file);
-    return rv;
-}
-
-nsresult
-nsDiskCacheMap::GetLocalFileForDiskCacheRecord(nsDiskCacheRecord * record,
-                                                  PRBool              meta,
-                                                  nsILocalFile **     result)
-{
-    nsCOMPtr<nsIFile> file;
-    nsresult rv = GetFileForDiskCacheRecord(record, meta, getter_AddRefs(file));
-    if (NS_FAILED(rv))  return rv;
-    
-    nsCOMPtr<nsILocalFile> localFile = do_QueryInterface(file, &rv);
-    if (NS_FAILED(rv))  return rv;
-    
-    NS_IF_ADDREF(*result = localFile);
-    return rv;
-}
-
-
-nsresult
-nsDiskCacheMap::GetBlockFileForIndex(PRUint32 index, nsILocalFile ** result)
-{
-    if (!mCacheDirectory)  return NS_ERROR_NOT_AVAILABLE;
-    
-    nsCOMPtr<nsIFile> file;
-    nsresult rv = mCacheDirectory->Clone(getter_AddRefs(file));
-    if (NS_FAILED(rv))  return rv;
-    
-    char name[32];
-    ::sprintf(name, "_CACHE_%03d_", index + 1);
-    rv = file->Append(name);
-    if (NS_FAILED(rv))  return rv;
-    
-    nsCOMPtr<nsILocalFile> localFile = do_QueryInterface(file, &rv);
-    NS_IF_ADDREF(*result = localFile);
-
-    return rv;
-}
-
-
-PRUint32
-nsDiskCacheMap::GetBlockSizeForIndex(PRUint32 index)
-{
-    return 256 << (2 * (index));  // XXX magic numbers
-
-}

mozilla/netwerk/cache/src/nsDiskCacheMap.h

@@ -1,499 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsDiskCacheMap.h, released March 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Patrick C. Beard <beard@netscape.com>
- *    Gordon Sheridan  <gordon@netscape.com>
- */
-
-#ifndef _nsDiskCacheMap_h_
-#define _nsDiskCacheMap_h_
-
-#include <limits.h>
-
-#include "prtypes.h"
-#include "prnetdb.h"
-#include "nsDebug.h"
-#include "nsError.h"
-#include "nsILocalFile.h"
-
-#include "nsDiskCache.h"
-#include "nsDiskCacheBlockFile.h"
- 
- 
-class nsDiskCacheBinding;
-class nsDiskCacheEntry;
-
-/******************************************************************************
- *  nsDiskCacheRecord
- *
- *   Cache Location Format
- *
- *    1000 0000 0000 0000 0000 0000 0000 0000 : initialized bit
- *
- *    0011 0000 0000 0000 0000 0000 0000 0000 : File Selector (0 = separate file)
- *    0000 0011 0000 0000 0000 0000 0000 0000 : number of extra contiguous blocks 1-4
- *    0100 1100 0000 0000 0000 0000 0000 0000 : reserved bits
- *    0000 0000 1111 1111 1111 1111 1111 1111 : block#  0-16777216 (2^24)
- *
- *    0000 0000 1111 1111 1111 1111 0000 0000 : eFileSizeMask (size of file in k: see note)
- *    0000 0000 0000 0000 0000 0000 1111 1111 : eFileGenerationMask
- *
- *  File Selector:
- *      0 = separate file on disk
- *      1 = 256 byte block file
- *      2 = 1k block file
- *      3 = 4k block file
- *
- *  eFileSizeMask note:  Files larger than 64 Mb have zero size stored in the
- *                       location.  The file itself must be examined to determine
- *                       its actual size.
- *
- *****************************************************************************/
-
-class nsDiskCacheRecord {
-
-private:
-    PRUint32    mHashNumber;
-    PRUint32    mEvictionRank;
-    PRUint32    mDataLocation;
-    PRUint32    mMetaLocation;
- 
-    enum {
-        eLocationInitializedMask = 0x80000000,
-        
-        eLocationSelectorMask    = 0x30000000,
-        eLocationSelectorOffset  = 28,
-        
-        eExtraBlocksMask         = 0x03000000,
-        eExtraBlocksOffset       = 24,
-        
-        eReservedMask            = 0x4C000000,
-        
-        eBlockNumberMask         = 0x00FFFFFF,
-
-        eFileSizeMask            = 0x00FFFF00,
-        eFileSizeOffset          = 8,
-        eFileGenerationMask      = 0x000000FF,
-        eFileReservedMask        = 0x4F000000
-        
-    };
-
-public:
-    nsDiskCacheRecord()
-        :   mHashNumber(0), mEvictionRank(0), mDataLocation(0), mMetaLocation(0)
-    {
-    }
-    
-    PRBool  ValidRecord()
-    {
-        if ((mDataLocation & eReservedMask) || (mMetaLocation & eReservedMask))
-            return PR_FALSE;
-        return PR_TRUE;
-    }
-    
-    // HashNumber accessors
-    PRUint32  HashNumber() const                  { return mHashNumber; }
-    void      SetHashNumber( PRUint32 hashNumber) { mHashNumber = hashNumber; }
-
-    // EvictionRank accessors
-    PRUint32  EvictionRank() const              { return mEvictionRank; }
-    void      SetEvictionRank( PRUint32 rank)   { mEvictionRank = rank; }
-
-    // DataLocation accessors
-    PRBool    DataLocationInitialized() { return mDataLocation & eLocationInitializedMask; }
-    
-    PRUint32  DataLocation()                      { return mDataLocation; }
-    void      SetDataLocation( PRUint32 location) { mDataLocation = location; }
-    
-    PRUint32  DataFile() const
-    {
-        return (PRUint32)(mDataLocation & eLocationSelectorMask) >> eLocationSelectorOffset;
-    }
-
-    void      SetDataBlocks( PRUint32 index, PRUint32 startBlock, PRUint32 blockCount)
-    {
-        // clear everything
-        mDataLocation = 0;
-        
-        // set file index
-        NS_ASSERTION( index < 4,"invalid location index");
-        NS_ASSERTION( index > 0,"invalid location index");
-        mDataLocation |= (index << eLocationSelectorOffset) & eLocationSelectorMask;
-
-        // set startBlock
-        NS_ASSERTION(startBlock == (startBlock & eBlockNumberMask), "invalid block number");
-        mDataLocation |= startBlock & eBlockNumberMask;
-        
-        // set blockCount
-        NS_ASSERTION( (blockCount>=1) && (blockCount<=4),"invalid block count");
-        blockCount = --blockCount;
-        mDataLocation |= (blockCount << eExtraBlocksOffset) & eExtraBlocksMask;
-        
-        mDataLocation |= eLocationInitializedMask;
-    }
-
-    PRUint32   DataBlockCount() const
-    {
-        return (PRUint32)((mDataLocation & eExtraBlocksMask) >> eExtraBlocksOffset) + 1;
-    }
-
-    PRUint32   DataStartBlock() const
-    {
-        return (mDataLocation & eBlockNumberMask);
-    }
-    
-    PRUint32   DataFileSize() const  { return (mDataLocation & eFileSizeMask) >> eFileSizeOffset; }
-    void       SetDataFileSize(PRUint32  size)
-    {
-        NS_ASSERTION((mDataLocation & eFileReservedMask) == 0, "bad location");
-        mDataLocation &= ~eFileSizeMask;    // clear eFileSizeMask
-        mDataLocation |= (size << eFileSizeOffset) & eFileSizeMask;
-    }
-
-    PRUint16   DataFileGeneration() const
-    {
-        return (mDataLocation & eFileGenerationMask);
-    }
-
-    void       SetDataFileGeneration( PRUint8 generation)
-    {
-        // clear everything, (separate file index = 0)
-        mDataLocation = 0;
-        mDataLocation |= generation & eFileGenerationMask;
-        mDataLocation |= eLocationInitializedMask;
-    }
-
-    // MetaLocation accessors
-    PRBool    MetaLocationInitialized() { return mMetaLocation & eLocationInitializedMask; }
-    
-    PRUint32  MetaLocation()                     { return mMetaLocation; }
-    void      SetMetaLocation( PRUint32 location) { mMetaLocation = location; }
-    
-    PRUint32  MetaFile() const
-    {
-        return (PRUint32)(mMetaLocation & eLocationSelectorMask) >> eLocationSelectorOffset;
-    }
-
-    void      SetMetaBlocks( PRUint32 index, PRUint32 startBlock, PRUint32 blockCount)
-    {
-        // clear everything
-        mMetaLocation = 0;
-        
-        // set file index
-        NS_ASSERTION( index < 4, "invalid location index");
-        NS_ASSERTION( index > 0, "invalid location index");
-        mMetaLocation |= (index << eLocationSelectorOffset) & eLocationSelectorMask;
-
-        // set startBlock
-        NS_ASSERTION(startBlock == (startBlock & eBlockNumberMask), "invalid block number");
-        mMetaLocation |= startBlock & eBlockNumberMask;
-        
-        // set blockCount
-        NS_ASSERTION( (blockCount>=1) && (blockCount<=4),"invalid block count");
-        blockCount = --blockCount;
-        mMetaLocation |= (blockCount << eExtraBlocksOffset) & eExtraBlocksMask;
-        
-        mMetaLocation |= eLocationInitializedMask;
-    }
-
-    PRUint32   MetaBlockCount() const
-    {
-        return (PRUint32)((mMetaLocation & eExtraBlocksMask) >> eExtraBlocksOffset) + 1;
-    }
-
-    PRUint32   MetaStartBlock() const
-    {
-        return (mMetaLocation & eBlockNumberMask);
-    }
-
-    PRUint32   MetaFileSize() const  { return (mMetaLocation & eFileSizeMask) >> eFileSizeOffset; }
-    void       SetMetaFileSize(PRUint32  size)
-    {
-        mMetaLocation &= ~eFileSizeMask;    // clear eFileSizeMask
-        mMetaLocation |= (size << eFileSizeOffset) & eFileSizeMask;
-    }
-
-    PRUint16   MetaFileGeneration() const
-    {
-        return (mMetaLocation & eFileGenerationMask);
-    }
-
-    void       SetMetaFileGeneration( PRUint8 generation)
-    {
-        // clear everything, (separate file index = 0)
-        mMetaLocation = 0;
-        mMetaLocation |= generation & eFileGenerationMask;
-        mMetaLocation |= eLocationInitializedMask;
-    }
-
-    PRUint8   Generation() const
-    {
-        if ((mDataLocation & eLocationInitializedMask)  &&
-            (DataFile() == 0))
-            return DataFileGeneration();
-            
-        if ((mMetaLocation & eLocationInitializedMask)  &&
-            (MetaFile() == 0))
-            return MetaFileGeneration();
-        
-        return 0;  // no generation
-    }
-
-
-
-    void        Swap()
-    {
-#if defined(IS_LITTLE_ENDIAN)
-        mHashNumber   = ::PR_htonl(mHashNumber);
-        mEvictionRank = ::PR_htonl(mEvictionRank);
-        mDataLocation = ::PR_htonl(mDataLocation);
-        mMetaLocation = ::PR_htonl(mMetaLocation);
-#endif
-    }
-    
-    void        Unswap()
-    {
-#if defined(IS_LITTLE_ENDIAN)
-        mHashNumber   = ::PR_ntohl(mHashNumber);
-        mEvictionRank = ::PR_ntohl(mEvictionRank);
-        mDataLocation = ::PR_ntohl(mDataLocation);
-        mMetaLocation = ::PR_ntohl(mMetaLocation);
-#endif
-    }
-
-};
-
-
-/******************************************************************************
- *  nsDiskCacheRecordVisitor
- *****************************************************************************/
-
-enum {  kDeleteRecordAndContinue = -1,
-        kStopVisitingRecords     =  0,
-        kVisitNextRecord         =  1
-};
-
-class nsDiskCacheRecordVisitor {
-    public:
-
-    virtual PRInt32  VisitRecord( nsDiskCacheRecord *  mapRecord) = 0;
-};
-
-
-/******************************************************************************
- *  nsDiskCacheBucket
- *****************************************************************************/
-enum {
-    kRecordsPerBucket = 256,
-    kBucketsPerTable = (1 << 5)         // must be a power of 2!
-};
-
-struct nsDiskCacheBucket {
-    nsDiskCacheRecord   mRecords[kRecordsPerBucket];
-    
-    void      Swap();
-    void      Unswap();
-    PRUint32  CountRecords();
-    PRUint32  EvictionRank();   // return largest rank in bucket
-    PRInt32   VisitEachRecord( nsDiskCacheRecordVisitor *  visitor,
-                               PRUint32                    evictionRank,
-                               PRUint32 *                  recordsDeleted);
-};
-
-
-/******************************************************************************
- *  nsDiskCacheHeader
- *****************************************************************************/
-
-struct nsDiskCacheHeader {
-    PRUint32    mVersion;                           // cache version.
-    PRInt32     mDataSize;                          // size of cache in bytes.
-    PRInt32     mEntryCount;                        // number of entries stored in cache.
-    PRUint32    mIsDirty;                           // dirty flag.
-    PRUint32    mEvictionRank[kBucketsPerTable];
-    
-    // pad to blocksize
-    enum { kReservedBytes = sizeof(nsDiskCacheBucket)
-                            - sizeof(PRUint32) * 4      // version, size, count, dirty
-                            - sizeof(PRUint32) * kBucketsPerTable   // eviction array
-    };
-                            
-    PRUint8     reserved[kReservedBytes];
-
-    // XXX need a bitmap?
-    
-    nsDiskCacheHeader()
-        : mVersion(nsDiskCache::kCurrentVersion)
-        , mDataSize(0)
-        , mEntryCount(0)
-        , mIsDirty(PR_TRUE)
-    {}
-
-    void        Swap()
-    {
-#if defined(IS_LITTLE_ENDIAN)
-        mVersion     = ::PR_htonl(mVersion);
-        mDataSize    = ::PR_htonl(mDataSize);
-        mEntryCount  = ::PR_htonl(mEntryCount);
-        mIsDirty     = ::PR_htonl(mIsDirty);
-#endif
-    }
-    
-    void        Unswap()
-    {
-#if defined(IS_LITTLE_ENDIAN)
-        mVersion     = ::PR_ntohl(mVersion);
-        mDataSize    = ::PR_ntohl(mDataSize);
-        mEntryCount  = ::PR_ntohl(mEntryCount);
-        mIsDirty     = ::PR_ntohl(mIsDirty);
-#endif
-    }
-};
-
-
-/******************************************************************************
- *  nsDiskCacheMap
- *****************************************************************************/
-
-// XXX fixed capacity for 8192 entries. Future: make dynamic
-
-enum {
-    kCacheMapSize = sizeof(nsDiskCacheHeader) +
-                    kBucketsPerTable * sizeof(nsDiskCacheBucket)
-};
-
-
-class nsDiskCacheMap {
-public:
-
-     nsDiskCacheMap()
-        : mCacheDirectory(nsnull)
-        , mMapFD(nsnull)
-        {
-            NS_ASSERTION(sizeof(nsDiskCacheHeader) == sizeof(nsDiskCacheBucket), "structure misalignment");
-        }
-    ~nsDiskCacheMap()                   { (void) Close(); }
-
-/**
- *  File Operations
- *
- *  Open
- *
- *  Creates a new cache map file if one doesn't exist.
- *  Returns error if it detects change in format or cache wasn't closed.
- */
-    nsresult  Open( nsILocalFile *  cacheDirectory);
-    nsresult  Close();
-
-//  nsresult  Flush();
-    nsresult  FlushHeader();
-    nsresult  FlushBuckets( PRBool unswap);
-
-/**
- *  Record operations
- */
-    nsresult AddRecord( nsDiskCacheRecord *  mapRecord, nsDiskCacheRecord * oldRecord);
-    nsresult UpdateRecord( nsDiskCacheRecord *  mapRecord);
-    nsresult FindRecord( PRUint32  hashNumber, nsDiskCacheRecord *  mapRecord);
-    nsresult DeleteRecord( nsDiskCacheRecord *  mapRecord);
-    nsresult VisitRecords( nsDiskCacheRecordVisitor * visitor);
-    nsresult EvictRecords( nsDiskCacheRecordVisitor * visitor);
-
-/**
- *  Disk Entry operations
- */
-    nsresult    DoomRecord( nsDiskCacheRecord *  record);
-    nsresult    DeleteStorage( nsDiskCacheRecord *  record);
-    nsresult    DeleteRecordAndStorage( nsDiskCacheRecord *  record);
-
-    nsresult    GetFileForDiskCacheRecord( nsDiskCacheRecord * record,
-                                           PRBool              meta,
-                                           nsIFile **          result);
-                                          
-    nsresult    GetLocalFileForDiskCacheRecord( nsDiskCacheRecord *  record,
-                                                PRBool               meta,
-                                                nsILocalFile **      result);
-
-    nsresult    ReadDiskCacheEntry( nsDiskCacheRecord *  record,
-                                    nsDiskCacheEntry **  result);
-
-    nsresult    WriteDiskCacheEntry( nsDiskCacheBinding *  binding);
-    
-    /**
-     *  Statistical Operations
-     */
-    void     IncrementTotalSize( PRInt32  delta)
-             {
-                NS_ASSERTION(mHeader.mDataSize >= 0, "disk cache size negative?");
-                mHeader.mDataSize += delta;
-                mHeader.mIsDirty   = PR_TRUE;
-             }
-             
-    void     DecrementTotalSize( PRInt32  delta)
-             {
-                mHeader.mDataSize -= delta;
-                mHeader.mIsDirty   = PR_TRUE;
-                NS_ASSERTION(mHeader.mDataSize >= 0, "disk cache size negative?");
-             }
-    
-    PRInt32  TotalSize()   { return mHeader.mDataSize; }
-    
-    PRInt32  EntryCount()  { return mHeader.mEntryCount; }
-
-
-private:
-
-    /**
-     *  Private methods
-     */
-    nsresult    OpenBlockFiles();
-    nsresult    CloseBlockFiles();
-
-    nsresult    GetBlockFileForIndex( PRUint32 index, nsILocalFile ** result);
-    PRUint32    GetBlockSizeForIndex( PRUint32 index);
-    
-    nsresult    DeleteStorage( nsDiskCacheRecord * record, PRBool metaData);
-
-    nsresult GetBucketForHashNumber( PRUint32  hashNumber, nsDiskCacheBucket ** result)
-    {
-        *result = &mBuckets[GetBucketIndex(hashNumber)];
-        return NS_OK;
-    }
-
-    PRUint32 GetBucketIndex( PRUint32 hashNumber)
-    {
-        return (hashNumber & (kBucketsPerTable - 1));
-    }
-    
-
-   
-
-/**
- *  data members
- */
-private:
-    nsCOMPtr<nsILocalFile>  mCacheDirectory;
-    PRFileDesc *            mMapFD;
-    nsDiskCacheBlockFile    mBlockFile[3];
-    nsDiskCacheHeader       mHeader;
-    nsDiskCacheBucket       mBuckets[kBucketsPerTable];
-};
-
-#endif // _nsDiskCacheMap_h_

mozilla/netwerk/cache/src/nsMemoryCacheDevice.cpp

@@ -1,496 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsMemoryCacheDevice.cpp, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, <gordon@netscape.com>
- *    Patrick C. Beard <beard@netscape.com>
- */
-
-#include "nsMemoryCacheDevice.h"
-#include "nsCacheService.h"
-#include "nsICacheService.h"
-#include "nsIComponentManager.h"
-#include "nsNetCID.h"
-#include "nsIObserverService.h"
-#include "nsIPref.h"
-#include "nsICacheVisitor.h"
-#include "nsITransport.h"
-#include "signal.h"
-
-
-static NS_DEFINE_CID(kStorageTransportCID, NS_STORAGETRANSPORT_CID);
-
-const char *gMemoryDeviceID      = "memory";
-const char *gMemoryCacheSizePref = "browser.cache.memory_cache_size";
-
-
-nsMemoryCacheDevice::nsMemoryCacheDevice()
-    : mEvictionThreshold(40 * 1024),
-      mHardLimit(0),
-      mSoftLimit(0),
-      mTotalSize(0),
-      mInactiveSize(0),
-      mEntryCount(0),
-      mMaxEntryCount(0)
-{
-    PR_INIT_CLIST(&mEvictionList[mostLikelyToEvict]);
-    PR_INIT_CLIST(&mEvictionList[leastLikelyToEvict]);
-}
-
-
-nsMemoryCacheDevice::~nsMemoryCacheDevice()
-{
-#if DEBUG
-    printf("### starting ~nsMemoryCacheDevice()\n");
-#endif    
-    nsresult rv;
-    NS_WITH_SERVICE(nsIPref, prefs, NS_PREF_CONTRACTID, &rv);
-    if (NS_SUCCEEDED(rv)) {
-        prefs->UnregisterCallback(gMemoryCacheSizePref, MemoryCacheSizeChanged, this);
-    }
-    
-    Shutdown();
-}
-
-
-int PR_CALLBACK
-nsMemoryCacheDevice::MemoryCacheSizeChanged(const char * pref, void * closure)
-{
-    nsresult  rv;
-    PRUint32   softLimit = 0;
-    nsMemoryCacheDevice * device = (nsMemoryCacheDevice *)closure;
-
-    NS_WITH_SERVICE(nsIPref, prefs, NS_PREF_CONTRACTID, &rv);
-    if (NS_FAILED(rv))  return rv;
-
-    rv = prefs->GetIntPref(gMemoryCacheSizePref, (PRInt32 *)&softLimit);
-    if (NS_FAILED(rv)) return rv;
-    
-    softLimit *= 1024;  // convert k into bytes
-    PRUint32 hardLimit = softLimit + 1024*1024*2;  // XXX find better limit than +2Meg
-    device->AdjustMemoryLimits(softLimit, hardLimit);
-
-    return 0; // XXX what are we supposed to return?
-}
-
-
-nsresult
-nsMemoryCacheDevice::Init()
-{
-    nsresult  rv;
-
-    rv = mMemCacheEntries.Init();
-    
-    // set some default memory limits, in case prefs aren't available
-    mSoftLimit = 1024 * 1024 * 3;
-    mHardLimit = mSoftLimit + 1024 *1024 * 2;
-
-    // read user prefs for memory cache limits
-    NS_WITH_SERVICE(nsIPref, prefs, NS_PREF_CONTRACTID, &rv);
-    if (NS_SUCCEEDED(rv)) {
-
-        rv = prefs->RegisterCallback(gMemoryCacheSizePref, MemoryCacheSizeChanged, this);
-        if (NS_FAILED(rv))  return rv;
-
-        // Initialize the pref
-        MemoryCacheSizeChanged(gMemoryCacheSizePref, this);
-    }
-
-    // Register as a memory pressure observer
-    NS_WITH_SERVICE(nsIObserverService,
-                    observerService,
-                    NS_OBSERVERSERVICE_CONTRACTID, &rv);
-    if (NS_SUCCEEDED(rv)) {
-        // XXX rv = observerServcie->AddObserver(this, NS_MEMORY_PRESSURE_TOPIC);
-    }
-    // Ignore failure of memory pressure registration
-
-    return rv;
-}
-
-nsresult
-nsMemoryCacheDevice::Shutdown()
-{
-    mMemCacheEntries.Shutdown();
-
-    // evict all entries
-    nsCacheEntry * entry, * next;
-
-    for (int i=mostLikelyToEvict; i <= leastLikelyToEvict; ++i) {
-        entry = (nsCacheEntry *)PR_LIST_HEAD(&mEvictionList[i]);
-        while (entry != &mEvictionList[i]) {
-            NS_ASSERTION(entry->IsInUse() == PR_FALSE, "### shutting down with active entries.\n");
-            next = (nsCacheEntry *)PR_NEXT_LINK(entry);
-            PR_REMOVE_AND_INIT_LINK(entry);
-        
-            // update statistics
-            PRUint32 memoryRecovered = entry->Size();
-            mTotalSize    -= memoryRecovered;
-            mInactiveSize -= memoryRecovered;
-            --mEntryCount;
-
-            delete entry;
-            entry = next;
-        }
-    }
-
-/*
- * we're not factoring in changes to meta data yet...    
- *  NS_ASSERTION(mTotalSize == 0, "### mem cache leaking entries?\n");
- */
-    NS_ASSERTION(mInactiveSize == 0, "### mem cache leaking entries?\n");
-    NS_ASSERTION(mEntryCount == 0, "### mem cache leaking entries?\n");
-    
-    return NS_OK;
-}
-
-const char *
-nsMemoryCacheDevice::GetDeviceID()
-{
-    return gMemoryDeviceID;
-}
-
-
-nsCacheEntry *
-nsMemoryCacheDevice::FindEntry(nsCString * key)
-{
-    nsCacheEntry * entry = mMemCacheEntries.GetEntry(key);
-    if (!entry)  return nsnull;
-
-    // move entry to the tail of an eviction list
-    PR_REMOVE_AND_INIT_LINK(entry);
-    PR_APPEND_LINK(entry, &mEvictionList[EvictionList(entry, 0)]);
-    
-    mInactiveSize -= entry->Size();
-
-    return entry;
-}
-
-
-nsresult
-nsMemoryCacheDevice::DeactivateEntry(nsCacheEntry * entry)
-{
-    if (entry->IsDoomed()) {
-#if debug
-        // XXX verify we've removed it from mMemCacheEntries & eviction list
-#endif
-        // update statistics
-        mTotalSize    -= entry->Size();
-        --mEntryCount;
-
-        delete entry;
-        return NS_OK;
-    }
-
-    nsCacheEntry * ourEntry = mMemCacheEntries.GetEntry(entry->Key());
-    NS_ASSERTION(ourEntry, "DeactivateEntry called for an entry we don't have!");
-    NS_ASSERTION(entry == ourEntry, "entry doesn't match ourEntry");
-    if (ourEntry != entry)
-        return NS_ERROR_INVALID_POINTER;
-
-    mInactiveSize += entry->Size();
-    EvictEntriesIfNecessary();
-
-    return NS_OK;
-}
-
-
-nsresult
-nsMemoryCacheDevice::BindEntry(nsCacheEntry * entry)
-{
-    NS_ASSERTION(PR_CLIST_IS_EMPTY(entry),"entry is already on a list!");
-
-	if (!entry->IsDoomed()) {
-        // append entry to the eviction list
-        PR_APPEND_LINK(entry, &mEvictionList[EvictionList(entry, 0)]);
-
-        // add entry to hashtable of mem cache entries
-        nsresult  rv = mMemCacheEntries.AddEntry(entry);
-        if (NS_FAILED(rv)) {
-            PR_REMOVE_AND_INIT_LINK(entry);
-            return rv;
-        }
-	}
-
-    // add size of entry to memory totals
-    ++mEntryCount;
-    if (mMaxEntryCount < mEntryCount) mMaxEntryCount = mEntryCount;
-
-    mTotalSize += entry->Size();
-    EvictEntriesIfNecessary();
-    
-    return NS_OK;
-}
-
-
-void
-nsMemoryCacheDevice::DoomEntry(nsCacheEntry * entry)
-{
-    // XXX debug code to verify we have entry
-    mMemCacheEntries.RemoveEntry(entry);
-
-    // remove entry from our eviction list
-    PR_REMOVE_AND_INIT_LINK(entry);
-}
-
-
-nsresult
-nsMemoryCacheDevice::GetTransportForEntry( nsCacheEntry *    entry,
-                                           nsCacheAccessMode mode,
-                                           nsITransport   ** transport )
-{
-    NS_ENSURE_ARG_POINTER(entry);
-    NS_ENSURE_ARG_POINTER(transport);
-
-    nsCOMPtr<nsISupports> data;
-
-    nsresult rv = entry->GetData(getter_AddRefs(data));
-    if (NS_FAILED(rv))
-        return rv;
-
-    if (data)
-        return CallQueryInterface(data, transport);
-    else {
-        // create a new transport for this entry
-        rv = nsComponentManager::CreateInstance(kStorageTransportCID,
-                                                nsnull,
-                                                NS_GET_IID(nsITransport),
-                                                (void **) transport);
-        if (NS_FAILED(rv)) return rv;
-
-        entry->SetData(*transport);
-        return NS_OK;
-    }
-}
-
-
-nsresult
-nsMemoryCacheDevice::GetFileForEntry( nsCacheEntry *    entry,
-                                      nsIFile **        result )
-{
-    return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-
-nsresult
-nsMemoryCacheDevice::OnDataSizeChange( nsCacheEntry * entry, PRInt32 deltaSize)
-{
-    if (entry->IsStreamData()) {
-        // we have the right to refuse or pre-evict
-    }
-
-    // adjust our totals
-    mTotalSize    += deltaSize;
-    
-    if (!entry->IsDoomed()) {
-        // move entry to the tail of the appropriate eviction list
-        PR_REMOVE_AND_INIT_LINK(entry);
-        PR_APPEND_LINK(entry, &mEvictionList[EvictionList(entry, deltaSize)]);
-    }
-
-    EvictEntriesIfNecessary();
-
-    return NS_OK;
-}
-
-
-void
-nsMemoryCacheDevice::AdjustMemoryLimits(PRUint32  softLimit, PRUint32  hardLimit)
-{
-    mSoftLimit = softLimit;
-    mHardLimit = hardLimit;
-    EvictEntriesIfNecessary();
-}
-
-
-void
-nsMemoryCacheDevice::EvictEntry(nsCacheEntry * entry)
-{
-    // remove entry from our hashtable
-    mMemCacheEntries.RemoveEntry(entry);
-    
-    // remove entry from the eviction list
-    PR_REMOVE_AND_INIT_LINK(entry);
-    
-    // update statistics
-    PRUint32 memoryRecovered = entry->Size();
-    mTotalSize    -= memoryRecovered;
-    mInactiveSize -= memoryRecovered;
-    --mEntryCount;
-
-    delete entry;
-}
-
-
-void
-nsMemoryCacheDevice::EvictEntriesIfNecessary(void)
-{
-    nsCacheEntry * entry, * next;
-
-    if ((mTotalSize < mHardLimit) && (mInactiveSize < mSoftLimit))
-        return;
-
-    for (int i=mostLikelyToEvict; i<=leastLikelyToEvict; ++i) {
-        entry = (nsCacheEntry *)PR_LIST_HEAD(&mEvictionList[i]);
-        while (entry != &mEvictionList[i]) {
-            if (entry->IsInUse()) {
-                entry = (nsCacheEntry *)PR_NEXT_LINK(entry);
-                continue;
-            }
-
-            next = (nsCacheEntry *)PR_NEXT_LINK(entry);
-            EvictEntry(entry);
-            entry = next;
-
-            if ((mTotalSize < mHardLimit) && (mInactiveSize < mSoftLimit))
-                return;
-        }
-    }
-}
-
-
-int
-nsMemoryCacheDevice::EvictionList(nsCacheEntry * entry, PRUint32  deltaSize)
-{
-    PRUint32  size = entry->Size() + deltaSize;
-    if ((size > mEvictionThreshold) || (entry->ExpirationTime() != 0))
-        return mostLikelyToEvict;
-    
-    return leastLikelyToEvict;
-}
-
-
-nsresult
-nsMemoryCacheDevice::Visit(nsICacheVisitor * visitor)
-{
-    nsMemoryCacheDeviceInfo * deviceInfo = new nsMemoryCacheDeviceInfo(this);
-    nsCOMPtr<nsICacheDeviceInfo> deviceRef(deviceInfo);
-    if (!deviceInfo) return NS_ERROR_OUT_OF_MEMORY;
-
-    PRBool keepGoing;
-    nsresult rv = visitor->VisitDevice(gMemoryDeviceID, deviceInfo, &keepGoing);
-    if (NS_FAILED(rv)) return rv;
-
-    if (!keepGoing)
-        return NS_OK;
-
-    nsCacheEntry *              entry;
-    nsCOMPtr<nsICacheEntryInfo> entryRef;
-
-    for (int i=mostLikelyToEvict; i <= leastLikelyToEvict; ++i) {
-        entry = (nsCacheEntry *)PR_LIST_HEAD(&mEvictionList[i]);
-        while (entry != &mEvictionList[i]) {
-            nsCacheEntryInfo * entryInfo = new nsCacheEntryInfo(entry);
-            if (!entryInfo) return NS_ERROR_OUT_OF_MEMORY;
-            entryRef = entryInfo;
-
-            rv = visitor->VisitEntry(gMemoryDeviceID, entryInfo, &keepGoing);
-            entryInfo->DetachEntry();
-            if (NS_FAILED(rv)) return rv;
-            if (!keepGoing) break;
-
-            entry = (nsCacheEntry *)PR_NEXT_LINK(entry);
-        }
-    }
-    return NS_OK;
-}
-
-
-nsresult
-nsMemoryCacheDevice::EvictEntries(const char * clientID)
-{
-    nsCacheEntry * entry;
-    PRUint32 prefixLength = (clientID ? nsCRT::strlen(clientID) : 0);
-
-    for (int i=mostLikelyToEvict; i<=leastLikelyToEvict; ++i) {
-        PRCList * elem = PR_LIST_HEAD(&mEvictionList[i]);
-        while (elem != &mEvictionList[i]) {
-            entry = (nsCacheEntry *)elem;
-            elem = PR_NEXT_LINK(elem);
-            
-            const char * key = entry->Key()->get();
-            if (clientID && nsCRT::strncmp(clientID, key, prefixLength) != 0)
-                continue;
-            
-            if (entry->IsInUse()) {
-                nsresult rv = nsCacheService::GlobalInstance()->DoomEntry_Locked(entry);
-                if (NS_FAILED(rv)) return rv;
-            } else {
-                EvictEntry(entry);
-            }
-        }
-    }
-    return NS_OK;
-}
-
-
-/******************************************************************************
- * nsMemoryCacheDeviceInfo - for implementing about:cache
- *****************************************************************************/
-
-
-NS_IMPL_ISUPPORTS1(nsMemoryCacheDeviceInfo, nsICacheDeviceInfo);
-
-
-NS_IMETHODIMP
-nsMemoryCacheDeviceInfo::GetDescription(char ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    *result = nsCRT::strdup("Memory cache device");
-    if (!*result) return NS_ERROR_OUT_OF_MEMORY;
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsMemoryCacheDeviceInfo::GetUsageReport(char ** result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    *result = nsCRT::strdup("Memory cache usage report:");
-    if (!*result) return NS_ERROR_OUT_OF_MEMORY;
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsMemoryCacheDeviceInfo::GetEntryCount(PRUint32 * result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    // XXX compare calculated count vs. mEntryCount
-    *result = mDevice->mEntryCount;
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsMemoryCacheDeviceInfo::GetTotalSize(PRUint32 * result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    *result = mDevice->mTotalSize;
-    return NS_OK;
-}
-
-
-NS_IMETHODIMP
-nsMemoryCacheDeviceInfo::GetMaximumSize(PRUint32 * result)
-{
-    NS_ENSURE_ARG_POINTER(result);
-    *result = mDevice->mHardLimit;
-    return NS_OK;
-}

mozilla/netwerk/cache/src/nsMemoryCacheDevice.h

@@ -1,119 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * 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
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsMemoryCacheDevice.h, released February 20, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 20-February-2001
- */
-
-#ifndef _nsMemoryCacheDevice_h_
-#define _nsMemoryCacheDevice_h_
-
-#include "nsCacheDevice.h"
-#include "pldhash.h"
-#include "nsCacheEntry.h"
-
-
-class nsMemoryCacheDeviceInfo;
-
-/******************************************************************************
- * nsMemoryCacheDevice
- ******************************************************************************/
-class nsMemoryCacheDevice : public nsCacheDevice
-{
-public:
-    nsMemoryCacheDevice();
-    virtual ~nsMemoryCacheDevice();
-
-    virtual nsresult        Init();
-    virtual nsresult        Shutdown();
-
-    virtual const char *    GetDeviceID(void);
-
-    virtual nsresult        BindEntry( nsCacheEntry * entry );
-    virtual nsCacheEntry *  FindEntry( nsCString * key );
-    virtual void            DoomEntry( nsCacheEntry * entry );
-    virtual nsresult        DeactivateEntry( nsCacheEntry * entry );
-
-    virtual nsresult GetTransportForEntry( nsCacheEntry * entry,
-                                           nsCacheAccessMode mode,
-                                           nsITransport **transport );
-
-    virtual nsresult GetFileForEntry( nsCacheEntry *    entry,
-                                      nsIFile **        result );
-
-    virtual nsresult OnDataSizeChange( nsCacheEntry * entry, PRInt32 deltaSize );
-
-    virtual nsresult Visit( nsICacheVisitor * visitor );
-
-    virtual nsresult        EvictEntries(const char * clientID);
-    
-    static int PR_CALLBACK MemoryCacheSizeChanged(const char * pref, void * closure);
- 
-private:
-    friend class nsMemoryCacheDeviceInfo;
-    void      AdjustMemoryLimits( PRUint32  softLimit, PRUint32  hardLimit);
-    void      EvictEntry( nsCacheEntry * entry );
-    void      EvictEntriesIfNecessary();
-    int       EvictionList(nsCacheEntry * entry, PRUint32  deltaSize);
-
-    /*
-     *  Data members
-     */
-    
-    nsCacheEntryHashTable   mMemCacheEntries;
-    
-    enum { mostLikelyToEvict = 0, leastLikelyToEvict = 1 };   // constants to differentiate eviction lists
-    PRCList                 mEvictionList[2];
-    PRUint32                mEvictionThreshold;
-
-    PRUint32                mHardLimit;
-    PRUint32                mSoftLimit;
-
-    PRUint32                mTotalSize;
-    PRUint32                mInactiveSize;
-
-    PRUint32                mEntryCount;
-
-    PRUint32                mMaxEntryCount;
-    // XXX what other stats do we want to keep?
-};
-
-
-/******************************************************************************
- * nsMemoryCacheDeviceInfo - used to call nsIVisitor for about:cache
- ******************************************************************************/
-class nsMemoryCacheDeviceInfo : public nsICacheDeviceInfo {
-public:
-    NS_DECL_ISUPPORTS
-    NS_DECL_NSICACHEDEVICEINFO
-
-    nsMemoryCacheDeviceInfo(nsMemoryCacheDevice* device)
-        :   mDevice(device)
-    {
-        NS_INIT_ISUPPORTS();
-    }
-
-    virtual ~nsMemoryCacheDeviceInfo() {}
-    
-private:
-    nsMemoryCacheDevice* mDevice;
-};
-
-
-#endif // _nsMemoryCacheDevice_h_

mozilla/netwerk/cache/src/win32.order

@@ -1,231 +0,0 @@
-?AddRef@nsCacheEntryDescriptor@@UAGKXZ ; 35743
-?HashKey@nsCacheEntryHashTable@@CAIPAUPLDHashTable@@PBX@Z ; 29743
-?Release@nsCacheEntryDescriptor@@UAGKXZ ; 21199
-??_EnsCString@@UAEPAXI@Z ; 19905
-?AddRef@nsCacheSession@@UAGKXZ ; 17435
-?GetEntry@nsCacheEntryHashTable@@QAEPAVnsCacheEntry@@PBVnsCString@@@Z ; 17433
-?SecondsFromPRTime@@YAI_J@Z ; 14263
-?CalculateSize@nsCacheMetaData@@CA?AW4PLDHashOperator@@PAUPLDHashTable@@PAUPLDHashEntryHdr@@IPAX@Z ; 14243
-?Release@nsCacheEntryInfo@@UAGKXZ ; 10964
-?GetLastModified@nsDiskCacheEntryInfo@@UAGIPAI@Z ; 9800
-?Release@nsANSIOutputStream@@UAGKXZ ; 9758
-?MatchEntry@nsCacheEntryHashTable@@CAHPAUPLDHashTable@@PBUPLDHashEntryHdr@@PBX@Z ; 9663
-?QueryInterface@nsCacheEntryInfo@@UAGIABUnsID@@PAPAX@Z ; 8638
-??Rdo_QueryElementAt@@UBEIABUnsID@@PAPAX@Z ; 8638
-?assign_assuming_AddRef@nsCOMPtr_base@@IAEXPAVnsISupports@@@Z ; 8259
-??0nsDiskCacheRecord@@QAE@XZ ; 8192
-?EnsureEntryHasDevice@nsCacheService@@AAEPAVnsCacheDevice@@PAVnsCacheEntry@@@Z ; 7918
-?MoveEntry@nsCacheEntryHashTable@@CAXPAUPLDHashTable@@PBUPLDHashEntryHdr@@PAU3@@Z ; 7653
-?GetKey@nsCacheEntryHashTable@@CAPBXPAUPLDHashTable@@PAUPLDHashEntryHdr@@@Z ; 7653
-?Close@nsANSIOutputStream@@UAGIXZ ; 7092
-?Write@nsANSIOutputStream@@UAGIPBDIPAI@Z ; 7067
-?AccumulateElements@nsCacheMetaData@@CA?AW4PLDHashOperator@@PAUPLDHashTable@@PAUPLDHashEntryHdr@@IPAX@Z ; 7063
-?Release@nsDiskCacheDeviceInfo@@UAGKXZ ; 6471
-?CreateRequest@nsCacheService@@AAEIPAVnsCacheSession@@PBDHPAVnsICacheListener@@PAPAVnsCacheRequest@@@Z ; 6468
-?ActivateEntry@nsCacheService@@AAEIPAVnsCacheRequest@@PAPAVnsCacheEntry@@@Z ; 6468
-?ProcessRequest@nsCacheService@@AAEIPAVnsCacheRequest@@PAPAVnsICacheEntryDescriptor@@@Z ; 6468
-??1nsCacheRequest@@AAE@XZ ; 6468
-?OpenCacheEntry@nsCacheService@@QAEIPAVnsCacheSession@@PBDHPAVnsICacheListener@@PAPAVnsICacheEntryDescriptor@@@Z ; 6468
-??0nsCacheRequest@@AAE@PAVnsCString@@PAVnsICacheListener@@HPAVnsCacheSession@@@Z ; 6468
-?Hash@nsDiskCacheEntry@@SAIPBD@Z ; 6166
-?HashKey@nsDiskCacheEntryHashTable@@CAIPAUPLDHashTable@@PBX@Z ; 6037
-?EvictEntriesIfNecessary@nsMemoryCacheDevice@@AAEXXZ ; 5780
-?TouchData@nsCacheEntry@@QAEXXZ ; 5503
-?OpenCacheEntry@nsCacheSession@@UAGIPBDHPAPAVnsICacheEntryDescriptor@@@Z ; 5165
-?RequestAccess@nsCacheEntry@@QAEIPAVnsCacheRequest@@PAH@Z ; 5099
-?Fetched@nsCacheEntry@@QAEXXZ ; 5094
-??0nsTransportWrapper@nsCacheEntryDescriptor@@QAE@XZ ; 5092
-?CreateDescriptor@nsCacheEntry@@QAEIPAVnsCacheRequest@@HPAPAVnsICacheEntryDescriptor@@@Z ; 5092
-??0nsCacheEntryDescriptor@@QAE@PAVnsCacheEntry@@H@Z ; 5092
-?RemoveDescriptor@nsCacheEntry@@QAEHPAVnsCacheEntryDescriptor@@@Z ; 5090
-?CloseDescriptor@nsCacheService@@QAEXPAVnsCacheEntryDescriptor@@@Z ; 5090
-?Close@nsCacheEntryDescriptor@@UAGIXZ ; 5090
-??_GnsCacheEntryDescriptor@@UAEPAXI@Z ; 5090
-??1nsCacheEntryDescriptor@@UAE@XZ ; 5090
-?SearchCacheDevices@nsCacheService@@AAEPAVnsCacheEntry@@PAVnsCString@@H@Z ; 4993
-?AddEntry@nsCacheEntryHashTable@@QAEIPAVnsCacheEntry@@@Z ; 4993
-?FindEntry@nsMemoryCacheDevice@@UAEPAVnsCacheEntry@@PAVnsCString@@@Z ; 4993
-?ClearEntry@nsCacheEntryHashTable@@CAXPAUPLDHashTable@@PAUPLDHashEntryHdr@@@Z ; 4993
-?RemoveEntry@nsCacheEntryHashTable@@QAEXPAVnsCacheEntry@@@Z ; 4921
-?GetData@nsCacheEntry@@QAEIPAPAVnsISupports@@@Z ; 4811
-?Release@nsDiskCacheEntry@@UAGKXZ ; 4784
-?RequestDataSizeChange@nsCacheEntryDescriptor@@QAEIH@Z ; 4127
-?OnDataSizeChange@nsCacheService@@QAEIPAVnsCacheEntry@@H@Z ; 4127
-?SetElement@nsCacheMetaData@@QAEIABVnsACString@@0@Z ; 3682
-?ClearEntry@nsCacheMetaData@@CAXPAUPLDHashTable@@PAUPLDHashEntryHdr@@@Z ; 3681
-?FreeElements@nsCacheMetaData@@CA?AW4PLDHashOperator@@PAUPLDHashTable@@PAUPLDHashEntryHdr@@IPAX@Z ; 3681
-?GetEntry@nsDiskCacheEntryHashTable@@QAEPAVnsDiskCacheEntry@@PBD@Z ; 3651
-?GetRecord@nsDiskCacheMap@@QAEPAVnsDiskCacheRecord@@I@Z ; 3650
-?Size@nsCacheMetaData@@QAEIXZ ; 3628
-?DeactivateEntry@nsCacheService@@AAEXPAVnsCacheEntry@@@Z ; 3619
-?TouchMetaData@nsCacheEntry@@QAEXXZ ; 3601
-?SetMetaDataElement@nsCacheEntryDescriptor@@UAGIPBD0@Z ; 3601
-?SetMetaDataElement@nsCacheEntry@@QAEIABVnsACString@@0@Z ; 3601
-?getFileForHashNumber@nsDiskCacheDevice@@QAEIIHIPAPAVnsIFile@@@Z ; 3587
-?Read@nsANSIInputStream@@UAGIPADIPAI@Z ; 3570
-?getFileForDiskCacheEntry@nsDiskCacheDevice@@QAEIPAVnsDiskCacheEntry@@HPAPAVnsIFile@@@Z ; 3560
-?Unswap@MetaDataHeader@@QAEXXZ ; 3545
-??1MetaDataFile@@QAE@XZ ; 3545
-?OnDataSizeChange@nsDiskCacheDevice@@UAEIPAVnsCacheEntry@@H@Z ; 3210
-?ProcessPendingRequests@nsCacheService@@AAEIPAVnsCacheEntry@@@Z ; 2800
-??0nsCacheEntry@@QAE@PAVnsCString@@HH@Z ; 2673
-??1nsCacheEntry@@QAE@XZ ; 2673
-?MarkValid@nsCacheEntryDescriptor@@UAGIXZ ; 2592
-?ValidateEntry@nsCacheService@@QAEIPAVnsCacheEntry@@@Z ; 2592
-?GetCacheElement@nsCacheEntryDescriptor@@UAGIPAPAVnsISupports@@@Z ; 2413
-?MatchEntry@nsDiskCacheEntryHashTable@@CAHPAUPLDHashTable@@PBUPLDHashEntryHdr@@PBX@Z ; 2383
-?Release@nsANSIInputStream@@UAGKXZ ; 2380
-?AddRef@nsANSIInputStream@@UAGKXZ ; 2380
-?MatchEntry@nsCacheMetaData@@CAHPAUPLDHashTable@@PBUPLDHashEntryHdr@@PBX@Z ; 2365
-?GetMetaDataElement@nsCacheEntry@@QAEIABVnsACString@@PAPBV2@@Z ; 2365
-?GetElement@nsCacheMetaData@@QAEPBVnsACString@@PBV2@@Z ; 2365
-?GetMetaDataElement@nsCacheEntryDescriptor@@UAGIPBDPAPAD@Z ; 2365
-?openOutputStream@nsDiskCacheDevice@@SAIPAVnsIFile@@PAPAVnsIOutputStream@@@Z ; 2356
-?updateDiskCacheEntry@nsDiskCacheDevice@@QAEIPAVnsDiskCacheEntry@@@Z ; 2356
-??0nsANSIOutputStream@@QAE@PAU_iobuf@@@Z ; 2356
-??_EnsANSIOutputStream@@UAEPAXI@Z ; 2356
-??1nsANSIOutputStream@@UAE@XZ ; 2356
-?Swap@MetaDataHeader@@QAEXXZ ; 2355
-?FlattenMetaData@nsCacheMetaData@@QAEIPAPADPAI@Z ; 2355
-?Init@MetaDataFile@@QAEIPAVnsCacheEntry@@@Z ; 2355
-?updateCacheMap@nsDiskCacheDevice@@QAEIPAVnsDiskCacheEntry@@@Z ; 2355
-??0MetaDataHeader@@QAE@PAVnsCacheEntry@@@Z ; 2355
-?Write@MetaDataFile@@QAEIPAVnsIOutputStream@@@Z ; 2355
-?FlattenMetaData@nsCacheEntry@@QAEIPAPADPAI@Z ; 2355
-?DeactivateEntry@nsMemoryCacheDevice@@UAEIPAVnsCacheEntry@@@Z ; 2322
-?SetExpirationTime@nsCacheEntryDescriptor@@UAGII@Z ; 2259
-?QueryInterface@nsCacheEntryDescriptor@@UAGIABUnsID@@PAPAX@Z ; 2186
-?GetDataSize@nsCacheEntryDescriptor@@UAGIPAI@Z ; 2107
-?OnDataSizeChange@nsMemoryCacheDevice@@UAEIPAVnsCacheEntry@@H@Z ; 2082
-?SetDataSize@nsCacheEntryDescriptor@@UAGII@Z ; 2082
-?Write@nsOutputStreamWrapper@nsCacheEntryDescriptor@@UAGIPBDIPAI@Z ; 2045
-?OnWrite@nsOutputStreamWrapper@nsCacheEntryDescriptor@@AAEII@Z ; 2045
-?GetNonBlocking@nsOutputStreamWrapper@nsCacheEntryDescriptor@@UAGIPAH@Z ; 1550
-?SetCacheElement@nsCacheEntryDescriptor@@UAGIPAVnsISupports@@@Z ; 1376
-?BindEntry@nsMemoryCacheDevice@@UAEIPAVnsCacheEntry@@@Z ; 1376
-?AsyncOpenCacheEntry@nsCacheSession@@UAGIPBDHPAVnsICacheListener@@@Z ; 1303
-?NotifyListener@nsCacheService@@AAEIPAVnsCacheRequest@@PAVnsICacheEntryDescriptor@@HI@Z ; 1303
-??0nsCacheMetaData@@QAE@XZ ; 1298
-??1nsCacheMetaData@@QAE@XZ ; 1298
-?FindEntry@nsDiskCacheDevice@@UAEPAVnsCacheEntry@@PAVnsCString@@@Z ; 1295
-?Init@nsCacheMetaData@@QAEIXZ ; 1295
-?Finalize@nsCacheMetaData@@CAXPAUPLDHashTable@@@Z ; 1295
-?Create@nsCacheMetaData@@SAPAV1@XZ ; 1295
-?getTransportForFile@nsDiskCacheDevice@@SAIPAVnsIFile@@HPAPAVnsITransport@@@Z ; 1199
-?GetTransportForEntry@nsDiskCacheDevice@@UAEIPAVnsCacheEntry@@HPAPAVnsITransport@@@Z ; 1198
-?AddRef@nsTransportWrapper@nsCacheEntryDescriptor@@UAGKXZ ; 1198
-?EnsureTransportWithAccess@nsTransportWrapper@nsCacheEntryDescriptor@@QAEIH@Z ; 1198
-?GetTransport@nsCacheEntryDescriptor@@UAGIPAPAVnsITransport@@@Z ; 1198
-?GetTransportForEntry@nsCacheService@@QAEIPAVnsCacheEntry@@HPAPAVnsITransport@@@Z ; 1198
-?Release@nsTransportWrapper@nsCacheEntryDescriptor@@UAGKXZ ; 1198
-?GetSecurityInfo@nsCacheEntryDescriptor@@UAGIPAPAVnsISupports@@@Z ; 1195
-?GetSecurityInfo@nsCacheEntry@@QAEIPAPAVnsISupports@@@Z ; 1195
-??1nsDiskCacheEntry@@UAE@XZ ; 1193
-??0nsDiskCacheEntry@@QAE@PAVnsCacheEntry@@@Z ; 1193
-??_EnsDiskCacheEntry@@UAEPAXI@Z ; 1193
-?DeactivateEntry@nsDiskCacheDevice@@UAEIPAVnsCacheEntry@@@Z ; 1193
-?AddEntry@nsDiskCacheEntryHashTable@@QAEIPAVnsDiskCacheEntry@@@Z ; 1193
-?ClearEntry@nsDiskCacheEntryHashTable@@CAXPAUPLDHashTable@@PAUPLDHashEntryHdr@@@Z ; 1193
-?RemoveEntry@nsDiskCacheEntryHashTable@@QAEXPAVnsDiskCacheEntry@@@Z ; 1193
-?openInputStream@nsDiskCacheDevice@@SAIPAVnsIFile@@PAPAVnsIInputStream@@@Z ; 1191
-??1nsANSIInputStream@@UAE@XZ ; 1190
-?Read@MetaDataFile@@QAEIPAVnsIInputStream@@@Z ; 1190
-??0nsANSIInputStream@@QAE@PAU_iobuf@@@Z ; 1190
-??_EnsANSIInputStream@@UAEPAXI@Z ; 1190
-??0MetaDataHeader@@QAE@XZ ; 1190
-?OpenOutputStream@nsTransportWrapper@nsCacheEntryDescriptor@@UAGIIIIPAPAVnsIOutputStream@@@Z ; 1166
-?BindEntry@nsDiskCacheDevice@@UAEIPAVnsCacheEntry@@@Z ; 1166
-?IsAllowedOnDisk@nsCacheEntry@@QAEHXZ ; 1166
-??1nsOutputStreamWrapper@nsCacheEntryDescriptor@@UAE@XZ ; 1165
-?NewOutputStreamWrapper@nsCacheEntryDescriptor@@CAIPAPAVnsIOutputStream@@PAV1@PAV2@@Z ; 1165
-?GetAccessGranted@nsCacheEntryDescriptor@@UAGIPAH@Z ; 1165
-??0nsOutputStreamWrapper@nsCacheEntryDescriptor@@QAE@PAV1@PAVnsIOutputStream@@@Z ; 1165
-?Init@nsOutputStreamWrapper@nsCacheEntryDescriptor@@QAEIXZ ; 1165
-??_GnsOutputStreamWrapper@nsCacheEntryDescriptor@@UAEPAXI@Z ; 1165
-??0MetaDataFile@@QAE@XZ ; 1163
-?GetDataSize@nsDiskCacheEntryInfo@@UAGIPAI@Z ; 1163
-??_GnsDiskCacheEntryInfo@@UAEPAXI@Z ; 1163
-?Swap@nsDiskCacheRecord@@QAEXXZ ; 1123
-?Unswap@nsDiskCacheRecord@@QAEXXZ ; 1123
-?GetExpirationTime@nsCacheEntryDescriptor@@UAGIPAI@Z ; 1118
-?GetKey@nsDiskCacheEntryHashTable@@CAPBXPAUPLDHashTable@@PAUPLDHashEntryHdr@@@Z ; 395
-?MoveEntry@nsDiskCacheEntryHashTable@@CAXPAUPLDHashTable@@PBUPLDHashEntryHdr@@PAU3@@Z ; 395
-?DoomEntry_Locked@nsCacheService@@QAEIPAVnsCacheEntry@@@Z ; 106
-?DoomEntry@nsCacheService@@QAEIPAVnsCacheEntry@@@Z ; 104
-?Doom@nsCacheEntryDescriptor@@UAGIXZ ; 104
-?FreeCacheEntries@nsCacheEntryHashTable@@CA?AW4PLDHashOperator@@PAUPLDHashTable@@PAUPLDHashEntryHdr@@IPAX@Z ; 72
-?AsyncRead@nsTransportWrapper@nsCacheEntryDescriptor@@UAGIPAVnsIStreamListener@@PAVnsISupports@@IIIPAPAVnsIRequest@@@Z ; 32
-??_H@YGXPAXIHP6EX0@Z@Z ; 32
-?getFileForKey@nsDiskCacheDevice@@QAEIPBDHIPAPAVnsIFile@@@Z ; 27
-?UnflattenMetaData@nsCacheMetaData@@QAEIPADI@Z ; 27
-?UnflattenMetaData@nsCacheEntry@@QAEIPADI@Z ; 27
-?readDiskCacheEntry@nsDiskCacheDevice@@QAEIPBDPAPAVnsDiskCacheEntry@@@Z ; 27
-?GetLastModified@nsCacheEntryDescriptor@@UAGIPAI@Z ; 25
-?AddRef@nsDiskCacheObserver@@UAGKXZ ; 12
-?Release@nsDiskCacheObserver@@UAGKXZ ; 12
-?AddRef@nsCacheService@@UAGKXZ ; 9
-?Release@nsCacheService@@UAGKXZ ; 9
-?QueryInterface@nsDiskCacheObserver@@UAGIABUnsID@@PAPAX@Z ; 6
-?QueryInterface@nsCacheService@@UAGIABUnsID@@PAPAX@Z ; 6
-?do_GetService@@YA?BVnsGetServiceByContractID@@PBDPAI@Z ; 5
-?DeleteRecord@nsDiskCacheMap@@QAEXI@Z ; 3
-??0nsCacheSession@@QAE@PBDHH@Z ; 3
-??1nsCacheSession@@UAE@XZ ; 3
-??_EnsCacheSession@@UAEPAXI@Z ; 3
-?deleteDiskCacheEntry@nsDiskCacheDevice@@QAEIPAVnsDiskCacheEntry@@@Z ; 3
-?DoomEntry@nsDiskCacheDevice@@UAEXPAVnsCacheEntry@@@Z ; 3
-?CreateSession@nsCacheService@@UAGIPBDHHPAPAVnsICacheSession@@@Z ; 3
-?setPrefsObserver@nsDiskCacheDevice@@QAEXPAVnsIObserver@@@Z ; 2
-?VisitEntries@nsDiskCacheEntryHashTable@@QAEXPAVVisitor@1@@Z ; 2
-?DetachDescriptors@nsCacheEntry@@AAEXXZ ; 2
-?ClearPendingRequests@nsCacheService@@AAEXPAVnsCacheEntry@@@Z ; 2
-?SetDoomEntriesIfExpired@nsCacheSession@@UAGIH@Z ; 2
-?Finalize@nsCacheEntryHashTable@@CAXPAUPLDHashTable@@@Z ; 2
-?DeactivateAndClearEntry@nsCacheService@@CA?AW4PLDHashOperator@@PAUPLDHashTable@@PAUPLDHashEntryHdr@@IPAX@Z ; 2
-?Init@nsCacheEntryHashTable@@QAEIXZ ; 2
-?updateDiskCacheEntries@nsDiskCacheDevice@@QAEIXZ ; 2
-?scanDiskCacheEntries@nsDiskCacheDevice@@QAEIPAPAVnsISupportsArray@@@Z ; 2
-?AdjustMemoryLimits@nsMemoryCacheDevice@@AAEXII@Z ; 1
-_NSGetModule ; 1
-?Finalize@nsDiskCacheEntryHashTable@@CAXPAUPLDHashTable@@@Z ; 1
-??0nsMemoryCacheDevice@@QAE@XZ ; 1
-?evictDiskCacheEntries@nsDiskCacheDevice@@QAEIXZ ; 1
-??0nsDiskCacheMap@@QAE@XZ ; 1
-?ClearActiveEntries@nsCacheService@@AAEXXZ ; 1
-?setCacheCapacity@nsDiskCacheDevice@@QAEXI@Z ; 1
-?Init@nsDiskCacheEntryHashTable@@QAEIXZ ; 1
-?DoomEntry@nsMemoryCacheDevice@@UAEXPAVnsCacheEntry@@@Z ; 1
-?getPrefsObserver@nsDiskCacheDevice@@QAEXPAPAVnsIObserver@@@Z ; 1
-??_EnsMemoryCacheDevice@@UAEPAXI@Z ; 1
-?setCacheDirectory@nsDiskCacheDevice@@QAEXPAVnsILocalFile@@@Z ; 1
-?Shutdown@nsCacheService@@UAGIXZ ; 1
-??_GnsCacheService@@UAEPAXI@Z ; 1
-?ClearDoomList@nsCacheService@@AAEXXZ ; 1
-?QueryInterface@nsANSIOutputStream@@UAGIABUnsID@@PAPAX@Z ; 1
-?Init@nsCacheService@@UAGIXZ ; 1
-??0nsDiskCacheDevice@@QAE@XZ ; 1
-?Swap@nsDiskCacheHeader@@QAEXXZ ; 1
-?GetFileForEntry@nsCacheService@@QAEIPAVnsCacheEntry@@PAPAVnsIFile@@@Z ; 1
-??_GnsDiskCacheDevice@@UAEPAXI@Z ; 1
-??1nsCacheService@@UAE@XZ ; 1
-?GetFileForEntry@nsDiskCacheDevice@@UAEIPAVnsCacheEntry@@PAPAVnsIFile@@@Z ; 1
-?Init@nsMemoryCacheDevice@@UAEIXZ ; 1
-?GetFile@nsCacheEntryDescriptor@@UAGIPAPAVnsIFile@@@Z ; 1
-?Seek@nsANSIOutputStream@@UAGIHH@Z ; 1
-?MemoryCacheSizeChanged@nsMemoryCacheDevice@@SAHPBDPAX@Z ; 1
-?SetStoragePolicy@nsCacheEntryDescriptor@@UAGIH@Z ; 1
-??0nsCacheService@@QAE@XZ ; 1
-?Observe@nsCacheService@@UAGIPAVnsISupports@@PBG1@Z ; 1
-?writeCacheMap@nsDiskCacheDevice@@QAEIXZ ; 1
-?Init@nsDiskCacheDevice@@UAEIXZ ; 1
-?Create@nsCacheService@@SGIPAVnsISupports@@ABUnsID@@PAPAX@Z ; 1
-?NS_GetSpecialDirectory@@YAIPBDPAPAVnsIFile@@@Z ; 1
-??1nsDiskCacheDevice@@UAE@XZ ; 1
-?readCacheMap@nsDiskCacheDevice@@QAEIXZ ; 1
-??1nsDiskCacheMap@@QAE@XZ ; 1
-??_EnsDiskCacheObserver@@UAEPAXI@Z ; 1
-?Unswap@nsDiskCacheHeader@@QAEXXZ ; 1
-?CreateDiskDevice@nsCacheService@@AAEIXZ ; 1
-??1nsMemoryCacheDevice@@UAE@XZ ; 1
-?Shutdown@nsDiskCacheDevice@@UAEIXZ ; 1
-?Write@nsDiskCacheMap@@QAEIPAVnsIOutputStream@@@Z ; 1