This commit was manufactured by cvs2svn to create tag

'CacheIntegration_BASE'.

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

mozilla/netwerk/cache/Makefile.in

@@ -0,0 +1,28 @@
+#
+# 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
+
+DIRS		= public obj mgr pref module tests
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/Makefile.win

@@ -0,0 +1,29 @@
+#!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=..\..
+DIRS= 	\
+	public \
+	obj			\
+	mgr			\
+	pref			\
+	module			\
+	tests			\
+	$(NULL)
+
+include <$(DEPTH)\config\rules.mak> 

mozilla/netwerk/cache/filecache/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		= necko 
+LIBRARY_NAME = necko_diskcache
+IS_COMPONENT	= 1
+
+REQUIRES	= nspr dbm 
+
+EXTRA_DSO_LDOPTS  +=  -L$(DIST)/lib  -lmozdbm_s
+
+CPPSRCS		= \
+        nsDBAccessor.cpp\
+        nsDBEnumerator.cpp \
+        nsNetDiskCache.cpp \
+        nsDiskCacheRecord.cpp \
+		$(NULL)
+
+EXTRA_LIBS	= $(NSPR_LIBS) 
+
+DIRS = test
+
+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> 
+
+libs:: $(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,324 @@
+/* -*- 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.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 "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)
+{
+  m_Lock = PR_NewLock() ;
+  if(!m_Lock)
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  char* dbname ;
+
+  // this should cover all platforms. 
+  dbfile->GetNativePath(&dbname) ;
+
+  HASHINFO hash_info = {
+    16*1024 , /* bucket size */
+    0 ,       /* fill factor */
+    0 ,       /* number of elements */
+    0 ,       /* bytes to cache */
+    0 ,       /* hash function */
+    0} ;      /* byte order */
+
+  nsAutoLock lock(m_Lock) ;
+
+  mDB = dbopen(dbname,
+               O_RDWR | O_CREAT ,
+               0600 ,
+               DB_HASH ,
+               & hash_info) ;
+
+  if(!mDB)
+    return NS_ERROR_FAILURE ;
+
+  // set mSessionID
+  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 ;
+    }
+    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 ;
+  }
+
+  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)) {
+    (*mDB->sync)(mDB, 0) ;
+    return NS_OK ;
+  }
+  else {
+    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") ;
+
+  // 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) {
+    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) {
+    printf(" delete error\n") ;
+    return NS_ERROR_FAILURE ;
+  } 
+  (*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 ;
+    }
+    (*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 ;
+
+  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,60 @@
+/* -*- 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.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.
+ */
+#ifndef _NSIDBACCESSOR_H_
+#define _NSIDBACCESSOR_H_
+
+#include "nsIDBAccessor.h"
+#include "mcom_db.h"
+
+// bogus string for the key of session id 
+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,91 @@
+/* -*- 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.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 "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,53 @@
+/* -*- 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.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.
+ */
+
+#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
+
+  /* boolean HasMoreElements (); */
+  NS_IMETHOD HasMoreElements(PRBool *_retval) ;
+
+  /* nsISupports GetNext (); */
+  NS_IMETHOD GetNext(nsISupports **_retval) ;
+
+  nsDBEnumerator(nsIDBAccessor* aDB, nsNetDiskCache* aCache) ;
+  virtual ~nsDBEnumerator() ;
+
+  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/nsDiskCacheFactory.cpp

@@ -0,0 +1,187 @@
+/* -*- 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.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 "nsIFactory.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsIDBAccessor.h"
+#include "nsNetDiskCacheCID.h"
+#include "nsDBAccessor.h"
+#include "nsNetDiskCache.h"
+
+static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
+static NS_DEFINE_CID (kComponentManagerCID, NS_COMPONENTMANAGER_CID) ;
+static NS_DEFINE_CID(kNetDiskCacheCID, NS_NETDISKCACHE_CID) ;
+
+class nsNetDiskCacheFactory : public nsIFactory
+{
+  public:
+  nsNetDiskCacheFactory() ;
+  virtual ~nsNetDiskCacheFactory() ;
+
+  // nsISupports methods
+  NS_DECL_ISUPPORTS
+
+  // nsIFactory methods
+  NS_IMETHOD CreateInstance(nsISupports *aOuter,
+                            const nsIID &aIID,
+                            void **aResult);
+
+  NS_IMETHOD LockFactory(PRBool aLock);
+  private:
+
+//  static PRInt32 DiskCacheLockCnt ;
+} ;
+
+nsNetDiskCacheFactory::nsNetDiskCacheFactory()
+{
+//  DiskCacheLockCnt = 0 ;
+  NS_INIT_REFCNT();
+}
+
+nsNetDiskCacheFactory::~nsNetDiskCacheFactory()
+{
+  NS_ASSERTION(mRefCnt == 0, "non-zero refcnt at destruction");
+}
+
+NS_IMPL_ISUPPORTS(nsNetDiskCacheFactory, kIFactoryIID) ;
+
+NS_IMETHODIMP
+nsNetDiskCacheFactory::CreateInstance(nsISupports *aOuter,
+                                   const nsIID &aIID,
+                                   void **aResult)
+{
+  if(!aResult)
+    return NS_ERROR_NULL_POINTER ;
+
+  *aResult = nsnull ;
+
+  nsISupports *inst = new nsNetDiskCache ;
+
+  if(!inst) 
+    return NS_ERROR_OUT_OF_MEMORY ;
+
+  nsresult rv = inst->QueryInterface(aIID, aResult) ;
+
+  if(NS_FAILED(rv)) 
+    delete inst ;
+
+  rv = NS_STATIC_CAST(nsNetDiskCache*, inst)->Init() ;
+  if(NS_FAILED(rv)) {
+    NS_IF_RELEASE(inst) ;
+    return NS_ERROR_FAILURE ;
+  }
+
+  return rv ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCacheFactory::LockFactory(PRBool aLock)
+{
+  /*
+  if(aLock) 
+    PR_AtomicIncrement (&DiskCacheLockCnt) ;
+            
+  else 
+    PR_AtomicDecrement (&DiskCacheLockCnt) ;
+
+  */
+  return NS_OK ;
+}
+
+extern "C" NS_EXPORT nsresult
+NSGetFactory(nsISupports *serviceMgr, 
+             const nsCID &aCID,
+			 const char * aClassName,
+			 const char * aProgID,
+			 nsIFactory **aResult)
+{
+  if(!aResult)
+	return NS_ERROR_NULL_POINTER ;
+
+  *aResult = nsnull ;
+
+  nsISupports *inst ;
+
+  if(aCID.Equals(kNetDiskCacheCID)) {
+    inst = new nsNetDiskCacheFactory() ; 
+  }
+  else {
+	return NS_ERROR_NO_INTERFACE ;
+  }
+
+  if(!inst)
+	return NS_ERROR_OUT_OF_MEMORY ;
+
+  nsresult rv = inst->QueryInterface(kIFactoryIID, (void **)aResult) ;
+
+  if (NS_FAILED(rv)) {
+	delete inst ;
+  }
+
+  return rv ;
+}
+
+extern "C" NS_EXPORT PRBool
+NSCanUnload (nsISupports* serviceMgr)
+{
+  // not implemented
+  return PR_TRUE ;
+}
+
+extern "C" NS_EXPORT nsresult
+NSRegisterSelf(nsISupports *aServMgr, const char *path)
+{
+  nsresult rv = NS_OK ;
+
+  nsIServiceManager *sm ;
+
+  rv = aServMgr->QueryInterface(nsIServiceManager::GetIID(), (void**)&sm) ;
+
+  if(NS_FAILED(rv)) {
+	return rv;
+  }
+
+  nsIComponentManager *cm ;
+
+  rv = sm->GetService(kComponentManagerCID, 
+                      nsIComponentManager::GetIID(), 
+                      (nsISupports **) &cm) ;
+  if (NS_FAILED(rv)) {
+	NS_RELEASE(sm) ;
+	return rv ;
+  }
+
+  rv = cm->RegisterComponent(kNetDiskCacheCID, "Disk Cache Module", 
+                             "component://netscape/network/cache/db-access",
+                             path, PR_TRUE, PR_TRUE) ;
+
+  sm->ReleaseService(kComponentManagerCID, cm) ;
+
+  NS_RELEASE(sm) ;
+
+  return rv ;
+}
+
+extern "C" NS_EXPORT nsresult
+NSUnregisterSelf(nsISupports* aServMgr, const char *path)
+{
+  // not implemented
+  return NS_OK ;
+}
+

mozilla/netwerk/cache/filecache/nsDiskCacheRecord.cpp

@@ -0,0 +1,488 @@
+/* -*- 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.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 "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) ,
+  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
+  mDB->GetID(key, length, &mRecordID) ;
+
+  // 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] ;
+  PR_snprintf(dirName, 3, "%.2x", (((PRUint32)mRecordID) % 32)) ;
+  mFile->AppendRelativeUnixPath(dirName) ;
+
+  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) ;
+  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 {
+    nsCOMPtr<nsIFileSpec> newfile;
+    NS_NewFileSpec(getter_AddRefs(newfile)) ;
+
+    char *newname, *oldname=nsnull ;
+    rv = mFile->GetLeafName(&oldname) ; // save the old file name 
+    if(!oldname)
+      return NS_ERROR_FAILURE ;
+
+    newfile->FromFileSpec(mFile) ;
+    newfile->MakeUnique() ; // generate a unique new file name
+    newfile->GetLeafName(&newname) ;
+
+    mFile->Rename(newname) ; // rename the old file 
+    mFile->SetLeafName(oldname) ;  // get the old name back
+
+    newfile->OpenStreamForReading() ;
+    mFile->OpenStreamForWriting() ;
+
+    PRUint32 buffer_size = 1024 ;
+    char buffer[1024], *p_buf ;
+    PRInt32 result ;
+    PRUint32 size_left = aStoredContentLength, size_written = 0 ;
+    p_buf = buffer ;
+
+    do {
+      if(size_left > buffer_size) 
+        size_written = buffer_size ;
+      else
+        size_written = size_left ;
+
+      rv = newfile->Read(&p_buf, size_written, &result) ;
+      if(NS_FAILED(rv) || result != NS_STATIC_CAST(PRInt32, size_written)) 
+        return NS_ERROR_FAILURE ;
+
+      rv = mFile->Write(buffer, size_written, &result) ;
+      if(NS_FAILED(rv) || result != NS_STATIC_CAST(PRInt32, size_written))
+        return NS_ERROR_FAILURE ;
+
+      size_left -= size_written ;
+    } while(size_left) ;
+
+    mFile->CloseStream() ;
+    newfile->CloseStream() ;
+
+    nsFileSpec extra_file ;
+    newfile->GetFileSpec(&extra_file) ;
+    extra_file.Delete(PR_TRUE) ;
+
+    return NS_OK ;
+  }
+}
+
+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,66 @@
+/* -*- 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.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.
+ */
+
+#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,330 @@
+/* -*- 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.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 "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(); 
+}
+
+WriteStreamWrapper::~WriteStreamWrapper()
+{
+
+}
+
+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-- ;
+}
+
+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
+                        nsnull,    // original uri same as uri
+                        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->mFile->GetFileSize(&oldLength) ;
+  rv = mFileTransport->OpenOutputStream(startPosition, getter_AddRefs(outputStream)) ;
+  if(NS_FAILED(rv)) return rv ;
+  if(startPosition < oldLength)
+    NotifyStorageInUse(startPosition - oldLength) ;
+
+  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::GetLoadGroup(nsILoadGroup* *aLoadGroup)
+{
+  *aLoadGroup = mLoadGroup ;
+  NS_IF_ADDREF(*aLoadGroup) ;
+  return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsDiskCacheRecordChannel::GetOriginalURI(nsIURI* *aURI)
+{
+  return NS_ERROR_NOT_IMPLEMENTED ;
+}

mozilla/netwerk/cache/filecache/nsDiskCacheRecordChannel.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.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.
+ */
+
+#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,56 @@
+/* -*- 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.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.
+ */
+
+#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,634 @@
+/* -*- 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.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 "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) ;
+
+  if(m_BaseDirNum > 32)
+    RemoveDirs(32) ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::Init(void) 
+{
+  nsresult rv ;
+  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 ;
+
+    if(NS_SUCCEEDED(pref->GetIntPref(DISK_CACHE_PREF, &nTemp))) {
+      printf("cache size is %d\n", nTemp) ;
+      m_Capacity = 1024*nTemp ;
+    } else {
+      m_Capacity = DISK_CACHE_SIZE_DEFAULT ;
+      printf("using default capacity value, %d bytes\n", m_Capacity) ;
+    }
+
+    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_Capacity = DISK_CACHE_SIZE_DEFAULT ;
+    m_pDiskCacheFolder->SetUnixStyleFilePath("/tmp") ;
+  }
+
+  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));
+
+  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)) ;
+  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
+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) ;
+
+  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) ;
+
+  // 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) ;
+    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 {
+    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 ;
+}
+
+NS_IMETHODIMP
+nsNetDiskCache::GetCapacity(PRUint32 *aCapacity)
+{
+  *aCapacity = m_Capacity ;
+  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 ;
+
+  // 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? 
+    nsresult rv = RemoveAll() ;
+    return rv ;
+  }
+  else 
+    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)) ;
+  p_spec->Exists(&does_exist) ;
+  if(!does_exist) {
+    CreateDir(p_spec) ;
+    dir_spec->CreateDir() ;
+  }
+  else {
+    dir_spec->CreateDir() ;
+  }
+  
+  return NS_OK ;
+}
+
+// this will walk through db and update m_NumEntries and m_StorageInUse
+NS_IMETHODIMP
+nsNetDiskCache::UpdateInfo(void)
+{
+  // count num of entries in db
+  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() ;
+  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,77 @@
+/* -*- 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.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.
+ */
+
+#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 ;
+  PRInt32 			                m_Capacity ;
+  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,28 @@
+/* -*- 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.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.
+ */
+
+#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/include/nsBkgThread.h

@@ -0,0 +1,63 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+/* This is a super cool class that does the background thread magic using
+ * NSPR Threads. This class is used to maintain odd tasks in the background
+ * like like updating, expiration, validation and garbage collection. 
+ * 
+ * Note that this is a noop active when the cache manager is offline. 
+ * 
+ * In PRThread terms, this is a PR_USER_THREAD with local scope.
+ *
+ * -Gagan Saksena 09/15/98
+ */
+#ifndef nsBkgThread_h__
+#define nsBkgThread_h__
+
+//#include "nsISupports.h"
+#include "prthread.h"
+#include "prinrval.h"
+
+class nsBkgThread//: public nsISupports
+{
+
+public:
+            nsBkgThread(PRIntervalTime iSleepTime, PRBool bStart=PR_TRUE);
+    virtual ~nsBkgThread();
+/*
+    NS_IMETHOD              QueryInterface(const nsIID& aIID, 
+                                           void** aInstancePtr);
+    NS_IMETHOD_(nsrefcnt)   AddRef(void);
+    NS_IMETHOD_(nsrefcnt)   Release(void);
+*/
+    void            Process(void);
+    virtual void    Run(void) = 0;
+    void            Stop(void);
+protected:
+    PRThread*       m_pThread;
+    PRBool          m_bContinue;
+    PRIntervalTime  m_SleepTime;
+
+private:
+    nsBkgThread(const nsBkgThread& o);
+    nsBkgThread& operator=(const nsBkgThread& o);
+
+};
+
+#endif // nsBkgThread_h__
+

mozilla/netwerk/cache/include/nsCacheBkgThd.h

@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+/* This class is the actual implementation of the original class nsBkgThread, 
+ * but I am too lazy to move the comments from nsBkgThread's 
+ * header file to here. :-)
+ * 
+ * -Gagan Saksena 09/15/98
+ */
+#ifndef nsCacheBkgThd_h__
+#define nsCacheBkgThd_h__
+
+#include "nsBkgThread.h"
+
+class nsCacheBkgThd: public nsBkgThread
+{
+
+public:
+            nsCacheBkgThd(PRIntervalTime iSleepTime);
+    virtual ~nsCacheBkgThd();
+/*
+    NS_IMETHOD              QueryInterface(const nsIID& aIID, 
+                                           void** aInstancePtr);
+    NS_IMETHOD_(nsrefcnt)   AddRef(void);
+    NS_IMETHOD_(nsrefcnt)   Release(void);
+*/
+    void        Run(void);
+
+protected:
+
+private:
+    nsCacheBkgThd(const nsCacheBkgThd& o);
+    nsCacheBkgThd& operator=(const nsCacheBkgThd& o);
+};
+
+#endif // nsCacheBkgThd_h__
+

mozilla/netwerk/cache/include/nsCacheIterator.h

@@ -0,0 +1,86 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (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.
+ *
+ * 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.
+ */
+
+/* A simple cache iterator for cache architecture. This is a temporary class
+ * which will be (should be) replaced by more professional quality code, or 
+ * at least moved to a more common area later on. 
+ *
+ * -Gagan Saksena 09/15/98 
+ */
+#ifndef nsCacheIterator_h__
+#define nsCacheIterator_h__
+
+#include "nsIterator.h"
+#include "prtypes.h"
+#include "nsICacheModule.h"
+#include "nsICacheObject.h"
+
+class nsCacheIterator: public nsIterator
+{
+
+public:
+            nsCacheIterator(nsICacheModule* i_pModule);
+    virtual ~nsCacheIterator();
+
+    virtual PRBool          IsDone(void) const;
+    virtual nsICacheObject*  Current(void) const;
+
+private:
+    nsCacheIterator(const nsCacheIterator& o);
+    nsCacheIterator& operator=(const nsCacheIterator& o);
+    nsICacheModule*    m_pModule;
+};
+
+inline
+nsCacheIterator::nsCacheIterator(nsICacheModule* i_pModule): m_pModule(i_pModule)
+{
+}
+
+inline
+nsCacheIterator::~nsCacheIterator()
+{
+}
+
+inline
+PRBool nsCacheIterator::IsDone(void) const
+{
+	/*
+    if (m_pModule)
+    {
+        return m_pModule->Entries() <= m_Index;
+    }
+    else
+        return PR_FALSE;
+		*/
+}
+
+inline
+nsICacheObject* nsCacheIterator::Current(void) const
+{
+	nsICacheObject* pObj ;
+
+    if (m_pModule)
+    {
+        m_pModule->GetObjectByIndex(m_Index, &pObj);
+		return pObj ;
+    }
+    return 0;
+}
+#endif // nsCacheIterator_h__
+

mozilla/netwerk/cache/include/nsCacheManager.h

@@ -0,0 +1,208 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+/* 
+ * nsCacheManager- The boss of cache architecture. Contains all "external"
+ * functions for use by people who don't care/want to know the internals
+ * of the cache architecture. 
+ *
+ * - Gagan Saksena 09/15/98
+ *
+ * Design and original implementation by Gagan Saksena 02/02/98
+ * 
+ */
+
+#ifndef _CacheManager_H_
+#define _CacheManager_H_
+
+#include "nsISupports.h"
+#include "nsIFactory.h"
+#include "nsICacheManager.h"
+
+#include "prlog.h"
+
+#include "nsMonitorable.h"
+#include "nsICacheModule.h"
+#include "nsICacheObject.h"
+#include "nsCacheBkgThd.h"
+#include <stdio.h>
+
+// class nsMemModule;
+// class nsDiskModule;
+// class nsCachePref;
+// class nsCacheBkgThd;
+
+
+class nsCacheManager : public nsICacheManager , public nsMonitorable 
+{
+
+public:
+
+    nsCacheManager();
+    virtual ~nsCacheManager();
+
+	NS_DECL_ISUPPORTS
+
+    NS_IMETHOD Contains(const char* i_url ) const;
+	// PRBool Contains(const char* i_url) const ;
+    
+    /* Number of modules in the cache manager */
+    NS_IMETHOD Entries(PRInt16 * n_Entries) const;
+	// PRInt16 				Entries( ) const ;
+
+    NS_IMETHOD AddModule(PRInt16 * n_Index, nsICacheModule* pModule);
+                            // InsertModule
+
+    NS_IMETHOD GetModule (PRInt16 i_index, nsICacheModule** pmodule) const ;
+    // nsCacheModule*          GetModule(PRInt16 i_index) const;
+
+    NS_IMETHOD GetDiskModule(nsICacheModule** pmodule) const ;
+    // nsDiskModule*           GetDiskModule() const;
+
+    NS_IMETHOD GetMemModule(nsICacheModule** pmodule) const ;
+    // nsMemModule*            GetMemModule() const;
+ 
+    NS_IMETHOD GetPrefs(nsICachePref** pPref) const ;
+    // nsCachePref*            GetPrefs(void) const;
+
+    NS_IMETHOD GetObj(const char* i_url, void ** o_pObject) const;
+
+    NS_IMETHOD InfoAsHTML(char** o_Buffer) const;
+
+    NS_IMETHOD IsOffline(PRBool *bOffline) const;
+
+    NS_IMETHOD Offline(PRBool bSet);
+
+    NS_IMETHOD Remove(const char* i_url);
+
+    /* Performance measure- microseconds */
+    NS_IMETHOD WorstCaseTime(PRUint32 * o_Time) const;
+   
+    /* Singleton */
+    static nsCacheManager*  GetInstance();
+
+    // Initialize the cache manager. Constructor doesn't call this. 
+    // So you must specify this separately. 
+
+	// GetInstance will call it automatically. - yixiong
+    void                    Init();
+
+    // const char*             Trace() const;
+
+protected:
+    
+    NS_IMETHOD ContainsExactly(const char* i_url, PRBool * bContain) const;
+  
+    nsICacheModule*          LastModule() const;
+    //PRBool                  Lock(void);
+    //void                    Unlock(void);
+
+/*
+    class MgrMonitor
+    {
+    public:
+        MgrMonitor() { nsCacheManager::GetInstance()->Lock();}
+        ~MgrMonitor() { nsCacheManager::GetInstance()->Unlock();}
+    };
+
+    friend MgrMonitor;
+*/
+
+private:
+    nsCacheBkgThd*       m_pBkgThd;
+    nsICacheModule*      m_pFirstModule;
+    PRMonitor*           m_pMonitor;
+    PRBool               m_bOffline;
+    nsICachePref*        m_pPrefs;
+
+    nsCacheManager(const nsCacheManager& cm);
+    nsCacheManager& operator=(const nsCacheManager& cm);
+	static nsCacheManager * gInstance ;
+};
+
+class nsCacheManagerFactory : public nsIFactory 
+{
+  public:
+    nsCacheManagerFactory( ) ;
+	virtual ~nsCacheManagerFactory( ) ;
+
+	NS_DECL_ISUPPORTS
+
+	NS_IMETHOD CreateInstance(nsISupports *aOuter, 
+	                          const nsIID &aIID,
+							  void **aResult) ;
+
+	NS_IMETHOD LockFactory(PRBool aLock) ;
+} ;
+
+inline NS_IMETHODIMP
+nsCacheManager::GetDiskModule( nsICacheModule ** pModule) const
+{
+    PR_ASSERT(m_pFirstModule);
+
+	nsresult rv ;
+	*pModule = nsnull ;
+
+    // return (m_pFirstModule) ? (nsDiskModule*) m_pFirstModule->NextModule() : NULL;
+	if (m_pFirstModule) {
+
+	  rv = m_pFirstModule->GetNextModule(pModule) ;
+
+	  if (NS_SUCCEEDED(rv) && *pModule){
+        return NS_OK ;
+	  }
+//      else 
+//	    return NS_ERROR_FAILURE ;
+	}
+
+	return NS_ERROR_FAILURE ;
+}
+
+inline NS_IMETHODIMP
+nsCacheManager::GetMemModule(nsICacheModule ** pModule ) const
+{
+    PR_ASSERT(m_pFirstModule);
+    *pModule = m_pFirstModule;
+
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCacheManager::GetPrefs(nsICachePref ** pPref) const
+{
+    PR_ASSERT(m_pPrefs);
+    *pPref =  m_pPrefs;
+
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCacheManager::IsOffline(PRBool * bOffline) const
+{
+    *bOffline = m_bOffline;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCacheManager::Offline(PRBool i_bSet) 
+{
+    m_bOffline = i_bSet;
+	return NS_OK ;
+}
+
+#endif

mozilla/netwerk/cache/include/nsCacheObject.h

@@ -0,0 +1,465 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+/* nsCacheObject is the class that holds the basic definition of the 
+ * cache object.  A lot of changes are likely to occur before this 
+ * goes on stage. 
+ *
+ * -Gagan Saksena 09/15/98
+ */
+#ifndef nsCacheObject_h__
+#define nsCacheObject_h__
+
+// #if 0
+#include "nsISupports.h"
+// #endif
+#include "pratom.h"
+#include "nscore.h"
+#include "nsIFactory.h"
+#include "nsRepository.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsStream.h"
+#include "prtypes.h"
+#include "prinrval.h"
+#include "nsICacheObject.h"
+
+static const PRUint32 kCACHE_VERSION = 5;
+
+// class nsStream;
+
+class nsCacheObject : public nsICacheObject
+{
+
+public:
+
+    enum state_flags 
+    {
+        INIT=0,
+        PARTIAL=1,
+        COMPLETE=2,
+        ABORTED=3,
+        EXPIRED=4,
+        CORRUPT=5
+    };
+
+    nsCacheObject();
+    nsCacheObject(const nsCacheObject& another);
+    nsCacheObject(const char* i_url);
+
+    virtual ~nsCacheObject();
+
+    NS_DECL_ISUPPORTS
+
+
+/* public interface */
+
+//    NS_IMETHOD Create(const char * i_url, void * aObj) = 0 ;
+
+//    NS_IMETHOD Destroy(void * pThis) = 0 ;
+
+    NS_IMETHOD GetAddress(char ** Addr) const ;
+    NS_IMETHOD SetAddress(const char* i_Address) ;
+
+    NS_IMETHOD GetCharset(char ** CSet) const ;
+    NS_IMETHOD SetCharset(const char* i_CharSet) ;
+
+    NS_IMETHOD GetContentEncoding(char ** Encoding) const ;
+    NS_IMETHOD SetContentEncoding(const char* i_Encoding) ;
+
+    NS_IMETHOD GetContentLength(PRUint32 * CLeng) const ;
+    NS_IMETHOD SetContentLength(PRUint32 i_Len) ;
+
+    NS_IMETHOD GetContentType(char ** CType) const ;
+    NS_IMETHOD SetContentType(const char* i_Type) ;
+
+    NS_IMETHOD GetEtag(char ** Etag) const ;
+    NS_IMETHOD SetEtag(const char* i_Etag) ;
+
+    NS_IMETHOD GetExpires(PRIntervalTime * iTime) const ;
+    NS_IMETHOD SetExpires(const PRIntervalTime i_Time) ;
+
+    NS_IMETHOD GetFilename(char ** Filename) const ;
+    NS_IMETHOD SetFilename(const char* i_Filename) ;
+
+    NS_IMETHOD GetIsCompleted(PRBool *bComplete) const ;
+    NS_IMETHOD SetIsCompleted(PRBool bComplete) ;
+
+    NS_IMETHOD GetLastAccessed(PRIntervalTime * iTime) const ;
+
+    NS_IMETHOD GetLastModified(PRIntervalTime * iTime) const ;
+    NS_IMETHOD SetLastModified(const PRIntervalTime i_Time) ;
+
+    NS_IMETHOD GetModuleIndex(PRInt16 * m_index) const ;
+    NS_IMETHOD SetModuleIndex(const PRUint16 m_index) ;
+
+    NS_IMETHOD GetPageServicesURL(char ** o_url) const ;
+    NS_IMETHOD SetPageServicesURL(const char* i_Url) ;
+
+    NS_IMETHOD GetPostData(char ** pData) const ;
+    NS_IMETHOD SetPostData(const char* i_PostData, const PRUint32 i_Len) ;
+
+    NS_IMETHOD GetPostDataLen(PRUint32 * dLeng) const ;
+
+    /* Accessor functions for the size of the cache object */
+    NS_IMETHOD GetSize(PRUint32 * pSize) const ;
+    NS_IMETHOD SetSize(const PRUint32 i_Size) ;
+
+    /* Accessor functions for the state of the cache object.
+     * Some states are changed internally.
+     */
+    NS_IMETHOD GetState(PRUint32 * pState) const ;
+    NS_IMETHOD SetState(const PRUint32 i_State) ;
+
+    NS_IMETHOD GetStream(nsStream ** pStream) const ;
+//	NS_IMETHOD MakeStream(void) ;
+
+    NS_IMETHOD Hits(PRUint32 * pHits) const ;
+
+    NS_IMETHOD IsExpired(PRBool *bGet) const ;
+
+    NS_IMETHOD IsPartial(PRBool *bGet) const ;
+
+    NS_IMETHOD Read(char* o_Destination, PRUint32 i_Len, 
+                                                       PRUint32 * pLeng) ;
+
+    /* Reset the streams/state, read/write locks, etc. */
+    NS_IMETHOD Reset(void) ;
+
+//    NS_IMETHOD Synch(void) = 0 ;
+
+    NS_IMETHOD Write(const char* i_buffer, const PRUint32 i_length, 
+                                                        PRUint32 * oLeng) ;
+
+//	NS_IMETHOD InitUrl(const char* i_url) ;
+
+    /* Read and write info about this cache object */
+    NS_IMETHOD GetInfo(void** o_info) ;
+    NS_IMETHOD SetInfo(void* i_info /*, PRUint32 len */);
+
+    NS_IMETHOD GetInfoSize(PRUint32* o_size) ;
+
+/* end public interface */
+
+    const char*     Trace() const;
+
+protected:
+
+    void            Init();
+
+    char*           m_Charset;
+    char*           m_ContentEncoding;
+    PRUint32        m_ContentLength;
+    char*           m_ContentType;
+    char*           m_Etag;
+    PRIntervalTime  m_Expires;
+    char*           m_Filename;
+    PRUint32        m_State;
+    PRUint16        m_Hits;
+    PRUint32        m_info_size;
+    PRBool          m_bIsCompleted; /* Marked when the stream complete is called */
+    PRIntervalTime  m_LastAccessed, m_LastModified;
+    PRInt16         m_Module;
+    void*           m_pInfo;
+    char*           m_PageServicesURL;
+    char*           m_PostData;
+    PRUint32        m_PostDataLen;
+    PRUint32        m_Size;
+    nsStream*       m_pStream;
+    char*           m_URL;
+
+private:
+    nsCacheObject& operator=(const nsCacheObject& x);
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetAddress(char ** Addr) const
+{
+	if (!Addr)
+	  return NS_ERROR_NULL_POINTER;
+
+	*Addr = m_URL ;
+    return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetCharset(char ** CSet) const
+{
+	if (!CSet)
+	  return NS_ERROR_NULL_POINTER;
+
+	*CSet = m_Charset;
+    return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCacheObject::GetContentEncoding(char ** Encoding) const
+{
+	if (!Encoding)
+	  return NS_ERROR_NULL_POINTER;
+
+    *Encoding=m_ContentEncoding;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCacheObject::GetContentLength(PRUint32 * CLeng) const
+{
+	if (!CLeng)
+	  return NS_ERROR_NULL_POINTER;
+
+    *CLeng = m_ContentLength;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::SetContentLength(PRUint32 i_Size)
+{
+    m_ContentLength = i_Size;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetContentType(char ** CType) const
+{
+	if (!CType)
+	  return NS_ERROR_NULL_POINTER;
+
+    *CType = m_ContentType;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetEtag(char ** Etag) const 
+{
+	if (!Etag)
+	  return NS_ERROR_NULL_POINTER;
+
+    *Etag = m_Etag;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetExpires(PRIntervalTime * iTime) const
+{
+	if (!iTime)
+	  return NS_ERROR_NULL_POINTER;
+
+    *iTime = m_Expires;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::SetExpires(PRIntervalTime i_Expires)
+{
+    m_Expires = i_Expires;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetFilename(char ** Filename) const
+{
+	if (!Filename)
+	  return NS_ERROR_NULL_POINTER;
+
+    *Filename = m_Filename;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCacheObject::Hits(PRUint32 * pHits) const
+{
+    *pHits = m_Hits;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetIsCompleted(PRBool *bComplete) const
+{
+    if (m_bIsCompleted) {
+	  *bComplete=PR_TRUE ;
+	}
+	else {
+	  *bComplete=PR_FALSE ;
+	}
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCacheObject::SetIsCompleted(PRBool bComplete) 
+{
+    m_bIsCompleted = bComplete;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCacheObject::IsExpired(PRBool *bExpired) const
+{
+    if (nsCacheObject::EXPIRED==m_State)
+	  *bExpired = PR_TRUE ;
+
+    if (m_Expires <= PR_IntervalNow()) {
+        ((nsCacheObject*)this)->m_State = nsCacheObject::EXPIRED;
+		*bExpired = PR_TRUE ;
+	}
+	else 
+	  *bExpired = PR_FALSE ;
+
+	return NS_OK ;
+
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::IsPartial(PRBool *bPartial) const
+{
+    if (m_ContentLength != m_Size) 
+	  *bPartial = PR_TRUE ;
+	else 
+	  *bPartial = PR_FALSE ;
+
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetLastAccessed(PRIntervalTime * iTime) const
+{
+    *iTime = m_LastAccessed;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetLastModified(PRIntervalTime * iTime) const
+{
+    *iTime = m_LastModified;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::SetLastModified(const PRIntervalTime i_LastModified)
+{
+    m_LastModified = i_LastModified;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetModuleIndex(PRInt16 * m_index) const
+{
+    *m_index = m_Module;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::SetModuleIndex(PRUint16 m_index) 
+{
+    m_Module = m_index;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetPageServicesURL(char ** o_url) const
+{
+    if (!o_url)
+	  return NS_ERROR_NULL_POINTER;
+
+    *o_url = m_PageServicesURL;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCacheObject::GetPostData(char ** pData) const
+{
+	if (!pData)
+	  return NS_ERROR_NULL_POINTER;
+
+    *pData = m_PostData;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCacheObject::GetPostDataLen(PRUint32 * dLeng) const
+{
+	if (!dLeng)
+	  return NS_ERROR_NULL_POINTER;
+
+    *dLeng = m_PostDataLen;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCacheObject::GetSize(PRUint32 * pSize) const
+{
+	if (!pSize)
+	  return NS_ERROR_NULL_POINTER;
+
+    *pSize = m_Size;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::SetSize(PRUint32 i_Size)
+{
+    m_Size = i_Size;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetState(PRUint32 * pState) const
+{
+	if (!pState)
+	  return NS_ERROR_NULL_POINTER;
+
+    *pState = m_State;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::SetState(PRUint32 i_State)
+{
+    m_State = i_State;
+	return NS_OK ;
+};
+
+inline NS_IMETHODIMP
+nsCacheObject::GetStream(nsStream** pStream) const
+{
+    if (!pStream)
+	  return NS_ERROR_NULL_POINTER;
+
+    *pStream = m_pStream;
+	return NS_OK ;
+}
+
+/////////////////////////////////////////////////////////////////////
+// nsCacheObjectFactory
+
+class nsCacheObjectFactory : public nsIFactory {
+public:
+    nsCacheObjectFactory();
+    virtual ~nsCacheObjectFactory();
+            
+    NS_DECL_ISUPPORTS
+                  
+    NS_IMETHOD CreateInstance(nsISupports *aOuter,  
+                             const nsIID &aIID,  
+                             void **aResult);  
+                
+    NS_IMETHOD LockFactory(PRBool aLock);
+
+} ;
+
+#endif // nsCacheObject_h__

mozilla/netwerk/cache/include/nsCachePref.h

@@ -0,0 +1,195 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+/* nsCachePref. A class to separate the preference related code to 
+ * one place. This is an incomplete implementation, I need to access
+ * the libprefs directly, but that would add another dependency. And 
+ * libpref comes with a JS dependency... so holding this off for the 
+ * moment. 
+ * 
+ * -Gagan Saksena 09/15/98
+ */
+#ifndef nsCachePref_h__
+#define nsCachePref_h__
+
+#include "nsICachePref.h"
+#include "nsIFactory.h"
+#include "prtypes.h"
+#include "prlog.h"
+
+class nsCachePref : public nsICachePref
+{
+
+public:
+    
+    nsCachePref(void);
+    virtual ~nsCachePref();
+
+ /*
+    NS_IMETHOD              QueryInterface(const nsIID& aIID, 
+                                           void** aInstancePtr);
+    NS_IMETHOD_(nsrefcnt)   AddRef(void);
+    NS_IMETHOD_(nsrefcnt)   Release(void);
+*/
+    NS_DECL_ISUPPORTS
+	/*
+    enum Refresh 
+    {
+        ONCE,
+        ALWAYS,
+        NEVER
+    };
+	*/
+    NS_IMETHOD	GetBkgSleepTime (PRUint32* o_time) ;
+    
+    NS_IMETHOD	GetDiskCacheDBFilename (char** o_name) ; /* like Fat.db */
+    NS_IMETHOD	GetDiskCacheFolder (char** o_folder) ;   /* Cache dir */
+
+    NS_IMETHOD	GetDiskCacheSSL (PRBool* o_bSet) ;
+    NS_IMETHOD	SetDiskCacheSSL (PRBool i_bSet) ;
+
+    NS_IMETHOD	GetDiskCacheSize (PRUint32* o_size) ;
+    NS_IMETHOD	SetDiskCacheSize (const PRUint32 i_size) ;
+
+    NS_IMETHOD	GetMemCacheSize (PRUint32 * o_size) ;
+    NS_IMETHOD	SetMemCacheSize (const PRUint32 i_size) ;
+
+    NS_IMETHOD	GetFrequency (nsICachePref::Refresh* o_frequency) ;
+
+    /* Revalidating in background, makes IMS calls in the bkg thread to 
+       update cache entries. TODO, this should be at a bigger time period
+       than the cache cleanup routine */
+    NS_IMETHOD	RevalidateInBkg (PRBool* i_bRevalidateInBkg) ;
+
+    /* Setup all prefs */
+    NS_IMETHOD	SetupPrefs(const char* i_Pref) ;
+
+    static nsICachePref* GetInstance(void);
+
+private:
+    nsCachePref(const nsCachePref& o);
+    nsCachePref& operator=(const nsCachePref& o);
+
+    PRBool                  m_bRevalidateInBkg;
+    PRBool                  m_bDiskCacheSSL;
+    nsICachePref::Refresh    m_RefreshFreq;
+    PRUint32                m_MemCacheSize;
+    PRUint32                m_DiskCacheSize;
+    char*                   m_DiskCacheDBFilename;
+    char*                   m_DiskCacheFolder;
+    PRUint32                m_BkgSleepTime;
+};
+
+inline NS_IMETHODIMP
+nsCachePref::GetDiskCacheSize(PRUint32* o_size)
+{
+	if (!o_size)
+	  return NS_ERROR_NULL_POINTER ;
+
+    *o_size = m_DiskCacheSize;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCachePref::SetDiskCacheSize(const PRUint32 i_Size)
+{
+    m_DiskCacheSize = i_Size;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCachePref::GetDiskCacheSSL(PRBool* o_bSet)
+{
+	if (!o_bSet)
+	  return NS_ERROR_NULL_POINTER ;
+
+    *o_bSet = m_bDiskCacheSSL;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCachePref::SetDiskCacheSSL(PRBool bSet)
+{
+    m_bDiskCacheSSL = bSet;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCachePref::GetDiskCacheFolder(char** o_folder)
+{
+    if (!o_folder)
+	  return NS_ERROR_NULL_POINTER ;
+
+    PR_ASSERT(m_DiskCacheFolder);
+	*o_folder = m_DiskCacheFolder ;
+    return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCachePref::GetMemCacheSize(PRUint32 * o_size)
+{
+	if (!o_size)
+	  return NS_ERROR_NULL_POINTER ;
+
+    *o_size = m_MemCacheSize;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCachePref::SetMemCacheSize(const PRUint32 i_Size)
+{
+    m_MemCacheSize = i_Size;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCachePref::RevalidateInBkg(PRBool* o_RevalidateInBkg)
+{
+	if (!o_RevalidateInBkg) 
+	  return NS_ERROR_NULL_POINTER ;
+
+    *o_RevalidateInBkg = m_bRevalidateInBkg;
+	return NS_OK ;
+}
+
+inline NS_IMETHODIMP
+nsCachePref::GetFrequency (nsICachePref::Refresh* o_frequency)
+{
+  if (!o_frequency)
+	return NS_ERROR_NULL_POINTER ;
+
+  *o_frequency = m_RefreshFreq ;
+  return NS_OK ;
+}
+
+/////////////////////////////////////////////////////////////////////
+// nsCacheObjectFactory
+
+class nsCachePrefFactory : public nsIFactory {
+    public:
+	  nsCachePrefFactory();
+	  virtual ~nsCachePrefFactory();
+
+	  NS_DECL_ISUPPORTS
+	  NS_IMETHOD CreateInstance(nsISupports *aOuter,
+	                            const nsIID &aIID,
+                                void **aResult);
+      NS_IMETHOD LockFactory(PRBool aLock);
+} ;
+
+#endif // nsCachePref_h__

mozilla/netwerk/cache/include/nsDiskModule.h

@@ -0,0 +1,132 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+/* 
+ * nsDiskModule. The disk cache module that stores the cache objects
+ * on the disk. 
+ *
+ * Gagan Saksena 02/03/98
+ * 
+ */
+#ifndef _nsDiskModule_H_
+#define _nsDiskModule_H_
+
+#include "nsICacheModule.h"
+#include "nsIterator.h"
+#include "nsCacheIterator.h"
+#include "nsEnumeration.h"
+#include "nsCachePref.h"
+#include "nsMonitorable.h"
+#include "mcom_db.h"
+
+
+class nsDiskModule : public nsMonitorable, public nsICacheModule
+{
+
+public:
+	NS_DECL_ISUPPORTS
+
+
+    //////////////////////////////////////////////////////////////////////////
+    // nsICacheModule Methods:
+
+    NS_IMETHOD  AddObject(nsICacheObject* i_pObject);
+    
+    NS_IMETHOD  ContainsURL(const char* i_url, PRBool* o_bContain);
+
+    NS_IMETHOD  ContainsCacheObj(nsICacheObject* i_pObject, PRBool* o_bContain) ;
+    
+    NS_IMETHOD  Enable (PRBool i_Enable);
+    
+    NS_IMETHOD  GetNumOfEntries (PRUint32* o_entry);
+
+    NS_IMETHOD  GetEnumerator (nsEnumeration** o_enum);
+    /* Enumerations with a function pointer - TODO */
+
+    //TODO move to own interface for both Garbage Collection and Revalidation
+    NS_IMETHOD  GarbageCollect (void);
+
+    NS_IMETHOD  GetObjectByURL (const char* i_url, nsICacheObject** o_pObj);
+
+    NS_IMETHOD  GetObjectByIndex (const PRUint32 i_index, nsICacheObject** o_pObj);
+
+    NS_IMETHOD  GetStreamFor (const nsICacheObject* i_pObject, nsStream** o_pStream);
+
+    NS_IMETHOD  IsEnabled (PRBool* o_bEnabled);
+
+    /* Can't do additions, deletions, validations, expirations */
+    NS_IMETHOD  IsReadOnly (PRBool* o_bReadOnly); 
+
+    NS_IMETHOD  GetNextModule (nsICacheModule** o_pCacheModule);
+    NS_IMETHOD  SetNextModule (nsICacheModule* i_pCacheModule);
+
+    NS_IMETHOD  RemoveByURL (const char* i_url);
+
+    NS_IMETHOD  RemoveByIndex (const PRUint32 i_index);
+
+    NS_IMETHOD  RemoveByObject (nsICacheObject* i_pObject);
+
+    NS_IMETHOD  RemoveAll (void);
+
+    NS_IMETHOD  Revalidate (void);
+
+    NS_IMETHOD	ReduceSizeTo (const PRUint32 i_newsize);
+
+    NS_IMETHOD  GetSize (PRUint32* o_size);
+
+    NS_IMETHOD  SetSize (const PRUint32 i_size);
+
+    NS_IMETHOD  GetSizeInUse (PRUint32* o_size);
+
+	/////////////////////////////////////////////////////////////////////////
+	// nsDiskModule Methods
+    nsDiskModule();
+    nsDiskModule(const PRUint32 size);
+    virtual ~nsDiskModule();
+
+    PRUint32        AverageSize(void) const;
+
+    static NS_METHOD
+    Create (nsISupports *aOuter, REFNSIID aIID, void** aResult);
+
+private:
+    enum sync_frequency
+    {
+        EVERYTIME,
+        IDLE,
+        NEVER
+    } m_Sync;
+
+    PRBool          InitDB(void);
+
+    nsDiskModule(const nsDiskModule& dm);
+    nsDiskModule& operator=(const nsDiskModule& dm);
+
+
+    PRUint32            m_Entries;
+    PRUint32            m_Size;
+    PRUint32            m_SizeInUse;
+    PRBool              m_Enabled;
+    nsEnumeration*      m_pEnumeration;
+    nsCacheIterator*    m_pIterator;
+    nsICacheModule*     m_pNext;
+    DB* m_pDB;
+
+};
+
+#endif

mozilla/netwerk/cache/include/nsEnumeration.h

@@ -0,0 +1,98 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (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.
+ *
+ * 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.
+ */
+
+/* Another temporary class that needs to be replaced by a commonly 
+ * used one, or made a commonly used one. 
+ * 
+ * -Gagan Saksena 09/15/98
+ */
+#ifndef nsEnumeration_h__
+#define nsEnumeration_h__
+
+//#include "nsISupports.h"
+#include "nsIterator.h"
+#include "prlog.h"
+
+class nsEnumeration //: public nsISupports
+{
+
+public:
+            nsEnumeration(nsIterator* iter);
+    virtual ~nsEnumeration();
+
+    PRBool  HasMoreElements(void);
+    void*   NextElement(void);
+    void    Reset(void);
+/*
+    NS_IMETHOD              QueryInterface(const nsIID& aIID, 
+                                           void** aInstancePtr);
+    NS_IMETHOD_(nsrefcnt)   AddRef(void);
+    NS_IMETHOD_(nsrefcnt)   Release(void);
+*/
+protected:
+    nsIterator* m_pIter;
+private:
+    nsEnumeration(const nsEnumeration& o);
+    nsEnumeration& operator=(const nsEnumeration& o);
+};
+
+inline 
+nsEnumeration::nsEnumeration(nsIterator* iter):m_pIter(iter)
+{
+    PR_ASSERT(iter);
+    if (m_pIter)
+        m_pIter->First();
+}
+
+inline
+nsEnumeration::~nsEnumeration()
+{
+}
+
+inline
+PRBool nsEnumeration::HasMoreElements(void)
+{
+    if (m_pIter) //remove this check for optimization?
+        return m_pIter->IsDone() ? PR_FALSE : PR_TRUE;
+    return PR_FALSE;
+}
+
+inline
+void* nsEnumeration::NextElement(void)
+{
+    if (m_pIter)
+    {
+        void* pTemp = m_pIter->CurrentItem();
+        m_pIter->Next();
+        return pTemp;
+    }
+    return 0;
+}
+
+inline
+void nsEnumeration::Reset(void)
+{
+    if (m_pIter)
+    {
+        m_pIter->First();
+    }
+}
+
+#endif // nsEnumeration_h__
+

mozilla/netwerk/cache/include/nsFileStream.h

@@ -0,0 +1,68 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (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.
+ *
+ * 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.
+ */
+
+/* nsFileStream. The file/disk based implementation of the nsStream class.
+ * It basically maps the read write functions to the file equivalents.
+ * 
+ * -Gagan Saksena 09/15/98
+ */
+#ifndef nsFileStream_h__
+#define nsFileStream_h__
+
+//#include "nsISupports.h"
+#include "nsStream.h"
+#include "prio.h" // PRFileDesc
+
+class nsFileStream: public nsStream
+{
+
+public:
+            nsFileStream(const char* i_Filename);
+    virtual ~nsFileStream();
+/*
+    NS_IMETHOD              QueryInterface(const nsIID& aIID, 
+                                           void** aInstancePtr);
+    NS_IMETHOD_(nsrefcnt)   AddRef(void);
+    NS_IMETHOD_(nsrefcnt)   Release(void);
+*/
+    PRFileDesc* FileDesc(void);
+
+    PRInt32     Read(void* o_Buffer, PRUint32 i_Len);
+    void        Reset(void);
+    PRInt32     Write(const void* i_Buffer, PRUint32 i_Len);
+
+protected:
+
+    PRBool      Open(void);
+
+private:
+    nsFileStream(const nsFileStream& o);
+    nsFileStream& operator=(const nsFileStream& o);
+    PRFileDesc* m_pFile;    
+    char* m_pFilename;
+};
+
+inline
+PRFileDesc* nsFileStream::FileDesc(void)
+{
+    return m_pFile;
+}
+
+#endif // nsFileStream_h__
+

mozilla/netwerk/cache/include/nsIterator.h

@@ -0,0 +1,71 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (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.
+ *
+ * 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.
+ */
+
+/* Another common class that needs to be replaced/removed/recycled.
+ * 
+ * -Gagan Saksena 09/15/98
+ */
+#ifndef nsIterator_h__
+#define nsIterator_h__
+
+//#include "nsISupports.h"
+#include "prtypes.h"
+
+class nsIterator //:public nsISupports
+{
+
+public:
+
+    virtual void    First(void);
+    virtual PRBool  IsDone(void) const = 0;
+    virtual void    Next(void);
+    virtual void*   CurrentItem(void) const;
+/*
+    NS_IMETHOD              QueryInterface(const nsIID& aIID, 
+                                           void** aInstancePtr);
+    NS_IMETHOD_(nsrefcnt)   AddRef(void);
+    NS_IMETHOD_(nsrefcnt)   Release(void);
+*/
+
+protected:
+    nsIterator() {m_Index = 0;};
+
+    PRUint32    m_Index;
+
+};
+
+inline 
+void nsIterator::First(void)
+{
+    m_Index = 0;
+}
+
+inline
+void nsIterator::Next(void)
+{
+    ++m_Index;
+}
+
+inline
+void* nsIterator::CurrentItem(void) const
+{
+    return 0;
+}
+#endif // nsIterator_h__
+

mozilla/netwerk/cache/include/nsMemModule.h

@@ -0,0 +1,158 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+/* 
+* nsMemModule. The memory based cache module.  
+*
+* Gagan Saksena
+* 02/03/98
+* 
+*/
+
+#ifndef _nsMemModule_H_
+#define _nsMemModule_H_
+
+#include "nsICacheModule.h"
+#include "nsMemCacheObject.h"
+#include "nsCachePref.h"
+#include "nsCacheIterator.h"
+#include "nsMonitorable.h"
+
+//#include "nsHash.h" // TODO - replace with nsHashtable when the XPCOM_BRANCH merges
+
+//#include "nsHashtable.h"
+
+
+
+class nsMemModule : public nsMonitorable, public nsICacheModule
+{
+
+public:
+	NS_DECL_ISUPPORTS
+
+
+    //////////////////////////////////////////////////////////////////////////
+    // nsICacheModule Methods:
+
+    NS_IMETHOD  AddObject(nsICacheObject* i_pObject);
+    
+    NS_IMETHOD  ContainsURL(const char* i_url, PRBool* o_bContain);
+
+    NS_IMETHOD  ContainsCacheObj(nsICacheObject* i_pObject, PRBool* o_bContain) ;
+    
+    NS_IMETHOD  Enable (PRBool i_Enable);
+    
+    NS_IMETHOD  GetNumOfEntries (PRUint32* o_entry);
+
+    NS_IMETHOD  GetEnumerator (nsEnumeration** o_enum);
+    /* Enumerations with a function pointer - TODO */
+
+    //TODO move to own interface for both Garbage Collection and Revalidation
+    NS_IMETHOD  GarbageCollect (void);
+
+    NS_IMETHOD  GetObjectByURL (const char* i_url, nsICacheObject** o_pObj);
+
+    NS_IMETHOD  GetObjectByIndex (const PRUint32 i_index, nsICacheObject** o_pObj);
+
+    NS_IMETHOD  GetStreamFor (const nsICacheObject* i_pObject, nsStream** o_pStream);
+
+    NS_IMETHOD  IsEnabled (PRBool* o_bEnabled);
+
+    /* Can't do additions, deletions, validations, expirations */
+    NS_IMETHOD  IsReadOnly (PRBool* o_bReadOnly); 
+
+    NS_IMETHOD  GetNextModule (nsICacheModule** o_pCacheModule);
+    NS_IMETHOD  SetNextModule (nsICacheModule* i_pCacheModule);
+
+    NS_IMETHOD  RemoveByURL (const char* i_url);
+
+    NS_IMETHOD  RemoveByIndex (const PRUint32 i_index);
+
+    NS_IMETHOD  RemoveByObject (nsICacheObject* i_pObject);
+
+    NS_IMETHOD  RemoveAll (void);
+
+    NS_IMETHOD  Revalidate (void);
+
+    NS_IMETHOD	ReduceSizeTo (const PRUint32 i_newsize);
+
+    NS_IMETHOD  GetSize (PRUint32* o_size);
+
+    NS_IMETHOD  SetSize (const PRUint32 i_size);
+
+    NS_IMETHOD  GetSizeInUse (PRUint32* o_size);
+
+
+	///////////////////////////////////////////////////////////////////////////
+    // Start of nsMemModule specific stuff...
+    // Here is a sample implementation using linked list
+
+	nsMemModule();
+	nsMemModule(const PRUint32 size);
+	virtual ~nsMemModule();
+
+
+	static NS_METHOD
+	Create (nsISupports *aOuter, REFNSIID aIID, void **aResult);
+
+protected:
+    nsMemCacheObject* LastObject(void) const;
+
+private:
+    nsMemCacheObject* m_pFirstObject;
+
+    //nsHash m_ht; //TODO replace with nsHashtable
+    //Optimization
+    nsMemCacheObject* m_pLastObject;
+
+    nsMemModule(const nsMemModule& mm);
+    nsMemModule& operator=(const nsMemModule& mm);
+
+/*    
+    class nsMemKey : public nsHashKey
+    {
+    public:
+                    nsMemKey();
+                    ~nsMemKey();
+      PRUint32      HashValue();
+      PRBool        Equals(nsHashKey *aKey);
+      nsHashKey*    Clone();
+    };
+*/    
+
+
+    PRUint32            m_Entries;
+    PRUint32            m_Size;
+    PRUint32            m_SizeInUse;
+    PRBool              m_Enabled;
+    nsEnumeration*      m_pEnumeration;
+    nsCacheIterator*    m_pIterator;
+    nsICacheModule*     m_pNext;
+};
+
+
+
+inline
+NS_IMETHODIMP nsMemModule::Revalidate(void)
+{
+    // Mem module elements are never revalidated.
+	// It is a no-op.
+    return NS_OK; 
+}
+
+#endif

mozilla/netwerk/cache/include/nsMemStream.h

@@ -0,0 +1,60 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this Mem are subject to the Netscape Public License
+ * Version 1.0 (the "License"); you may not use this Mem 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.
+ *
+ * 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.
+ */
+
+/* nsMemStream. A memory based stream for use with memory objects 
+ *
+ * -Gagan Saksena 09/15/98.
+ */
+#ifndef nsMemStream_h__
+#define nsMemStream_h__
+
+//#include "nsISupports.h"
+#include "nsStream.h"
+
+class nsMemStream: public nsStream
+{
+
+public:
+            nsMemStream();
+    virtual ~nsMemStream();
+/*
+    NS_IMETHOD              QueryInterface(const nsIID& aIID, 
+                                           void** aInstancePtr);
+    NS_IMETHOD_(nsrefcnt)   AddRef(void);
+    NS_IMETHOD_(nsrefcnt)   Release(void);
+*/
+    PRInt32     Read(void* o_Buffer, PRUint32 i_Len);
+    void        Reset(void);
+    PRInt32     Write(const void* i_Buffer, PRUint32 i_Len);
+
+protected:
+
+private:
+    nsMemStream(const nsMemStream& o);
+    nsMemStream& operator=(const nsMemStream& o);
+
+    PRUint32    m_AllocSize; 
+    PRUint32    m_ReadOffset;
+    PRUint32    m_WriteOffset;
+    void*       m_pStart;
+    PRUint32    m_Size;
+};
+
+#endif // nsMemStream_h__
+

mozilla/netwerk/cache/include/nsMonitorable.h

@@ -0,0 +1,106 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (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.
+ *
+ * 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.
+ */
+
+/* nsMonitorable. This is a cool class too. Its an easy of adding monitors
+ * actually PRMonitor behaviour to existing classes. The nsMonitorLocker is 
+ * an excursion class that locks the scope in which is declared (on stack). 
+ * 
+ * -Gagan Saksena 09/15/98
+ */
+#ifndef nsMonitorable_h__
+#define nsMonitorable_h__
+
+//#include "nsISupports.h"
+
+#include "prmon.h"
+#include "prlog.h"
+
+class nsMonitorable//: public nsISupports
+{
+
+public:
+            nsMonitorable();
+    virtual ~nsMonitorable();
+
+/*
+    NS_IMETHOD              QueryInterface(const nsIID& aIID, 
+                                           void** aInstancePtr);
+    NS_IMETHOD_(nsrefcnt)   AddRef(void);
+    NS_IMETHOD_(nsrefcnt)   Release(void);
+*/
+    PRBool      Lock(void);
+    void        Unlock(void);
+
+protected:
+
+    class MonitorLocker
+    {
+    public:
+        MonitorLocker(nsMonitorable* i_pThis);
+        ~MonitorLocker();
+    private:
+        nsMonitorable* m_pMonitorable;
+    };
+
+    PRMonitor*          m_pMonitor;
+
+private:
+    nsMonitorable(const nsMonitorable& o);
+    nsMonitorable& operator=(const nsMonitorable& o);
+};
+
+inline
+nsMonitorable::nsMonitorable(void):m_pMonitor(PR_NewMonitor())
+{
+}
+
+inline
+nsMonitorable::~nsMonitorable()
+{
+    if (m_pMonitor)
+    {
+    PR_DestroyMonitor(m_pMonitor);
+    m_pMonitor = 0;
+    }
+}
+
+inline
+PRBool nsMonitorable::Lock(void)
+{
+    if (!m_pMonitor)
+    {
+        m_pMonitor = PR_NewMonitor();
+        if (!m_pMonitor)
+            return PR_FALSE;
+    }
+    PR_EnterMonitor(m_pMonitor);
+    return PR_TRUE;
+}
+
+
+inline
+void nsMonitorable::Unlock(void)
+{
+    PR_ASSERT(m_pMonitor);
+    if (m_pMonitor)
+        PR_ExitMonitor(m_pMonitor);
+}
+
+#endif // nsMonitorable_h__
+

mozilla/netwerk/cache/include/nsStream.h

@@ -0,0 +1,71 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (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.
+ *
+ * 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.
+ */
+
+/* A placeholder for the actual professional strength streams class. Works
+ * ok for me for now.
+ *
+ * -Gagan Saksena 09/15/98
+ */
+
+#ifndef nsStream_h__
+#define nsStream_h__
+
+//#include "nsISupports.h"
+
+#include "prtypes.h"
+
+class nsStream//: public nsISupports
+{
+
+public:
+            nsStream();
+    virtual ~nsStream();
+/*
+    NS_IMETHOD              QueryInterface(const nsIID& aIID, 
+                                           void** aInstancePtr);
+    NS_IMETHOD_(nsrefcnt)   AddRef(void);
+    NS_IMETHOD_(nsrefcnt)   Release(void);
+*/
+    virtual
+        PRInt32     Read(void* o_Buffer, PRUint32 i_Len) = 0;
+    virtual
+        void        Reset(void) = 0;
+    virtual
+        PRInt32     Write(const void* i_Buffer, PRUint32 i_Len) = 0;
+
+protected:
+
+private:
+    nsStream(const nsStream& o);
+    nsStream& operator=(const nsStream& o);
+};
+
+inline
+nsStream::nsStream(void)
+{
+    //noop
+}
+
+inline
+nsStream::~nsStream()
+{
+    //noop
+}
+#endif // nsStream_h__
+

mozilla/netwerk/cache/mgr/Makefile.in

@@ -0,0 +1,43 @@
+#
+# 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		= cachemgr
+LIBRARY_NAME	= cachemgr
+IS_COMPONENT	= 1
+
+REQUIRES	= nspr
+
+CPPSRCS		= \
+		nsCacheManager.cpp \
+		nsMonitorable.cpp \
+		nsCacheBkgThd.cpp \
+		nsBkgThread.cpp \
+		$(NULL)
+
+LOCAL_INCLUDES	= -I$(srcdir)/../public -I$(srcdir)/../include
+
+EXTRA_LIBS	= $(NSPR_LIBS)
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/mgr/Makefile.win

@@ -0,0 +1,59 @@
+#!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=cachemgr
+
+IS_COMPONENT=1
+MAKE_OBJ_TYPE=DLL
+DLLNAME=cachemgr
+DLL=.\$(OBJDIR)\$(DLLNAME).dll
+
+LLIBS= $(LLIBS) \
+	$(LIBNSPR)				\
+	$(DIST)\lib\xpcom.lib	\
+	$(NULL)
+
+CPP_OBJS=                                  \
+	.\$(OBJDIR)\nsCacheManager.obj     \
+	.\$(OBJDIR)\nsMonitorable.obj      \
+	.\$(OBJDIR)\nsCacheBkgThd.obj	   \
+	.\$(OBJDIR)\nsBkgThread.obj        \
+	$(NULL)
+
+LOCAL_INCLUDES=	-I. \
+	  	-I..\public \
+		-I..\include \
+
+INCLUDES = $(LOCAL_INCLUDES)
+
+REQUIRES = nspr
+
+INCS = $(INCS)                  \
+	-I..\include 		\
+        -I..\public 		\
+        -I$(DEPTH)\dist\include \
+        $(NULL)
+
+include <$(DEPTH)\config\rules.mak> 
+
+install:: $(DLL)
+	$(MAKE_INSTALL) $(DLL) $(DIST)\bin\components
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib
+

mozilla/netwerk/cache/mgr/nsBkgThread.cpp

@@ -0,0 +1,92 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 "nsBkgThread.h"
+#include "prlog.h"
+
+static void PR_CALLBACK RunFunction(void* arg);
+
+static void PR_CALLBACK RunFunction(void* arg)
+{
+    nsBkgThread* pBT = (nsBkgThread*) arg;
+    if (pBT)
+    {
+        pBT->Process();
+    }
+}
+
+nsBkgThread::nsBkgThread(PRIntervalTime iSleepTime, PRBool bStart /* =PR_TRUE */)
+{
+    m_SleepTime = iSleepTime;
+    m_bContinue = bStart;
+    m_pThread = PR_CreateThread(
+        PR_USER_THREAD,
+        RunFunction,
+        this,
+        PR_PRIORITY_NORMAL,
+        PR_LOCAL_THREAD,
+        PR_JOINABLE_THREAD,
+        0);
+    PR_ASSERT(NULL != m_pThread);
+}
+
+nsBkgThread::~nsBkgThread()
+{
+    m_bContinue = PR_FALSE;
+    if (m_pThread != NULL)
+    {
+        Stop();
+    }
+}
+/*
+nsrefcnt nsBkgThread::AddRef(void)
+{
+    return ++m_RefCnt;
+}
+nsrefcnt nsBkgThread::Release(void)
+{
+    if (--m_RefCnt == 0)
+    {
+        delete this;
+        return 0;
+    }
+    return m_RefCnt;
+}
+
+nsresult nsBkgThread::QueryInterface(const nsIID& aIID,
+                                        void** aInstancePtrResult)
+{
+    return NS_OK;
+}
+
+*/
+void nsBkgThread::Process(void)
+{
+    while (m_bContinue)
+    {
+        PR_Sleep(m_SleepTime);
+        Run();
+    }
+}
+
+void nsBkgThread::Stop(void)
+{
+    m_bContinue = PR_FALSE;
+    PRStatus status = PR_Interrupt(m_pThread);
+    PR_ASSERT(PR_SUCCESS == status);
+}

mozilla/netwerk/cache/mgr/nsCacheBkgThd.cpp

@@ -0,0 +1,102 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 "prlog.h"
+#include "nsCacheBkgThd.h"
+#include "nsIServiceManager.h"
+#include "nsCacheManager.h"
+//#include "nsCacheModule.h"
+#include "nsCachePref.h"
+
+static NS_DEFINE_IID(kICachePrefIID, NS_ICACHEPREF_IID) ;
+static NS_DEFINE_IID(kCachePrefCID, NS_CACHEPREF_CID) ;
+
+nsCacheBkgThd::nsCacheBkgThd(PRIntervalTime iSleepTime):
+    nsBkgThread(iSleepTime)
+{
+}
+
+nsCacheBkgThd::~nsCacheBkgThd()
+{
+}
+
+/*
+nsrefcnt nsCacheBkgThd::AddRef(void)
+{
+    return ++m_RefCnt;
+}
+nsrefcnt nsCacheBkgThd::Release(void)
+{
+    if (--m_RefCnt == 0)
+    {
+        delete this;
+        return 0;
+    }
+    return m_RefCnt;
+}
+
+nsresult nsCacheBkgThd::QueryInterface(const nsIID& aIID,
+                                        void** aInstancePtrResult)
+{
+    return NS_OK;
+}
+*/
+
+void nsCacheBkgThd::Run(void)
+{
+    /* Step thru all the modules and call cleanup on each */
+    nsCacheManager* pCM  = nsCacheManager::GetInstance();
+
+	nsICachePref* pref ;
+
+	nsServiceManager::GetService(kCachePrefCID,
+	                             kICachePrefIID,
+								 (nsISupports **)&pref) ;
+
+	PRBool offline ;
+
+    PR_ASSERT(pCM);
+    pCM->IsOffline(&offline) ;
+    if (offline)
+        return; /* Dont update entries if offline */
+    PRInt16 i ;
+	pCM->Entries(&i);
+    while (i>0)
+    {
+        nsICacheModule* pModule ;
+		pCM->GetModule(--i, &pModule);
+        PR_ASSERT(pModule);
+
+        /* TODO change this based on if it supports garbage cleaning */
+
+		PRBool ro, revalidate ;
+		pModule->IsReadOnly(&ro) ;
+        if (!ro)
+        {
+            pModule->GarbageCollect();
+
+            pref->RevalidateInBkg(&revalidate) ;
+
+            if (revalidate)
+            {
+                pModule->Revalidate();
+            }
+        }
+    }
+}
+

mozilla/netwerk/cache/mgr/nsCacheManager.cpp

@@ -0,0 +1,740 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+/*
+ * Gagan Saksena  02/02/98
+ * 
+ */
+
+#include "prtypes.h"
+#include "pratom.h"
+#include "nscore.h"
+#include "prinrval.h"
+#include "plstr.h"
+#include "prprf.h" //PR_smprintf and PR_smprintf_free
+
+#include "nsISupports.h"
+
+#include "nsRepository.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+
+// #include "nsCacheTrace.h"
+// #include "nsCachePref.h"
+#include "nsICacheModule.h"
+//#include "nsMemModule.h"
+//#include "nsDiskModule.h"
+#include "nsCacheBkgThd.h"
+
+// #include "nsMemModule.h"
+// #include "nsDiskModule.h"
+#include "nsCacheManager.h"
+
+/* TODO move this to InitNetLib */
+// static nsCacheManager TheManager;
+nsCacheManager * nsCacheManager::gInstance = NULL ;
+
+static PRInt32 gLockCnt = 0 ;
+static PRInt32 gInstanceCnt = 0 ;
+
+static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID) ;
+static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID) ;
+static NS_DEFINE_IID(kICacheManagerIID, NS_ICACHEMANAGER_IID) ;
+static NS_DEFINE_IID(kCacheManagerCID, NS_CACHEMANAGER_CID) ;
+
+static NS_DEFINE_IID(kICachePrefIID, NS_ICACHEPREF_IID) ;
+static NS_DEFINE_IID(kCachePrefCID, NS_CACHEPREF_CID) ;
+
+static NS_DEFINE_IID(kICacheModuleIID, NS_ICACHEMODULE_IID) ;
+static NS_DEFINE_IID(kCacheDiskModuleCID, NS_DISKMODULE_CID) ;
+static NS_DEFINE_IID(kCacheMemModuleCID, NS_MEMMODULE_CID) ;
+
+PRUint32 NumberOfObjects(void);
+
+nsCacheManager::nsCacheManager(): 
+    m_pFirstModule(0), 
+    m_bOffline(PR_FALSE),
+    m_pPrefs(0)
+{
+  NS_INIT_ISUPPORTS( ) ;
+  PR_AtomicIncrement(&gInstanceCnt) ;
+}
+
+nsCacheManager::~nsCacheManager()
+{
+    if (m_pPrefs)
+    {
+        // delete m_pPrefs;
+		NS_RELEASE(m_pPrefs) ;
+        m_pPrefs = 0;
+    }
+    if (m_pFirstModule)
+    {
+        // delete m_pFirstModule;
+		NS_RELEASE(m_pFirstModule) ;
+        m_pFirstModule = 0;
+    }
+    if (m_pBkgThd)
+    {
+        m_pBkgThd->Stop();
+        delete m_pBkgThd;
+        m_pBkgThd = 0;
+    }
+
+    // Shutdown( ) ;
+
+    NS_ASSERTION(mRefCnt==0, "wrong Ref count" ) ;
+    PR_AtomicDecrement(&gInstanceCnt) ;
+
+}
+
+
+nsCacheManager* 
+nsCacheManager::GetInstance()
+{
+  if (!gInstance)
+  {
+	gInstance = new nsCacheManager( ) ;
+	gInstance->Init( ) ;
+  }
+  return gInstance ;
+//    return &TheManager;
+}
+
+#if 0
+/* Caller must free returned char* */
+const char* 
+nsCacheManager::Trace() const
+{
+
+    char linebuffer[128];
+    char* total;
+	PRInt16 n_entries=0 ;
+
+	Entries(&n_entries) ;
+
+    sprintf(linebuffer, "nsCacheManager: Modules = %d\n", n_entries);
+
+    total = new char[strlen(linebuffer) + 1];
+    strcpy(total, linebuffer);
+    return total;
+}
+#endif
+
+NS_IMETHODIMP
+nsCacheManager::AddModule(PRInt16 * n_Index, nsICacheModule* pModule)
+{
+  // PRInt16 *n_Entries ;
+  // nsresult rv ;
+
+	if (!n_Index)
+	  return NS_ERROR_NULL_POINTER ;
+	  
+    MonitorLocker ml(this);
+    if (pModule) 
+    {
+        if (m_pFirstModule)
+            LastModule()->SetNextModule(pModule);
+        else
+            m_pFirstModule = pModule;
+
+		Entries(n_Index) ;
+		(*n_Index)-- ;
+
+		return NS_OK ;
+    }
+    else
+        return NS_ERROR_FAILURE ;
+}
+
+NS_IMETHODIMP
+nsCacheManager::Contains(const char* i_url) const
+{
+    MonitorLocker ml((nsMonitorable*)this);
+    // Add logic to check for IMAP type URLs, byteranges, and search with / appended as well...
+    // TODO 
+	PRBool bContain ;
+
+    nsresult rv = ContainsExactly(i_url, &bContain);
+
+    if (!bContain)
+    {
+     // try alternate stuff
+     //  char* extraBytes;
+     //  char extraBytesSeparator;
+    }
+#if !defined(NDEBUG) && defined(DEBUG_gagan)
+		fputs(i_url, stdout);
+		fputs(NS_SUCCEEDED(bStatus) ? " is " : " is not ", stdout);
+		fputs("in cache\n", stdout);
+#endif
+    return rv ;
+}
+
+
+/*
+PRBool
+nsCacheManager::Contains(const char* i_url) const
+{
+    MonitorLocker ml((nsMonitorable*)this);
+    // Add logic to check for IMAP type URLs, byteranges, and search with / appended as well...
+    // TODO 
+    PRBool bStatus = ContainsExactly(i_url);
+    if (!bStatus)
+    {
+        // try alternate stuff
+       //  char* extraBytes;
+      //  char extraBytesSeparator;
+    }
+#if !defined(NDEBUG) && defined(DEBUG_gagan)
+		fputs(i_url, stdout);
+		fputs(bStatus ? " is " : " is not ", stdout);
+		fputs("in cache\n", stdout);
+#endif
+	return bStatus ;
+}
+*/
+
+NS_IMETHODIMP
+nsCacheManager::ContainsExactly(const char* i_url, PRBool * contains) const
+{
+    nsresult rv ;
+
+	*contains = PR_FALSE ;
+
+    if (m_pFirstModule)
+    {
+        nsICacheModule* pModule = m_pFirstModule;
+        while (pModule)
+        {
+		  rv = pModule->ContainsURL(i_url, contains) ;
+
+            if ( contains )
+            {
+                return NS_OK;
+            }
+            rv = pModule->GetNextModule(&pModule);
+        }
+    }
+    return NS_ERROR_FAILURE ; 
+}
+
+NS_IMETHODIMP
+nsCacheManager::GetObj(const char* i_url, void ** o_pObject) const
+{
+	nsresult rv ;
+
+    if ( !o_pObject)
+	  return NS_ERROR_NULL_POINTER ;
+
+	*o_pObject = nsnull ;
+
+    MonitorLocker ml((nsMonitorable*)this);
+
+    if (m_pFirstModule) 
+    {
+        nsICacheModule* pModule = m_pFirstModule;
+
+        while (pModule)
+        {
+            rv = pModule->GetObjectByURL(i_url, (nsICacheObject**) o_pObject);
+
+			if (*o_pObject)
+			  return NS_OK ;
+
+            rv = pModule->GetNextModule(&pModule);
+        }
+    }
+    return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+nsCacheManager::Entries(PRInt16 * n_Entries) const
+{
+    nsresult rv ;
+
+    if (!n_Entries)
+	  return NS_ERROR_NULL_POINTER ;
+
+    MonitorLocker ml((nsMonitorable*)this);
+    if (m_pFirstModule) 
+    {
+        PRInt16 count=1;
+        nsICacheModule* pModule ;
+
+		rv = m_pFirstModule->GetNextModule(&pModule);
+
+        while (pModule)
+        {
+            count++;
+			rv = pModule->GetNextModule(&pModule);
+        }
+		*n_Entries = count ;
+        return NS_OK;
+    }
+    return NS_ERROR_FAILURE ;
+}
+
+/*
+PRInt16
+nsCacheManager::Entries(void) const
+{
+    MonitorLocker ml((nsMonitorable*)this);
+    if (m_pFirstModule) 
+    {
+        PRInt16 count=1;
+        nsCacheModule* pModule = m_pFirstModule->NextModule();
+        while (pModule)
+        {
+            count++;
+			pModule = pModule->NextModule();
+        }
+        return count;
+    }
+    return -1 ;
+}
+*/
+
+// todo: use PROGID instead of index
+NS_IMETHODIMP
+nsCacheManager::GetModule(PRInt16 i_index, nsICacheModule** pModule) const
+{
+	nsresult rv ;
+
+    if (!pModule)
+	  return NS_ERROR_NULL_POINTER ;
+
+    MonitorLocker ml((nsMonitorable*)this);
+
+	PRInt16 n_entries = 0 ;
+
+	rv = Entries(&n_entries) ;
+
+    if ((i_index < 0) || (i_index >= n_entries))
+        return NS_ERROR_FAILURE ;
+
+    *pModule = m_pFirstModule;
+
+    PR_ASSERT(*pModule);
+    for (PRInt16 i=0; i<i_index; (*pModule)->GetNextModule(pModule))
+    {
+        i++;
+        PR_ASSERT(*pModule);
+    }
+    return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCacheManager::InfoAsHTML(char** o_Buffer) const
+{
+	PRInt16 n_entries = 0;
+	Entries(&n_entries) ;
+
+	if (!o_Buffer)
+	  return NS_ERROR_NULL_POINTER ;
+
+	MonitorLocker ml((nsMonitorable*)this);
+
+	char* tmpBuffer =/* TODO - make this cool */
+		PR_smprintf("<HTML><h2>Your cache has %d modules</h2> \
+			It has a total of %d cache objects. Hang in there for the details. </HTML>\0", 
+			n_entries,
+			NumberOfObjects());
+	
+	if (tmpBuffer)
+	{
+		PL_strncpyz(*o_Buffer, tmpBuffer, PL_strlen(tmpBuffer)+1);
+		PR_smprintf_free(tmpBuffer);
+	}
+	return NS_OK ;
+}
+
+void
+nsCacheManager::Init() 
+{
+    nsresult rv=nsnull ;
+	PRUint32 size ;
+
+    MonitorLocker ml(this);
+    
+    //Init prefs
+    if (!m_pPrefs)
+    //    m_pPrefs = new nsCachePref();
+		
+		rv = nsComponentManager::CreateInstance(kCachePrefCID,
+		                                        nsnull,
+												kICachePrefIID, 
+												(void**)&m_pPrefs) ;
+
+		rv=nsnull ;
+
+    if (m_pFirstModule)
+        delete m_pFirstModule;
+
+    // m_pFirstModule = new nsMemModule(nsCachePref::GetInstance()->MemCacheSize());
+	rv = nsComponentManager::CreateInstance(kCacheMemModuleCID,
+	                                        nsnull,
+											kICacheModuleIID,
+											(void**)&m_pFirstModule) ;
+
+	rv = m_pPrefs->GetMemCacheSize(&size) ;
+
+	rv = m_pFirstModule -> SetSize(size) ;
+
+    PR_ASSERT(m_pFirstModule);
+
+    if (m_pFirstModule)
+    {
+		rv = m_pPrefs->GetDiskCacheSize(&size) ;
+
+        nsICacheModule* p_Temp ;
+		// = new nsDiskModule(nsCachePref::GetInstance()->DiskCacheSize());
+
+    	rv = nsComponentManager::CreateInstance(kCacheDiskModuleCID,
+	                                        nsnull,
+											kICacheModuleIID,
+											(void**)&p_Temp) ;
+
+		rv = m_pPrefs->SetDiskCacheSize(size) ;
+
+		rv = p_Temp->SetSize(size) ;
+
+        PR_ASSERT(p_Temp);
+        rv = m_pFirstModule->SetNextModule(p_Temp);
+
+		PRUint32 time ;
+
+        rv = m_pPrefs->GetBkgSleepTime(&time) ;
+
+        m_pBkgThd = new nsCacheBkgThd(PR_SecondsToInterval(time));
+
+        PR_ASSERT(m_pBkgThd);
+    }
+}
+
+nsICacheModule* 
+nsCacheManager::LastModule() const 
+{
+    MonitorLocker ml((nsMonitorable*)this);
+
+	nsresult rv ;
+
+    if (m_pFirstModule) 
+    {
+        nsICacheModule* temp = m_pFirstModule;
+		nsICacheModule* pModule=temp ; 
+
+		rv = temp->GetNextModule(&temp) ;
+
+        while(temp) {
+		    pModule = temp ; 
+			rv = temp->GetNextModule(&temp) ;
+        }
+
+        return pModule;
+    }
+    return 0;
+}
+
+NS_IMETHODIMP
+nsCacheManager::Remove(const char* i_url)
+{
+    MonitorLocker ml(this);
+    nsresult rv ; 
+
+    if (m_pFirstModule)
+    {
+        nsICacheModule* pModule = m_pFirstModule;
+
+		do {
+		  rv = pModule ->RemoveByURL(i_url) ;
+		  if ( NS_SUCCEEDED(rv) ) return rv ;
+
+		  rv = pModule ->GetNextModule(&pModule) ;
+		} while (pModule) ;
+	}
+
+    return NS_ERROR_FAILURE ;
+}
+
+NS_IMETHODIMP
+nsCacheManager::WorstCaseTime(PRUint32 * o_Time) const 
+{
+    PRIntervalTime start = PR_IntervalNow();
+
+	o_Time = nsnull ;
+
+    if (NS_SUCCEEDED(this->Contains("a vague string that should not be in any of the modules")))
+    {
+        PR_ASSERT(0);
+    }
+    *o_Time = PR_IntervalToMicroseconds(PR_IntervalNow() - start);
+
+	return NS_OK ;
+}
+
+PRUint32
+NumberOfObjects(void)
+{
+    PRUint32 objs = 0, temp; 
+	nsresult rv ;
+	nsICacheModule* pModule ;
+	nsICacheManager* cacheManager ;
+
+    PRInt16 i ;
+
+	rv = nsServiceManager::GetService(kCacheManagerCID,
+	                                  kICacheManagerIID,
+									  (nsISupports **)&cacheManager) ; 
+
+	rv = cacheManager->Entries(&i);
+
+    while (i>0)
+    {
+        rv = cacheManager->GetModule(--i, &pModule) ;
+		pModule->GetNumOfEntries(&temp);
+		objs+=temp ;
+    }
+    return objs;
+}
+
+/*
+NS_IMETHODIMP
+nsCacheManager::QueryInterface(const nsIID &aIID, void **aResult)
+{
+  if(!aResult)
+	return NS_ERROR_NULL_POINTER ;
+
+  if (aIID.Equals(kISupportsIID)) {
+	*aResult = NS_STATIC_CAST(nsISupports*, this) ;
+  }
+  else if (aIID.Equals(kICacheManagerIID)) {
+	*aResult = NS_STATIC_CAST(nsISupports*, 
+	           NS_STATIC_CAST(nsICacheManager*, this)) ;
+  }
+  else {
+	*aResult = nsnull ;
+	return NS_ERROR_NO_INTERFACE ;
+  }
+
+  NS_ADDREF(NS_REINTERPRET_CAST(nsISupports*, *aResult)) ;
+
+  return NS_OK ;
+}
+
+NS_IMPL_ADDREF(nsCacheManager) 
+NS_IMPL_RELEASE(nsCacheManager)
+*/
+
+NS_IMPL_ISUPPORTS(nsCacheManager, kICacheManagerIID) ;
+
+nsCacheManagerFactory::nsCacheManagerFactory( )
+{
+  NS_INIT_ISUPPORTS( ) ;
+  PR_AtomicIncrement(&gInstanceCnt) ;
+}
+
+nsCacheManagerFactory::~nsCacheManagerFactory( )
+{
+  PR_AtomicDecrement(&gInstanceCnt) ;
+}
+
+/*
+NS_IMETHODIMP
+nsCacheManagerFactory::QueryInterface(const nsIID &aIID, void ** aResult)
+{
+  if (!aResult)
+	return NS_ERROR_NULL_POINTER ;
+
+  if (aIID.Equals(kISupportsIID)) {
+	*aResult = NS_STATIC_CAST(nsISupports*, this) ;
+  }
+  else if (aIID.Equals(kIFactoryIID)) {
+	*aResult = NS_STATIC_CAST(nsISupports*, 
+	           NS_STATIC_CAST(nsIFactory*, this)) ;
+  }
+  else {
+	*aResult = nsnull ;
+	return NS_ERROR_NO_INTERFACE ;
+  }
+
+  NS_ADDREF(NS_REINTERPRET_CAST(nsISupports*, *aResult)) ;
+
+  return NS_OK ;
+}
+
+NS_IMPL_ADDREF(nsCacheManagerFactory)
+NS_IMPL_RELEASE(nsCacheManagerFactory)
+*/
+
+NS_IMPL_ISUPPORTS(nsCacheManagerFactory, kIFactoryIID) ;
+
+// Todo, needs to enforce singleton
+
+NS_IMETHODIMP
+nsCacheManagerFactory::CreateInstance(nsISupports *aOuter, 
+                                      const nsIID &aIID,
+									  void **aResult)
+{
+  if (!aResult)
+	return NS_ERROR_NULL_POINTER ;
+
+  *aResult = nsnull ;
+
+  nsISupports *inst = nsCacheManager::GetInstance( ) ;
+
+  if (!inst) {
+	return NS_ERROR_OUT_OF_MEMORY ;
+  }
+
+  nsresult rv = inst -> QueryInterface(aIID, aResult) ;
+
+  if (NS_FAILED(rv)) {
+	delete inst ;
+  }
+
+  return rv ;
+}
+
+NS_IMETHODIMP
+nsCacheManagerFactory::LockFactory(PRBool aLock)
+{
+  if (aLock) {
+	PR_AtomicIncrement (&gLockCnt) ;
+  }
+  else {
+	PR_AtomicDecrement (&gLockCnt) ;
+  }
+
+  return NS_OK ;
+}
+
+// static NS_DEFINE_CID (kCacheManagerCID, NS_CACHEMANAGER_CID) ;
+static NS_DEFINE_CID (kComponentManagerCID, NS_COMPONENTMANAGER_CID) ;
+
+static const char * g_desc = "Mozilla xpcom cache manager" ;
+
+extern "C" NS_EXPORT nsresult
+NSGetFactory(nsISupports *serviceMgr, 
+             const nsCID &aCID,
+			 const char * aClassName,
+			 const char * aProgID,
+			 nsIFactory **aResult)
+{
+  if (!aResult)
+	return NS_ERROR_NULL_POINTER ;
+
+  *aResult = nsnull ;
+
+  nsISupports *inst ;
+
+  if (aCID.Equals(kCacheManagerCID)) {
+	inst = new nsCacheManagerFactory( ) ;
+  }
+  else {
+	return NS_ERROR_NO_INTERFACE ;
+  }
+
+  if (!inst)
+	return NS_ERROR_OUT_OF_MEMORY ;
+
+  nsresult rv = inst->QueryInterface(kIFactoryIID, (void **)aResult) ;
+
+  if (NS_FAILED(rv)) {
+	delete inst ;
+  }
+
+  return rv ;
+}
+
+extern "C" NS_EXPORT PRBool
+NSCanUnload (nsISupports* serviceMgr)
+{
+  return PRBool(gInstanceCnt == 0 && gLockCnt == 0) ;
+}
+
+extern "C" NS_EXPORT nsresult
+NSRegisterSelf(nsISupports *aServMgr, const char *path)
+{
+  nsresult rv = NS_OK ;
+
+  nsIServiceManager *sm ;
+
+  rv = aServMgr->QueryInterface(nsIServiceManager::GetIID(), (void**)&sm) ;
+
+  if(NS_FAILED(rv)) {
+	return rv;
+  }
+
+  nsIComponentManager *cm ;
+
+  rv = sm->GetService(kComponentManagerCID, 
+                      nsIComponentManager::GetIID(), 
+                      (nsISupports **) &cm) ;
+  if (NS_FAILED(rv)) {
+	NS_RELEASE(sm) ;
+	return rv ;
+  }
+
+  rv = cm->RegisterComponent(kCacheManagerCID, g_desc, "component://nucache",
+                             path, PR_TRUE, PR_TRUE) ;
+
+  sm->ReleaseService(kComponentManagerCID, cm) ;
+
+  NS_RELEASE(sm) ;
+
+#ifdef NS_DEBUG
+  printf("*** %s registered\n", g_desc) ;
+#endif
+
+  return rv ;
+}
+
+extern "C" NS_EXPORT nsresult
+NSUnregisterSelf(nsISupports* aServMgr, const char *path)
+{
+  nsresult rv = NS_OK ;
+
+  nsIServiceManager *sm ;
+
+  rv = aServMgr ->QueryInterface(nsIServiceManager::GetIID(),
+                                 (void **)&sm) ;
+
+  if(NS_FAILED(rv)) {
+	return rv ;
+  }
+
+  nsIComponentManager *cm ;
+
+  rv = sm->GetService(kComponentManagerCID, nsIComponentManager::GetIID(), 
+                      (nsISupports**) &cm) ;
+
+  if(NS_FAILED(rv)) {
+	NS_RELEASE(sm) ;
+	return rv ;
+  }
+
+  rv = cm->UnregisterComponent(kCacheManagerCID, path);
+
+  sm->ReleaseService(kComponentManagerCID, cm) ;
+
+  NS_RELEASE(sm) ;
+
+  return rv ;
+}
+

mozilla/netwerk/cache/mgr/nsMonitorable.cpp

@@ -0,0 +1,38 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (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.
+ *
+ * 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.
+ */
+
+/* 
+ * This is the implementation of the nsMonitorable::MonitorLocker class.
+ * Although the inlines work ok elsewhere, IRIX chokes on these. Hence
+ * moving these to a cpp.
+ * -Gagan Saksena 09/15/98 
+ */
+
+#include "nsMonitorable.h"
+
+nsMonitorable::MonitorLocker::MonitorLocker(nsMonitorable* i_pThis):
+	m_pMonitorable(i_pThis)
+{
+	if (m_pMonitorable) m_pMonitorable->Lock();
+}
+
+nsMonitorable::MonitorLocker::~MonitorLocker()
+{
+	if (m_pMonitorable) m_pMonitorable->Unlock();
+}

mozilla/netwerk/cache/module/Makefile.in

@@ -0,0 +1,28 @@
+#
+# 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
+
+DIRS		= disk memory
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/module/Makefile.win

@@ -0,0 +1,25 @@
+#!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=..\..\..
+DIRS= 	\
+	disk		\
+	memory			\
+	$(NULL)
+
+include <$(DEPTH)\config\rules.mak> 

mozilla/netwerk/cache/module/disk/Makefile.in

@@ -0,0 +1,41 @@
+#
+# 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		= diskcache
+LIBRARY_NAME	= diskcache
+IS_COMPONENT	= 1
+
+CPPSRCS		= \
+		nsDiskModule.cpp \
+		nsMonitorable.cpp \
+		nsFileStream.cpp \
+		nsDiskModuleFactory.cpp \
+		$(NULL)
+
+LOCAL_INCLUDES	= -I../../public -I../../include -I..
+
+include $(topsrcdir)/config/rules.mk
+
+DSO_LDOPTS	+= -ldb
+

mozilla/netwerk/cache/module/disk/Makefile.win

@@ -0,0 +1,61 @@
+#!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=diskcache
+
+IS_COMPONENT=1
+MAKE_OBJ_TYPE=DLL
+DLLNAME=diskcache
+DLL=.\$(OBJDIR)\$(DLLNAME).dll
+
+LLIBS= $(LLIBS) \
+	$(LIBNSPR)		\
+	$(DIST)\lib\xpcom.lib	\
+	$(DIST)\lib\dbm32.lib	\
+	$(NULL)
+
+CPP_OBJS= 	                                 \
+	.\$(OBJDIR)\nsDiskModule.obj		 \
+	.\$(OBJDIR)\nsMonitorable.obj		 \
+	.\$(OBJDIR)\nsFileStream.obj		 \
+	.\$(OBJDIR)\nsDiskModuleFactory.obj      \
+	$(NULL)
+
+LOCAL_INCLUDES=	-I. \
+	  	-I..\..\public \
+		-I..\..\include \
+
+INCLUDES = $(LOCAL_INCLUDES)
+
+REQUIRES = nspr
+
+INCS = 	-I..\..\public \
+      	-I..\..\include \
+	$(INCS) \
+       -I$(DEPTH)\dist\include \
+        $(NULL)
+
+include <$(DEPTH)\config\rules.mak> 
+
+install:: $(DLL)
+	$(MAKE_INSTALL) $(DLL) $(DIST)\bin\components
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib
+

mozilla/netwerk/cache/module/disk/nsCacheModule.cpp

@@ -0,0 +1,98 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 "nsCacheModule.h"
+#include "nsCacheTrace.h"
+#include "nsCacheIterator.h"
+
+/* 
+ * nsCacheModule
+ *
+ * Gagan Saksena 02/02/98
+ * 
+ */
+
+
+#define DEFAULT_SIZE 10*0x100000L
+
+nsCacheModule::nsCacheModule(const PRUint32 i_size=DEFAULT_SIZE):
+    m_Size(i_size),
+    m_SizeInUse(0),
+    m_pEnumeration(0),
+    m_pNext(0),
+    m_Entries(0)
+{
+    m_pIterator = new nsCacheIterator(this);
+}
+
+nsCacheModule::~nsCacheModule()
+{
+    if (m_pNext)
+    {
+        delete m_pNext;
+        m_pNext = 0;
+    }
+    if (m_pIterator)
+    {
+        delete m_pIterator;
+        m_pIterator = 0;
+    }
+    if (m_pEnumeration)
+    {
+        delete m_pEnumeration;
+        m_pEnumeration = 0;
+    }
+}
+
+void nsCacheModule::GarbageCollect(void) 
+{
+}
+
+PRBool nsCacheModule::ReduceSizeTo(const PRUint32 i_NewSize)
+{
+	MonitorLocker ml(this);
+    //TODO
+    return PR_TRUE;
+}
+
+PRBool nsCacheModule::RemoveAll(void)
+{
+	MonitorLocker ml(this);
+    PRBool status = PR_TRUE;
+    while (m_Entries > 0)
+    {
+        status &= Remove(--m_Entries);
+    }
+    return status;
+}
+
+#if 0
+// Caller must free this 
+const char* nsCacheModule::Trace() const
+{
+    char linebuffer[128];
+    char* total;
+
+    PR_sprintf(linebuffer, "nsCacheModule: Objects = %d\n", Entries());
+
+    total = new char[PR_strlen(linebuffer) + 1];
+    strcpy(total, linebuffer);
+
+    return total;
+}
+#endif

mozilla/netwerk/cache/module/disk/nsDiskModule.cpp

@@ -0,0 +1,839 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+/* 
+ * nsDiskModule
+ *
+ * Gagan Saksena 02/02/98
+ * 
+ */
+
+#include "prtypes.h"
+#include "prmem.h"
+#include "plstr.h"
+#include "prlog.h"
+#include "prclist.h" 
+#include "prio.h" 
+#include "prsystem.h" // Directory Separator 
+
+#include "nsDiskModule.h"
+#include "nsICacheObject.h"
+#include "nsCacheObject.h"
+#include "nsCacheManager.h"
+#include "nsFileStream.h"
+#include "nsCachePref.h"
+#include "nsRepository.h"
+
+#include "mcom_db.h"
+
+#define ENSURE_INIT  \
+    if (!m_pDB)     \
+    {               \
+        nsDiskModule* pThis = (nsDiskModule*) this; \
+        PRBool res = pThis->InitDB();   \
+        PR_ASSERT(res);                 \
+    }
+
+struct recentlyUsedObject {
+    PRCList link;
+    nsICacheObject* cacheObject;
+};
+
+/* Find pointer to recentlyUsedObject struct 
+ * from the list linkaged embedded in it 
+ */
+#define OBJECT_PTR(_link) \
+    ((recentlyUsedObject*) ((char*) (_link) - offsetof(recentlyUsedObject,link)))
+
+//File static list of recently used cache objects
+static PRCList g_RecentlyUsedList;
+static nsICacheObject* g_pTempObj=0;
+static char* g_FullFilename=0;
+const static int MAX_FILENAME_LEN = 512;
+const static int MAX_OBJECTS_IN_RECENTLY_USED_LIST = 20; // change later TODO.
+
+// Every time we cleanup we cleanup to 75% of the max available size. 
+// This should ideally change to a more const number than a percentage. 
+// Since someone may have a bigger cache size, so we don't really want to 
+// be cleaning up 5 megs if some one has a 20 megs cache size.
+// I will revisit this issue once the basic architecture is up and running. 
+#define CLEANUP_FACTOR 0.75
+
+//Returns the full filename including the cache directory.
+static char* FullFilename(const char* i_Filename);
+
+//Returns the Least Recently Used object in the database
+static nsICacheObject* LRUObject(DB* pDB);
+
+
+static NS_DEFINE_IID (kICacheObjectIID, NS_ICACHEOBJECT_IID);
+static NS_DEFINE_IID (kCacheObjectCID,  NS_CACHEOBJECT_CID);
+
+static NS_DEFINE_IID (kICacheManagerIID, NS_ICACHEMANAGER_IID);
+static NS_DEFINE_IID (kCacheManagerCID,  NS_CACHEMANAGER_CID);
+
+
+static nsICachePref* 
+GetPrefsInstance ()
+{
+    nsICacheManager* pICacheMgr = nsnull;
+    nsServiceManager::GetService (kCacheManagerCID, kICacheManagerIID,
+                                  (nsISupports **) &pICacheMgr);
+
+    if (!pICacheMgr)
+        return nsnull;
+
+    nsICachePref* pICachePref = nsnull;
+    pICacheMgr->GetPrefs (&pICachePref);
+    return pICachePref;
+}
+
+
+//
+// Constructors: nsDiskModule
+//
+nsDiskModule::nsDiskModule():
+    m_SizeInUse(0),
+    m_pEnumeration(0),
+    m_pNext(0),
+    m_pDB(0)
+{
+    nsICachePref* pICachePref = GetPrefsInstance();
+    PR_ASSERT (pICachePref);
+    pICachePref->GetDiskCacheSize (&m_Size);
+
+    PR_INIT_CLIST(&g_RecentlyUsedList);
+}
+
+nsDiskModule::nsDiskModule(const PRUint32 size):
+    m_Size (size),
+    m_SizeInUse(0),
+    m_pEnumeration(0),
+    m_pNext(0),
+    m_pDB(0)
+{
+    PR_INIT_CLIST(&g_RecentlyUsedList);
+}
+
+nsDiskModule::~nsDiskModule()
+{
+    //This will free up any operational "over the limit" cache objects.
+    GarbageCollect();
+
+    if (m_pDB)
+    {
+        (*m_pDB->sync)(m_pDB, 0);
+        (*m_pDB->close)(m_pDB);
+        m_pDB = 0;
+    }
+
+    /* Clean up the recently used list */
+    recentlyUsedObject* obj;
+    while (!PR_CLIST_IS_EMPTY(&g_RecentlyUsedList)) 
+    {
+        obj = (recentlyUsedObject*) PR_LIST_HEAD(&g_RecentlyUsedList);
+        if (obj->cacheObject)
+            delete obj->cacheObject;
+        PR_REMOVE_LINK(&obj->link);
+    }
+
+    PR_ASSERT(PR_CLIST_IS_EMPTY(&g_RecentlyUsedList));
+
+    if (g_FullFilename)
+    {
+        delete[] g_FullFilename;
+        g_FullFilename = 0;
+    }
+
+    if (g_pTempObj)
+    {
+        delete g_pTempObj;
+        g_pTempObj = 0;
+    }
+}
+
+NS_IMETHODIMP
+nsDiskModule::AddObject(nsICacheObject* io_pObject)
+{
+    ENSURE_INIT;
+    
+    if (!m_pDB || !io_pObject)
+    {   
+        // Set some error state TODO
+        return NS_ERROR_FAILURE;
+    }   
+
+	char *url = nsnull;
+	nsresult r = io_pObject->GetAddress (&url);
+    if (r == NS_OK && url)
+    {
+        MonitorLocker ml(this);
+        
+        //Remove the earliar copy- silently handles if not found
+        RemoveByURL(url);
+
+        // TODO optimize these further- make static - Gagan
+        DBT* key = PR_NEW(DBT);
+        DBT* data = PR_NEW(DBT);
+        
+        //Set the module
+        io_pObject->SetModuleIndex (nsCacheManager::DISK);
+        
+        //Close the corresponding file 
+        nsStream* pStream = (nsStream *) nsnull;
+		r = io_pObject->GetStream (&pStream);
+
+		if (pStream)
+			PR_Close(((nsFileStream*)pStream)->FileDesc());
+
+        key->data = (void*)url;
+        /* Later on change this to include post data- io_pObject->KeyData() */
+        key->size = PL_strlen(url);
+
+		io_pObject->GetInfo ((void **) &data->data);
+		io_pObject->GetInfoSize (&data->size);
+
+        int status = (*m_pDB->put)(m_pDB, key, data, 0);
+        if (status == 0)
+        {
+//            if (m_Sync == EVERYTIME)
+                status = (*m_pDB->sync)(m_pDB, 0);
+                m_Entries++;
+                PRUint32 size;
+				io_pObject->GetSize(&size);
+                m_SizeInUse += size;
+        }
+        PR_Free(key);
+        PR_Free(data);
+        return ((status == 0) ? NS_OK : NS_ERROR_FAILURE);
+    }
+    return NS_ERROR_FAILURE;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::ContainsCacheObj(nsICacheObject* io_pObject, PRBool* o_bContain)
+{
+    ENSURE_INIT;
+
+	*o_bContain = PR_FALSE;
+    if (!m_pDB || !io_pObject)
+        return NS_OK;
+
+	char *url;
+	if (io_pObject->GetAddress (&url) != NS_OK)
+		return NS_OK;
+
+    nsICacheObject* pTemp = 0;
+    if (GetObjectByURL(url, &pTemp) != NS_OK)
+		return NS_OK;
+
+    if (pTemp)
+    {
+        //PR_ASSERT(io_pObject == pTemp); 
+        // until I do a copyFrom function
+        *o_bContain = PR_TRUE;
+    }
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::ContainsURL(const char* i_url, PRBool* o_bContain)
+{
+
+    ENSURE_INIT;
+
+	*o_bContain = PR_FALSE;
+    if (!m_pDB || !i_url || !*i_url)
+        return NS_OK;
+
+    DBT key, data;
+
+    key.data = (void*) i_url;
+    key.size = PL_strlen(i_url);
+
+    int status = (*m_pDB->get)(m_pDB, &key, &data, 0);
+
+	*o_bContain = (status == 0)? PR_TRUE : PR_FALSE;
+	return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::GarbageCollect(void)
+{
+    MonitorLocker ml(this);
+    ReduceSizeTo((PRUint32)(CLEANUP_FACTOR*m_Size));
+
+    // if the recentlyusedlist has grown too big, trim some objects from there as well
+    // Count how many are there
+    int count=0;
+    if (!PR_CLIST_IS_EMPTY(&g_RecentlyUsedList))
+    {
+        PRCList* list = g_RecentlyUsedList.next;
+        while (list != &g_RecentlyUsedList)
+		{
+            count++;
+            list = list->next;
+        }
+    }
+    // Then trim the extra ones.
+    int extra = count-MAX_OBJECTS_IN_RECENTLY_USED_LIST;
+    while (extra>0)
+    {
+        recentlyUsedObject* obj = (recentlyUsedObject*) PR_LIST_HEAD(&g_RecentlyUsedList);
+        if (obj->cacheObject)
+            delete obj->cacheObject;
+        PR_REMOVE_LINK(&obj->link);
+        extra--;
+    }
+	return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::GetObjectByIndex(const PRUint32 i_index, 
+								nsICacheObject** ppICacheObject)
+{
+    ENSURE_INIT;
+
+	if (!ppICacheObject)
+		return NS_ERROR_NULL_POINTER;
+
+	*ppICacheObject = (nsICacheObject *) nsnull;
+    if (!m_pDB)
+        return NS_OK;
+
+//todo
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::GetObjectByURL(const char* i_url, nsICacheObject** ppICacheObject)
+{
+    ENSURE_INIT;
+    MonitorLocker ml((nsDiskModule*)this);
+
+	if (!ppICacheObject)
+		return NS_ERROR_NULL_POINTER;
+
+	*ppICacheObject = (nsICacheObject *) nsnull;
+
+    if (!m_pDB || !i_url || !*i_url)
+        return NS_OK;
+
+    /* Check amongst recently used objects */
+    recentlyUsedObject* obj;
+    PRCList* list = &g_RecentlyUsedList;
+    if (!PR_CLIST_IS_EMPTY(&g_RecentlyUsedList)) 
+    {
+        list = g_RecentlyUsedList.next;
+        nsICacheObject* pObj;
+        while (list != &g_RecentlyUsedList)
+        {
+            obj = OBJECT_PTR(list);
+            pObj = obj->cacheObject;
+			char *addr;
+			nsresult r = pObj->GetAddress (&addr);
+			if (r != NS_OK)
+				return r;
+            if (0 == PL_strcasecmp(i_url, addr)) //todo also validate
+			{
+				*ppICacheObject = pObj;
+                return NS_OK;
+			}
+            list = list->next;
+        }
+    }
+
+    DBT key, data;
+
+    key.data = (void*) i_url;
+    key.size = PL_strlen(i_url);
+
+    if (0 == (*m_pDB->get)(m_pDB, &key, &data, 0))
+    {
+        nsICacheObject* pTemp;
+	nsresult rv = nsComponentManager::CreateInstance(kCacheObjectCID,
+						nsnull,
+						kICacheObjectIID,
+						(void**) &pTemp);
+        PR_ASSERT(rv == NS_OK);
+        pTemp->SetInfo(data.data);
+        recentlyUsedObject* pNode = PR_NEWZAP(recentlyUsedObject);
+        PR_APPEND_LINK(&pNode->link, &g_RecentlyUsedList);
+        pNode->cacheObject = pTemp;
+		*ppICacheObject = pTemp;
+    }
+
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::GetStreamFor(const nsICacheObject* i_pObject, nsStream** o_stream)
+{
+    ENSURE_INIT;
+    MonitorLocker ml(this);
+
+	*o_stream = 0;
+    if (i_pObject)
+    {
+        nsresult r = i_pObject->GetStream(o_stream);
+        if (r != NS_OK)
+            return r;
+
+		char *filename = nsnull;
+		i_pObject->GetFilename (&filename);
+        PR_ASSERT(filename);
+
+        char* fullname = FullFilename(filename);
+
+        if (fullname)
+        {
+            *o_stream = new nsFileStream(fullname);
+        }
+    }
+    return NS_OK;
+}
+
+
+//  Private Function
+PRBool nsDiskModule::InitDB(void) 
+{
+    MonitorLocker ml(this);
+
+    if (m_pDB)
+        return PR_TRUE;
+
+    HASHINFO hash_info = {
+        16*1024,  /* bucket size */
+        0,        /* fill factor */
+        0,        /* number of elements */
+        0,        /* bytes to cache */
+        0,        /* hash function */
+        0};       /* byte order */
+
+    char *filename;
+    nsICachePref* pICachePref = GetPrefsInstance();
+    PR_ASSERT (pICachePref);
+    pICachePref->GetDiskCacheDBFilename (&filename);
+
+    m_pDB = dbopen(
+        FullFilename(filename), 
+        O_RDWR | O_CREAT, 
+        0600, // this is octal, yixiong 
+        DB_HASH, 
+        &hash_info);
+
+    if (!m_pDB)
+        return PR_FALSE;
+
+    /* Open and read in the number of existing entries */
+    m_Entries = 0;
+    m_SizeInUse = 0;
+    int status;
+    DBT key, data;
+    if (0 == g_pTempObj)
+    {
+	nsresult rv = nsComponentManager::CreateInstance(kCacheObjectCID,
+						nsnull,
+						kICacheObjectIID,
+						(void**) &g_pTempObj);
+        PR_ASSERT (rv == NS_OK);
+    }
+    if(!(status = (*m_pDB->seq)(m_pDB, &key, &data, R_FIRST)))
+    {
+        do
+        {
+            /* Also validate the corresponding file here *///TODO
+
+            g_pTempObj->SetInfo(data.data);
+			PRUint32 size;
+			g_pTempObj->GetSize(&size);
+            m_SizeInUse += size;
+            m_Entries++;
+        }
+        while(!(status = (*m_pDB->seq) (m_pDB, &key, &data, R_NEXT)));
+    }
+
+    if (status < 0)
+        return PR_FALSE;
+
+    return PR_TRUE;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::ReduceSizeTo(const PRUint32 i_NewSize)
+{
+    MonitorLocker ml(this);
+
+    PRInt32 needToFree = m_SizeInUse - i_NewSize;
+    if ((m_Entries>0) && (needToFree > 0))
+    {
+        PRUint32 avg = m_SizeInUse/m_Entries;
+        if (avg==0)
+            return NS_ERROR_FAILURE; 
+        
+        PRUint32 nObjectsToFree = needToFree/avg;
+        if (nObjectsToFree < 1)
+            nObjectsToFree = 1;
+
+        while (nObjectsToFree > 0)
+        {
+            RemoveByObject (LRUObject(m_pDB));
+            --nObjectsToFree;
+        }
+        
+        return NS_OK;
+    }
+    
+    return NS_ERROR_FAILURE;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::RemoveByURL(const char* i_url)
+{
+    ENSURE_INIT;
+	nsICacheObject* pICacheObject;
+	nsresult r = GetObjectByURL(i_url, &pICacheObject);
+	if (r != NS_OK)
+		return r;
+    return RemoveByObject(pICacheObject);
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::RemoveByObject(nsICacheObject* pObject)
+{
+    MonitorLocker ml(this);
+    nsresult bStatus = NS_ERROR_FAILURE;
+    if (!pObject)
+        return bStatus;
+    
+    //PR_ASSERT(Contains(pObject);
+
+    // TODO Mark the objects state for deletion so that we dont 
+    // read it in the meanwhile.
+    pObject->SetState(nsCacheObject::EXPIRED);
+
+    //Remove it from the index
+    DBT key;
+    pObject->GetAddress((char **) &key.data);
+    key.size = PL_strlen((char *)key.data);
+    if (0 == (*m_pDB->del)(m_pDB, &key, 0))
+    {
+        --m_Entries;
+		PRUint32 size;
+		pObject->GetSize (&size);
+        m_SizeInUse -= size;
+		if (-1 == (*m_pDB->sync)(m_pDB, 0))
+		{
+			//Failed to sync database
+			PR_ASSERT(0);
+		}
+    }
+    
+    //Remove it from the recently used list
+    recentlyUsedObject* obj;
+    PRCList* list = &g_RecentlyUsedList;
+    if (!PR_CLIST_IS_EMPTY(&g_RecentlyUsedList)) 
+    {
+        list = g_RecentlyUsedList.next;
+        nsICacheObject* pObj;
+        PRBool bDone = PR_FALSE;
+        while ((list != &g_RecentlyUsedList) && !bDone)
+        {
+            obj = OBJECT_PTR(list);
+            pObj = obj->cacheObject;
+            if (pObj == pObject)
+            {
+                bDone = PR_TRUE;
+                PR_REMOVE_LINK(&obj->link);
+            }
+            list = list->next;
+        }
+    }
+    
+    //Remove it from the disk
+	char *filename;
+	pObject->GetFilename(&filename);
+    if (PR_SUCCESS == PR_Delete(FullFilename(filename)))
+    {
+        bStatus = NS_OK;
+    }
+    else
+    {
+        //Failed to delete the file off the disk!
+        bStatus = NS_ERROR_FAILURE;
+    }
+
+    //Finally delete it 
+    delete pObject; 
+    pObject = 0;
+
+    return bStatus;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::RemoveByIndex(const PRUint32 i_index)
+{
+    //This will probably go away. 
+    ENSURE_INIT;
+    //TODO
+    // Also remove the file corresponding to this item. 
+    //return PR_FALSE;
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::RemoveAll(void)
+{
+    MonitorLocker ml (this);
+    while (m_Entries > 0)
+    {
+        RemoveByIndex (--m_Entries);
+    }
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::Revalidate(void)
+{
+    ENSURE_INIT;
+    //TODO - This will add a dependency on HTTP lib
+    //return PR_FALSE;
+	return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::SetSize(const PRUint32 i_Size)
+{
+    MonitorLocker ml(this);
+    m_Size = i_Size;
+    if (m_Size >0)
+    {
+        ReduceSizeTo((PRUint32)(CLEANUP_FACTOR*m_Size));
+    }
+    else
+    {
+        RemoveAll();
+    }
+
+	return NS_OK;
+}
+
+char* FullFilename(const char* i_Filename)
+{
+    static int cacheFolderLength=0;
+    if (0 == g_FullFilename)
+    {
+        g_FullFilename = new char[MAX_FILENAME_LEN];
+        *g_FullFilename = '\0';
+        if (0 == g_FullFilename)
+            return 0;
+    }
+	char *folder;
+    nsICachePref* pICachePref = GetPrefsInstance();
+    PR_ASSERT (pICachePref);
+    pICachePref->GetDiskCacheFolder (&folder);
+
+    PR_ASSERT (folder);
+    PL_strcpy(g_FullFilename, folder);
+    if (0==cacheFolderLength)
+        cacheFolderLength = PL_strlen(folder);
+#ifndef XP_MAC
+	if (g_FullFilename[cacheFolderLength-1]!=PR_GetDirectorySeparator())
+	{
+		g_FullFilename[cacheFolderLength] = PR_GetDirectorySeparator(); 
+		g_FullFilename[cacheFolderLength+1] = '\0';
+	}
+#endif
+    PL_strcat(g_FullFilename, i_Filename);
+    return g_FullFilename;
+}
+
+nsICacheObject* LRUObject(DB* pDB)
+{
+    int status;
+    DBT key, data;
+    
+    nsICacheObject* pTempObj;
+    nsresult rv = nsComponentManager::CreateInstance(kCacheObjectCID,
+						nsnull,
+						kICacheObjectIID,
+						(void**) &pTempObj);
+    
+    if (rv != NS_OK)
+        return nsnull;
+
+    nsICacheObject* pOldest=0;
+    if(!(status = (*pDB->seq)(pDB, &key, &data, R_FIRST)))
+    {
+        do
+        {
+            pTempObj->SetInfo(data.data);
+
+			PRIntervalTime old, current;
+			if (pOldest)
+			{
+				pOldest->GetLastAccessed (&old);
+			}
+			pTempObj->GetLastAccessed (&current);
+            if (!pOldest || (old > current))
+                pOldest = pTempObj;
+			   
+        }
+        while(!(status = (*pDB->seq) (pDB, &key, &data, R_NEXT)));
+    }
+    return ((nsICacheObject *) pOldest);
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::QueryInterface(const nsIID& aIID, void** aInstancePtr)
+{
+	NS_ASSERTION(aInstancePtr, "no instance pointer");
+
+	*aInstancePtr = 0;
+
+	if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID()) ||
+		aIID.Equals(nsCOMTypeInfo<nsICacheModule>::GetIID()))
+    {
+        *aInstancePtr = NS_STATIC_CAST (nsICacheModule*, this);
+		NS_ADDREF_THIS();
+		return NS_OK;
+	}
+	return NS_NOINTERFACE;
+}
+
+
+NS_IMPL_ADDREF(nsDiskModule);
+NS_IMPL_RELEASE(nsDiskModule);
+
+
+NS_METHOD
+nsDiskModule::Create(nsISupports* aOuter, const nsIID& aIID, void** aResult)
+{
+	nsDiskModule* cm = new nsDiskModule();
+	if (cm == nsnull)
+		return NS_ERROR_OUT_OF_MEMORY;
+
+	NS_ADDREF (cm);
+	nsresult rv = cm->QueryInterface (aIID, aResult);
+	NS_RELEASE (cm);
+	return rv;
+}
+
+
+NS_IMETHODIMP 
+nsDiskModule::Enable(PRBool i_bEnable)
+{
+    m_Enabled = i_bEnable;
+	return NS_OK;
+}
+
+NS_IMETHODIMP 
+nsDiskModule::GetNumOfEntries(PRUint32* o_nEntries)
+{
+    *o_nEntries = m_Entries;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::GetEnumerator(nsEnumeration** o_enum)
+{
+    MonitorLocker ml((nsMonitorable*)this);
+    if (!m_pEnumeration)
+    {
+        PR_ASSERT(m_pIterator);
+        ((nsDiskModule*)this)->m_pEnumeration = 
+									new nsEnumeration((nsIterator*)m_pIterator);
+    }
+    else
+        ((nsDiskModule*)this)->m_pEnumeration->Reset();
+    *o_enum = m_pEnumeration;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::IsEnabled(PRBool* o_bEnabled)
+{
+	*o_bEnabled = m_Enabled;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::IsReadOnly (PRBool* o_bReadOnly)
+{
+	*o_bReadOnly  = PR_FALSE;		// for Now
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::GetNextModule(nsICacheModule** o_pICacheModule)
+{
+	*o_pICacheModule = m_pNext;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::SetNextModule(nsICacheModule* pNext) 
+{
+    /* No overwriting */
+    PR_ASSERT(m_pNext == 0);
+    if (m_pNext)
+    {
+        /* ERROR */
+        delete m_pNext; //Worst case. 
+        m_pNext = 0;
+    }
+    m_pNext = pNext;
+	return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::GetSize(PRUint32* o_size)
+{
+	*o_size = m_Size;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsDiskModule::GetSizeInUse(PRUint32* o_size)
+{
+	*o_size = m_SizeInUse;
+    return NS_OK;
+}
+
+#undef ENSURE_INIT

mozilla/netwerk/cache/module/disk/nsDiskModuleFactory.cpp

@@ -0,0 +1,87 @@
+/* -*- 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.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 "nsIGenericFactory.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsDiskModule.h"
+#include "nscore.h"
+
+static NS_DEFINE_CID(kComponentManagerCID,      NS_COMPONENTMANAGER_CID);
+static NS_DEFINE_CID(kDiskModuleCID,   		NS_DISKMODULE_CID);
+
+////////////////////////////////////////////////////////////////////////////////
+
+// return the proper factory to the caller
+extern "C" PR_IMPLEMENT(nsresult)
+NSGetFactory(nsISupports* aServMgr,
+             const nsCID &aClass,
+             const char *aClassName,
+             const char *aProgID,
+             nsIFactory **aFactory)
+{
+    nsresult rv;
+    if (aFactory == nsnull)
+        return NS_ERROR_NULL_POINTER;
+
+    nsIGenericFactory* fact;
+    if (aClass.Equals(kDiskModuleCID)) {
+        rv = NS_NewGenericFactory(&fact, nsDiskModule::Create);
+    }
+    else {
+        rv = NS_ERROR_FAILURE;
+    }
+
+    if (NS_SUCCEEDED(rv))
+        *aFactory = fact;
+    return rv;
+}
+
+extern "C" PR_IMPLEMENT(nsresult)
+NSRegisterSelf(nsISupports* aServMgr , const char* aPath)
+{
+    nsresult rv;
+
+    NS_WITH_SERVICE1(nsIComponentManager, compMgr, aServMgr, 
+			kComponentManagerCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = compMgr->RegisterComponent(kDiskModuleCID,  
+                                    "Disk Module Cache",
+                                    "components://necko/cache/disk",
+                                    aPath, PR_TRUE, PR_TRUE);
+    if (NS_FAILED(rv)) return rv;;
+
+    return rv;
+}
+
+extern "C" PR_IMPLEMENT(nsresult)
+NSUnregisterSelf(nsISupports* aServMgr, const char* aPath)
+{
+    nsresult rv;
+
+    NS_WITH_SERVICE1(nsIComponentManager, compMgr, aServMgr, kComponentManagerCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = compMgr->UnregisterComponent(kDiskModuleCID, aPath);
+    if (NS_FAILED(rv)) return rv;
+
+    return rv;
+}
+
+////////////////////////////////////////////////////////////////////////////////

mozilla/netwerk/cache/module/disk/nsFileStream.cpp

@@ -0,0 +1,110 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (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.
+ *
+ * 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.
+ */
+
+#include "nsFileStream.h"
+#include "plstr.h"
+#include "prlog.h"
+
+nsFileStream::nsFileStream(const char* i_Filename):m_pFile(0),m_pFilename(0)
+{
+    PR_ASSERT(i_Filename);
+    if (i_Filename)
+    {
+        m_pFilename = new char[PL_strlen(i_Filename)+1];
+        PL_strcpy(m_pFilename, i_Filename);
+        Open();
+    }
+}
+
+nsFileStream::~nsFileStream()
+{
+    if (m_pFilename)
+    {
+        delete[] m_pFilename;
+        m_pFilename = 0;
+    }
+    if (m_pFile)
+        PR_Close(m_pFile);
+}
+
+/*
+nsrefcnt nsFileStream::AddRef(void)
+{
+    return ++m_RefCnt;
+}
+nsrefcnt nsFileStream::Release(void)
+{
+    if (--m_RefCnt == 0)
+    {
+        delete this;
+        return 0;
+    }
+    return m_RefCnt;
+}
+
+nsresult nsFileStream::QueryInterface(const nsIID& aIID,
+                                        void** aInstancePtrResult)
+{
+    return NS_OK;
+}
+*/
+
+PRBool nsFileStream::Open()
+{
+    if (m_pFile)
+        PR_Close(m_pFile);
+    PR_ASSERT(m_pFilename);
+    if (m_pFilename)
+    {
+        m_pFile = PR_Open(
+                m_pFilename, 
+                PR_CREATE_FILE | PR_RDWR,
+                0600);// Read and write by owner only
+
+        PR_ASSERT(m_pFile);
+        if (m_pFile)
+            return PR_TRUE;
+    }
+    return PR_FALSE;
+}
+
+PRInt32 nsFileStream::Read(void* o_Buffer, PRUint32 i_Len)
+{
+    if (!m_pFile && !Open())
+        return 0;
+
+	// heck, remove later. 
+	// PRInt32 r = PR_Seek(m_pFile, 0, PR_SEEK_SET) ;
+	// end heck 
+
+    return PR_Read(m_pFile, o_Buffer, i_Len);
+}
+
+void nsFileStream::Reset()
+{
+    Open();
+}
+
+PRInt32 nsFileStream::Write(const void* i_Buffer, PRUint32 i_Len)
+{
+    if (!m_pFile && !Open())
+        return 0;
+    return PR_Write(m_pFile, i_Buffer, i_Len);
+}
+

mozilla/netwerk/cache/module/disk/nsMonitorable.cpp

@@ -0,0 +1,38 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (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.
+ *
+ * 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.
+ */
+
+/* 
+ * This is the implementation of the nsMonitorable::MonitorLocker class.
+ * Although the inlines work ok elsewhere, IRIX chokes on these. Hence
+ * moving these to a cpp.
+ * -Gagan Saksena 09/15/98 
+ */
+
+#include "nsMonitorable.h"
+
+nsMonitorable::MonitorLocker::MonitorLocker(nsMonitorable* i_pThis):
+	m_pMonitorable(i_pThis)
+{
+	if (m_pMonitorable) m_pMonitorable->Lock();
+}
+
+nsMonitorable::MonitorLocker::~MonitorLocker()
+{
+	if (m_pMonitorable) m_pMonitorable->Unlock();
+}

mozilla/netwerk/cache/module/memory/Makefile.in

@@ -0,0 +1,49 @@
+#
+# 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		= memcache
+LIBRARY_NAME	= memcache
+IS_COMPONENT	= 1
+
+REQUIRES	= nspr
+
+CPPSRCS		= \
+		nsMemModule.cpp \
+		nsMemCacheObject.cpp \
+		nsMemStream.cpp \
+		nsMonitorable.cpp \
+		nsMemModuleFactory.cpp \
+		$(NULL)
+
+LOCAL_INCLUDES	= \
+		-I$(srcdir) \
+		-I$(srcdir)/../../include \
+		-I$(srcdir)/../../public \
+		-I$(srcdir)/.. \
+		$(NULL)
+
+EXTRA_LIBS	= $(NSPR_LIBS)
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/module/memory/Makefile.win

@@ -0,0 +1,61 @@
+#!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=MemoryCache
+
+IS_COMPONENT=1
+MAKE_OBJ_TYPE=DLL
+DLLNAME=MemoryCache
+DLL=.\$(OBJDIR)\$(DLLNAME).dll
+
+LLIBS= $(LLIBS) \
+	$(LIBNSPR)		\
+	$(DIST)\lib\xpcom.lib	\
+	$(NULL)
+
+CPP_OBJS= 	                                \
+	.\$(OBJDIR)\nsMemModule.obj		\
+	.\$(OBJDIR)\nsMonitorable.obj		\
+	.\$(OBJDIR)\nsMemCacheObject.obj      	\
+	.\$(OBJDIR)\nsMemStream.obj      	\
+	.\$(OBJDIR)\nsMemModuleFactory.obj      \
+	$(NULL)
+
+LOCAL_INCLUDES=	-I. \
+	  	-I..\..\public \
+		-I..\..\include \
+
+INCLUDES = $(LOCAL_INCLUDES)
+
+REQUIRES = nspr
+
+INCS = 	-I..\..\public \
+      	-I..\..\include \
+	$(INCS) \
+       -I$(DEPTH)\dist\include \
+        $(NULL)
+
+include <$(DEPTH)\config\rules.mak> 
+
+install:: $(DLL)
+	$(MAKE_INSTALL) $(DLL) $(DIST)\bin\components
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib
+

mozilla/netwerk/cache/module/memory/nsMemCacheObject.cpp

@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+/* 
+ * nsMemCacheObject
+ *
+ * Gagan Saksena 04/22/98
+ * 
+ */
+#include "prtypes.h"
+#include "nsMemCacheObject.h"
+#include "nsMemStream.h"
+
+nsMemCacheObject::~nsMemCacheObject()
+{
+    if (m_pNextObject)
+    {
+        delete m_pNextObject;
+        m_pNextObject = 0;
+    }
+
+    if (m_pObject)
+    {
+	nsStream* pStream;
+        m_pObject->GetStream(&pStream);
+	if (pStream)
+        	delete (nsMemStream*)pStream;
+        delete m_pObject;
+        m_pObject = 0;
+    }
+}

mozilla/netwerk/cache/module/memory/nsMemCacheObject.h

@@ -0,0 +1,99 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+/* The nsMemCacheObject class holds the actual nsCacheObject and a pointer
+ * to the next nsMemCacheObject. Pretty simple solution for the time being. 
+ * Should be replaced once the memory hash table stuff gets up and running. 
+ * 
+ * -Gagan Saksena 09/15/98.
+ */
+
+#ifndef _nsMemCacheObject_h_
+#define _nsMemCacheObject_h_
+
+#include "prtypes.h"
+#include "prlog.h"
+#include "nsICacheObject.h"
+#include "nsCacheObject.h"
+
+class nsMemCacheObject
+{
+public:
+
+    nsMemCacheObject(void);
+    nsMemCacheObject(nsICacheObject* io_pObject);
+    nsMemCacheObject(const char* i_url); 
+    ~nsMemCacheObject();
+
+    void                Next(nsMemCacheObject* pObject);
+    void                Next(nsICacheObject* io_pObject);
+    
+    nsMemCacheObject*   Next(void) const;
+    
+    nsICacheObject*      ThisObject(void) const;
+    
+private:
+    nsICacheObject*  m_pObject;
+    nsMemCacheObject* m_pNextObject;
+
+    nsMemCacheObject& operator=(const nsMemCacheObject& mco);
+    nsMemCacheObject(const nsMemCacheObject&);
+
+};
+
+inline nsMemCacheObject::nsMemCacheObject(void):
+    m_pObject((nsICacheObject *) new nsCacheObject()), 
+    m_pNextObject(0)
+{
+}
+
+inline nsMemCacheObject::nsMemCacheObject(nsICacheObject* io_pObject):
+    m_pObject(io_pObject),
+    m_pNextObject(0)
+{
+}
+
+inline nsMemCacheObject::nsMemCacheObject(const char* i_url):
+    m_pObject((nsICacheObject *) new nsCacheObject(i_url)), 
+    m_pNextObject(0)
+{
+}
+
+inline nsMemCacheObject* nsMemCacheObject::Next(void) const
+{
+    return m_pNextObject;
+}
+
+inline void nsMemCacheObject::Next(nsMemCacheObject* pObject)
+{
+    PR_ASSERT(0==m_pNextObject);
+    m_pNextObject = pObject;
+}
+
+inline void nsMemCacheObject::Next(nsICacheObject* pObject)
+{
+    PR_ASSERT(0==m_pNextObject);
+    m_pNextObject = new nsMemCacheObject(pObject);
+}
+
+inline nsICacheObject* nsMemCacheObject::ThisObject(void) const
+{
+   return m_pObject;
+}
+
+#endif //_nsMemCacheObject_h_

mozilla/netwerk/cache/module/memory/nsMemModule.cpp

@@ -0,0 +1,485 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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 "prtypes.h"
+#include "prmem.h"
+#include "plstr.h"
+#include "prclist.h"
+#include "prio.h"
+#include "prsystem.h"
+#include "prlog.h"
+
+#include "nsMemModule.h"
+#include "nsMemCacheObject.h"
+#include "nsCacheManager.h"
+#include "nsICacheManager.h"
+#include "nsICachePref.h"
+#include "nsMemStream.h"
+
+/* 
+ * nsMemModule
+ *
+ * Gagan Saksena 02/02/98
+ * 
+ */
+
+static NS_DEFINE_IID(kICacheManagerIID, NS_ICACHEMANAGER_IID);
+static NS_DEFINE_IID(kCacheManagerCID, NS_CACHEMANAGER_CID);
+
+nsMemModule::nsMemModule(): 
+    m_pFirstObject(0),
+    m_SizeInUse(0),
+    m_pEnumeration(0),
+    m_pNext(0)
+{
+    nsICacheManager* pICacheMgr;
+    nsresult rv = nsServiceManager::GetService (kCacheManagerCID,
+						kICacheManagerIID,
+						(nsISupports **) &pICacheMgr);
+    PR_ASSERT (rv == NS_OK);
+   
+    nsICachePref* pPref;
+    rv = pICacheMgr->GetPrefs (&pPref);
+
+    PR_ASSERT (rv == NS_OK);
+
+    pPref->GetMemCacheSize(&m_Size);
+    
+}
+
+nsMemModule::nsMemModule(const PRUint32 size): 
+    m_pFirstObject(0),
+    m_Size (size),
+    m_SizeInUse(0),
+    m_pEnumeration(0),
+    m_pNext(0)
+{
+}
+
+nsMemModule::~nsMemModule()
+{
+    if (m_pFirstObject) {
+        delete m_pFirstObject;
+        m_pFirstObject = 0;
+    }
+}
+
+
+NS_IMETHODIMP 
+nsMemModule::AddObject(nsICacheObject* io_pObject)
+{
+
+#if 0
+    if (io_pObject)
+    {
+        m_ht.Put(io_pObject->Address(), io_pObject);
+    }
+    return NS_ERROR_FAILURE;
+#endif
+
+    if (io_pObject)
+    {
+        MonitorLocker ml((nsMonitorable*)this);
+		nsStream* pStream = (nsStream *) nsnull;
+		io_pObject->GetStream(&pStream);
+
+		// I removed this assert. I don't think it should be here. yixiong
+		// pStream would be set later by GetStreamFor( ) in nsCacheobject
+        // PR_ASSERT(pStream); // A valid stream does exist for this 
+
+        if (m_pFirstObject) 
+        {
+            LastObject()->Next(new nsMemCacheObject(io_pObject)); 
+        }
+        else
+        {
+            m_pFirstObject = new nsMemCacheObject(io_pObject);
+        }
+        m_Entries++;
+
+        io_pObject->SetModuleIndex(nsCacheManager::MEM);
+
+        return NS_OK;
+    }
+	// Todo:  Better error handling
+    return NS_ERROR_FAILURE;
+}
+
+
+
+NS_IMETHODIMP 
+nsMemModule::ContainsURL (const char* i_url, PRBool* o_bContain)
+{
+    MonitorLocker ml((nsMonitorable*)this);
+
+    *o_bContain = PR_FALSE;
+    if (m_pFirstObject && i_url && *i_url)
+    {
+        nsMemCacheObject* pObj = m_pFirstObject;
+        do
+        {
+			char *thisURL = nsnull;
+			pObj->ThisObject()->GetAddress (&thisURL);
+            if (0 == PL_strcasecmp(thisURL, i_url))
+			{
+				*o_bContain = PR_TRUE;
+                break;
+			}
+            pObj = pObj->Next();
+        }
+        while (pObj);
+    }
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::ContainsCacheObj(nsICacheObject* i_pObject, PRBool* o_bContain)
+{
+    MonitorLocker ml((nsMonitorable*)this);
+
+	*o_bContain = PR_FALSE;
+	char *url = (char *) nsnull;
+	if (i_pObject)
+    {
+        i_pObject->GetAddress (&url);
+	}
+    if (url && *url)
+    {
+        this->ContainsURL(url, o_bContain);
+    }
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::GarbageCollect(void)
+{
+    MonitorLocker ml((nsMonitorable*) this);
+
+    if (m_Entries > 0)
+    {
+        nsEnumeration* pEnum;
+		GetEnumerator(&pEnum);
+        PRUint32 idx = 0;
+        while (pEnum->HasMoreElements())
+        {
+            nsICacheObject* pObj = (nsICacheObject*) pEnum->NextElement();
+			PRBool bExpired = PR_FALSE;
+            if (pObj)
+			{
+				pObj->IsExpired (&bExpired);
+           	}
+            if (bExpired == PR_TRUE)
+            {
+                nsresult r = RemoveByIndex (idx);
+                PR_ASSERT(r == NS_OK);
+            }
+            ++idx;
+        }
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemModule::GetObjectByIndex (const PRUint32 i_index, 
+								nsICacheObject** ppICacheObject)
+{
+    MonitorLocker ml((nsMonitorable*)this);
+    nsMemCacheObject* pNth = 0;
+    if (m_pFirstObject)
+    {
+        PRUint32 idx = 0;
+        pNth = m_pFirstObject;
+        while (pNth->Next() && (idx++ != i_index ))
+        {
+            pNth = pNth->Next();
+        }
+    }
+    if (pNth)
+		*ppICacheObject = pNth->ThisObject();
+	else
+		*ppICacheObject = (nsICacheObject *) nsnull;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::GetObjectByURL(const char* i_url, nsICacheObject** ppICacheObject)
+{
+    MonitorLocker ml((nsMonitorable*)this);
+    *ppICacheObject = (nsICacheObject *) nsnull;
+
+    if (m_pFirstObject && i_url && *i_url)
+    {
+        nsMemCacheObject* pObj = m_pFirstObject;
+        do
+        {
+            char *thisURL;
+			pObj->ThisObject()->GetAddress (&thisURL);
+            if (0 == PL_strcasecmp(thisURL, i_url))
+			{
+				*ppICacheObject = pObj->ThisObject();
+                break;
+			}
+            pObj = pObj->Next();
+        }
+        while (pObj);
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsMemModule::GetStreamFor(const nsICacheObject* i_pObject, nsStream** o_stream)
+{
+    MonitorLocker ml(this);
+
+	*o_stream = nsnull;
+    if (i_pObject)
+    {
+        PRBool bContain = PR_FALSE;
+        ContainsCacheObj((nsICacheObject*) i_pObject, &bContain);
+        if (bContain)
+        {
+            nsStream* pStream = (nsStream *) nsnull;
+            i_pObject->GetStream(&pStream);
+            if (pStream)
+			{
+				*o_stream = pStream;
+				return NS_OK;
+			}
+        }
+        // Set up a new stream for this object
+        *o_stream = new nsMemStream();
+    }
+    return NS_OK;
+}
+
+
+nsMemCacheObject* nsMemModule::LastObject(void) const
+{
+    MonitorLocker ml((nsMonitorable*)this);
+    
+    nsMemCacheObject* pLast = 0;
+    if (m_pFirstObject)
+    {
+        pLast = m_pFirstObject;
+        while (pLast->Next())
+            pLast = pLast->Next();
+    }
+    return pLast;
+}
+
+NS_IMETHODIMP
+nsMemModule::ReduceSizeTo(const PRUint32 i_NewSize)
+{
+    //TODO
+    return PR_TRUE;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::RemoveByURL (const char* i_url)
+{
+    //TODO
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::RemoveByIndex(const PRUint32 i_index)
+{
+    //TODO
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::RemoveByObject(nsICacheObject* i_pObj)
+{
+    //TODO
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::RemoveAll()
+{
+	//TODO
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::SetSize(const PRUint32 i_Size)
+{
+	//TODO
+    return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+NS_IMETHODIMP
+nsMemModule::QueryInterface(const nsIID& aIID, void** aInstancePtr)
+{
+    NS_ASSERTION(aInstancePtr, "no instance pointer");
+
+    *aInstancePtr = 0;
+
+    if (aIID.Equals(nsCOMTypeInfo<nsISupports>::GetIID()) ||
+        aIID.Equals(nsCOMTypeInfo<nsICacheModule>::GetIID()))
+    {
+        *aInstancePtr = NS_STATIC_CAST (nsICacheModule*, this);
+        NS_ADDREF_THIS();
+        return NS_OK;
+    }
+    return NS_NOINTERFACE;
+}
+
+
+NS_IMPL_ADDREF(nsMemModule);
+NS_IMPL_RELEASE(nsMemModule);
+
+NS_METHOD
+nsMemModule::Create (nsISupports *aOuter, REFNSIID aIID, void** aResult)
+{
+	if (aOuter)
+		return NS_ERROR_NO_AGGREGATION;
+
+	nsMemModule* pm = new nsMemModule();
+	if (pm == nsnull)
+		return NS_ERROR_OUT_OF_MEMORY;
+
+    NS_ADDREF (pm);
+    nsresult rv = pm->QueryInterface (aIID, aResult);
+    NS_RELEASE (pm);
+    return rv;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+NS_IMETHODIMP
+nsMemModule::Enable(PRBool i_bEnable)
+{
+    m_Enabled = i_bEnable;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP 
+nsMemModule::GetNumOfEntries(PRUint32* o_nEntries)
+{
+    *o_nEntries = m_Entries;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::GetEnumerator(nsEnumeration** o_enum)
+{
+    MonitorLocker ml((nsMonitorable*)this);
+    if (!m_pEnumeration)
+    {
+        PR_ASSERT(m_pIterator);
+        ((nsMemModule*)this)->m_pEnumeration = 
+									new nsEnumeration((nsIterator*)m_pIterator);
+    }
+    else
+        ((nsMemModule*)this)->m_pEnumeration->Reset();
+    *o_enum = m_pEnumeration;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::IsEnabled(PRBool* o_bEnabled)
+{
+	*o_bEnabled = m_Enabled;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::IsReadOnly (PRBool* o_bReadOnly)
+{
+	*o_bReadOnly  = PR_FALSE;		// for Now
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::GetNextModule(nsICacheModule** o_pICacheModule)
+{
+    if (m_pNext) {
+      *o_pICacheModule = m_pNext;
+      return NS_OK;
+	}
+	return NS_ERROR_FAILURE ;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::SetNextModule(nsICacheModule* pNext) 
+{
+    /* No overwriting */
+    PR_ASSERT(m_pNext == 0);
+    if (m_pNext)
+    {
+        /* ERROR */
+        delete m_pNext; //Worst case. 
+        m_pNext = 0;
+    }
+    m_pNext = pNext;
+	return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::GetSize(PRUint32* o_size)
+{
+	*o_size = m_Size;
+    return NS_OK;
+}
+
+
+NS_IMETHODIMP
+nsMemModule::GetSizeInUse(PRUint32* o_size)
+{
+	*o_size = m_SizeInUse;
+    return NS_OK;
+}
+
+/*
+PRUint32 nsMemModule::nsMemKey::HashValue()
+{
+    return 0;
+}
+PRBool nsMemModule::nsMemKey::Equals(nsHashKey *aKey)
+{
+    return PR_FALSE;
+}
+
+nsHashKey* nsMemModule::nsMemKey::Clone()
+{
+    return new nsMemModule::nsMemKey();
+}
+
+nsMemModule::nsMemKey::neMemKey()
+{
+}
+
+  */

mozilla/netwerk/cache/module/memory/nsMemModuleFactory.cpp

@@ -0,0 +1,87 @@
+/* -*- 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.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 "nsIGenericFactory.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsMemModule.h"
+#include "nscore.h"
+
+static NS_DEFINE_CID(kComponentManagerCID,      NS_COMPONENTMANAGER_CID);
+static NS_DEFINE_CID(kMemModuleCID,   		NS_MEMMODULE_CID);
+
+////////////////////////////////////////////////////////////////////////////////
+
+// return the proper factory to the caller
+extern "C" PR_IMPLEMENT(nsresult)
+NSGetFactory(nsISupports* aServMgr,
+             const nsCID &aClass,
+             const char *aClassName,
+             const char *aProgID,
+             nsIFactory **aFactory)
+{
+    nsresult rv;
+    if (aFactory == nsnull)
+        return NS_ERROR_NULL_POINTER;
+
+    nsIGenericFactory* fact;
+    if (aClass.Equals(kMemModuleCID)) {
+        rv = NS_NewGenericFactory(&fact, nsMemModule::Create);
+    }
+    else {
+        rv = NS_ERROR_FAILURE;
+    }
+
+    if (NS_SUCCEEDED(rv))
+        *aFactory = fact;
+    return rv;
+}
+
+extern "C" PR_IMPLEMENT(nsresult)
+NSRegisterSelf(nsISupports* aServMgr , const char* aPath)
+{
+    nsresult rv;
+
+    NS_WITH_SERVICE1(nsIComponentManager, compMgr, aServMgr, 
+			kComponentManagerCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = compMgr->RegisterComponent(kMemModuleCID,  
+                                    "Mem Module Cache",
+                                    "component://necko/cache/MemModule",
+                                    aPath, PR_TRUE, PR_TRUE);
+    if (NS_FAILED(rv)) return rv;;
+
+    return rv;
+}
+
+extern "C" PR_IMPLEMENT(nsresult)
+NSUnregisterSelf(nsISupports* aServMgr, const char* aPath)
+{
+    nsresult rv;
+
+    NS_WITH_SERVICE1(nsIComponentManager, compMgr, aServMgr, kComponentManagerCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = compMgr->UnregisterComponent(kMemModuleCID, aPath);
+    if (NS_FAILED(rv)) return rv;
+
+    return rv;
+}
+
+////////////////////////////////////////////////////////////////////////////////

mozilla/netwerk/cache/module/memory/nsMemStream.cpp

@@ -0,0 +1,124 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (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.
+ *
+ * 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.
+ */
+
+#include "nsMemStream.h"
+#include "prmem.h"
+#include "prlog.h" /* Assert */
+
+#ifndef XP_MAC
+#include "memory.h"
+#else
+#include "cstring"
+#endif
+
+static const PRUint32 kPageSize = 1024;//4096;
+nsMemStream::nsMemStream():m_AllocSize(0),m_Size(0),m_pStart(0),m_ReadOffset(0),m_WriteOffset(0)
+{
+}
+
+nsMemStream::~nsMemStream()
+{
+    PR_FREEIF(m_pStart);
+}
+/*
+nsrefcnt nsMemStream::AddRef(void)
+{
+    return ++m_RefCnt;
+}
+nsrefcnt nsMemStream::Release(void)
+{
+    if (--m_RefCnt == 0)
+    {
+        delete this;
+        return 0;
+    }
+    return m_RefCnt;
+}
+
+nsresult nsMemStream::QueryInterface(const nsIID& aIID,
+                                        void** aInstancePtrResult)
+{
+    return NS_OK;
+}
+*/
+
+PRInt32 nsMemStream::Read(void* o_Buffer, PRUint32 i_Len)
+{
+    if (m_Size > 0)
+    {
+        PR_ASSERT(m_pStart); //This has to be there if m_Size > 0
+
+        char* pCurrentRead = (char*) m_pStart + m_ReadOffset;
+
+        unsigned int validLen = m_Size - m_ReadOffset;
+    
+        if (0 == validLen)
+            return 0;
+
+        if (validLen > i_Len)
+            validLen = i_Len;
+
+        memcpy(o_Buffer, pCurrentRead, validLen);
+        m_ReadOffset += validLen;
+        return validLen;
+    }
+    return 0;
+}
+
+void nsMemStream::Reset()
+{
+    m_ReadOffset = 0;
+}
+
+PRInt32 nsMemStream::Write(const void* i_Buffer, PRUint32 i_Len)
+{
+    if (!m_pStart)
+    {
+        m_pStart = PR_Calloc(1, kPageSize); 
+        if (!m_pStart)
+        {
+            PR_Free(m_pStart);
+            return 0;
+        }
+        m_WriteOffset = 0;
+        m_AllocSize = kPageSize;
+    }
+    unsigned int validLen = m_AllocSize - m_Size;
+    while (validLen < i_Len)
+    {
+        //Alloc some more
+        m_pStart = PR_Realloc(m_pStart, m_AllocSize+kPageSize);
+        if (!m_pStart)
+        {
+            PR_Free(m_pStart);
+            m_AllocSize = 0;
+            m_WriteOffset = 0;
+            m_Size = 0;
+            return 0;
+        }
+        m_AllocSize += kPageSize;
+        validLen += kPageSize;
+    }
+    char* pCurrentWrite = (char*)m_pStart + m_WriteOffset;
+    memcpy(pCurrentWrite, i_Buffer, i_Len);
+    m_WriteOffset += i_Len;
+    m_Size += i_Len;
+    return i_Len;
+}
+

mozilla/netwerk/cache/module/memory/nsMonitorable.cpp

@@ -0,0 +1,38 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * The contents of this file are subject to the Netscape Public License
+ * Version 1.0 (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.
+ *
+ * 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.
+ */
+
+/* 
+ * This is the implementation of the nsMonitorable::MonitorLocker class.
+ * Although the inlines work ok elsewhere, IRIX chokes on these. Hence
+ * moving these to a cpp.
+ * -Gagan Saksena 09/15/98 
+ */
+
+#include "nsMonitorable.h"
+
+nsMonitorable::MonitorLocker::MonitorLocker(nsMonitorable* i_pThis):
+	m_pMonitorable(i_pThis)
+{
+	if (m_pMonitorable) m_pMonitorable->Lock();
+}
+
+nsMonitorable::MonitorLocker::~MonitorLocker()
+{
+	if (m_pMonitorable) m_pMonitorable->Unlock();
+}

mozilla/netwerk/cache/obj/Makefile.in

@@ -0,0 +1,42 @@
+#
+# 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		= cacheobj
+LIBRARY_NAME	= cacheobj
+IS_COMPONENT	= 1
+
+CPPSRCS		= nsCacheObject.cpp
+
+REQUIRES	= nspr
+
+LOCAL_INCLUDES	= \
+		-I$(srcdir)/../include \
+		-I$(srcdir)/../public \
+		-I$(PUBLIC)/netlib \
+		$(NULL)
+
+EXTRA_LIBS	= $(NSPR_LIBS)
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/obj/Makefile.win

@@ -0,0 +1,57 @@
+#!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=cacheobj
+
+IS_COMPONENT=1
+MAKE_OBJ_TYPE=DLL
+DLLNAME=cacheobj
+DLL=.\$(OBJDIR)\$(DLLNAME).dll
+
+LLIBS= $(LLIBS) \
+	$(LIBNSPR)				\
+	$(DIST)\lib\xpcom.lib	\
+	$(NULL)
+
+CPP_OBJS=                                  \
+	.\$(OBJDIR)\nsCacheObject.obj      \
+	$(NULL)
+
+LOCAL_INCLUDES=	-I. \
+	  	-I..\public \
+		-I..\include \
+
+INCLUDES = $(LOCAL_INCLUDES)
+
+REQUIRES = nspr
+
+INCS = $(INCS)                  \
+	-I..\include 		\
+        -I..\public 		\
+        -I$(DEPTH)\dist\include \
+        $(NULL)
+
+include <$(DEPTH)\config\rules.mak> 
+
+install:: $(DLL)
+	$(MAKE_INSTALL) $(DLL) $(DIST)\bin\components
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib
+

mozilla/netwerk/cache/obj/nsCacheObject.cpp

@@ -0,0 +1,934 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+#ifndef XP_MAC
+#include "memory.h"
+#else
+#include "cstring"
+#endif
+
+//#include "nspr.h"
+#include "nscore.h"
+#include "prmem.h"
+#include "prprf.h"
+#include "plstr.h"
+#include "prinrval.h"
+
+// #include "nsStream.h"
+// #include "nsCacheTrace.h"
+#include "nsICacheModule.h"
+#include "nsICacheManager.h"
+
+#include "nsCacheObject.h"
+
+/* 
+ * nsCacheObject
+ *
+ * Gagan Saksena 02/02/98
+ * 
+ */
+
+static const PRIntervalTime DEFAULT_EXPIRES = PR_SecondsToInterval(86400);
+//static const PRIntervalTime DEFAULT_EXPIRES = 1000;
+//static const PRIntervalTime DEFAULT_EXPIRES = PR_IntervalNow();
+
+// Globals, need to check if safe to unload module
+static PRInt32 gLockCnt = 0;
+static PRInt32 gInstanceCnt = 0;
+
+// Define constants for easy use
+static NS_DEFINE_IID(kICACHEOBJECTIID, NS_ICACHEOBJECT_IID);  
+static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
+static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
+static NS_DEFINE_IID(kICACHEMANAGERIID, NS_ICACHEMANAGER_IID);  
+static NS_DEFINE_IID(kCacheManagerCID, NS_CACHEMANAGER_CID);  
+
+#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
+
+/* Convenient macros used in stuffing and reading back cache object to a void * */
+/* TODO: Change these to file scope functions */
+#define STUFF_STRING(string)                 \
+{                                            \
+  len = (string ? PL_strlen(string)+1 : 0);  \
+  COPY_INT32((void *)cur_ptr, &len);         \
+  cur_ptr = cur_ptr + sizeof(int32);         \
+  if(len)                                    \
+      memcpy((void *)cur_ptr, string, len);  \
+  cur_ptr += len;                            \
+}
+
+#define STUFF_NUMBER(number)                \
+{                                           \
+  COPY_INT32((void *)cur_ptr, &number);     \
+  cur_ptr = cur_ptr + sizeof(PRUint32);        \
+}
+
+#define STUFF_TIME(number)                      \
+{                                               \
+  COPY_INT32((void *)cur_ptr, &number);         \
+  cur_ptr = cur_ptr + sizeof(PRIntervalTime);   \
+}
+
+#define STUFF_BOOL(bool_val)                \
+{                                           \
+  if(bool_val)                              \
+    ((char *)(cur_ptr))[0] = 1;             \
+  else                                      \
+    ((char *)(cur_ptr))[0] = 0;             \
+  cur_ptr = cur_ptr + sizeof(char);         \
+}
+
+/* if any strings are larger than this then
+ * there was a serious database error
+ */
+#define MAX_HUGE_STRING_SIZE 10000
+
+#define RETRIEVE_STRING(string)     \
+{                                   \
+    if(cur_ptr > max_ptr)           \
+    {                               \
+        return PR_TRUE;             \
+    }                               \
+    COPY_INT32(&len, cur_ptr);      \
+    cur_ptr += sizeof(int32);       \
+    if(len)                         \
+    {                               \
+        if(len > MAX_HUGE_STRING_SIZE)  \
+        {                               \
+            return PR_FALSE;            \
+        }                               \
+        string = new char[len]; \
+        if(!string)                     \
+        {                               \
+            return PR_FALSE;            \
+        }                               \
+        memcpy(string, cur_ptr, len);   \
+        cur_ptr += len;                 \
+   }                                    \
+}
+
+#define RETRIEVE_NUMBER(number)     \
+{                                   \
+    if(cur_ptr > max_ptr)           \
+        return PR_TRUE;             \
+    COPY_INT32(&number, cur_ptr);   \
+    cur_ptr += sizeof(int32);       \
+}
+
+#define RETRIEVE_TIME(number)           \
+{                                       \
+    if(cur_ptr > max_ptr)               \
+        return PR_TRUE;                 \
+    COPY_INT32(&number, cur_ptr);       \
+    cur_ptr += sizeof(PRIntervalTime);  \
+}
+
+#define RETRIEVE_BOOL(bool)         \
+{                                   \
+  if(cur_ptr > max_ptr)             \
+    return PR_TRUE;                 \
+  if(((char *)(cur_ptr))[0])        \
+    bool = TRUE;                    \
+  else                              \
+    bool = FALSE;                   \
+  cur_ptr += sizeof(char);          \
+}
+
+/*  TODO- Further optimization, initialize these to null, 
+    but that will add more work on copy constructor which is ok */
+nsCacheObject::nsCacheObject():
+    m_Charset(new char[1]),
+    m_ContentEncoding(new char[1]),
+    m_ContentType(new char[1]),
+    m_Etag(new char[1]),
+    m_Filename(new char[1]),
+    m_State(INIT), 
+    m_bIsCompleted(PR_FALSE),
+    m_Module(-1),
+    m_pInfo(0),
+    m_PageServicesURL(new char[1]),
+    m_PostData(new char[1]),
+    m_PostDataLen(0),
+    m_pStream(0),
+    m_URL(new char[1]) 
+{
+    Init();
+    *m_Charset = '\0';
+    *m_ContentEncoding = '\0';
+    *m_ContentType = '\0';
+    *m_Etag = '\0';
+    *m_Filename = '\0';
+    *m_PageServicesURL = '\0';
+    *m_PostData = '\0';
+    *m_URL = '\0';
+
+	NS_INIT_ISUPPORTS() ;
+	PR_AtomicIncrement(&gInstanceCnt) ;
+}
+
+nsCacheObject::~nsCacheObject() 
+{
+    if (m_Charset)
+        delete[] m_Charset;
+    if (m_ContentEncoding)
+        delete[] m_ContentEncoding;
+    if (m_ContentType)
+        delete[] m_ContentType;
+    if (m_Etag)
+        delete[] m_Etag;
+    if (m_Filename)
+        delete[] m_Filename;
+    if (m_PageServicesURL)
+        delete[] m_PageServicesURL;
+    if (m_PostData)
+        delete[] m_PostData;
+    if (m_URL)
+        delete[] m_URL;
+    if (m_pStream)
+        delete m_pStream;
+
+	PR_AtomicDecrement(&gInstanceCnt) ;
+}
+
+nsCacheObject::nsCacheObject(const nsCacheObject& another):
+    m_Charset(new char[PL_strlen(another.m_Charset)+1]), 
+    m_ContentEncoding(new char[PL_strlen(another.m_ContentEncoding)+1]),
+    m_ContentType(new char[PL_strlen(another.m_ContentType)+1]),
+    m_Etag(new char[PL_strlen(another.m_Etag)+1]),
+    m_Filename(new char[PL_strlen(another.m_Filename)+1]),
+    m_State(another.m_State),
+    m_bIsCompleted(another.m_bIsCompleted),
+    m_pInfo(0), /* Should this be copied as well? */
+    m_PageServicesURL(new char[PL_strlen(another.m_PageServicesURL)+1]),
+    m_PostData(new char[another.m_PostDataLen+1]),
+    m_PostDataLen(another.m_PostDataLen),
+    m_pStream(0),
+    m_URL(new char[PL_strlen(another.m_URL)+1])
+{
+    PL_strncpyz(m_Charset, another.m_Charset, PL_strlen(another.m_Charset)+1);
+    PL_strncpyz(m_ContentEncoding, another.m_ContentEncoding, PL_strlen(another.m_ContentEncoding)+1);
+    PL_strncpyz(m_ContentType, another.m_ContentType, PL_strlen(another.m_ContentType)+1);
+    PL_strncpyz(m_Etag, another.m_Etag, PL_strlen(another.m_Etag)+1);
+    PL_strncpyz(m_Filename, another.m_Filename, PL_strlen(another.m_Filename)+1);
+    PL_strncpyz(m_PageServicesURL, another.m_PageServicesURL, PL_strlen(another.m_PageServicesURL)+1);
+    PL_strncpyz(m_PostData, another.m_PostData, another.m_PostDataLen+1);
+    PL_strncpyz(m_URL, another.m_URL, PL_strlen(another.m_URL)+1);
+
+    m_Hits = another.m_Hits;
+    m_LastAccessed = another.m_LastAccessed;
+    m_LastModified = another.m_LastModified;
+    m_Size = another.m_Size;
+    m_Module = another.m_Module;
+
+	NS_INIT_ISUPPORTS() ;
+	PR_AtomicIncrement(&gInstanceCnt) ;
+
+}
+
+nsCacheObject::nsCacheObject(const char* i_url):
+    m_Charset(new char[1]),
+    m_ContentEncoding(new char[1]),
+    m_ContentType(new char[1]),
+    m_Etag(new char[1]),
+    m_Filename(new char[1]),
+    m_State(INIT), 
+    m_bIsCompleted(PR_FALSE),
+    m_Module(-1),
+    m_pInfo(0),
+    m_PageServicesURL(new char[1]),
+    m_PostData(new char[1]),
+    m_PostDataLen(0),
+    m_pStream(0),
+    m_URL(new char[PL_strlen(i_url)+1])
+{
+    Init();
+    PR_ASSERT(i_url);
+    PL_strncpyz(m_URL, i_url, PL_strlen(i_url)+1);
+
+    *m_Charset = '\0';
+    *m_ContentEncoding = '\0';
+    *m_ContentType = '\0';
+    *m_Etag = '\0';
+    *m_Filename = '\0';
+    *m_PageServicesURL = '\0';
+    *m_PostData = '\0';
+
+	NS_INIT_ISUPPORTS() ;
+	PR_AtomicIncrement(&gInstanceCnt) ;
+
+}
+
+NS_IMPL_ISUPPORTS(nsCacheObject, nsCOMTypeInfo<nsICacheObject>::GetIID( )) ;
+
+NS_IMETHODIMP 
+nsCacheObject::SetAddress(const char* i_url) 
+{
+    PR_ASSERT(i_url && *i_url);
+    if (!i_url)
+        return NS_ERROR_NULL_POINTER ;
+    if (m_URL)
+        delete[] m_URL;
+    int len = PL_strlen(i_url);
+    m_URL = new char[len + 1];
+    PL_strncpyz(m_URL, i_url, len+1);
+
+	return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCacheObject::SetCharset(const char* i_Charset) 
+{
+//    PR_ASSERT(i_Charset && *i_Charset);
+    if (!i_Charset) //TODO reset m_charset here 
+        return NS_ERROR_NULL_POINTER ;
+    if (m_Charset)
+        delete[] m_Charset;
+    int len = PL_strlen(i_Charset);
+    m_Charset = new char[len + 1];
+    PL_strncpyz(m_Charset, i_Charset, len+1);
+
+	return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCacheObject::SetContentEncoding(const char* i_Encoding) 
+{
+//    PR_ASSERT(i_Encoding && *i_Encoding);
+    if (!i_Encoding)
+        return NS_ERROR_NULL_POINTER ;
+    if (m_ContentEncoding)
+        delete[] m_ContentEncoding;
+    int len = PL_strlen(i_Encoding);
+    m_ContentEncoding = new char[len + 1];
+    PL_strncpyz(m_ContentEncoding, i_Encoding, len+1);
+
+	return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCacheObject::SetContentType(const char* i_Type) 
+{
+//    PR_ASSERT(i_Type && *i_Type);
+    if (!i_Type)
+    {
+        /* Reset to empty */ // TODO ??
+        return NS_ERROR_NULL_POINTER ;
+    }
+    if (m_ContentType)
+        delete[] m_ContentType;
+    int len = PL_strlen(i_Type);
+    m_ContentType = new char[len + 1];
+    PL_strncpyz(m_ContentType, i_Type, len+1);
+
+	return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCacheObject::SetEtag(const char* i_etag) 
+{
+//    PR_ASSERT(i_etag && *i_etag);
+    if (!i_etag)
+        return NS_ERROR_NULL_POINTER ;
+    if (m_Etag)
+        delete[] m_Etag;
+    m_Etag = new char[PL_strlen(i_etag) + 1];
+    PL_strncpyz(m_Etag, i_etag, PL_strlen(i_etag)+1);
+
+	return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCacheObject::SetFilename(const char* i_Filename)
+{
+//    PR_ASSERT(i_Filename && *i_Filename);
+    if (!i_Filename)
+        return NS_ERROR_NULL_POINTER ;
+    if (m_Filename)
+        delete[] m_Filename;
+    int len = PL_strlen(i_Filename);
+    m_Filename = new char[len +1];
+    PL_strncpyz(m_Filename, i_Filename, len+1);
+
+	return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCacheObject::GetInfo(void** o_info) 
+{
+	if (!o_info)
+	  return NS_ERROR_NULL_POINTER ;
+
+    if (m_pInfo) {
+        *o_info = m_pInfo;
+		return NS_OK ;
+	}
+    
+    nsCacheObject* pThis = (nsCacheObject*) this;
+
+    if (m_URL){
+
+        pThis->m_info_size = sizeof(nsCacheObject);
+        
+        pThis->m_info_size -= sizeof(void*); // m_info itself is not being serialized
+        pThis->m_info_size -= sizeof(char*); // neither is m_PostData
+        pThis->m_info_size -= sizeof(nsStream*); // nor the stream
+        pThis->m_info_size -= sizeof(PRBool); // bIsCompleted. 
+        //todo -optimize till here
+
+        //Add the strings sizes
+        pThis->m_info_size += PL_strlen(m_Charset)+1;
+        pThis->m_info_size += PL_strlen(m_ContentEncoding)+1;
+        pThis->m_info_size += PL_strlen(m_ContentType)+1;
+        pThis->m_info_size += PL_strlen(m_Etag)+1;
+        pThis->m_info_size += PL_strlen(m_Filename)+1;
+        pThis->m_info_size += PL_strlen(m_PageServicesURL)+1;
+        pThis->m_info_size += PL_strlen(m_URL)+1;
+        
+        //Add the Postdata len
+        pThis->m_info_size += m_PostDataLen+1;
+
+		//For the virtual function table. This is really nasty, yixiong
+		pThis->m_info_size -= sizeof(void*) ;
+
+        void* new_obj = PR_Calloc(1, m_info_size * sizeof(char));
+     
+        if (!new_obj)
+        {
+            PR_Free(new_obj);
+            return NS_ERROR_OUT_OF_MEMORY ;
+        }
+
+        PRUint32 len;
+
+        char* cur_ptr = (char*) new_obj;
+        /* put the total size of the struct into
+         * the first field so that we have
+         * a cross check against corruption
+         */
+        COPY_INT32((void *)cur_ptr, &m_info_size);
+
+        cur_ptr += sizeof(PRUint32);
+
+        /* put the version number of the structure
+         * format that we are using. By using a version 
+         * string when writting we can support 
+         * backwards compatibility in our reading code
+         */
+        COPY_INT32((void *)cur_ptr, &kCACHE_VERSION);
+        cur_ptr += sizeof(PRUint32);
+
+        STUFF_STRING(m_Charset);
+        STUFF_STRING(m_ContentEncoding);
+        STUFF_NUMBER(m_ContentLength);
+        STUFF_STRING(m_ContentType);
+        STUFF_STRING(m_Etag);
+        STUFF_TIME(m_Expires);
+        STUFF_STRING(m_Filename);
+        STUFF_NUMBER(m_Hits);
+        STUFF_TIME(m_LastAccessed);
+        STUFF_TIME(m_LastModified);
+        STUFF_NUMBER(m_Module);
+        STUFF_STRING(m_PageServicesURL);
+        STUFF_NUMBER(m_PostDataLen);
+
+        /* There is a possibility of it not being a string! */
+        if (m_PostData)
+        {
+			// 4 bytes missing, yixiong
+            memcpy(cur_ptr, m_PostData, m_PostDataLen+1);
+            cur_ptr += m_PostDataLen+1;
+        }
+        STUFF_NUMBER(m_Size);
+        STUFF_NUMBER(m_State);
+        STUFF_STRING(m_URL);
+
+        // Important Assertion. Dont remove!
+        // If this fails then you or somebody has added a variable to the 
+        // nsCacheObject class and a decision on its "cacheability" has
+        // not yet been made. 
+        PR_ASSERT(cur_ptr == (char*) new_obj + m_info_size);
+        pThis->m_pInfo = new_obj;
+
+		*o_info = pThis->m_pInfo ;
+    }
+    return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCacheObject::SetInfo(void* i_data) 
+{
+    if (!i_data)
+        return NS_ERROR_NULL_POINTER ;
+    
+    char* cur_ptr = (char*) i_data;
+
+    //Reset the m_pInfo;
+    if (m_pInfo)
+    {
+        PR_Free(m_pInfo);
+        m_pInfo = 0;
+    }
+
+    //Reset all strings
+    if (m_Charset)
+        delete[] m_Charset;
+    if (m_ContentEncoding)
+        delete[] m_ContentEncoding;
+    if (m_ContentType)
+        delete[] m_ContentType;
+    if (m_Etag)
+        delete[] m_Etag;
+    if (m_Filename)
+        delete[] m_Filename;
+    if (m_PageServicesURL)
+        delete[] m_PageServicesURL;
+    if (m_URL)
+        delete[] m_URL;
+    if (m_PostData)
+        delete[] m_PostData;
+
+    m_PostDataLen = 0;
+
+    COPY_INT32(&m_info_size, cur_ptr);
+    char* max_ptr = cur_ptr + m_info_size;
+    cur_ptr += sizeof(PRUint32);
+
+    PRUint32 version;
+    COPY_INT32(&version, cur_ptr);
+    cur_ptr += sizeof(PRUint32);
+
+    PR_ASSERT(version == kCACHE_VERSION);
+    if (version != kCACHE_VERSION)
+    {
+        //TODO Bad cache version
+        return NS_ERROR_FAILURE ;
+    }
+
+    PRUint32 len;
+    
+    RETRIEVE_STRING(m_Charset);
+    RETRIEVE_STRING(m_ContentEncoding);
+    RETRIEVE_NUMBER(m_ContentLength);
+    RETRIEVE_STRING(m_ContentType);
+    RETRIEVE_STRING(m_Etag);
+    RETRIEVE_TIME(m_Expires);
+    RETRIEVE_STRING(m_Filename);
+    RETRIEVE_NUMBER(m_Hits);
+    RETRIEVE_TIME(m_LastAccessed);
+    RETRIEVE_TIME(m_LastModified);
+    RETRIEVE_NUMBER(m_Module);
+    RETRIEVE_STRING(m_PageServicesURL);
+    RETRIEVE_NUMBER(m_PostDataLen);
+    // Special case-
+    m_PostData = new char[m_PostDataLen + 1];
+    if (m_PostData)
+    {
+        memcpy(m_PostData, cur_ptr, m_PostDataLen+1);
+    }
+    cur_ptr += m_PostDataLen +1;
+
+    RETRIEVE_NUMBER(m_Size);
+    RETRIEVE_NUMBER(m_State);
+    RETRIEVE_STRING(m_URL);
+ 
+    // Most important assertion! Don't ever remove!
+    PR_ASSERT(cur_ptr == max_ptr);
+
+    // Since we are reading off its info from an indexed entry
+    m_bIsCompleted = PR_TRUE;
+
+    return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCacheObject::GetInfoSize(PRUint32 *o_size) 
+{
+    if (!m_pInfo)
+    {
+        GetInfo(&m_pInfo);
+    }
+    *o_size = m_info_size;
+	return NS_OK ;
+}
+
+void nsCacheObject::Init() 
+{
+    m_Size = 0;
+    m_Expires = PR_IntervalNow() + DEFAULT_EXPIRES;
+    m_Hits = 0;
+}
+
+NS_IMETHODIMP
+nsCacheObject::SetPageServicesURL(const char* i_Url) 
+{
+//    PR_ASSERT(i_Url && *i_Url);
+    if (!i_Url)
+        return NS_ERROR_NULL_POINTER ;
+    if (m_PageServicesURL)
+        delete[] m_PageServicesURL;
+    m_PageServicesURL = new char[PL_strlen(i_Url) + 1];
+    PL_strncpyz(m_PageServicesURL, i_Url, PL_strlen(i_Url)+1);
+
+	return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCacheObject::SetPostData(const char* i_data, const PRUint32 i_Len)
+{
+    if (!i_data || (0 ==i_Len))
+        return NS_ERROR_NULL_POINTER ;
+    if (m_PostData)
+        delete[] m_PostData;
+    m_PostData = new char[i_Len+1];
+    PL_strncpyz(m_PostData, i_data, i_Len+1);
+    m_PostDataLen = i_Len;
+
+	return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCacheObject::Read(char* o_Buffer, PRUint32 len, PRUint32 * pLeng)
+{
+	nsresult rv ;
+
+    if (!m_pStream)
+    {
+        PR_ASSERT(m_Module >=0);
+        if (0 <= m_Module)
+        {
+            nsICacheModule* pModule ;
+			nsICacheManager* cacheManager ;
+			rv = nsServiceManager::GetService(kCacheManagerCID,
+			                                  kICACHEMANAGERIID,
+											  (nsISupports **)&cacheManager) ;
+
+			rv = cacheManager->GetModule(m_Module, &pModule);
+
+            if (NS_SUCCEEDED(rv) && pModule)
+            {
+				rv = pModule->GetStreamFor(this, &m_pStream);
+                if (NS_SUCCEEDED(rv) && m_pStream)
+                {
+                    *pLeng = m_pStream->Read(o_Buffer, len);
+					return NS_OK ;
+                }
+            }
+        }
+        return NS_ERROR_FAILURE ;
+    }
+    *pLeng = m_pStream->Read(o_Buffer, len);
+	return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCacheObject::Reset(void)
+{
+    if (m_pStream)
+        m_pStream->Reset();
+    // TODO change states too.
+
+	return NS_OK ;
+}
+
+#if 0
+/* Caller must free returned string */
+// TODO  change to use PR_stuff...
+const char* nsCacheObject::Trace() const
+{
+    char linebuffer[256];
+    char* total;
+
+    PR_Sprintf(linebuffer, "nsCacheObject:URL=%s,SIZE=%d,ET=%s,\n\tLM=%d,LA=%d,EXP=%d,HITS=%d\n", 
+        m_URL, 
+        m_Size,
+        m_Etag,
+        m_LastModified,
+        m_LastAccessed,
+        m_Expires,
+        m_Hits);
+
+    total = new char[PL_strlen(linebuffer) +1];
+    PL_strcpy(total, linebuffer);
+
+    return total;
+}
+#endif
+
+NS_IMETHODIMP
+nsCacheObject::Write(const char* i_Buffer, const PRUint32 len, PRUint32 * oLeng)
+{
+	nsresult rv ;
+
+	if (!oLeng)
+	  return NS_ERROR_NULL_POINTER ;
+
+    PRUint32 amountWritten = 0;
+    if (!m_pStream)
+    {
+        PR_ASSERT(m_Module >=0);
+        if (0 <= m_Module)
+        {
+            nsICacheModule* pModule ;
+			nsICacheManager* cacheManager ;
+
+			rv = nsServiceManager::GetService(kCacheManagerCID,
+			                                  kICACHEMANAGERIID,
+											  (nsISupports **)&cacheManager) ;
+
+            rv = cacheManager->GetModule(m_Module, &pModule);
+
+            if (NS_SUCCEEDED(rv) && pModule)
+            {   
+				rv = pModule->GetStreamFor(this, &m_pStream);
+                PR_ASSERT(m_pStream);
+                if (!m_pStream)
+                    return NS_ERROR_FAILURE ;
+            }
+        }
+        else
+            return NS_ERROR_FAILURE ;
+    }
+    amountWritten = m_pStream->Write(i_Buffer, len);
+    m_Size += amountWritten;
+    *oLeng = amountWritten;
+
+	return NS_OK ;
+}
+
+nsCacheObjectFactory::nsCacheObjectFactory ()
+{
+	NS_INIT_ISUPPORTS();
+	PR_AtomicIncrement(&gInstanceCnt);
+}
+
+nsCacheObjectFactory::~nsCacheObjectFactory ()
+{
+	PR_AtomicDecrement(&gInstanceCnt);
+}
+
+/*
+NS_IMETHODIMP 
+nsCacheObjectFactory::QueryInterface(const nsIID &aIID, void **aResult)
+{
+	if (!aResult)
+		return NS_ERROR_NULL_POINTER;
+
+	if (aIID.Equals(kISupportsIID)) {
+		*aResult = NS_STATIC_CAST(nsISupports*,this);
+	} else if (aIID.Equals(kIFactoryIID)) {
+		*aResult = NS_STATIC_CAST(nsISupports*,NS_STATIC_CAST(nsIFactory*,this));
+	} else {
+		*aResult = nsnull;
+		return NS_ERROR_NO_INTERFACE;
+	}
+
+	NS_ADDREF(NS_REINTERPRET_CAST(nsISupports*,*aResult));
+
+	return NS_OK;
+}
+
+NS_IMPL_ADDREF(nsCacheObjectFactory)
+NS_IMPL_RELEASE(nsCacheObjectFactory)
+*/
+
+NS_IMPL_ISUPPORTS(nsCacheObjectFactory, kIFactoryIID) ;
+
+NS_IMETHODIMP
+nsCacheObjectFactory::CreateInstance(nsISupports *aOuter, 
+                                const nsIID &aIID, 
+                                void **aResult) 
+{ 
+	if (!aResult)
+		return NS_ERROR_NULL_POINTER; 
+
+	*aResult = nsnull; 
+
+	nsISupports *inst = new nsCacheObject(); 
+
+	if (!inst) { 
+		return NS_ERROR_OUT_OF_MEMORY; 
+	} 
+
+	// All XPCOM methods return nsresult
+	nsresult rv = inst->QueryInterface(aIID, aResult); 
+
+	// There are handy macros, NS_SUCCEEDED and NS_FAILED
+	// to test the return value of an XPCOM method.
+	if (NS_FAILED(rv)) { 
+		// We didn't get the right interface, so clean up 
+		delete inst; 
+	} 
+
+	return rv; 
+} 
+
+NS_IMETHODIMP
+nsCacheObjectFactory::LockFactory(PRBool aLock) 
+{ 
+	if (aLock) { 
+		PR_AtomicIncrement(&gLockCnt); 
+	} else { 
+		PR_AtomicDecrement(&gLockCnt); 
+	} 
+
+	return NS_OK;
+}
+
+
+/////////////////////////////////////////////////////////////////////
+// Exported functions. With these in place we can compile
+// this module into a dynamically loaded and registered
+// component.
+
+static NS_DEFINE_CID(kCacheObjectCID, NS_CACHEOBJECT_CID);
+static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID);
+
+// The "name" of our component
+static const char* g_desc = "Cache Object XPCOM Module";
+
+extern "C" NS_EXPORT nsresult 
+NSGetFactory(nsISupports *serviceMgr,
+			 const nsCID &aCID,
+			 const char *aClassName,
+			 const char *aProgID,
+		     nsIFactory **aResult)  
+{ 
+	if (!aResult)
+		return NS_ERROR_NULL_POINTER; 
+
+	*aResult = nsnull; 
+
+	nsISupports *inst; 
+
+	if (aCID.Equals(kCacheObjectCID)) {
+		// Ok, we know this CID and here is the factory
+		// that can manufacture the objects
+		inst = new nsCacheObjectFactory(); 
+	} else { 
+		return NS_ERROR_NO_INTERFACE; 
+	} 
+
+	if (!inst)
+		return NS_ERROR_OUT_OF_MEMORY; 
+
+	nsresult rv = inst->QueryInterface(kIFactoryIID, 
+							(void **) aResult); 
+
+	if (NS_FAILED(rv)) { 
+		delete inst; 
+	} 
+
+	return rv; 
+} 
+
+extern "C" NS_EXPORT PRBool 
+NSCanUnload(nsISupports* serviceMgr) 
+{
+	return PRBool(gInstanceCnt == 0 && gLockCnt == 0); 
+}
+
+extern "C" NS_EXPORT nsresult 
+NSRegisterSelf(nsISupports *aServMgr, const char *path)
+{
+	nsresult rv = NS_OK;
+
+	// We will use the service manager to obtain the component
+	// manager, which will enable us to register a component
+	// with a ProgID (text string) instead of just the CID.
+
+	nsIServiceManager *sm;
+
+	// We can get the IID of an interface with the static GetIID() method as
+	// well.
+	rv = aServMgr->QueryInterface(nsIServiceManager::GetIID(), (void **)&sm);
+
+	if (NS_FAILED(rv))
+		return rv;
+
+	nsIComponentManager *cm;
+
+	rv = sm->GetService(kComponentManagerCID, nsIComponentManager::GetIID(), (nsISupports **)&cm);
+
+	if (NS_FAILED(rv)) {
+		NS_RELEASE(sm);
+
+		return rv;
+	}
+
+	// Note the text string, we can access the hello component with just this
+	// string without knowing the CID
+	rv = cm->RegisterComponent(kCacheObjectCID, g_desc, "component://cacheobject",
+		path, PR_TRUE, PR_TRUE);
+
+	sm->ReleaseService(kComponentManagerCID, cm);
+
+	NS_RELEASE(sm);
+
+#ifdef NS_DEBUG
+	printf("*** %s registered\n",g_desc);
+#endif
+
+	return rv;
+}
+
+extern "C" NS_EXPORT nsresult 
+NSUnregisterSelf(nsISupports* aServMgr, const char *path)
+{
+	nsresult rv = NS_OK;
+
+	nsIServiceManager *sm;
+
+	rv = aServMgr->QueryInterface(nsIServiceManager::GetIID(), (void **)&sm);
+
+	if (NS_FAILED(rv))
+		return rv;
+
+	nsIComponentManager *cm;
+
+	rv = sm->GetService(kComponentManagerCID, nsIComponentManager::GetIID(), (nsISupports **)&cm);
+
+	if (NS_FAILED(rv)) {
+		NS_RELEASE(sm);
+
+		return rv;
+	}
+
+	rv = cm->UnregisterComponent(kCacheObjectCID, path);
+
+	sm->ReleaseService(kComponentManagerCID, cm);
+
+	NS_RELEASE(sm);
+
+	return rv;
+}
+
+

mozilla/netwerk/cache/pref/Makefile.in

@@ -0,0 +1,42 @@
+#
+# 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		= cachepref
+LIBRARY_NAME	= cachepref
+IS_COMPONENT	= 1
+
+CPPSRCS		= nsCachePref.cpp
+
+REQUIRES	= nspr
+
+LOCAL_INCLUDES	= \
+		-I$(srcdir)/../include \
+		-I$(srcdir)/../public \
+		-I$(PUBLIC)/netlib \
+		$(NULL)
+
+EXTRA_LIBS	= $(NSPR_LIBS)
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/pref/Makefile.win

@@ -0,0 +1,56 @@
+#!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=cachepref
+
+IS_COMPONENT=1
+MAKE_OBJ_TYPE=DLL
+DLLNAME=cachepref
+DLL=.\$(OBJDIR)\$(DLLNAME).dll
+
+LLIBS= $(LLIBS) \
+	$(LIBNSPR)				\
+	$(DIST)\lib\xpcom.lib	\
+	$(NULL)
+
+CPP_OBJS=                                  \
+	.\$(OBJDIR)\nsCachePref.obj     \
+	$(NULL)
+
+LOCAL_INCLUDES=	-I. \
+	  	-I..\public \
+		-I..\include \
+
+INCLUDES = $(LOCAL_INCLUDES)
+
+REQUIRES = nspr
+
+INCS = $(INCS)                  \
+        -I..\include		\
+        -I..\public 		\
+        -I$(DEPTH)\dist\include \
+        $(NULL)
+
+include <$(DEPTH)\config\rules.mak> 
+
+install:: $(DLL)
+	$(MAKE_INSTALL) $(DLL) $(DIST)\bin\components
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib
+

mozilla/netwerk/cache/pref/nsCachePref.cpp

@@ -0,0 +1,508 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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.
+ */
+
+#ifndef XP_UNIX
+#include "xp.h" // This complains on unix. Works ok without there.
+#endif
+//#include "prefapi.h"
+#include "nsIPref.h"
+#include "prmem.h"
+#include "prprf.h"
+#include "nsICacheManager.h"
+#include "plstr.h"
+#if defined(XP_PC)
+#include <direct.h>
+#endif /* XP_PC */
+#include "nspr.h"
+#include "nscore.h"
+#include "nsRepository.h"
+#include "nsIFactory.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+
+#ifdef XP_MAC
+#include "uprefd.h"
+#endif
+
+#include "nsCachePref.h"
+
+static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
+static NS_DEFINE_IID(kICachePrefIID, NS_ICACHEPREF_IID);  
+static NS_DEFINE_IID(kCachePrefCID, NS_CACHEPREF_CID);  
+static NS_DEFINE_IID(kICACHEMANAGERIID, NS_ICACHEMANAGER_IID);  
+static NS_DEFINE_IID(kCacheManagerCID, NS_CACHEMANAGER_CID);  
+static NS_DEFINE_IID(knsPrefCID, NS_PREF_CID);
+static NS_DEFINE_IID(kInsPrefIID, NS_IPREF_IID);
+
+static const PRUint32 MEM_CACHE_SIZE_DEFAULT = 1024*1024;
+static const PRUint32 DISK_CACHE_SIZE_DEFAULT = 5*MEM_CACHE_SIZE_DEFAULT;
+static const PRUint32 BKG_THREAD_SLEEP = 15*60; /*in seconds, 15 minutes */
+static const PRUint16 BUGS_FOUND_SO_FAR = 0;
+
+//Preferences
+static const char * const MEM_CACHE_PREF   = "browser.cache.memory_cache_size";
+static const char * const DISK_CACHE_PREF  = "browser.cache.disk_cache_size";
+static const char * const CACHE_DIR_PREF   = "browser.cache.directory";
+static const char * const FREQ_PREF        = "browser.cache.check_doc_frequency";
+//Not implemented as yet...
+static const char * const BKG_CLEANUP      = "browser.cache.cleanup_period"; //Default for BKG_THREAD_SLEEP	
+
+/* Find a bug in NU_CACHE, get these many chocolates */
+static const PRUint16 CHOCOLATES_PER_BUG_FOUND = 2^BUGS_FOUND_SO_FAR; 
+
+static int PR_CALLBACK Cache_PrefChangedFunc(const char *pref, void *data);
+
+static PRInt32 gInstanceCnt = 0 ;
+static PRInt32 gLockCnt = 0 ;
+
+nsCachePref::nsCachePref(void):
+    m_RefreshFreq(ONCE) ,
+    m_MemCacheSize(MEM_CACHE_SIZE_DEFAULT),
+    m_DiskCacheSize(DISK_CACHE_SIZE_DEFAULT),
+    m_DiskCacheDBFilename(new char[6+1]),
+    m_DiskCacheFolder(0),
+    m_BkgSleepTime(BKG_THREAD_SLEEP)
+{
+	nsIPref * pref=nsnull ;
+    nsresult rv = nsServiceManager::GetService(knsPrefCID,
+	                                           kInsPrefIID,
+											   (nsISupports **)&pref) ;
+
+    rv = pref->RegisterCallback("browser.cache",Cache_PrefChangedFunc,0); 
+
+	m_DiskCacheDBFilename = "nufat.db" ;
+    SetupPrefs(0);
+
+	NS_INIT_ISUPPORTS() ;
+	PR_AtomicIncrement(&gInstanceCnt) ;
+}
+
+nsCachePref::~nsCachePref()
+{
+    if (m_DiskCacheFolder)
+    {
+        delete m_DiskCacheFolder;
+        m_DiskCacheFolder = 0;
+    }
+
+	PR_AtomicDecrement(&gInstanceCnt) ;
+}
+
+//Read all the stuff from pref here. 
+NS_IMETHODIMP 
+nsCachePref::SetupPrefs(const char* i_Pref)
+{
+    PRBool bSetupAll = PR_FALSE;
+    
+    PRInt32 nTemp;
+    char* tempPref=0;
+
+    if (!i_Pref)
+        bSetupAll = PR_TRUE;
+
+	nsIPref * pref ;
+
+	nsServiceManager::GetService(knsPrefCID,
+	                                           kInsPrefIID,
+											   (nsISupports **)&pref) ;
+
+    if (bSetupAll || !PL_strcmp(i_Pref,MEM_CACHE_PREF)) 
+    {
+        if (NS_SUCCEEDED(pref->GetIntPref(MEM_CACHE_PREF,&nTemp)) ) {
+            m_MemCacheSize = 1024*nTemp;
+		}
+        else {
+            m_MemCacheSize = MEM_CACHE_SIZE_DEFAULT;
+		}
+    }
+
+    if (bSetupAll || !PL_strcmp(i_Pref,DISK_CACHE_PREF)) 
+    {
+        if (NS_SUCCEEDED(pref->GetIntPref(DISK_CACHE_PREF,&nTemp)))
+            m_DiskCacheSize = 1024*nTemp;
+        else
+            m_DiskCacheSize = DISK_CACHE_SIZE_DEFAULT;
+    }
+
+    if (bSetupAll || !PL_strcmp(i_Pref,FREQ_PREF)) 
+    {
+        if (NS_SUCCEEDED(pref->GetIntPref(FREQ_PREF,&nTemp)))
+        {
+            m_RefreshFreq = (nsCachePref::Refresh)nTemp;
+        }
+        else
+            m_RefreshFreq = ONCE;
+    }
+
+    if (bSetupAll || !PL_strcmp(i_Pref,CACHE_DIR_PREF)) 
+    {
+		/* the CopyPathPref is not in nsIPref, is CopyCharPref ok? -xyz */
+
+		nsresult rv = pref->CopyCharPref(CACHE_DIR_PREF,&tempPref) ;
+
+	    if (NS_SUCCEEDED(rv))
+        {
+            PR_ASSERT(tempPref);
+
+            delete [] m_DiskCacheFolder;
+			m_DiskCacheFolder =  new char[PL_strlen(tempPref)+2];
+	        if (!m_DiskCacheFolder)
+	        {
+	            if (tempPref)
+	                PR_Free(tempPref);
+	            return NS_OK ;
+	        }
+            PL_strcpy(m_DiskCacheFolder, tempPref);
+	    }
+        else //TODO set to temp folder
+        {
+#if defined(XP_PC)
+            char tmpBuf[_MAX_PATH];
+            PRFileInfo dir;
+            PRStatus status;
+            char *cacheDir = new char [_MAX_PATH];
+            if (!cacheDir)
+                return NS_OK;
+            cacheDir = _getcwd(cacheDir, _MAX_PATH);
+
+            // setup the cache dir.
+            PL_strcpy(tmpBuf, cacheDir);
+            sprintf(cacheDir,"%s%s%s%s", tmpBuf, "\\", "cache", "\\");
+            status = PR_GetFileInfo(cacheDir, &dir);
+            if (PR_FAILURE == status) {
+                // Create the dir.
+                status = PR_MkDir(cacheDir, 0600);
+                if (PR_SUCCESS != status) {
+                    m_DiskCacheFolder = new char[1];
+					*m_DiskCacheFolder = '\0';
+                    return NS_OK;
+                }
+            }
+            m_DiskCacheFolder = cacheDir;
+#endif /* XP_PC */
+
+			delete [] m_DiskCacheFolder;
+			m_DiskCacheFolder = new char[5] ;
+			PL_strcpy(m_DiskCacheFolder,  "/tmp") ;
+        }
+
+    }
+
+    if (tempPref)
+        PR_Free(tempPref);
+
+	return NS_OK ;
+}
+
+NS_IMETHODIMP
+nsCachePref::GetBkgSleepTime(PRUint32* o_time)
+{
+    *o_time = BKG_THREAD_SLEEP; 
+	return NS_OK ;
+}
+
+NS_IMETHODIMP 
+nsCachePref::GetDiskCacheDBFilename(char** o_name)
+{
+    *o_name = "nufat.db";
+	return NS_OK ;
+}
+
+nsICachePref* 
+nsCachePref::GetInstance()
+{
+    nsICacheManager * cachemanager ;
+	nsICachePref * cachepref ;
+
+	nsresult rv = nsServiceManager::GetService(kCacheManagerCID,
+	                                           kICACHEMANAGERIID,
+											   (nsISupports **) &cachemanager) ;
+
+    rv = cachemanager->GetPrefs(&cachepref);
+	return cachepref ;
+}
+
+/*
+nsrefcnt nsCachePref::AddRef(void)
+{
+    return ++m_RefCnt;
+}
+nsrefcnt nsCachePref::Release(void)
+{
+    if (--m_RefCnt == 0)
+    {
+        delete this;
+        return 0;
+    }
+    return m_RefCnt;
+}
+
+nsresult nsCachePref::QueryInterface(const nsIID& aIID,
+                                        void** aInstancePtrResult)
+{
+    return NS_OK;
+}
+*/
+
+NS_IMPL_ISUPPORTS(nsCachePref, nsCOMTypeInfo<nsICachePref>::GetIID() ) ;
+
+int PR_CALLBACK Cache_PrefChangedFunc(const char *pref, void *data) {
+    
+    // nsCachePref::GetInstance()->SetupPrefs(pref);
+	nsICachePref* cachepref ;
+
+	nsresult rv = nsServiceManager::GetService(kCachePrefCID,
+	                                           kICachePrefIID,
+											   (nsISupports **)&cachepref) ;
+
+	if (NS_FAILED(rv))
+	  return PR_FALSE ;
+	else 
+	{
+	  cachepref->SetupPrefs(pref) ;
+	  return PR_TRUE;
+	}
+} 
+
+
+/////////////////////////////////////////////////////////////////////
+// Exported functions. With these in place we can compile
+// this module into a dynamically loaded and registered
+// component.
+
+//static NS_DEFINE_CID(kCacheObjectCID, NS_CACHEOBJECT_CID);
+/*
+#include "nsIFactory.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nspr.h"
+#include "nscore.h"
+#include "nsRepository.h"
+#include "nsICacheManager.h"
+
+#include "nsICachePref.h"
+#include "nsCachePref.h"
+*/
+
+// static NS_DEFINE_IID(kICachePrefIID, NS_ICACHEPREF_IID);  
+//static NS_DEFINE_IID(kCachePrefCID, NS_CACHEPREF_CID);  
+static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID);
+// static NS_DEFINE_IID(kICACHEMANAGERIID, NS_ICACHEMANAGER_IID);  
+static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
+
+
+// The "name" of our component
+static const char* g_desc = "Cache Prefrence XPCOM Module";
+
+nsCachePrefFactory::nsCachePrefFactory ()
+{
+	NS_INIT_ISUPPORTS();
+	PR_AtomicIncrement(&gInstanceCnt);
+}
+
+nsCachePrefFactory::~nsCachePrefFactory ()
+{
+	PR_AtomicDecrement(&gInstanceCnt);
+}
+
+/*
+NS_IMETHODIMP 
+nsCacheObjectFactory::QueryInterface(const nsIID &aIID, void **aResult)
+{
+	if (!aResult)
+		return NS_ERROR_NULL_POINTER;
+
+	if (aIID.Equals(kISupportsIID)) {
+		*aResult = NS_STATIC_CAST(nsISupports*,this);
+	} else if (aIID.Equals(kIFactoryIID)) {
+		*aResult = NS_STATIC_CAST(nsISupports*,NS_STATIC_CAST(nsIFactory*,this));
+	} else {
+		*aResult = nsnull;
+		return NS_ERROR_NO_INTERFACE;
+	}
+
+	NS_ADDREF(NS_REINTERPRET_CAST(nsISupports*,*aResult));
+
+	return NS_OK;
+}
+
+NS_IMPL_ADDREF(nsCacheObjectFactory)
+NS_IMPL_RELEASE(nsCacheObjectFactory)
+*/
+
+NS_IMPL_ISUPPORTS(nsCachePrefFactory, kIFactoryIID) ;
+
+NS_IMETHODIMP
+nsCachePrefFactory::CreateInstance(nsISupports *aOuter, 
+                                const nsIID &aIID, 
+                                void **aResult) 
+{ 
+	if (!aResult)
+		return NS_ERROR_NULL_POINTER; 
+
+	*aResult = nsnull; 
+
+	nsISupports *inst = new nsCachePref(); 
+
+	if (!inst) { 
+		return NS_ERROR_OUT_OF_MEMORY; 
+	} 
+
+	// All XPCOM methods return nsresult
+	nsresult rv = inst->QueryInterface(aIID, aResult); 
+
+	// There are handy macros, NS_SUCCEEDED and NS_FAILED
+	// to test the return value of an XPCOM method.
+	if (NS_FAILED(rv)) { 
+		// We didn't get the right interface, so clean up 
+		delete inst; 
+	} 
+
+	return rv; 
+} 
+
+NS_IMETHODIMP
+nsCachePrefFactory::LockFactory(PRBool aLock) 
+{ 
+	if (aLock) { 
+		PR_AtomicIncrement(&gLockCnt); 
+	} else { 
+		PR_AtomicDecrement(&gLockCnt); 
+	} 
+
+	return NS_OK;
+}
+
+extern "C" NS_EXPORT nsresult 
+NSGetFactory(nsISupports *serviceMgr,
+			 const nsCID &aCID,
+			 const char *aClassName,
+			 const char *aProgID,
+		     nsIFactory **aResult)  
+{ 
+	if (!aResult)
+		return NS_ERROR_NULL_POINTER; 
+
+	*aResult = nsnull; 
+
+	nsISupports *inst; 
+
+	if (aCID.Equals(kCachePrefCID)) {
+		// Ok, we know this CID and here is the factory
+		// that can manufacture the objects
+		inst = new nsCachePrefFactory(); 
+	} else { 
+		return NS_ERROR_NO_INTERFACE; 
+	} 
+
+	if (!inst)
+		return NS_ERROR_OUT_OF_MEMORY; 
+
+	nsresult rv = inst->QueryInterface(kIFactoryIID, 
+							(void **) aResult); 
+
+	if (NS_FAILED(rv)) { 
+		delete inst; 
+	} 
+
+	return rv; 
+} 
+
+extern "C" NS_EXPORT PRBool 
+NSCanUnload(nsISupports* serviceMgr) 
+{
+	return PRBool(gInstanceCnt == 0 && gLockCnt == 0); 
+}
+
+extern "C" NS_EXPORT nsresult 
+NSRegisterSelf(nsISupports *aServMgr, const char *path)
+{
+	nsresult rv = NS_OK;
+
+	// We will use the service manager to obtain the component
+	// manager, which will enable us to register a component
+	// with a ProgID (text string) instead of just the CID.
+
+	nsIServiceManager *sm;
+
+	// We can get the IID of an interface with the static GetIID() method as
+	// well.
+	rv = aServMgr->QueryInterface(nsIServiceManager::GetIID(), (void **)&sm);
+
+	if (NS_FAILED(rv))
+		return rv;
+
+	nsIComponentManager *cm;
+
+	rv = sm->GetService(kComponentManagerCID, nsIComponentManager::GetIID(), (nsISupports **)&cm);
+
+	if (NS_FAILED(rv)) {
+		NS_RELEASE(sm);
+
+		return rv;
+	}
+
+	// Note the text string, we can access the hello component with just this
+	// string without knowing the CID
+	rv = cm->RegisterComponent(kCachePrefCID, g_desc, "component://cachePref",
+		path, PR_TRUE, PR_TRUE);
+
+	sm->ReleaseService(kComponentManagerCID, cm);
+
+	NS_RELEASE(sm);
+
+#ifdef NS_DEBUG
+	printf("*** %s registered\n",g_desc);
+#endif
+
+	return rv;
+}
+
+extern "C" NS_EXPORT nsresult 
+NSUnregisterSelf(nsISupports* aServMgr, const char *path)
+{
+	nsresult rv = NS_OK;
+
+	nsIServiceManager *sm;
+
+	rv = aServMgr->QueryInterface(nsIServiceManager::GetIID(), (void **)&sm);
+
+	if (NS_FAILED(rv))
+		return rv;
+
+	nsIComponentManager *cm;
+
+	rv = sm->GetService(kComponentManagerCID, nsIComponentManager::GetIID(), (nsISupports **)&cm);
+
+	if (NS_FAILED(rv)) {
+		NS_RELEASE(sm);
+
+		return rv;
+	}
+
+	rv = cm->UnregisterComponent(kCachePrefCID, path);
+
+	sm->ReleaseService(kComponentManagerCID, cm);
+
+	NS_RELEASE(sm);
+
+	return rv;
+}
+
+
+

mozilla/netwerk/cache/public/Makefile.in

@@ -19,49 +19,21 @@
 # Contributor(s): 
 #
 
-DEPTH		= ../..
+DEPTH		= ../../..
 topsrcdir	= @top_srcdir@
 srcdir		= @srcdir@
 VPATH		= @srcdir@
 
 include $(DEPTH)/config/autoconf.mk
 
-DIRS		= xpwidgets support
+EXPORTS		= \
+		nsICacheManager.h \
+		nsICacheObject.h \
+		nsICachePref.h \
+		nsICacheModule.h \
+		$(NULL)
 
-#
-# Dont build the DSO under the 'build' directory as windows does.
-#
-# The DSOs get built in the toolkit dir itself.  Do this so that 
-# multiple implementations of widget can be built on the same
-# source tree.
-#
-ifndef MOZ_MONOLITHIC_TOOLKIT
-
-ifdef MOZ_ENABLE_GTK
-DIRS		+= gtksuperwin
-DIRS		+= gtk
-endif
-
-ifdef MOZ_ENABLE_MOTIF
-DIRS		+= motif
-endif
-
-ifdef MOZ_ENABLE_XLIB
-DIRS		+= xlib
-endif
-
-ifdef MOZ_ENABLE_QT
-DIRS		+= qt
-endif
-
-else
-DIRS		+= $(MOZ_WIDGET_TOOLKIT)
-endif
-
-# unix_services are only useful in unix, duh...
-ifeq (,$(filter beos os2 rhapsody photon,$(MOZ_WIDGET_TOOLKIT)))
-DIRS		+= unix_services
-endif
+EXPORTS		:= $(addprefix $(srcdir)/, $(EXPORTS))
 
 include $(topsrcdir)/config/rules.mk
 

mozilla/netwerk/cache/public/Makefile.win

@@ -0,0 +1,41 @@
+#!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): 
+
+MODULE = netcache
+
+DEPTH = ..\..\..
+include <$(DEPTH)/config/config.mak>
+
+
+EXPORTS =                   \
+        $(NULL)
+
+XPIDLSRCS =                             \
+        .\nsICachedNetData.idl          \
+        .\nsINetDataCacheManager.idl    \
+        .\nsINetDataCache.idl           \
+        .\nsINetDataCacheRecord.idl     \
+        .\nsINetDataDiskCache.idl       \
+        .\nsIStreamAsFile.idl           \
+        $(NULL)
+
+include <$(DEPTH)/config/rules.mak>
+

mozilla/netwerk/cache/public/nsICacheManager.h

@@ -0,0 +1,57 @@
+#ifndef _nsICacheManger_H_
+#define _nsICacheManger_H_
+
+#include "nsISupports.h"
+#include "nsICacheModule.h"
+#include "nsICachePref.h"
+
+// nsICacheManager {05A4BC00-3E1A-11d3-87EE-000629D01344}
+#define NS_ICACHEMANAGER_IID \
+{0x5a4bc00, 0x3e1a, 0x11d3, \
+ {0x87, 0xee, 0x0, 0x6, 0x29, 0xd0, 0x13, 0x44}}
+
+// {B8B5D4E0-3F92-11d3-87EF-000629D01344}
+#define NS_CACHEMANAGER_CID \
+ {0xb8b5d4e0, 0x3f92, 0x11d3, \
+  {0x87, 0xef, 0x0, 0x6, 0x29, 0xd0, 0x13, 0x44}}
+
+class nsICacheManager : public nsISupports
+{
+  public:
+	
+    //Reserved modules
+    enum modules
+    {
+       MEM =0,
+       DISK=1
+    };
+
+    NS_DEFINE_STATIC_IID_ACCESSOR(NS_ICACHEMANAGER_IID) ;
+
+    NS_IMETHOD Contains(const char* i_url) const = 0 ;
+
+    NS_IMETHOD Entries(PRInt16 * n_Entries) const  = 0 ;
+
+    NS_IMETHOD GetObj(const char* i_url, void ** o_Object) const = 0 ;    
+
+    NS_IMETHOD GetModule(PRInt16 i_index, nsICacheModule** o_module) const = 0 ;
+    NS_IMETHOD GetDiskModule(nsICacheModule** o_module) const = 0 ;
+    NS_IMETHOD GetMemModule(nsICacheModule** o_module) const = 0 ;
+
+    NS_IMETHOD AddModule (PRInt16 * o_Index, nsICacheModule * pModule) = 0 ;
+
+    NS_IMETHOD GetPrefs(nsICachePref** o_Pref) const = 0 ;
+
+    NS_IMETHOD InfoAsHTML(char** o_Buffer) const = 0 ;
+
+    NS_IMETHOD IsOffline(PRBool * bOffline) const = 0 ;
+
+    NS_IMETHOD Offline(PRBool bSet) = 0 ;
+
+    NS_IMETHOD Remove(const char* i_url) = 0 ;
+
+    NS_IMETHOD WorstCaseTime(PRUint32 * o_Time) const = 0 ;
+
+} ;
+
+#endif

mozilla/netwerk/cache/public/nsICacheModule.h

@@ -0,0 +1,112 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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): 
+ */
+
+/* 
+ * nsCacheModule. A class that defines the way a cache module 
+ * should be written. Its the super class for any new modules. 
+ * Two sample modules derived from this one are nsMemModule and nsDiskModule.
+ *
+ * Gagan Saksena 02/03/98
+ * 
+ */
+
+#ifndef nsICacheModule_h__
+#define nsICacheModule_h__
+
+#include <nsISupports.h>
+#include "nsICacheObject.h"
+#include "nsEnumeration.h"
+
+// {5D51B24F-E6C2-11d1-AFE5-006097BFC036}
+#define NS_ICACHEMODULE_IID \
+{ 0x5d51b24f, 0xe6c2, 0x11d1, \
+{ 0xaf, 0xe5, 0x0, 0x60, 0x97, 0xbf, 0xc0, 0x36 } };
+
+
+class nsICacheModule : public nsISupports 
+{
+
+public:
+    NS_DEFINE_STATIC_IID_ACCESSOR (NS_ICACHEMODULE_IID);
+
+
+    NS_IMETHOD  AddObject(nsICacheObject* i_pObject) = 0;
+    
+    NS_IMETHOD  ContainsURL(const char* i_url, PRBool* o_bContain) = 0;
+
+    NS_IMETHOD  ContainsCacheObj(nsICacheObject* i_pObject, PRBool* o_bContain) = 0;
+    
+    NS_IMETHOD  Enable (PRBool i_bEnable) = 0;
+    
+    NS_IMETHOD  GetNumOfEntries (PRUint32* o_nEntries) = 0;
+
+    NS_IMETHOD  GetEnumerator (nsEnumeration** o_enum) = 0;
+    /* Enumerations with a function pointer - TODO */
+
+    //TODO move to own interface for both Garbage Collection and Revalidation
+    NS_IMETHOD  GarbageCollect (void) = 0;
+
+    NS_IMETHOD  GetObjectByURL (const char* i_url, nsICacheObject** o_pObj) = 0;
+
+    NS_IMETHOD  GetObjectByIndex (const PRUint32 i_index, nsICacheObject** o_pObj) = 0;
+
+    NS_IMETHOD  GetStreamFor (const nsICacheObject* i_pObject, nsStream** o_pStream) = 0;
+
+    NS_IMETHOD  IsEnabled (PRBool* o_bEnabled) = 0;
+
+    /* Can't do additions, deletions, validations, expirations */
+    NS_IMETHOD  IsReadOnly (PRBool* o_bReadOnly) = 0; 
+
+    NS_IMETHOD  GetNextModule (nsICacheModule** o_pCacheModule) = 0;
+    NS_IMETHOD  SetNextModule (nsICacheModule* i_pCacheModule) = 0;
+
+    NS_IMETHOD  RemoveByURL (const char* i_url) = 0;
+
+    NS_IMETHOD  RemoveByIndex (const PRUint32 i_index) = 0;
+
+    NS_IMETHOD  RemoveByObject (nsICacheObject* i_pObject) = 0;
+
+    NS_IMETHOD  RemoveAll (void) = 0;
+
+    NS_IMETHOD  Revalidate (void) = 0;
+
+    NS_IMETHOD	ReduceSizeTo (const PRUint32 i_newsize) = 0;
+
+    NS_IMETHOD  GetSize (PRUint32* o_size) = 0;
+
+    NS_IMETHOD  SetSize (const PRUint32 i_size) = 0;
+
+    NS_IMETHOD  GetSizeInUse (PRUint32* o_size) = 0;
+
+};
+
+// {5D51B24E-E6C1-11d0-AFE5-006097BFC036}
+#define NS_DISKMODULE_CID \
+{ 0x5d51b24e, 0xe6c1, 0x11d0, \
+{ 0xaf, 0xe5, 0x0, 0x60, 0x97, 0xbf, 0xc0, 0x36 } };
+
+// {5D51B250-E6C2-11d1-AFE5-006097BFC036}
+#define NS_MEMMODULE_CID \
+{ 0x5d51b250, 0xe6c2, 0x11d1, \
+{ 0xaf, 0xe5, 0x0, 0x60, 0x97, 0xbf, 0xc0, 0x36 } };
+
+#endif

mozilla/netwerk/cache/public/nsICacheObject.h

@@ -0,0 +1,106 @@
+#ifndef _NS_CACHEOBJECT_H_
+#define _NS_CACHEOBJECT_H_
+
+#include "nsISupports.h"
+#include "nsStream.h"
+
+#include "prtypes.h"
+#include "prinrval.h"
+
+// nsICacheObject {A2D9A8A0-414B-11d3-87EF-000629D01344}
+#define NS_ICACHEOBJECT_IID \
+ {0xa2d9a8a0, 0x414b, 0x11d3, \
+  {0x87, 0xef, 0x0, 0x6, 0x29, 0xd0, 0x13, 0x44 }}
+
+// nsCacheObject {A2D9A8A1-414B-11d3-87EF-000629D01344}
+#define NS_CACHEOBJECT_CID \
+ {0xa2d9a8a1, 0x414b, 0x11d3, \
+  {0x87, 0xef, 0x0, 0x6, 0x29, 0xd0, 0x13, 0x44 }}
+
+
+class nsICacheObject :public nsISupports
+{
+  public:
+
+  NS_DEFINE_STATIC_IID_ACCESSOR(NS_ICACHEOBJECT_IID);
+
+  /* Cache Object- check nsCacheObject.h for details on these functions */
+
+  /* This is added because we need to initialize a new cacheobject 
+  NS_IMETHOD InitUrl(const char * i_url) = 0 ;
+  */
+
+  NS_IMETHOD GetAddress(char ** Addr) const = 0 ;
+  NS_IMETHOD SetAddress(const char* i_Address) = 0 ;
+
+  NS_IMETHOD GetCharset(char ** CSet) const = 0 ;
+  NS_IMETHOD SetCharset(const char* i_CharSet) = 0 ;
+
+  NS_IMETHOD GetContentEncoding(char ** Encoding) const = 0 ;
+  NS_IMETHOD SetContentEncoding(const char* i_Encoding) = 0 ;
+
+  NS_IMETHOD GetContentLength(PRUint32 * CLeng) const = 0 ;
+  NS_IMETHOD SetContentLength(PRUint32 i_Len) = 0 ;
+
+  NS_IMETHOD GetContentType(char ** CType) const = 0 ;
+  NS_IMETHOD SetContentType(const char* i_Type) = 0 ;
+
+  NS_IMETHOD GetEtag(char ** Etag) const = 0 ;
+  NS_IMETHOD SetEtag(const char* i_Etag) = 0 ;
+
+  NS_IMETHOD GetExpires(PRIntervalTime * iTime) const = 0 ;
+  NS_IMETHOD SetExpires(const PRIntervalTime i_Time) = 0 ;
+
+  NS_IMETHOD GetFilename(char ** Filename) const = 0 ;
+  NS_IMETHOD SetFilename(const char* i_Filename) = 0 ;
+
+  NS_IMETHOD GetIsCompleted(PRBool * bComplete) const = 0 ;
+  NS_IMETHOD SetIsCompleted(PRBool bComplete) = 0 ;
+
+  NS_IMETHOD GetLastAccessed(PRIntervalTime * iTime) const = 0 ;
+  NS_IMETHOD SetLastModified(const PRIntervalTime i_Time) = 0 ;
+
+  NS_IMETHOD GetLastModified(PRIntervalTime * iTime) const = 0 ;
+
+  NS_IMETHOD GetModuleIndex(PRInt16 * m_index) const = 0 ;
+  NS_IMETHOD SetModuleIndex(const PRUint16 m_index) = 0 ;
+
+  NS_IMETHOD GetPageServicesURL(char ** o_url) const = 0 ;
+  NS_IMETHOD SetPageServicesURL(const char* i_Url) = 0 ;
+
+  NS_IMETHOD GetPostData(char ** pData) const = 0 ;
+  NS_IMETHOD SetPostData(const char* i_PostData, const PRUint32 i_Len) = 0 ;
+
+  NS_IMETHOD GetPostDataLen(PRUint32 * dLeng) const = 0 ;
+
+  NS_IMETHOD GetSize(PRUint32 * pSize) const = 0 ;
+  NS_IMETHOD SetSize(const PRUint32 i_Size) = 0 ;
+
+  NS_IMETHOD GetState(PRUint32 * pState) const = 0 ;
+  NS_IMETHOD SetState(const PRUint32 i_State) = 0 ;
+
+  NS_IMETHOD GetStream(nsStream ** pStream) const = 0 ;
+//  NS_IMETHOD MakeStream(void) = 0 ;
+
+  NS_IMETHOD Hits(PRUint32 * pHits) const = 0 ;
+
+  NS_IMETHOD IsExpired(PRBool * bGet) const = 0 ;
+
+  NS_IMETHOD IsPartial(PRBool * bGet) const = 0;
+
+  NS_IMETHOD Read(char* o_Destination, PRUint32 i_Len, PRUint32 * pLeng) = 0 ;
+
+  NS_IMETHOD Reset(void) = 0 ;
+
+  NS_IMETHOD Write(const char* i_buffer, const PRUint32 i_length, 
+                                                      PRUint32 * oLeng) = 0 ;
+
+  /* Read and write info about this cache object */
+  NS_IMETHOD GetInfo(void** o_info)=0 ;
+  NS_IMETHOD SetInfo(void* i_info /*, PRUint32 len */)=0;
+
+  NS_IMETHOD GetInfoSize(PRUint32* o_size)=0 ;
+
+} ;
+
+#endif // _NSICACHEOBJECT_H_

mozilla/netwerk/cache/public/nsICachePref.h

@@ -0,0 +1,94 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * 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): 
+ */
+
+/* nsICachePref. A class to separate the preference related code to 
+ * one place. This is an incomplete implementation, I need to access
+ * the libprefs directly, but that would add another dependency. And 
+ * libpref comes with a JS dependency... so holding this off for the 
+ * moment. 
+ * 
+ * -Gagan Saksena 09/15/98
+ */
+#ifndef nsICachePref_h__
+#define nsICachePref_h__
+
+#include "nsISupports.h"
+#include "prtypes.h"
+#include "prlog.h"
+
+
+// {7C3ED031-45E4-11d3-9B7F-0004ACB74CEC}
+#define NS_ICACHEPREF_IID \
+{ 0x7c3ed031, 0x45e4, 0x11d3, \
+{ 0x9b, 0x7f, 0x0, 0x4, 0xac, 0xb7, 0x4c, 0xec } };
+
+// myCachePrefCID {99E9C911-46D9-11d3-87EF-000629D01344}
+#define NS_CACHEPREF_CID \
+{ 0x99e9c911, 0x46d9, 0x11d3, \
+{ 0x87, 0xef, 0x0, 0x6, 0x29, 0xd0, 0x13, 0x44}} ;
+
+class nsICachePref : public nsISupports
+{
+public:
+    NS_DEFINE_STATIC_IID_ACCESSOR (NS_ICACHEPREF_IID);
+
+    //  Was "static nsCachePref* GetInstance(void)"
+    //  Do I need this GetInstance??????
+//    NS_IMETHOD	GetInstance(nsICachePref** o_pICachePref ) = 0;
+
+    enum Refresh 
+    {
+        ONCE,
+        ALWAYS,
+        NEVER
+    };
+
+    NS_IMETHOD	GetBkgSleepTime (PRUint32* o_time) = 0;
+    
+    NS_IMETHOD	GetDiskCacheDBFilename (char** o_name) = 0; /* like Fat.db */
+
+    NS_IMETHOD	GetDiskCacheFolder (char** o_folder) = 0;   /* Cache dir */
+
+    NS_IMETHOD	GetDiskCacheSSL (PRBool* o_bSet) = 0;
+
+    NS_IMETHOD	SetDiskCacheSSL (PRBool i_bSet) = 0;
+
+    NS_IMETHOD	GetDiskCacheSize (PRUint32* o_size) = 0;
+    NS_IMETHOD	SetDiskCacheSize (const PRUint32 i_size) = 0;
+
+    NS_IMETHOD	GetMemCacheSize (PRUint32 * o_size) = 0;
+    NS_IMETHOD	SetMemCacheSize (const PRUint32 i_size) = 0;
+
+    NS_IMETHOD	GetFrequency (nsICachePref::Refresh* o_frequency) = 0;
+
+    /* Revalidating in background, makes IMS calls in the bkg thread to 
+       update cache entries. TODO, this should be at a bigger time period
+       than the cache cleanup routine */
+    NS_IMETHOD	RevalidateInBkg (PRBool* i_bRevalidateInBkg) = 0;
+
+    /* Setup all prefs */
+    NS_IMETHOD	SetupPrefs(const char* i_Pref) = 0;
+
+};
+
+#endif // nsICachePref_h__
+

mozilla/netwerk/cache/public/nsICachedNetData.idl

@@ -0,0 +1,205 @@
+/* -*- 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.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): 
+ */
+
+#include "nsrootidl.idl"
+#include "nsISupports.idl"
+
+interface nsIFileSpec;
+interface nsIURI;
+interface nsIObserver;
+interface nsIChannel;
+interface nsINetDataCache;
+interface nsINetDataCacheRecord;
+interface nsILoadGroup;
+interface nsIStreamListener;
+
+/**
+ * The nsICachedNetData interface represents a single entry in a database that
+ * caches data retrieved from the network. This interface is implemented by the
+ * cache manager on top of the low-level nsINetDataCacheRecord and
+ * nsINetDataCache interfaces that are implemented by the database.
+ *
+ * Each cache record may contain both content and metadata.  The content may
+ * be, for example, GIF image data or HTML, and it is accessed through
+ * nsIChannel's streaming API.  The opaque metadata, which may contain HTTP
+ * headers among other things, is stored as a byte array.  Each entry in the
+ * cache is indexed by two different keys: a record id number and a key created
+ * by combining the URI with a "secondary key", e.g. HTTP post data.
+ *
+ * @See nsINetDataCacheRecord
+ * @See nsINetDataCache
+ * @See nsINetDataDiskCache
+ * @See nsINetDataCacheManager
+ */
+[scriptable, uuid(6aeb2a40-6d43-11d3-90c8-000064657374)]
+interface nsICachedNetData : nsISupports
+{
+    /**
+     * String form of the URI provided as an argument to the call to
+     * nsINetDataCacheManager::GetCachedNetData() that created this record.
+     */
+    readonly attribute string uriSpec;
+    
+    /**
+     * Getter for the opaque secondary database key provided as an argument to
+     * the call to nsINetDataCacheManager::GetCachedNetData() that created this
+     * record.
+     */
+    void getSecondaryKey(out unsigned long length,
+                         [retval, size_is(length)] out string secondaryKey);
+
+    /**
+     * This flag may be set by a protocol handler to indicate that it supports
+     * partial fetching of data.  In that case, the cache manager is permitted
+     * to truncate the entry's content to accommodate incoming data for other
+     * cache entries rather than deleting it wholesale.
+     */
+    attribute boolean allowPartial;
+    
+    /**
+     * This flag indicates that the write stream supplying content data for the
+     * cache did not complete normally and, therefore, the content may be
+     * truncated.
+     */
+    readonly attribute boolean partial;
+
+    /**
+     * This flag can be set and cleared by a protocol handler as a form of
+     * self-notification, so as to avoid race conditions in which a protocol
+     * handler issues two identical network requests to fill the same cache
+     * entry.  The cache manager itself largely ignores this flag.
+     */
+    attribute boolean updateInProgress;
+
+    /**
+     * Date/time that the document was last stored on the origin server, as
+     * supplied by the protocol handler.  This value is used as input to the
+     * cache replacement policy, i.e. it is not used for validation.  If the
+     * protocol can't supply a last-modified time, this attribute should remain
+     * unset.  When unset, the value of this attribute is zero.
+     *
+     * FIXME: Should use nsIDateTime interface, once it's created
+     * instead of PRTime, for improved scriptability ? 
+     */
+    attribute PRTime lastModifiedTime;
+
+    /**
+     * Supplied by the protocol handler, the expirationTime attribute specifies
+     * the time until which the document is guaranteed fresh, i.e. the document
+     * does not have to be validated with the server and, therefore, any data
+     * in cache is definitely usable.  The value of this attribute serves as a
+     * hint to the cache replacement policy.  Only one of either staleTime or
+     * expirationTime may be set for a single cache record.  When unset, the
+     * value of this attribute is zero. 
+     */
+    attribute PRTime expirationTime;
+
+    /**
+     * Date/time supplied by the protocol handler, at which point the content
+     * is *likely* to be stale, i.e. the data in the cache may be out-of-date
+     * with respect to the data on the server.  This heuristic date does not
+     * necessarily correspond to the HTTP Expires header, as it does not
+     * determine when cached network data must be validated with the origin
+     * server, but only serves as a hint to the cache replacement policy.  Only
+     * one of either staleTime or expirationTime may be set for a single cache
+     * record.  When unset, the value of this attribute is zero.
+     */
+    attribute PRTime staleTime;
+
+    /**
+     * Date/time of last access of the data in this cache record, as determined
+     * by the cache manager.
+     */
+    readonly attribute PRTime lastAccessTime;
+
+    /**
+     * Number of times this record has been accessed since it was first stored.
+     */
+    readonly attribute PRUint16 numberAccesses;
+
+    /**
+     * Accessors for opaque protocol-specific meta-data which can be updated by
+     * the protocol handler for each cache entry, independently of the content
+     * data.
+     */
+    void getProtocolPrivate(out PRUint32 length, [size_is(length), retval] out string data);
+    void setProtocolPrivate(in  PRUint32 length, [size_is(length)] in string data);
+
+    /**
+     * As a getter, return the number of content bytes stored in the cache,
+     * i.e. via the nsIChannel streaming APIs.  This may be less than the
+     * complete content length if a partial cache fill occurred.  The cached
+     * content can be truncated by setting the value of this attribute.  The
+     * value of the attribute represents a logical, not a physical, length.  If
+     * compression has been used, the content may consume less storage than
+     * indicated by this attribute.
+     *
+     * When this attribute is set to zero the associated cache disk file, if
+     * any, should be deleted.
+     */
+    attribute PRUint32 storedContentLength;
+
+    /** 
+     * Notify any observers associated with this cache entry of the deletion
+     * request.  If all observers drop their reference to the cache entry,
+     * proceed to delete the underlying cache database record and associated
+     * content storage.
+     */
+    void delete();
+
+    /**
+     * Flush any changes in this entry's data to the cache database.  This
+     * method will automatically be called when the last reference to the cache
+     * is dropped, but it can also be called explicitly for a synchronous
+     * effect.
+     */
+    void commit();
+
+    /**
+     * Parent container cache for this entry.
+     */
+    readonly attribute nsINetDataCache cache;
+
+    /**
+     * Create a channel for reading or writing a stream of content into the
+     * entry.  It is expected that many of the nsIChannel methods return
+     * NS_NOT_IMPLEMENTED, including:
+     *
+     *    + GetURI()
+     *    + GetContentType()
+     *    + GetContentLength()
+     *
+     * Though nsIChannel provides for both async and synchronous I/O APIs, both
+     * may not be implemented.  Only AsyncRead() and OpenOutputStream() is
+     * required.
+     */
+    nsIChannel newChannel(in nsILoadGroup loadGroup);
+
+    /**
+     * This method can be used by a caching protocol handler to store data in
+     * the cache by forking an asynchronous read stream so that it is
+     * simultaneously sent to a requester and written into the cache.  This
+     * method implicitly sets the updateInProgress flag, if it has not already
+     * been set.
+     */
+    nsIStreamListener interceptAsyncRead(in nsIStreamListener aOriginalListener);
+};

mozilla/netwerk/cache/public/nsINetDataCache.idl

@@ -0,0 +1,148 @@
+/* -*- 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.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): 
+ */
+
+#include "nsISupports.idl"
+
+interface nsIURI;
+interface nsINetDataCacheRecord;
+interface nsISimpleEnumerator;
+interface nsIFileSpec;
+
+/**
+ * The nsINetDataCache defines the low-level API for a network-data
+ * cache, used to cache the responses to network retrieval commands.
+ * This interface, along with nsINetDataCacheRecord, is implemented by
+ * the memory cache, the file cache and, optionally, by some extension
+ * caches.  This interface is essentially a pseudo-private API for the
+ * cache manager.  Other clients should never use this interface.
+ *
+ * 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 a key created by combining the URI
+ * with a "secondary key", e.g. HTTP post data.
+ *
+ * The nsINetDataCache interface is agnostic as to where the data is
+ * stored and whether the storage is volatile or persistent.  The
+ * memory cache, any disk caches and any extension caches must all
+ * implement this interface.
+ *
+ */
+[scriptable, uuid(ccfc58c0-6dde-11d3-90c8-000064657374)]
+interface nsINetDataCache : nsISupports
+{
+	/**
+	 * Human-readable description of the cache module, e.g. "Disk Cache"
+	 */
+	readonly attribute wstring description;
+  
+    /**
+     * Returns true if cached data is available for the given opaque key,
+     * even if only partial data is stored.
+     */
+    boolean contains([size_is(length)] in string key, in PRUint32 length);
+
+    /**
+     * Fetch the cache entry record for the given opaque key.  If one does not
+     * exist, create a new, empty record.
+     */
+    nsINetDataCacheRecord getCachedNetData([size_is(length)] in string key,
+                                           in PRUint32 length);
+
+    /**
+     * Fetch the cache entry record for the given URI using the record ID as a key.
+     */
+    nsINetDataCacheRecord getCachedNetDataByID(in PRInt32 RecordID);
+
+	/**
+	 * False indicates that this cache is entirely bypassed.
+	 */
+    attribute boolean enabled;
+
+    /**
+     * Constants for flags attribute, below
+     */
+
+    // Used for extension caches, e.g. a CD-ROM cache
+    const long READ_ONLY          = 1 << 0;
+
+    // One of these bits must be set
+    const long MEMORY_CACHE       = 1 << 1;
+    const long FLAT_FILE_CACHE    = 1 << 2;
+    const long FILE_PER_URL_CACHE = 1 << 3;
+
+	/**
+	 * See constants defined above.
+	 */
+	readonly attribute PRUint32 flags;
+
+    /**
+     * Total number of URI entries stored in the cache.
+     */
+    readonly attribute PRUint32 numEntries;
+
+    /**
+     * Maximum number of URI entries that may be stored in the cache.
+     */
+    readonly attribute PRUint32 maxEntries;
+
+    /**
+     * Enumerate the URI entries stored in the cache.
+     */
+    nsISimpleEnumerator newCacheEntryIterator();
+
+	/**
+	 * Contains a reference to the next cache in search order.  For the memory
+	 * cache, this attribute always references the disk cache.  For the disk
+	 * cache, it contains a reference to the first extension cache.
+	 */
+    attribute nsINetDataCache nextCache;
+
+    /**
+     * The maximum permitted size of the cache, in kB.
+	 */
+    readonly attribute PRUint32 capacity;
+
+    /**
+     * An estimate of the amount of storage occupied by the cache, in kB.
+     * Actual use may be slightly higher than reported due to cache overhead
+     * and heap fragmentation (in the memory cache) or block quantization (in
+     * the disk cache).
+	 */
+    readonly attribute PRUint32 storageInUse;
+
+    /**
+     * Remove all entries from a writable cache.  This could be used, for
+     * example, after a guest ends a browser session.  This is equivalent to
+     * setting the cache's Capacity to zero, except that all cache entries,
+     * even those in active use, will be deleted.  Also, any global cache
+     * database files will be deleted.
+	 */
+    void removeAll();
+};
+
+%{ C++
+// 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

@@ -0,0 +1,156 @@
+/* -*- 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.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): 
+ */
+
+#include "nsISupports.idl"
+
+interface nsISimpleEnumerator;
+interface nsICachedNetData;
+interface nsINetDataCache;
+interface nsINetDataDiskCache;
+interface nsIURI;
+
+/**
+ * The network-response cache manager is partly responsible for the caching of
+ * content and associated metadata that has been retrieved via the network.
+ * (The remaining responsibility for caching lies with individual network
+ * protocol handlers.)
+ *
+ * The cache manager supervises the actions of individual cache components,
+ * such as the memory cache, the disk cache and any extension caches, e.g. a
+ * read-only CD-ROM cache.  It also manages the coalescing of multiple,
+ * simultaneous requests for the same URI.  That is, if a cache entry fill is
+ * in progress while a second request is made for the same URI, the cache
+ * manager will seamlessly splice together the streams from the stored disk
+ * content and the content inbound from the network.
+ *
+ * @See nsINetDataCache
+ * @See nsICachedNetData
+ */
+[scriptable, uuid(71c8ab00-6d5c-11d3-90c8-000064657374)]
+interface nsINetDataCacheManager : nsISupports
+{
+    /**
+     * Flag for the GetCachedNetData() method: If set, the memory cache is
+     * neither searched nor will any data be stored into it.  This might be
+     * appropriate, for example, with images, because they have their own
+     * cache for storing *decoded* images.
+     */
+    const unsigned long BYPASS_MEMORY_CACHE       = 1 << 0;
+
+    /**
+     * Flag for the GetCachedNetData() method: If set, the disk cache
+     * is neither searched nor will any be data stored into it.
+     * However, read-only extension caches may be searched.  This
+     * might be used to avoid leaving persistent records of secure
+     * data.
+     */
+    const unsigned long BYPASS_PERSISTENT_CACHE   = 1 << 1;
+
+    /**
+     * Flag for the GetCachedNetData() method: If set, any stream
+     * content is stored in the cache as a single disk file.  Content
+     * will not be cached in the memory cache nor is it cached in a
+     * flat-file cache database.  This is used to implement the jar
+     * protocol handler and to provide the stream-as-file semantics
+     * required by the classic bowser plugin API.
+     */
+    const unsigned long CACHE_AS_FILE             = 1 << 2;
+
+    /**
+     * 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:
+     *   + Memory cache
+     *   + Disk cache
+     *   + File cache (stream-as-file cache)
+     *   + All extension caches
+     *
+     * When writing, data is typically stored in both the memory cache and the
+     * disk cache.  Both the search order and this write policy can be modified by
+     * setting one or more of the flag argument bits, as defined above.
+     *
+     * The optionally-NULL secondaryKey argument can be used, e.g. for form
+     * post data or for HTTP headers in the case of HTTP.
+     */
+    nsICachedNetData getCachedNetData(in nsIURI uri,
+                                      [size_is(secondaryKeyLength)] in string secondaryKey,
+                                      in PRUint32 secondaryKeyLength,
+                                      in PRUint32 flags);
+
+    /**
+     * Returns true if cached content is available for the given URI, even if
+     * only partial data is stored.  The flags argument behaves the same as for
+     * the GetCachedNetData() method, above.
+     */
+    boolean contains(in nsIURI uri,
+                     [size_is(secondaryKeyLength)] in string secondaryKey,
+                     in PRUint32 secondaryKeyLength,
+                     in PRUint32 flags);
+
+    /**
+     * Total number of unexpired URI entries stored in all caches.  This number
+     * does not take into account duplicate URIs, e.g. because the memory cache
+     * and the disk cache might each contain an entry for the same URI.
+     */
+    readonly attribute PRUint32 numEntries;
+
+    /**
+     * Enumerate the unexpired URI entries stored in all caches.  Some URIs may
+     * be enumerated more than once, e.g.  because the the memory cache and the
+     * disk cache might each contain an entry for the same URI.
+     */
+    nsISimpleEnumerator newCacheEntryIterator();
+
+    /*
+     * Enumerate all the loaded nsINetDataCache-implementing cache modules.
+     * The first module enumerated will be the memory cache, the second will be
+     * the disk cache, then the file cache, followed by all the extension
+     * caches, in search order. 
+     */
+    nsISimpleEnumerator newCacheModuleIterator();
+
+    /**
+     * Remove all entries from all writable caches.  This could be used, for
+     * example, after a guest ends a browser session.  This is equivalent to
+     * setting the DiskCacheCapacity to zero, except that all cache entries,
+     * even those in active use, will be deleted.  Also, any global cache
+     * database files will be deleted.
+     */
+    void RemoveAll();
+
+    /**
+     * The disk cache is made up of the file cache (for stream-as-file
+     * requests) and a (possibly independent) persistent cache that handles all
+     * other cache requests.  This attribute sets/gets the combined capacity of
+     * these caches, measured in KBytes.  Setting the capacity lower than the
+     * current amount of space currently in use may cause cache entries to be
+     * evicted from the cache to accomodate the requested capacity.
+     */
+    attribute PRUint32 diskCacheCapacity;
+
+    /**
+     * This attribute sets/gets the capacity of the memory cache, measured in
+     * KBytes.  Setting the capacity lower than the current amount of space
+     * currently in use may cause cache entries to be evicted from the cache to
+     * accomodate the requested capacity.
+     */
+    attribute PRUint32 memCacheCapacity;
+};

mozilla/netwerk/cache/public/nsINetDataCacheRecord.idl

@@ -0,0 +1,125 @@
+/* -*- 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.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): 
+ */
+
+#include "nsISupports.idl"
+#include "nsrootidl.idl"
+
+interface nsIFileSpec;
+interface nsIChannel;
+interface nsINetDataCache;
+
+/**
+ * The nsINetDataCacheRecord represents a single entry in a database that
+ * caches data retrieved from the network. On top of this low-level interface
+ * to the raw record data, the cache manager implements a higher-level record
+ * interface, nsICachedNetData.  Each instance of nsINetDataCacheRecord is
+ * (internally) associated with a parent database, an instance of the
+ * nsINetDataCache interface.  This interface is essentially a pseudo-private
+ * API for the cache manager.  Other clients should never use this interface.
+ *
+ * Each cache record may contain both content and metadata.  The content may
+ * be, for example, GIF image data or HTML, and it is accessed through
+ * nsIChannel's streaming API.  The opaque metadata, which may contain HTTP
+ * headers among other things, is accessed as a contiguous byte array.  Each
+ * entry in the cache is indexed by two different keys: a unique record id
+ * number, generated by the cache, and an opaque string.  The latter contains
+ * the URI and other secondary key information, e.g. HTTP form post key/value
+ * pairs.
+ *
+ * The nsINetDataCacheRecord interface is agnostic as to where the data is
+ * stored and whether the storage is volatile or persistent.  The memory cache,
+ * the disk cache, a flat-file cache and any read-only extension caches must
+ * all implement this interface.
+ *
+ * @See nsICachedNetData
+ * @See nsINetDataCache
+ * @See nsINetDataDiskCache
+ * @See nsINetDataCacheManager
+ */
+
+interface nsILoadGroup;
+
+[scriptable, uuid(fdcdd6a0-7461-11d3-90ca-0040056a906e)]
+interface nsINetDataCacheRecord : nsISupports
+{
+    /**
+     * As far as the nsINetDataCacheRecord implementation is concerned, the
+     * cache entry database key is an opaque blob, but it's intended to contain
+     * both the URI and any secondary keys, such as HTTP post data.
+     */
+    void getKey(out unsigned long length, [size_is(length), retval] out string key);
+
+    /**
+     * A persistent record number assigned by the cache which must be unique
+     * among all entries stored within the same cache.  The record ID serves as
+     * an alternate key to the cache record.  Providing that they satisfy the
+     * afforementioned uniqueness requirement, record IDs can be assigned any
+     * value by the database except that they may never be zero.
+     */
+    readonly attribute PRInt32 recordID;
+
+    /**
+     * Opaque data which can be updated for each cache entry independently of
+     * the content data.  This data is a combination of protocol-independent
+     * data provided by the cache manager and protocol-specific meta-data,
+     * e.g. HTTP headers.
+     */
+    void getMetaData(out PRUint32 length, [size_is(length), retval] out string metaData);
+    void setMetaData(in  PRUint32 length, [size_is(length)] in string data);
+
+    /**
+     * Number of content bytes stored in the cache, i.e. via the nsIChannel
+     * streaming APIs.  This may be less than the complete content length if a
+     * partial cache fill occurred.  Additionally, the cached content can be
+     * truncated by reducing the value of this attribute.  When this attribute
+     * is set to zero the associated cache disk file, if any, should be
+     * deleted.
+     */
+    attribute PRUint32 storedContentLength;
+
+    /** 
+     * Delete this cache entry and its associated content.
+     */
+    void delete();
+
+    /**
+     * Create a channel for reading or writing a stream of content into the
+     * entry.  However, many of the nsIChannel methods may return
+     * NS_NOT_IMPLEMENTED, including:
+     *
+     *    + GetURI()
+     *    + GetContentType()
+     *    + GetContentLength()
+     */
+    nsIChannel newChannel(in nsILoadGroup loadGroup);
+
+    /**
+     * If a cache is implemented such that it stores each URI's content in an
+     * individual disk file, this method will identify the file corresponding
+     * to this record.  This may be used to implement the "stream-as-file"
+     * semantics required by some plugins and by the 'jar:' protocol handler.
+     * However, not all cache implementations are *required* to store the data
+     * from each URI in an individual file, so it is acceptable for an
+     * implementation of this method to signal NS_NOT_IMPLEMENTED.
+     */
+    readonly attribute nsIFileSpec filename;
+};

mozilla/netwerk/cache/public/nsINetDataDiskCache.idl

@@ -1,4 +1,4 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+/* -*- 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
@@ -20,30 +20,23 @@
  * Contributor(s): 
  */
 
-#ifndef nsTextAreaWidget_h__
-#define nsTextAreaWidget_h__
+#include "nsINetDataCache.idl"
 
-#include "nsTextHelper.h"
-#include "nsITextAreaWidget.h"
+interface nsIFileSpec;
 
 /**
- * Native GTK+ multi-line edit control wrapper.
+/**
+ * A network-data disk cache is used to persistently 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.
  */
-
-class nsTextAreaWidget : public nsTextHelper
+[scriptable, uuid(6408e390-6f13-11d3-90c8-000064657374)]
+interface nsINetDataDiskCache : nsINetDataCache
 {
-
-public:
-  nsTextAreaWidget();
-  virtual ~nsTextAreaWidget();
-
-  NS_DECL_ISUPPORTS_INHERITED
-
-  virtual void SetFontNative(GdkFont *aFont);
-
-protected:
-  NS_METHOD CreateNative(GtkObject *parentWindow);
+	/**
+	 * This attribute must be set before calling any other methods of this
+	 * interface.
+	 */
+    attribute nsIFileSpec diskCacheFolder;
 };
 
-
-#endif // nsTextAreaWidget_h__

mozilla/netwerk/cache/public/nsIStreamAsFile.idl

@@ -0,0 +1,106 @@
+/* -*- 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 "nsrootidl.idl"
+#include "nsISupports.idl"
+
+interface nsIFileSpec;
+interface nsIStreamAsFileObserver;
+
+/**
+ * In addition to enhancing effective network response time via caching, the
+ * cache manager serves a second purpose by providing the stream-as-file
+ * service required by traditional browser plugins and the jar: protocol
+ * handler.  The interface below provides a means for a client to determine the
+ * filename associated with a stream and to detect modification/deletion of
+ * that file.
+ */
+[scriptable, uuid(0eedbbf0-92d9-11d3-90d3-0040056a906e)]
+interface nsIStreamAsFile : nsISupports
+{
+    /**
+     * Filename containing stream-as-file
+     */
+    readonly attribute nsIFileSpec fileSpec;
+
+    /**
+     * Add an observer for this cache record.  When the cache wants to delete
+     * or truncate a record, so as to make space for another cache entry's
+     * content data, it will call <code>aObserver</code>'s Observe() method,
+     * passing the nsIStreamAsFile instance as the <code>aSubject</code>
+     * argument and an appropriate message.  If the observer does not wish to
+     * inhibit deletion/truncation, it should Release() any references it has to the
+     * cache record.
+     *
+     * @See nsIStreamAsFileObserver
+     */
+    void addObserver(in nsIStreamAsFileObserver aObserver);
+
+    /**
+     * Delete an observer that was added by the AddObserver() method.
+     */
+    void removeObserver(in nsIStreamAsFileObserver aObserver);
+};
+
+/**
+ * This interface can be implemented by a client to receive notifications of
+ * either modification or deletion of a file created by the cache manager using
+ * the stream-as-file semantics.
+ */
+[scriptable, uuid(a26e27c0-92da-11d3-90d3-0040056a906e)]
+interface nsIStreamAsFileObserver : nsISupports
+{
+    /**
+     * 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
+    const long REQUEST_DELETION    = 1 << 2; // Cache manager wishes to delete/truncate file
+    const long INVALIDATE          = 1 << 3; // File is out-of-date
+
+    // Convenience value
+    const long MAKE_UNAVAILABLE    = REQUEST_DELETION | INVALIDATE;
+    
+    /**
+     * Receive either a notification or a request concerning a file that has
+     * been opened using stream-as-file.  The aMessage and aError arguments
+     * have varying values depending on the nature of the notification.
+     * aMessage is set to NOTIFY_AVAILABLE when a complete stream has been read
+     * and stored on disk in a file.  At that point, and no sooner, may the
+     * filename attribute of the associated nsIStreamAsFile be accessed via the
+     * associated nsIStreamAsFile interface.  If the aMessage argument is
+     * NOTIFY_ERROR, the aError argument contains the relevant error code.  If
+     * the aMessage argument is either REQUEST_DELETION or REQUEST_TRUNCATION,
+     * the callee should immediately Release() all references to the
+     * nsIStreamAsFile (and any references to its associated nsICachedNetData
+     * instances), unless it wishes to inhibit the requested file modification.
+     * If the aMessage argument is INVALIDATE, the cache manager is replacing
+     * the file with a more recent version.  If a client wants to continue
+     * using the (now out-of-date) file, it must delete it when it has finished,
+     * as the cache manager will effectively relinquished ownership of the
+     * file.
+     */
+    void ObserveStreamAsFile(in nsIStreamAsFile aStreamAsFile,
+			     in PRUint32 aMessage,
+			     in nsresult aError);
+};

mozilla/netwerk/cache/tests/Makefile.in

@@ -0,0 +1,28 @@
+#
+# 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
+
+DIRS		= xptest
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/tests/Makefile.win

@@ -0,0 +1,24 @@
+#!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=..\..\..
+DIRS= 	\
+	xptest			\
+	$(NULL)
+
+include <$(DEPTH)\config\rules.mak> 

mozilla/netwerk/cache/tests/xptest/Makefile.in

@@ -0,0 +1,46 @@
+#
+# 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
+
+CPPSRCS		= \
+		disktest.cpp \
+		memtest.cpp \
+		$(NULL)
+
+SIMPLE_PROGRAMS	= $(CPPSRCS:.cpp=)
+
+LIBS		= \
+		-lpref \
+		-lsecfree \
+		-lmozjs \
+		-lxpcom \
+		$(ZLIB_LIBS) \
+		$(NSPR_LIBS) \
+		$(NULL)
+
+include $(topsrcdir)/config/rules.mk
+
+DEFINES		+= -DUSE_NSREG -DCACHE
+LIBS_DIR 	+= -L$(DIST)/bin/components
+INCLUDES	+= -I$(srcdir)/../../public -I$(srcdir)/../../include -I..
+

mozilla/netwerk/cache/tests/xptest/Makefile.win

@@ -0,0 +1,53 @@
+#!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=..\..\..\..  
+
+MAKE_OBJ_TYPE	= EXE 
+PROG1 = .\$(OBJDIR)\disktest.exe 
+PROG2 = .\$(OBJDIR)\memtest.exe 
+PROGRAMS = $(PROG1) $(PROG2) 
+
+LCFLAGS=-DUSE_NSREG -GX -DCACHE 
+
+REQUIRES=libreg 
+
+INCS = -I..\..\public \ 
+	-I..\..\include \ 
+	$(INCS)                  \ 
+        -I$(DEPTH)\dist\include \ 
+        $(NULL) 
+
+LLIBS=					\ 
+ $(DIST)\lib\xpcom.lib		\ 
+ $(DIST)\lib\gkgfxwin.lib		\ 
+ $(LIBNSPR)				\ 
+!if "$(MOZ_BITS)"=="32" && defined(MOZ_DEBUG) && defined(GLOWCODE) 
+LLIBS=$(LLIBS) $(GLOWDIR)\glowcode.lib 
+!endif 
+
+include <$(DEPTH)\config\rules.mak> 
+
+install:: $(PROGRAMS) 
+	-for %p in ($(PROGRAMS)) do $(MAKE_INSTALL) %p $(DIST)\bin 
+
+clobber:: 
+	-for %p in ($(PROGRAMS)) do $(RM) %p $(DIST)\bin\%p 
+
+$(PROG1): $(OBJDIR) disktest.cpp 
+
+$(PROG2): $(OBJDIR) memtest.cpp 

mozilla/netwerk/cache/tests/xptest/disktest.cpp

@@ -0,0 +1,817 @@
+/* -*- 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.
+ */
+
+/* 
+    The TestProtocols tests the basic protocols architecture and can 
+    be used to test individual protocols as well. If this grows too
+    big then we should split it to individual protocols. 
+    
+    -Gagan Saksena 04/29/99
+*/
+
+/*
+    This program would actually create a cache file in your /tmp
+	directory. It would try to use the default name from URI. If
+	that name can not be found, it will use nucache. Also, a database
+	file (for indexing, I guess) named nufat.db would also be generated 
+	in the same directory.
+
+	This is only a temporary solution. We are still waiting for the final
+	decision on which database to use.
+
+	-yixiong 08/10/99
+*/
+
+#include <stdio.h>
+#ifdef WIN32 
+#include <windows.h>
+#endif
+#include "nspr.h"
+#include "nscore.h"
+#include "nsCOMPtr.h"
+#include "nsIEventQueueService.h"
+#include "nsIIOService.h"
+#include "nsIServiceManager.h"
+#include "nsIStreamListener.h"
+#include "nsIInputStream.h"
+#include "nsIBufferInputStream.h"
+#include "nsCRT.h"
+#include "nsIChannel.h"
+#include "nsIURL.h"
+#include "nsIHTTPChannel.h"
+#include "nsIHttpEventSink.h" 
+#include "nsIEventSinkGetter.h" 
+#include "nsIDNSService.h" 
+
+#include "nsISimpleEnumerator.h"
+#include "nsIHTTPHeader.h"
+#include "nsXPIDLString.h"
+
+#ifdef CACHE
+#include "nsICacheManager.h"
+#include "nsICacheObject.h"
+#endif
+
+#ifdef NECKO
+// this test app handles cookies.
+#include "nsICookieService.h"
+static NS_DEFINE_CID(nsCookieServiceCID, NS_COOKIESERVICE_CID);
+#endif // NECKO
+
+static NS_DEFINE_CID(kEventQueueServiceCID,      NS_EVENTQUEUESERVICE_CID);
+static NS_DEFINE_CID(kIOServiceCID,              NS_IOSERVICE_CID);
+
+#ifdef CACHE
+static NS_DEFINE_IID(kICacheManagerIID, NS_ICACHEMANAGER_IID) ;
+static NS_DEFINE_IID(kCacheManagerCID, NS_CACHEMANAGER_CID) ;
+
+static NS_DEFINE_IID(kICacheObjectIID, NS_ICACHEOBJECT_IID) ;
+static NS_DEFINE_CID(kCacheObjectCID, NS_CACHEOBJECT_CID);
+#endif
+
+//static PRTime gElapsedTime; // enable when we time it...
+static int gKeepRunning = 0;
+static PRBool gVerbose = PR_FALSE;
+static nsIEventQueue* gEventQ = nsnull;
+
+class URLLoadInfo : public nsISupports
+{
+public:
+
+  URLLoadInfo(const char* aUrl);
+  virtual ~URLLoadInfo();
+
+  // ISupports interface...
+  NS_DECL_ISUPPORTS
+
+  const char* Name() { return mURLString.GetBuffer(); }
+  PRInt32   mBytesRead;
+  PRTime    mTotalTime;
+  PRTime    mConnectTime;
+  nsString  mURLString;
+};
+
+URLLoadInfo::URLLoadInfo(const char *aUrl) : mURLString(aUrl)
+{
+  NS_INIT_REFCNT();
+
+  mBytesRead = 0;
+  mConnectTime = mTotalTime = PR_Now();
+}
+
+URLLoadInfo::~URLLoadInfo()
+{
+}
+
+
+NS_IMPL_ISUPPORTS(URLLoadInfo,nsCOMTypeInfo<nsISupports>::GetIID());
+
+
+class TestHTTPEventSink : public nsIHTTPEventSink
+{
+public:
+
+  TestHTTPEventSink();
+  virtual ~TestHTTPEventSink();
+
+  // ISupports interface...
+  NS_DECL_ISUPPORTS
+
+  // nsIHTTPEventSink interface...
+  NS_IMETHOD      OnAwaitingInput(nsISupports* i_Context);
+
+  NS_IMETHOD      OnHeadersAvailable(nsISupports* i_Context);
+
+  NS_IMETHOD      OnProgress(nsISupports* i_Context, 
+                             PRUint32 i_Progress, 
+                             PRUint32 i_ProgressMax);
+
+  // OnRedirect gets fired only if you have set FollowRedirects on the handler!
+  NS_IMETHOD      OnRedirect(nsISupports* i_Context, 
+                             nsIURI* i_NewLocation);
+};
+
+TestHTTPEventSink::TestHTTPEventSink()
+{
+  NS_INIT_REFCNT();
+}
+
+TestHTTPEventSink::~TestHTTPEventSink()
+{
+}
+
+
+NS_IMPL_ISUPPORTS(TestHTTPEventSink,nsCOMTypeInfo<nsIHTTPEventSink>::GetIID());
+
+NS_IMETHODIMP
+TestHTTPEventSink::OnAwaitingInput(nsISupports* context)
+{
+    printf("\n+++ TestHTTPEventSink::OnAwaitingInput +++\n");
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+TestHTTPEventSink::OnHeadersAvailable(nsISupports* context)
+{
+    nsCOMPtr<nsISimpleEnumerator> enumerator;
+    nsCOMPtr<nsIHTTPChannel> pHTTPCon(do_QueryInterface(context));
+    PRBool bMoreHeaders;
+
+	printf("cachetest: 162, OnHeadersAvailable, \n") ;
+
+    if (pHTTPCon) {
+        pHTTPCon->GetRequestHeaderEnumerator(getter_AddRefs(enumerator));
+
+        printf("Request headers:\n");
+        enumerator->HasMoreElements(&bMoreHeaders);
+        while (bMoreHeaders) {
+            nsCOMPtr<nsISupports> item;
+            nsCOMPtr<nsIHTTPHeader> header;
+
+            enumerator->GetNext(getter_AddRefs(item));
+            header = do_QueryInterface(item);
+
+            if (header) {
+                nsCOMPtr<nsIAtom> key;
+                nsAutoString field(eOneByte);
+                nsXPIDLCString value;
+
+                header->GetField(getter_AddRefs(key));
+                key->ToString(field);
+                printf("\t%s: ", field.GetBuffer());
+
+                header->GetValue(getter_Copies(value));
+                printf("%s\n", (const char*)value);
+            }
+    
+            enumerator->HasMoreElements(&bMoreHeaders);
+        }
+
+        pHTTPCon->GetResponseHeaderEnumerator(getter_AddRefs(enumerator));
+
+        printf("Response headers:\n");
+        enumerator->HasMoreElements(&bMoreHeaders);
+        while (bMoreHeaders) {
+            nsCOMPtr<nsISupports> item;
+            nsCOMPtr<nsIHTTPHeader> header;
+
+            enumerator->GetNext(getter_AddRefs(item));
+            header = do_QueryInterface(item);
+
+            if (header) {
+                nsCOMPtr<nsIAtom> key;
+                nsAutoString field(eOneByte);
+                nsXPIDLCString value;
+
+                header->GetField(getter_AddRefs(key));
+                key->ToString(field);
+                printf("\t%s: ", field.GetBuffer());
+
+                header->GetValue(getter_Copies(value));
+                printf("%s\n", (const char*)value);
+            }
+    
+            enumerator->HasMoreElements(&bMoreHeaders);
+        }
+
+    }
+
+
+    if (gVerbose) {
+        printf("\n+++ TestHTTPEventSink::OnHeadersAvailable +++\n");
+        nsCOMPtr<nsIHTTPChannel> pHTTPCon(do_QueryInterface(context));
+        if (pHTTPCon) {
+            char* type;
+            //optimize later TODO allow atoms here...! intead of just the header strings
+            pHTTPCon->GetContentType(&type);
+            if (type) {
+                printf("\nReceiving ... %s\n", type);
+                nsCRT::free(type);
+            }
+        }
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+TestHTTPEventSink::OnProgress(nsISupports* context, PRUint32 i_Progress, PRUint32 i_ProgressMax)
+{
+    printf("\n+++ TestHTTPEventSink::OnProgress +++\n");
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+TestHTTPEventSink::OnRedirect(nsISupports* context, nsIURI* i_NewLocation)
+{
+    printf("\n+++ TestHTTPEventSink::OnRedirect +++\n");
+    return NS_OK;
+}
+
+
+class InputTestConsumer : public nsIStreamListener
+{
+public:
+
+  InputTestConsumer();
+  virtual ~InputTestConsumer();
+
+  // ISupports interface...
+  NS_DECL_ISUPPORTS
+
+  // IStreamListener interface...
+  NS_IMETHOD OnStartRequest(nsIChannel* channel, nsISupports* context);
+
+  NS_IMETHOD OnDataAvailable(nsIChannel* channel, nsISupports* context,
+                             nsIInputStream *aIStream, 
+                             PRUint32 aSourceOffset,
+                             PRUint32 aLength);
+
+  NS_IMETHOD OnStopRequest(nsIChannel* channel, nsISupports* context,
+                           nsresult aStatus,
+                           const PRUnichar* aMsg);
+
+#ifdef CACHE
+  private:
+
+  nsICacheObject* mCacheFile ;
+#endif 
+};
+
+
+InputTestConsumer::InputTestConsumer()
+{
+  NS_INIT_REFCNT();
+
+#ifdef CACHE
+  mCacheFile = nsnull ;
+#endif
+}
+
+InputTestConsumer::~InputTestConsumer()
+{
+#ifdef CACHE
+  NS_IF_RELEASE(mCacheFile) ;
+#endif
+}
+
+
+NS_IMPL_ISUPPORTS(InputTestConsumer,nsCOMTypeInfo<nsIStreamListener>::GetIID());
+
+
+NS_IMETHODIMP
+InputTestConsumer::OnStartRequest(nsIChannel* channel, nsISupports* context)
+{
+#ifdef CACHE
+  /* Stuff taken from nsPluginHostImpl.cpp */
+
+  char * aContentType = nsnull ;
+  nsIURI* aURL = nsnull ;
+  nsICacheModule* diskCache ;
+  nsICacheManager* cacheManager ;
+
+  nsresult rv = NS_OK, r1, r2 ;
+
+  rv = channel->GetContentType(&aContentType) ;
+  if (NS_FAILED(rv)) return rv ;
+
+  rv = channel ->GetURI(&aURL) ;
+  if (NS_FAILED(rv)) return rv ;
+
+  char * cString;
+  char * fileName ;
+
+  nsCOMPtr<nsIURL> pURL(do_QueryInterface(aURL)) ;
+
+  if (pURL) {
+    pURL -> GetSpec(&cString) ;
+
+  /* Todo, use PROGID instead */
+    rv = nsComponentManager::CreateInstance(kCacheObjectCID,
+                                          nsnull,
+										  kICacheObjectIID,
+										  (void**)&mCacheFile) ;
+
+    if (NS_FAILED(rv)) {
+      return rv ;
+    }
+
+	r1 = NS_ERROR_FAILURE ;
+    r1 = mCacheFile->SetAddress(cString) ;
+
+  /* use the actual filname of the net-based file as the cache filename */
+    r1 = pURL->GetFileName(&fileName) ;
+
+	if(!fileName) {
+	  fileName=new char[50] ;
+	  strcpy(fileName, "nucache") ;
+	}
+
+    r2 = mCacheFile ->SetFilename(fileName) ;
+
+	delete [] fileName ;
+  }
+
+  /* todo: use PROGID instead */
+  rv = nsServiceManager::GetService(kCacheManagerCID,
+										  kICacheManagerIID,
+										  (nsISupports **)&cacheManager) ;
+  if (NS_FAILED(rv)) return rv ;
+
+  // cacheManager->Init( ) ;
+
+  rv = cacheManager->GetDiskModule(&diskCache) ;
+  if (NS_FAILED(rv)) return rv ;
+
+  rv = diskCache->AddObject(mCacheFile) ;
+
+#endif
+
+  URLLoadInfo* info = (URLLoadInfo*)context;
+  if (info) {
+    info->mConnectTime = PR_Now() - info->mConnectTime;
+  }
+
+  if (gVerbose) {
+    printf("\nStarted loading: %s\n", info ? info->Name() : "UNKNOWN URL");
+  }
+/*
+  nsCOMPtr<nsIURI> pURI(do_QueryInterface(context));
+  char* location = nsnull;
+
+  if (pURI) {
+    pURI->GetSpec(&location);
+  }
+
+  printf("\nStarted loading: %s\n", location ? location : "UNKNOWN URL");
+  if (location) {
+    nsCRT::free(location);
+  }
+*/
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+InputTestConsumer::OnDataAvailable(nsIChannel* channel, 
+                                   nsISupports* context,
+                                   nsIInputStream *aIStream, 
+                                   PRUint32 aSourceOffset,
+                                   PRUint32 aLength)
+{
+  char buf[1025];
+  PRUint32 amt, amt_wrote;
+  nsresult rv;
+  URLLoadInfo* info = (URLLoadInfo*)context;
+
+  do {
+    rv = aIStream->Read(buf, 1024, &amt);
+
+#ifdef CACHE
+	if (nsnull != mCacheFile ) {
+	  mCacheFile->Write((char*)buf, amt, &amt_wrote) ;
+	}
+#endif
+
+    if (rv == NS_BASE_STREAM_EOF) break;
+    if (NS_FAILED(rv)) return rv;
+    if (gVerbose) {
+      buf[amt] = '\0';
+      puts(buf);
+    }
+    if (info) {
+      info->mBytesRead += amt;
+    }
+  } while (amt);
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+InputTestConsumer::OnStopRequest(nsIChannel* channel, 
+                                 nsISupports* context,
+                                 nsresult aStatus,
+                                 const PRUnichar* aMsg)
+{
+  URLLoadInfo* info = (URLLoadInfo*)context;
+
+  if (info) {
+    double connectTime;
+    double readTime;
+    PRUint32 httpStatus, o_amt=0, l ;
+	PRInt16 m ;
+    PRBool bHTTPURL = PR_FALSE, b;
+	char buf[2000], *s ;
+	PRIntervalTime t ;
+
+	if (mCacheFile) {
+	  mCacheFile->GetLastModified(&t) ;
+	  printf("\nlast modified: %d\n", t) ;
+
+	  mCacheFile->GetEtag(&s) ;
+	  printf("etag: %s\n", s) ;
+
+	  mCacheFile->GetContentType(&s) ;
+	  printf("content type: %s\n", s) ;
+
+	  mCacheFile->GetCharset(&s) ;
+	  printf("character set: %s\n", s) ;
+
+	  mCacheFile->GetContentEncoding(&s) ;
+	  printf("Content encoding: %s\n", s) ;
+	  
+	  mCacheFile->GetContentLength(&l) ; 
+	  printf("Content Length: %d\n", l) ;
+
+	  mCacheFile->GetExpires(&t) ;
+	  printf("Expires: %d\n", t) ;
+
+	  mCacheFile->GetFilename(&s) ;
+	  printf("Filename: %s\n", s) ;
+
+      mCacheFile->GetState(&l) ;
+	  printf("State: %d\n", l) ;
+
+	  mCacheFile->GetInfoSize(&l) ;
+	  printf("Info size: %d\n", l) ;
+
+      mCacheFile->IsPartial(&b) ;
+	  printf("Is completed: %s\n", b?"True":"False") ;
+
+	  mCacheFile->GetLastAccessed(&t) ;
+	  printf("Last Access time: %d\n", t) ;
+
+	  mCacheFile->GetLastModified(&t) ;
+	  printf("Last Modified time: %d\n", t) ;
+
+	  mCacheFile->GetModuleIndex(&m) ;
+	  printf("Module: %d\n", m) ;
+
+	  mCacheFile->GetPageServicesURL(&s) ;
+	  printf("Page Service URL: %s\n", s) ;
+
+	  mCacheFile->GetPostData(&s) ;
+	  printf("Post Data: %s\n", s) ;
+
+	  mCacheFile->GetPostDataLen(&l) ;
+	  printf("Post Data Length: %d\n", l) ;
+
+	  mCacheFile->GetSize(&l) ;
+	  printf("Size: %d\n", l) ;
+
+	  mCacheFile->GetAddress(&s) ;
+	  printf("URL Address: %s \n", s) ;
+
+	  /* I know my test webpage is less than 2000 bytes. yixiong */
+	  mCacheFile->Read (buf, (PRUint32) 2000, &o_amt) ;
+	  buf[o_amt] = '\0' ;
+//	  printf("%s\n   o_amt = %d \n", buf, o_amt) ;
+	}
+
+    info->mTotalTime = PR_Now() - info->mTotalTime;
+
+    connectTime = (info->mConnectTime/1000.0)/1000.0;
+    readTime    = ((info->mTotalTime-info->mConnectTime)/1000.0)/1000.0;
+
+    nsCOMPtr<nsIHTTPChannel> pHTTPCon(do_QueryInterface(channel));
+    if (pHTTPCon) {
+        pHTTPCon->GetResponseStatus(&httpStatus);
+        bHTTPURL = PR_TRUE;
+    }
+
+    printf("\nFinished loading: %s  Status Code: %x\n", info->Name(), aStatus);
+    if (bHTTPURL)
+        printf("\tHTTP Status: %u\n", httpStatus);
+     if (NS_ERROR_UNKNOWN_HOST == aStatus) {
+         printf("\tDNS lookup failed.\n");
+     }
+    printf("\tRead: %d bytes.\n", info->mBytesRead);
+    printf("\tTime to connect: %.3f seconds\n", connectTime);
+    printf("\tTime to read: %.3f seconds.\n", readTime);
+    if (readTime > 0.0) {
+      printf("\tThroughput: %.0f bps.\n", (info->mBytesRead*8)/readTime);
+    } else {
+      printf("\tThroughput: REAL FAST!!\n");
+    }
+  } else {
+    printf("\nFinished loading: UNKNOWN URL. Status Code: %x\n", aStatus);
+  }
+/*
+  nsCOMPtr<nsIURI> pURI(do_QueryInterface(context));
+  char* location = nsnull;
+
+  if (pURI) {
+    pURI->GetSpec(&location);
+  }
+
+  printf("\nFinished loading: %s  Status Code: %x\n", location ? location : "UNKNOWN URL", aStatus);
+
+  if (location) {
+    nsCRT::free(location);
+  }
+*/
+  gKeepRunning -= 1;
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+class nsEventSinkGetter : public nsIEventSinkGetter {
+public:
+    NS_DECL_ISUPPORTS
+
+    nsEventSinkGetter() {
+        NS_INIT_REFCNT();
+    }
+
+    NS_IMETHOD GetEventSink(const char* verb, const nsIID& eventSinkIID,
+                            nsISupports* *result) {
+        nsresult rv = NS_ERROR_FAILURE;
+
+        if (nsCRT::strcmp(verb, "load") == 0) { // makeshift verb for now
+            if (eventSinkIID.Equals(nsCOMTypeInfo<nsIHTTPEventSink>::GetIID())) {
+                TestHTTPEventSink *sink;
+
+                sink = new TestHTTPEventSink();
+                if (sink == nsnull)
+                    return NS_ERROR_OUT_OF_MEMORY;
+                NS_ADDREF(sink);
+                rv = sink->QueryInterface(eventSinkIID, (void**)result);
+                NS_RELEASE(sink);
+            }
+        }
+        return rv;
+    }
+};
+
+NS_IMPL_ISUPPORTS(nsEventSinkGetter, nsCOMTypeInfo<nsIEventSinkGetter>::GetIID());
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+nsresult StartLoadingURL(const char* aUrlString)
+{
+    nsresult rv;
+
+    NS_WITH_SERVICE(nsIIOService, pService, kIOServiceCID, &rv);
+    if (pService) {
+        nsCOMPtr<nsIURI> pURL;
+
+        rv = pService->NewURI(aUrlString, nsnull, getter_AddRefs(pURL));
+        if (NS_FAILED(rv)) {
+            printf("ERROR: NewURI failed for %s\n", aUrlString);
+            return rv;
+        }
+        nsCOMPtr<nsIChannel> pChannel;
+        nsEventSinkGetter* pMySink;
+
+        pMySink = new nsEventSinkGetter();
+        NS_IF_ADDREF(pMySink);
+        if (!pMySink) {
+            NS_ERROR("Failed to create a new consumer!");
+            return NS_ERROR_OUT_OF_MEMORY;;
+        }
+
+        // Async reading thru the calls of the event sink interface
+        rv = pService->NewChannelFromURI("load", pURL, nsnull, pMySink, 
+                                         getter_AddRefs(pChannel));
+        if (NS_FAILED(rv)) {
+            printf("ERROR: NewChannelFromURI failed for %s\n", aUrlString);
+            return rv;
+        }
+        NS_RELEASE(pMySink);
+
+        /* 
+           You may optionally add/set other headers on this
+           request object. This is done by QI for the specific
+           protocolConnection.
+        */
+        nsCOMPtr<nsIHTTPChannel> pHTTPCon(do_QueryInterface(pChannel));
+
+        if (pHTTPCon) {
+            // Setting a sample user agent string.
+            nsCOMPtr<nsIAtom> userAgent;
+
+            userAgent = NS_NewAtom("user-agent");
+            rv = pHTTPCon->SetRequestHeader(userAgent, "Mozilla/5.0 [en] (Win98; U)");
+            if (NS_FAILED(rv)) return rv;
+        }
+            
+        InputTestConsumer* listener;
+
+        listener = new InputTestConsumer;
+        NS_IF_ADDREF(listener);
+        if (!listener) {
+            NS_ERROR("Failed to create a new stream listener!");
+            return NS_ERROR_OUT_OF_MEMORY;;
+        }
+
+        URLLoadInfo* info;
+        info = new URLLoadInfo(aUrlString);
+        NS_IF_ADDREF(info);
+        if (!info) {
+            NS_ERROR("Failed to create a load info!");
+            return NS_ERROR_OUT_OF_MEMORY;;
+        }
+        
+
+        rv = pChannel->AsyncRead(0,         // staring position
+                                 -1,        // number of bytes to read
+                                 info,      // ISupports context
+                                 listener); // IStreamListener consumer
+        if (NS_SUCCEEDED(rv)) {
+            gKeepRunning += 1;
+        }
+        NS_RELEASE(listener);
+        NS_RELEASE(info);
+    }
+
+    return rv;
+}
+
+
+nsresult LoadURLsFromFile(char *aFileName)
+{
+    nsresult rv = NS_OK;
+    PRInt32 len, offset;
+    PRFileDesc* fd;
+    char buffer[1024];
+    nsString fileBuffer;
+    nsAutoString urlString(eOneByte);
+
+    fd = PR_Open(aFileName, PR_RDONLY, 777);
+    if (!fd) {
+        return NS_ERROR_FAILURE;
+    }
+
+    // Keep reading the file until EOF (or an error) is reached...        
+    do {
+        len = PR_Read(fd, buffer, sizeof(buffer));
+        if (len>0) {
+            fileBuffer.Append(buffer, len);
+            // Treat each line as a URL...
+            while ((offset = fileBuffer.FindChar('\n')) != -1) {
+                fileBuffer.Left(urlString, offset);
+                fileBuffer.Cut(0, offset+1);
+
+                urlString.StripChars("\r");
+                if (urlString.Length()) {
+                    printf("\t%s\n", urlString.GetBuffer());
+                    rv = StartLoadingURL(urlString.GetBuffer());
+                }
+            }
+        }
+    } while (len>0);
+
+    // If anything is left in the fileBuffer, treat it as a URL...
+    fileBuffer.StripChars("\r");
+    if (fileBuffer.Length()) {
+        printf("\t%s\n", fileBuffer.GetBuffer());
+        StartLoadingURL(fileBuffer.GetBuffer());
+    }
+    
+    PR_Close(fd);
+    return NS_OK;
+}
+
+
+nsresult NS_AutoregisterComponents()
+{
+  nsresult rv = nsComponentManager::AutoRegister(nsIComponentManager::NS_Startup, NULL /* default */);
+  return rv;
+}
+
+int
+main(int argc, char* argv[])
+{
+    nsresult rv= (nsresult)-1;
+    if (argc < 2) {
+        printf("usage: %s [-verbose] [-file <name>] <url> <url> ... \n", argv[0]);
+        return -1;
+    }
+
+    /* 
+      The following code only deals with XPCOM registration stuff. and setting
+      up the event queues. Copied from TestSocketIO.cpp
+    */
+
+    rv = NS_AutoregisterComponents();
+    if (NS_FAILED(rv)) return rv;
+
+    
+    // Create the Event Queue for this thread...
+    NS_WITH_SERVICE(nsIEventQueueService, eventQService, kEventQueueServiceCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = eventQService->CreateThreadEventQueue();
+    if (NS_FAILED(rv)) return rv;
+
+    eventQService->GetThreadEventQueue(PR_CurrentThread(), &gEventQ);
+
+#if 0 // Jud sez 
+    // fire up an instance of the cookie manager.
+    // I'm doing this using the serviceManager for convenience's sake.
+    // Presumably an application will init it's own cookie service a 
+    // different way (this way works too though).
+    NS_WITH_SERVICE(nsICookieService, cookieService, nsCookieServiceCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+#endif // NECKO
+
+    int i;
+    printf("\nTrying to load:\n");
+    for (i=1; i<argc; i++) {
+        // Turn on verbose printing...
+        if (PL_strcasecmp(argv[i], "-verbose") == 0) {
+            gVerbose = PR_TRUE;
+            continue;
+        } 
+
+        // Turn on netlib tracing...
+        if (PL_strcasecmp(argv[i], "-file") == 0) {
+            LoadURLsFromFile(argv[++i]);
+            continue;
+        } 
+
+        printf("\t%s\n", argv[i]);
+        rv = StartLoadingURL(argv[i]);
+    }
+
+  // Enter the message pump to allow the URL load to proceed.
+    while ( gKeepRunning ) {
+#ifdef WIN32
+        MSG msg;
+
+        if (GetMessage(&msg, NULL, 0, 0)) {
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        } else {
+            gKeepRunning = 0;
+    }
+#else
+#ifdef XP_MAC
+    /* Mac stuff is missing here! */
+#else
+    PLEvent *gEvent;
+    rv = gEventQ->GetEvent(&gEvent);
+    rv = gEventQ->HandleEvent(gEvent);
+#endif /* XP_UNIX */
+#endif /* !WIN32 */
+    }
+
+    return rv;
+}

mozilla/netwerk/cache/tests/xptest/memtest.cpp

@@ -0,0 +1,801 @@
+/* -*- 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.
+ */
+
+/* 
+    The TestProtocols tests the basic protocols architecture and can 
+    be used to test individual protocols as well. If this grows too
+    big then we should split it to individual protocols. 
+    
+    -Gagan Saksena 04/29/99
+*/
+
+#include <stdio.h>
+#ifdef WIN32 
+#include <windows.h>
+#endif
+#include "nspr.h"
+#include "nscore.h"
+#include "nsCOMPtr.h"
+#include "nsIEventQueueService.h"
+#include "nsIIOService.h"
+#include "nsIServiceManager.h"
+#include "nsIStreamListener.h"
+#include "nsIInputStream.h"
+#include "nsIBufferInputStream.h"
+#include "nsCRT.h"
+#include "nsIChannel.h"
+#include "nsIURL.h"
+#include "nsIHTTPChannel.h"
+#include "nsIHttpEventSink.h" 
+#include "nsIEventSinkGetter.h" 
+#include "nsIDNSService.h" 
+
+#include "nsISimpleEnumerator.h"
+#include "nsIHTTPHeader.h"
+#include "nsXPIDLString.h"
+
+#ifdef CACHE
+#include "nsICacheManager.h"
+#include "nsICacheObject.h"
+#endif
+
+#ifdef NECKO
+// this test app handles cookies.
+#include "nsICookieService.h"
+static NS_DEFINE_CID(nsCookieServiceCID, NS_COOKIESERVICE_CID);
+#endif // NECKO
+
+static NS_DEFINE_CID(kEventQueueServiceCID,      NS_EVENTQUEUESERVICE_CID);
+static NS_DEFINE_CID(kIOServiceCID,              NS_IOSERVICE_CID);
+
+#ifdef CACHE
+static NS_DEFINE_IID(kICacheManagerIID, NS_ICACHEMANAGER_IID) ;
+static NS_DEFINE_IID(kCacheManagerCID, NS_CACHEMANAGER_CID) ;
+
+static NS_DEFINE_IID(kICacheObjectIID, NS_ICACHEOBJECT_IID) ;
+static NS_DEFINE_CID(kCacheObjectCID, NS_CACHEOBJECT_CID);
+#endif
+
+//static PRTime gElapsedTime; // enable when we time it...
+static int gKeepRunning = 0;
+static PRBool gVerbose = PR_FALSE;
+static nsIEventQueue* gEventQ = nsnull;
+
+class URLLoadInfo : public nsISupports
+{
+public:
+
+  URLLoadInfo(const char* aUrl);
+  virtual ~URLLoadInfo();
+
+  // ISupports interface...
+  NS_DECL_ISUPPORTS
+
+  const char* Name() { return mURLString.GetBuffer(); }
+  PRInt32   mBytesRead;
+  PRTime    mTotalTime;
+  PRTime    mConnectTime;
+  nsString  mURLString;
+};
+
+URLLoadInfo::URLLoadInfo(const char *aUrl) : mURLString(aUrl)
+{
+  NS_INIT_REFCNT();
+
+  mBytesRead = 0;
+  mConnectTime = mTotalTime = PR_Now();
+}
+
+URLLoadInfo::~URLLoadInfo()
+{
+}
+
+
+NS_IMPL_ISUPPORTS(URLLoadInfo,nsCOMTypeInfo<nsISupports>::GetIID());
+
+
+class TestHTTPEventSink : public nsIHTTPEventSink
+{
+public:
+
+  TestHTTPEventSink();
+  virtual ~TestHTTPEventSink();
+
+  // ISupports interface...
+  NS_DECL_ISUPPORTS
+
+  // nsIHTTPEventSink interface...
+  NS_IMETHOD      OnAwaitingInput(nsISupports* i_Context);
+
+  NS_IMETHOD      OnHeadersAvailable(nsISupports* i_Context);
+
+  NS_IMETHOD      OnProgress(nsISupports* i_Context, 
+                             PRUint32 i_Progress, 
+                             PRUint32 i_ProgressMax);
+
+  // OnRedirect gets fired only if you have set FollowRedirects on the handler!
+  NS_IMETHOD      OnRedirect(nsISupports* i_Context, 
+                             nsIURI* i_NewLocation);
+};
+
+TestHTTPEventSink::TestHTTPEventSink()
+{
+  NS_INIT_REFCNT();
+}
+
+TestHTTPEventSink::~TestHTTPEventSink()
+{
+}
+
+
+NS_IMPL_ISUPPORTS(TestHTTPEventSink,nsCOMTypeInfo<nsIHTTPEventSink>::GetIID());
+
+NS_IMETHODIMP
+TestHTTPEventSink::OnAwaitingInput(nsISupports* context)
+{
+    printf("\n+++ TestHTTPEventSink::OnAwaitingInput +++\n");
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+TestHTTPEventSink::OnHeadersAvailable(nsISupports* context)
+{
+    nsCOMPtr<nsISimpleEnumerator> enumerator;
+    nsCOMPtr<nsIHTTPChannel> pHTTPCon(do_QueryInterface(context));
+    PRBool bMoreHeaders;
+
+	printf("cachetest: 162, OnHeadersAvailable, \n") ;
+
+    if (pHTTPCon) {
+        pHTTPCon->GetRequestHeaderEnumerator(getter_AddRefs(enumerator));
+
+        printf("Request headers:\n");
+        enumerator->HasMoreElements(&bMoreHeaders);
+        while (bMoreHeaders) {
+            nsCOMPtr<nsISupports> item;
+            nsCOMPtr<nsIHTTPHeader> header;
+
+            enumerator->GetNext(getter_AddRefs(item));
+            header = do_QueryInterface(item);
+
+            if (header) {
+                nsCOMPtr<nsIAtom> key;
+                nsAutoString field(eOneByte);
+                nsXPIDLCString value;
+
+                header->GetField(getter_AddRefs(key));
+                key->ToString(field);
+                printf("\t%s: ", field.GetBuffer());
+
+                header->GetValue(getter_Copies(value));
+                printf("%s\n", (const char*)value);
+            }
+    
+            enumerator->HasMoreElements(&bMoreHeaders);
+        }
+
+        pHTTPCon->GetResponseHeaderEnumerator(getter_AddRefs(enumerator));
+
+        printf("Response headers:\n");
+        enumerator->HasMoreElements(&bMoreHeaders);
+        while (bMoreHeaders) {
+            nsCOMPtr<nsISupports> item;
+            nsCOMPtr<nsIHTTPHeader> header;
+
+            enumerator->GetNext(getter_AddRefs(item));
+            header = do_QueryInterface(item);
+
+            if (header) {
+                nsCOMPtr<nsIAtom> key;
+                nsAutoString field(eOneByte);
+                nsXPIDLCString value;
+
+                header->GetField(getter_AddRefs(key));
+                key->ToString(field);
+                printf("\t%s: ", field.GetBuffer());
+
+                header->GetValue(getter_Copies(value));
+                printf("%s\n", (const char*)value);
+            }
+    
+            enumerator->HasMoreElements(&bMoreHeaders);
+        }
+
+    }
+
+
+    if (gVerbose) {
+        printf("\n+++ TestHTTPEventSink::OnHeadersAvailable +++\n");
+        nsCOMPtr<nsIHTTPChannel> pHTTPCon(do_QueryInterface(context));
+        if (pHTTPCon) {
+            char* type;
+            //optimize later TODO allow atoms here...! intead of just the header strings
+            pHTTPCon->GetContentType(&type);
+            if (type) {
+                printf("\nReceiving ... %s\n", type);
+                nsCRT::free(type);
+            }
+        }
+    }
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+TestHTTPEventSink::OnProgress(nsISupports* context, PRUint32 i_Progress, PRUint32 i_ProgressMax)
+{
+    printf("\n+++ TestHTTPEventSink::OnProgress +++\n");
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+TestHTTPEventSink::OnRedirect(nsISupports* context, nsIURI* i_NewLocation)
+{
+    printf("\n+++ TestHTTPEventSink::OnRedirect +++\n");
+    return NS_OK;
+}
+
+
+class InputTestConsumer : public nsIStreamListener
+{
+public:
+
+  InputTestConsumer();
+  virtual ~InputTestConsumer();
+
+  // ISupports interface...
+  NS_DECL_ISUPPORTS
+
+  // IStreamListener interface...
+  NS_IMETHOD OnStartRequest(nsIChannel* channel, nsISupports* context);
+
+  NS_IMETHOD OnDataAvailable(nsIChannel* channel, nsISupports* context,
+                             nsIInputStream *aIStream, 
+                             PRUint32 aSourceOffset,
+                             PRUint32 aLength);
+
+  NS_IMETHOD OnStopRequest(nsIChannel* channel, nsISupports* context,
+                           nsresult aStatus,
+                           const PRUnichar* aMsg);
+
+#ifdef CACHE
+  private:
+
+  nsICacheObject* mCacheFile ;
+#endif 
+};
+
+
+InputTestConsumer::InputTestConsumer()
+{
+  NS_INIT_REFCNT();
+
+#ifdef CACHE
+  mCacheFile = nsnull ;
+#endif
+}
+
+InputTestConsumer::~InputTestConsumer()
+{
+#ifdef CACHE
+  NS_IF_RELEASE(mCacheFile) ;
+#endif
+}
+
+
+NS_IMPL_ISUPPORTS(InputTestConsumer,nsCOMTypeInfo<nsIStreamListener>::GetIID());
+
+
+NS_IMETHODIMP
+InputTestConsumer::OnStartRequest(nsIChannel* channel, nsISupports* context)
+{
+#ifdef CACHE
+  /* Stuff taken from nsPluginHostImpl.cpp */
+
+  char * aContentType = nsnull ;
+  nsIURI* aURL = nsnull ;
+  nsICacheModule* memCache ;
+  nsICacheManager* cacheManager ;
+
+  nsresult rv = NS_OK, r1, r2 ;
+
+  rv = channel->GetContentType(&aContentType) ;
+  if (NS_FAILED(rv)) return rv ;
+
+  rv = channel ->GetURI(&aURL) ;
+  if (NS_FAILED(rv)) return rv ;
+
+  char * cString;
+  char * fileName ;
+
+  nsCOMPtr<nsIURL> pURL(do_QueryInterface(aURL)) ;
+
+  if (pURL) {
+    pURL -> GetSpec(&cString) ;
+
+  /* Todo, use PROGID instead */
+    rv = nsComponentManager::CreateInstance(kCacheObjectCID,
+                                          nsnull,
+										  kICacheObjectIID,
+										  (void**)&mCacheFile) ;
+
+    if (NS_FAILED(rv)) {
+      return rv ;
+    }
+
+	r1 = NS_ERROR_FAILURE ;
+    r1 = mCacheFile->SetAddress(cString) ;
+
+  /* use the actual filname of the net-based file as the cache filename */
+    pURL->GetFileName(&fileName) ;
+
+	/* temp hack, name resolution needs to be added */
+	if(!fileName) {
+	  fileName=new char[50] ;
+	  strcpy(fileName, "nucache") ;
+	}
+
+    r2 = mCacheFile ->SetFilename(fileName) ;
+	delete [] fileName ;
+  }
+
+  /* todo: use PROGID instead */
+  rv = nsServiceManager::GetService(kCacheManagerCID,
+										  kICacheManagerIID,
+										  (nsISupports **)&cacheManager) ;
+  if (NS_FAILED(rv)) return rv ;
+
+  rv = cacheManager->GetMemModule(&memCache) ;
+  if (NS_FAILED(rv)) return rv ;
+
+  rv = memCache->AddObject(mCacheFile) ;
+
+#endif
+
+  URLLoadInfo* info = (URLLoadInfo*)context;
+  if (info) {
+    info->mConnectTime = PR_Now() - info->mConnectTime;
+  }
+
+  if (gVerbose) {
+    printf("\nStarted loading: %s\n", info ? info->Name() : "UNKNOWN URL");
+  }
+/*
+  nsCOMPtr<nsIURI> pURI(do_QueryInterface(context));
+  char* location = nsnull;
+
+  if (pURI) {
+    pURI->GetSpec(&location);
+  }
+
+  printf("\nStarted loading: %s\n", location ? location : "UNKNOWN URL");
+  if (location) {
+    nsCRT::free(location);
+  }
+*/
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+InputTestConsumer::OnDataAvailable(nsIChannel* channel, 
+                                   nsISupports* context,
+                                   nsIInputStream *aIStream, 
+                                   PRUint32 aSourceOffset,
+                                   PRUint32 aLength)
+{
+  char buf[1025];
+  PRUint32 amt, amt_wrote;
+  nsresult rv;
+  URLLoadInfo* info = (URLLoadInfo*)context;
+
+  do {
+    rv = aIStream->Read(buf, 1024, &amt);
+
+#ifdef CACHE
+	if (nsnull != mCacheFile ) {
+	  mCacheFile->Write((char*)buf, amt, &amt_wrote) ;
+	}
+#endif
+
+    if (rv == NS_BASE_STREAM_EOF) break;
+    if (NS_FAILED(rv)) return rv;
+    if (gVerbose) {
+      buf[amt] = '\0';
+      puts(buf);
+    }
+    if (info) {
+      info->mBytesRead += amt;
+    }
+  } while (amt);
+
+  return NS_OK;
+}
+
+
+NS_IMETHODIMP
+InputTestConsumer::OnStopRequest(nsIChannel* channel, 
+                                 nsISupports* context,
+                                 nsresult aStatus,
+                                 const PRUnichar* aMsg)
+{
+  URLLoadInfo* info = (URLLoadInfo*)context;
+
+  if (info) {
+    double connectTime;
+    double readTime;
+    PRUint32 httpStatus, o_amt=0 ;
+    PRBool bHTTPURL = PR_FALSE ;
+	char buf[2000]  ;
+
+	if (mCacheFile) {
+	  /*
+	  mCacheFile->GetLastModified(&t) ;
+	  printf("\nlast modified: %d\n", t) ;
+
+	  mCacheFile->GetEtag(&s) ;
+	  printf("etag: %s\n", s) ;
+
+	  mCacheFile->GetContentType(&s) ;
+	  printf("content type: %s\n", s) ;
+
+	  mCacheFile->GetCharset(&s) ;
+	  printf("character set: %s\n", s) ;
+
+	  mCacheFile->GetContentEncoding(&s) ;
+	  printf("Content encoding: %s\n", s) ;
+	  
+	  mCacheFile->GetContentLength(&l) ; 
+	  printf("Content Length: %d\n", l) ;
+
+	  mCacheFile->GetExpires(&t) ;
+	  printf("Expires: %d\n", t) ;
+
+	  mCacheFile->GetFilename(&s) ;
+	  printf("Filename: %s\n", s) ;
+
+      mCacheFile->GetState(&l) ;
+	  printf("State: %d\n", l) ;
+
+	  mCacheFile->GetInfoSize(&l) ;
+	  printf("Info size: %d\n", l) ;
+
+      mCacheFile->IsPartial(&b) ;
+	  printf("Is completed: %s\n", b?"True":"False") ;
+
+	  mCacheFile->GetLastAccessed(&t) ;
+	  printf("Last Access time: %d\n", t) ;
+
+	  mCacheFile->GetLastModified(&t) ;
+	  printf("Last Modified time: %d\n", t) ;
+
+	  mCacheFile->GetModuleIndex(&m) ;
+	  printf("Module: %d\n", m) ;
+
+	  mCacheFile->GetPageServicesURL(&s) ;
+	  printf("Page Service URL: %s\n", s) ;
+
+	  mCacheFile->GetPostData(&s) ;
+	  printf("Post Data: %s\n", s) ;
+
+	  mCacheFile->GetPostDataLen(&l) ;
+	  printf("Post Data Length: %d\n", l) ;
+
+	  mCacheFile->GetSize(&l) ;
+	  printf("Size: %d\n", l) ;
+
+	  mCacheFile->GetAddress(&s) ;
+	  printf("URL Address: %s \n", s) ;
+	  */
+
+	  mCacheFile->Read (buf, (PRUint32) 2000, &o_amt) ;
+	  buf[o_amt] = '\0' ;
+	  printf("%s\no_amt = %d \n", buf, o_amt) ;
+	}
+
+    info->mTotalTime = PR_Now() - info->mTotalTime;
+
+    connectTime = (info->mConnectTime/1000.0)/1000.0;
+    readTime    = ((info->mTotalTime-info->mConnectTime)/1000.0)/1000.0;
+
+    nsCOMPtr<nsIHTTPChannel> pHTTPCon(do_QueryInterface(channel));
+    if (pHTTPCon) {
+        pHTTPCon->GetResponseStatus(&httpStatus);
+        bHTTPURL = PR_TRUE;
+    }
+
+    printf("\nFinished loading: %s  Status Code: %x\n", info->Name(), aStatus);
+    if (bHTTPURL)
+        printf("\tHTTP Status: %u\n", httpStatus);
+     if (NS_ERROR_UNKNOWN_HOST == aStatus) {
+         printf("\tDNS lookup failed.\n");
+     }
+    printf("\tRead: %d bytes.\n", info->mBytesRead);
+    printf("\tTime to connect: %.3f seconds\n", connectTime);
+    printf("\tTime to read: %.3f seconds.\n", readTime);
+    if (readTime > 0.0) {
+      printf("\tThroughput: %.0f bps.\n", (info->mBytesRead*8)/readTime);
+    } else {
+      printf("\tThroughput: REAL FAST!!\n");
+    }
+  } else {
+    printf("\nFinished loading: UNKNOWN URL. Status Code: %x\n", aStatus);
+  }
+/*
+  nsCOMPtr<nsIURI> pURI(do_QueryInterface(context));
+  char* location = nsnull;
+
+  if (pURI) {
+    pURI->GetSpec(&location);
+  }
+
+  printf("\nFinished loading: %s  Status Code: %x\n", location ? location : "UNKNOWN URL", aStatus);
+
+  if (location) {
+    nsCRT::free(location);
+  }
+*/
+  gKeepRunning -= 1;
+  return NS_OK;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+class nsEventSinkGetter : public nsIEventSinkGetter {
+public:
+    NS_DECL_ISUPPORTS
+
+    nsEventSinkGetter() {
+        NS_INIT_REFCNT();
+    }
+
+    NS_IMETHOD GetEventSink(const char* verb, const nsIID& eventSinkIID,
+                            nsISupports* *result) {
+        nsresult rv = NS_ERROR_FAILURE;
+
+        if (nsCRT::strcmp(verb, "load") == 0) { // makeshift verb for now
+            if (eventSinkIID.Equals(nsCOMTypeInfo<nsIHTTPEventSink>::GetIID())) {
+                TestHTTPEventSink *sink;
+
+                sink = new TestHTTPEventSink();
+                if (sink == nsnull)
+                    return NS_ERROR_OUT_OF_MEMORY;
+                NS_ADDREF(sink);
+                rv = sink->QueryInterface(eventSinkIID, (void**)result);
+                NS_RELEASE(sink);
+            }
+        }
+        return rv;
+    }
+};
+
+NS_IMPL_ISUPPORTS(nsEventSinkGetter, nsCOMTypeInfo<nsIEventSinkGetter>::GetIID());
+
+////////////////////////////////////////////////////////////////////////////////
+
+
+nsresult StartLoadingURL(const char* aUrlString)
+{
+    nsresult rv;
+
+    NS_WITH_SERVICE(nsIIOService, pService, kIOServiceCID, &rv);
+    if (pService) {
+        nsCOMPtr<nsIURI> pURL;
+
+        rv = pService->NewURI(aUrlString, nsnull, getter_AddRefs(pURL));
+        if (NS_FAILED(rv)) {
+            printf("ERROR: NewURI failed for %s\n", aUrlString);
+            return rv;
+        }
+        nsCOMPtr<nsIChannel> pChannel;
+        nsEventSinkGetter* pMySink;
+
+        pMySink = new nsEventSinkGetter();
+        NS_IF_ADDREF(pMySink);
+        if (!pMySink) {
+            NS_ERROR("Failed to create a new consumer!");
+            return NS_ERROR_OUT_OF_MEMORY;;
+        }
+
+        // Async reading thru the calls of the event sink interface
+        rv = pService->NewChannelFromURI("load", pURL, nsnull, pMySink, 
+                                         getter_AddRefs(pChannel));
+        if (NS_FAILED(rv)) {
+            printf("ERROR: NewChannelFromURI failed for %s\n", aUrlString);
+            return rv;
+        }
+        NS_RELEASE(pMySink);
+
+        /* 
+           You may optionally add/set other headers on this
+           request object. This is done by QI for the specific
+           protocolConnection.
+        */
+        nsCOMPtr<nsIHTTPChannel> pHTTPCon(do_QueryInterface(pChannel));
+
+        if (pHTTPCon) {
+            // Setting a sample user agent string.
+            nsCOMPtr<nsIAtom> userAgent;
+
+            userAgent = NS_NewAtom("user-agent");
+            rv = pHTTPCon->SetRequestHeader(userAgent, "Mozilla/5.0 [en] (Win98; U)");
+            if (NS_FAILED(rv)) return rv;
+        }
+            
+        InputTestConsumer* listener;
+
+        listener = new InputTestConsumer;
+        NS_IF_ADDREF(listener);
+        if (!listener) {
+            NS_ERROR("Failed to create a new stream listener!");
+            return NS_ERROR_OUT_OF_MEMORY;;
+        }
+
+        URLLoadInfo* info;
+        info = new URLLoadInfo(aUrlString);
+        NS_IF_ADDREF(info);
+        if (!info) {
+            NS_ERROR("Failed to create a load info!");
+            return NS_ERROR_OUT_OF_MEMORY;;
+        }
+        
+
+        rv = pChannel->AsyncRead(0,         // staring position
+                                 -1,        // number of bytes to read
+                                 info,      // ISupports context
+                                 listener); // IStreamListener consumer
+        if (NS_SUCCEEDED(rv)) {
+            gKeepRunning += 1;
+        }
+        NS_RELEASE(listener);
+        NS_RELEASE(info);
+    }
+
+    return rv;
+}
+
+
+nsresult LoadURLsFromFile(char *aFileName)
+{
+    nsresult rv = NS_OK;
+    PRInt32 len, offset;
+    PRFileDesc* fd;
+    char buffer[1024];
+    nsString fileBuffer;
+    nsAutoString urlString(eOneByte);
+
+    fd = PR_Open(aFileName, PR_RDONLY, 777);
+    if (!fd) {
+        return NS_ERROR_FAILURE;
+    }
+
+    // Keep reading the file until EOF (or an error) is reached...        
+    do {
+        len = PR_Read(fd, buffer, sizeof(buffer));
+        if (len>0) {
+            fileBuffer.Append(buffer, len);
+            // Treat each line as a URL...
+            while ((offset = fileBuffer.FindChar('\n')) != -1) {
+                fileBuffer.Left(urlString, offset);
+                fileBuffer.Cut(0, offset+1);
+
+                urlString.StripChars("\r");
+                if (urlString.Length()) {
+                    printf("\t%s\n", urlString.GetBuffer());
+                    rv = StartLoadingURL(urlString.GetBuffer());
+                }
+            }
+        }
+    } while (len>0);
+
+    // If anything is left in the fileBuffer, treat it as a URL...
+    fileBuffer.StripChars("\r");
+    if (fileBuffer.Length()) {
+        printf("\t%s\n", fileBuffer.GetBuffer());
+        StartLoadingURL(fileBuffer.GetBuffer());
+    }
+    
+    PR_Close(fd);
+    return NS_OK;
+}
+
+
+nsresult NS_AutoregisterComponents()
+{
+  nsresult rv = nsComponentManager::AutoRegister(nsIComponentManager::NS_Startup, NULL /* default */);
+  return rv;
+}
+
+int
+main(int argc, char* argv[])
+{
+    nsresult rv= (nsresult)-1;
+    if (argc < 2) {
+        printf("usage: %s [-verbose] [-file <name>] <url> <url> ... \n", argv[0]);
+        return -1;
+    }
+
+    /* 
+      The following code only deals with XPCOM registration stuff. and setting
+      up the event queues. Copied from TestSocketIO.cpp
+    */
+
+    rv = NS_AutoregisterComponents();
+    if (NS_FAILED(rv)) return rv;
+
+    
+    // Create the Event Queue for this thread...
+    NS_WITH_SERVICE(nsIEventQueueService, eventQService, kEventQueueServiceCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+
+    rv = eventQService->CreateThreadEventQueue();
+    if (NS_FAILED(rv)) return rv;
+
+    eventQService->GetThreadEventQueue(PR_CurrentThread(), &gEventQ);
+
+#if 0 // Jud sez 
+    // fire up an instance of the cookie manager.
+    // I'm doing this using the serviceManager for convenience's sake.
+    // Presumably an application will init it's own cookie service a 
+    // different way (this way works too though).
+    NS_WITH_SERVICE(nsICookieService, cookieService, nsCookieServiceCID, &rv);
+    if (NS_FAILED(rv)) return rv;
+#endif // NECKO
+
+    int i;
+    printf("\nTrying to load:\n");
+    for (i=1; i<argc; i++) {
+        // Turn on verbose printing...
+        if (PL_strcasecmp(argv[i], "-verbose") == 0) {
+            gVerbose = PR_TRUE;
+            continue;
+        } 
+
+        // Turn on netlib tracing...
+        if (PL_strcasecmp(argv[i], "-file") == 0) {
+            LoadURLsFromFile(argv[++i]);
+            continue;
+        } 
+
+        printf("\t%s\n", argv[i]);
+        rv = StartLoadingURL(argv[i]);
+    }
+
+  // Enter the message pump to allow the URL load to proceed.
+    while ( gKeepRunning ) {
+#ifdef WIN32
+        MSG msg;
+
+        if (GetMessage(&msg, NULL, 0, 0)) {
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        } else {
+            gKeepRunning = 0;
+    }
+#else
+#ifdef XP_MAC
+    /* Mac stuff is missing here! */
+#else
+    PLEvent *gEvent;
+    rv = gEventQ->GetEvent(&gEvent);
+    rv = gEventQ->HandleEvent(gEvent);
+#endif /* XP_UNIX */
+#endif /* !WIN32 */
+    }
+
+    return rv;
+}

mozilla/netwerk/makefile.win

@@ -0,0 +1,38 @@
+#!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 = ..
+
+MODULE = necko
+
+DIRS=            \
+	base     \
+	dns      \
+	build    \
+	protocol \
+	socket   \
+	util     \
+	mime     \
+	streamconv \
+	test     \
+	$(NULL)
+
+include <$(DEPTH)\config\rules.mak>

mozilla/netwerk/protocol/http/public/nsIHTTPHeader.idl

@@ -0,0 +1,28 @@
+/* -*- Mode: IDL; 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.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 "nsISupports.idl"
+
+interface nsIAtom;
+                  
+[scriptable, uuid(a3ec67f0-465a-11d3-9a89-0080c7cb1080)]
+interface nsIHTTPHeader : nsISupports
+{
+    void GetField(out nsIAtom headerAtom);
+    void GetValue(out string headerValue);
+};

mozilla/netwerk/test/makefile.win

@@ -0,0 +1,67 @@
+#!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=..\..
+
+MAKE_OBJ_TYPE	= EXE
+PROG1 = .\$(OBJDIR)\TestFileInput.exe
+PROG2 = .\$(OBJDIR)\TestSocketInput.exe
+PROG3 = .\$(OBJDIR)\TestSocketIO.exe
+PROG4 = .\$(OBJDIR)\TestProtocols.exe
+PROG5 = .\$(OBJDIR)\TestSocketTransport.exe
+PROG6 = .\$(OBJDIR)\urltest.exe
+PROG7 = .\$(OBJDIR)\TestFileInput2.exe
+PROG8 = .\$(OBJDIR)\TestFileTransport.exe
+PROGRAMS = $(PROG1) $(PROG2) $(PROG3) $(PROG4) $(PROG5) $(PROG6) $(PROG7) $(PROG8)
+
+LCFLAGS=-DUSE_NSREG -GX
+
+REQUIRES=libreg
+
+INCS = $(INCS)                  \
+        -I$(DEPTH)\dist\include \
+        $(NULL)
+
+LLIBS=					\
+ $(DIST)\lib\xpcom.lib		\
+ $(DIST)\lib\gkgfxwin.lib		\
+ $(LIBNSPR)				\
+ $(NULL)
+
+include <$(DEPTH)\config\rules.mak>
+
+install:: $(PROGRAMS)
+	-for %p in ($(PROGRAMS)) do $(MAKE_INSTALL) %p $(DIST)\bin
+
+clobber::
+	-for %p in ($(PROGRAMS)) do $(RM) %p $(DIST)\bin\%p
+
+$(PROG1): $(OBJDIR) TestFileInput.cpp
+
+$(PROG2): $(OBJDIR) TestSocketInput.cpp
+
+$(PROG3): $(OBJDIR) TestSocketIO.cpp
+
+$(PROG4): $(OBJDIR) TestProtocols.cpp
+
+$(PROG5): $(OBJDIR) TestSocketTransport.cpp
+
+$(PROG6): $(OBJDIR) urltest.cpp
+
+$(PROG7): $(OBJDIR) TestFileInput2.cpp
+
+$(PROG8): $(OBJDIR) TestFileTransport.cpp

mozilla/webshell/tests/viewer/Makefile.in

@@ -1,197 +0,0 @@
-#
-# 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
-
-PROGRAM			= viewer
-
-CPPSRCS			= \
-			$(TOOLKIT_CPPSRCS) \
-			nsBaseDialog.cpp \
-			nsFindDialog.cpp \
-			nsXPBaseWindow.cpp \
-			nsTableInspectorDialog.cpp \
-			nsImageInspectorDialog.cpp \
-			nsPrintSetupDialog.cpp \
-			nsBrowserWindow.cpp \
-			nsEditorMode.cpp \
-			nsSetupRegistry.cpp \
-			nsThrobber.cpp \
-			nsViewerApp.cpp \
-			nsWebCrawler.cpp \
-			$(NULL)
-
-EXPORT_RESOURCE_SAMPLES	:= \
-			$(wildcard $(srcdir)/samples/test*.html) \
-			$(wildcard $(srcdir)/samples/toolbarTest*.xul) \
-			$(wildcard $(srcdir)/samples/treeTest*.xul) \
-			$(wildcard $(srcdir)/samples/treeTest*.css) \
-			$(wildcard $(srcdir)/samples/slider*.xul) \
-			$(wildcard $(srcdir)/samples/scrollbar*.xul) \
-			$(srcdir)/resources/find.html \
-			$(srcdir)/resources/printsetup.html \
-			$(srcdir)/resources/image_props.html \
-			$(srcdir)/samples/aform.css \
-			$(srcdir)/samples/bform.css \
-			$(srcdir)/samples/cform.css \
-			$(srcdir)/samples/demoform.css \
-			$(srcdir)/samples/mozform.css \
-			$(srcdir)/samples/xulTest.css \
-			$(srcdir)/samples/Anieyes.gif \
-			$(srcdir)/samples/gear1.gif \
-			$(srcdir)/samples/rock_gra.gif \
-			$(srcdir)/samples/beeptest.html \
-			$(srcdir)/samples/soundtest.html \
-			$(srcdir)/samples/bg.jpg \
-			$(srcdir)/samples/raptor.jpg \
-			$(srcdir)/samples/test.wav \
-			$(srcdir)/samples/checkboxTest.xul \
-			$(NULL)
-
-EXPORT_RESOURCE_THROBBER := $(wildcard $(srcdir)/throbber/anim*.gif)
-
-ifeq (,$(filter beos os2 rhapsody photon,$(MOZ_WIDGET_TOOLKIT)))
-DIRS			+= unix
-UNIX_VIEWER_TK_LIBS	= $(DIST)/lib/libviewer_$(MOZ_WIDGET_TOOLKIT)_s.a
-else
-ifeq ($(MOZ_WIDGET_TOOLKIT),beos)
-BEOS_PROGRAM_RESOURCE	= $(srcdir)/viewer-beos.rsrc
-TOOLKIT_CPPSRCS		= nsBeOSMain.cpp
-endif
-ifeq ($(MOZ_WIDGET_TOOLKIT),photon)
-TOOLKIT_CPPSRCS		= nsPhMain.cpp nsPhMenu.cpp
-endif
-endif
-
-ifeq ($(MOZ_WIDGET_TOOLKIT),gtk)
-GTK_GLUE		= -lgtksuperwin
-endif
-
-ifdef MOZ_OJI
-JSJ_LIB			= -ljsj
-endif
-
-XP_DIST_LIBS		= \
-			-lraptorgfx \
-			-lmozjs \
-			-lxpcom \
-			$(JSJ_LIB) \
-			$(NULL)
-
-XP_NS_UNDERBAR_CRAP	= \
-			$(MOZ_NECKO_UTIL_LIBS) \
-			$(MOZ_TIMER_LIBS) \
-			$(MOZ_WIDGET_SUPPORT_LIBS) \
-			$(NULL)
-
-XP_LIBS			= \
-			$(XP_NS_UNDERBAR_CRAP) \
-			$(XP_DIST_LIBS) \
-			$(NSPR_LIBS) \
-			$(NULL)
-
-ifdef MOZ_FULLCIRCLE
-XP_LIBS			+= $(FULLCIRCLE_LIBS)
-endif
-
-LIBS			= \
-			$(UNIX_VIEWER_TK_LIBS) \
-			$(GTK_GLUE) \
-			$(XP_LIBS) \
-			$(TK_LIBS) \
-			$(NULL)
-
-MOTIF_LIBS		= -lviewer_motif_s $(XP_LIBS) $(MOZ_MOTIF_LDFLAGS)
-QT_LIBS			= -lviewer_qt_s $(XP_LIBS) $(MOZ_QT_LDFLAGS)
-XLIB_LIBS		= -lviewer_xlib_s $(XP_LIBS) $(MOZ_XLIB_LDFLAGS)
-GTK_LIBS		= -lviewer_gtk_s -lgtksuperwin $(XP_LIBS) $(MOZ_GTK_LDFLAGS)
-
-EXTRA_DEPS		= \
-			$(addprefix $(DIST)/,$(patsubst -l%,bin/lib%.$(DLL_SUFFIX),$(XP_DIST_LIBS:-l%_s=lib/lib%_s.a))) \
-			$(UNIX_VIEWER_TK_LIBS) \
-			$(XP_NS_UNDERBAR_CRAP) \
-			$(NULL)
-
-include $(topsrcdir)/config/rules.mk
-
-CXXFLAGS		+= $(MOZ_TOOLKIT_REGISTRY_CFLAGS)
-
-install:: $(PROGRAM) $(srcdir)/mozilla-viewer.sh
-	$(INSTALL) $(EXPORT_RESOURCE_SAMPLES) $(DIST)/bin/res/samples
-	$(INSTALL) $(EXPORT_RESOURCE_THROBBER) $(DIST)/bin/res/throbber
-	$(INSTALL) $(srcdir)/resources/viewer.properties $(DIST)/bin/res
-	$(INSTALL) $(srcdir)/mozilla-viewer.sh $(DIST)/bin
-
-$(PROGRAM)_gtk: $(PROGOBJS) $(EXTRA_DEPS) Makefile Makefile.in $(DIST)/lib/libviewer_gtk_s.a
-	$(CCC) -o $@ $(PROGOBJS) $(LDFLAGS) $(LIBS_DIR) $(GTK_LIBS) $(OS_LIBS)
-	$(MOZ_POST_PROGRAM_COMMAND) $@
-
-$(PROGRAM)_motif: $(PROGOBJS) $(EXTRA_DEPS) Makefile Makefile.in $(DIST)/lib/libviewer_motif_s.a
-	$(CCC) -o $@ $(PROGOBJS) $(LDFLAGS) $(LIBS_DIR) $(MOTIF_LIBS) $(OS_LIBS)
-	$(MOZ_POST_PROGRAM_COMMAND) $@
-
-$(PROGRAM)_qt: $(PROGOBJS) $(EXTRA_DEPS) Makefile Makefile.in $(DIST)/lib/libviewer_qt_s.a
-	$(CCC) -o $@ $(PROGOBJS) $(LDFLAGS) $(LIBS_DIR) $(QT_LIBS) $(OS_LIBS)
-	$(MOZ_POST_PROGRAM_COMMAND) $@
-
-$(PROGRAM)_xlib: $(PROGOBJS) $(EXTRA_DEPS) Makefile Makefile.in $(DIST)/lib/libviewer_xlib_s.a
-	$(CCC) -o $@ $(PROGOBJS) $(LDFLAGS) $(LIBS_DIR) $(XLIB_LIBS) $(OS_LIBS)
-	$(MOZ_POST_PROGRAM_COMMAND) $@
-
-ifdef MOZ_ENABLE_GTK
-install:: $(PROGRAM)_gtk
-	$(INSTALL) -m 555 $< $(DIST)/bin
-
-clobber::
-	rm -f $(PROGRAM)_gtk
-endif
-
-ifdef MOZ_ENABLE_MOTIF
-install:: $(PROGRAM)_motif
-	$(INSTALL) -m 555 $< $(DIST)/bin
-
-clobber::
-	rm -f $(PROGRAM)_motif
-endif
-
-ifdef MOZ_ENABLE_QT
-install:: $(PROGRAM)_qt
-	$(INSTALL) -m 555 $< $(DIST)/bin
-
-clobber::
-	rm -f $(PROGRAM)_qt
-endif
-
-ifdef MOZ_ENABLE_XLIB
-install:: $(PROGRAM)_xlib
-	$(INSTALL) -m 555 $< $(DIST)/bin
-
-clobber::
-	rm -f $(PROGRAM)_xlib
-endif
-

mozilla/webshell/tests/viewer/unix/gtk/nsGtkMenu.cpp

@@ -1,179 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * 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): 
- */
-
-#include <gtk/gtk.h>
-
-#include "gdksuperwin.h"
-#include "gtkmozbox.h"
-
-#include "nsBrowserWindow.h"
-#include "resources.h"
-#include "nscore.h"
-
-#include "stdio.h"
-
-typedef GtkItemFactoryCallback GIFC;
-
-void gtk_ifactory_cb (nsBrowserWindow *nbw,
-                      guint callback_action, 
-                      GtkWidget *widget)
-{
-  nbw->DispatchMenuItem(callback_action);
-}
-
-GtkItemFactoryEntry menu_items[] =
-{
-  { "/_File",				nsnull,	nsnull,			0,			"<Branch>" },
-  { "/File/_New Window",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_WINDOW_OPEN,	nsnull },
-  { "/File/_Open...",			nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_FILE_OPEN,	nsnull },
-  { "/File/_View Source",		nsnull, (GIFC)gtk_ifactory_cb,	VIEW_SOURCE,		nsnull },
-  { "/File/_Samples",			nsnull,	nsnull,			0,			"<Branch>" },
-  { "/File/Samples/demo #0",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO0,		nsnull },
-  { "/File/Samples/demo #1",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO1,		nsnull },
-  { "/File/Samples/demo #2",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO2,		nsnull },
-  { "/File/Samples/demo #3",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO3,		nsnull },
-  { "/File/Samples/demo #4",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO4,		nsnull },
-  { "/File/Samples/demo #5",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO5,		nsnull },
-  { "/File/Samples/demo #6",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO6,		nsnull },
-  { "/File/Samples/demo #7",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO7,		nsnull },
-  { "/File/Samples/demo #8",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO8,		nsnull },
-  { "/File/Samples/demo #9",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO9,		nsnull },
-  { "/File/Samples/demo #10",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO10,		nsnull },
-  { "/File/Samples/demo #11",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO11,		nsnull },
-  { "/File/Samples/demo #12",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO12,		nsnull },
-  { "/File/Samples/demo #13",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO13,		nsnull },
-  { "/File/Samples/demo #14",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO14,		nsnull },
-  { "/File/Samples/demo #15",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO15,		nsnull },
-  { "/File/Samples/demo #16",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO16,		nsnull },
-  { "/File/Samples/demo #17",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEMO17,		nsnull },
-  { "/File/_Test Sites",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_TOP100,		nsnull },
-  { "/File/XPToolkit Tests",		nsnull,	nsnull,			0,			"<Branch>" },
-  { "/File/XPToolkit Tests/Toolbar Test 1",       nsnull, (GIFC)gtk_ifactory_cb,  VIEWER_XPTOOLKITTOOLBAR1,     nsnull },
-  { "/File/XPToolkit Tests/Tree Test 1",       nsnull, (GIFC)gtk_ifactory_cb,  VIEWER_XPTOOLKITTREE1,     nsnull },
-  { "/File/sep1",			nsnull,	nsnull,			0,			"<Separator>" },
-  { "/File/Print Preview",	nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_ONE_COLUMN,	nsnull },
-  { "/File/Print",			nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_PRINT,		nsnull },
-  { "/File/Print Setup",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_PRINT_SETUP,	nsnull },
-  { "/File/sep2",			nsnull,	nsnull,			0,			"<Separator>" },
-  { "/File/_Exit",			nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_EXIT,		nsnull },
-
-  { "/_Edit",				nsnull,	nsnull,			0,			"<Branch>" },
-  { "/Edit/Cu_t",			nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_EDIT_CUT,	nsnull },
-  { "/Edit/_Copy",			nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_EDIT_COPY,	nsnull },
-  { "/Edit/_Paste",			nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_EDIT_PASTE,	nsnull },
-  { "/Edit/sep1",			nsnull,	nsnull,			0,			"<Separator>" },
-  { "/Edit/Select All",			nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_EDIT_SELECTALL,	nsnull },
-  { "/Edit/sep1",			nsnull,	nsnull,			0,			"<Separator>" },
-  { "/Edit/Find in Page",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_EDIT_FINDINPAGE,	nsnull },
-
-//#ifdef DEBUG // turning off for now
-  { "/_Debug",				nsnull,	nsnull,			0,			"<Branch>"	},
-  { "/Debug/_Visual Debugging",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_VISUAL_DEBUGGING,nsnull },
-  { "/Debug/sep1",			nsnull,	nsnull,			0,			"<Separator>" },
-  { "/Debug/Event Debugging/Toggle Paint Flashing",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_TOGGLE_PAINT_FLASHING,nsnull },
-  { "/Debug/Event Debugging/Toggle Paint Dumping",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_TOGGLE_PAINT_DUMPING,nsnull },
-  { "/Debug/Event Debugging/Toggle Invalidate Dumping",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_TOGGLE_INVALIDATE_DUMPING,nsnull },
-  { "/Debug/Event Debugging/Toggle Event Dumping",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_TOGGLE_EVENT_DUMPING,nsnull },
-  { "/Debug/Event Debugging/sep1", nsnull,	nsnull,			0,			"<Separator>" },
-  { "/Debug/Event Debugging/Toggle Motion Event Dumping",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_TOGGLE_MOTION_EVENT_DUMPING,nsnull },
-  { "/Debug/Event Debugging/Toggle Crossing Event Dumping",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_TOGGLE_CROSSING_EVENT_DUMPING,nsnull },
-  { "/Debug/sep1",			nsnull,	nsnull,			0,			"<Separator>" },
-  { "/Debug/_Reflow Test",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_REFLOW_TEST,	nsnull },
-  { "/Debug/sep1",			nsnull,	nsnull,			0,			"<Separator>" },
-  { "/Debug/Dump _Content",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DUMP_CONTENT,	nsnull },
-  { "/Debug/Dump _Frames",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DUMP_FRAMES,	nsnull },
-  { "/Debug/Dump _Views",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DUMP_VIEWS,	nsnull },
-  { "/Debug/sep1",			nsnull,	nsnull,			0,			"<Separator>" },
-  { "/Debug/Dump _Style Sheets",	nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DUMP_STYLE_SHEETS,	nsnull },
-  { "/Debug/Dump _Style Contexts",	nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DUMP_STYLE_CONTEXTS,	nsnull},
-  { "/Debug/sep1",			nsnull,	nsnull,			0,			"<Separator>" },
-  { "/Debug/Show Content Size",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_SHOW_CONTENT_SIZE,nsnull },
-  { "/Debug/Show Frame Size",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_SHOW_FRAME_SIZE,	nsnull },
-  { "/Debug/Show Style Size",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_SHOW_STYLE_SIZE,	nsnull },
-  { "/Debug/sep1",			nsnull,	nsnull,			0,			"<Separator>" },
-  { "/Debug/Debug Save",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEBUGSAVE,	nsnull },
-  { "/Debug/Debug Output Text",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DISPLAYTEXT,	nsnull },
-  { "/Debug/Debug Output HTML",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DISPLAYHTML,	nsnull },
-  { "/Debug/Debug Toggle Selection",	nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_TOGGLE_SELECTION,nsnull },
-  { "/Debug/sep1",			nsnull,	nsnull,			0,			"<Separator>" },
-  { "/Debug/Debug Robot",		nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_DEBUGROBOT,	nsnull },
-  { "/Debug/sep1",			nsnull,	nsnull,			0,			"<Separator>" },
-  { "/Debug/Show Content Quality",	nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_SHOW_CONTENT_QUALITY,	nsnull },
-  { "/_Style",				nsnull,	nsnull,			0,			"<Branch>"	},
-  { "/Style/Select _Style Sheet",	       nsnull, nsnull,        0,        "<Branch>" },
-  { "/Style/Select Style Sheet/List Available Sheets", nsnull, (GIFC)gtk_ifactory_cb, VIEWER_SELECT_STYLE_LIST, nsnull },
-  { "/Style/Select Style Sheet/sep1", nsnull, nsnull,        0,        "<Separator>" },
-  { "/Style/Select Style Sheet/Select Default", nsnull, (GIFC)gtk_ifactory_cb, VIEWER_SELECT_STYLE_DEFAULT, nsnull },
-  { "/Style/Select Style Sheet/sep1", nsnull, nsnull,        0,        "<Separator>" },
-  { "/Style/Select Style Sheet/Select Alternative 1", nsnull, (GIFC)gtk_ifactory_cb, VIEWER_SELECT_STYLE_ONE, nsnull },
-  { "/Style/Select Style Sheet/Select Alternative 2", nsnull, (GIFC)gtk_ifactory_cb, VIEWER_SELECT_STYLE_TWO, nsnull },
-  { "/Style/Select Style Sheet/Select Alternative 3", nsnull, (GIFC)gtk_ifactory_cb, VIEWER_SELECT_STYLE_THREE, nsnull },
-  { "/Style/Select Style Sheet/Select Alternative 4", nsnull, (GIFC)gtk_ifactory_cb, VIEWER_SELECT_STYLE_FOUR, nsnull },
-  { "/Style/_Compatibility Mode",		nsnull,	nsnull,			0,			"<Branch>" },
-  { "/Style/Compatibility Mode/Nav Quirks",	nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_NAV_QUIRKS_MODE,	nsnull },
-  { "/Style/Compatibility Mode/Standard",	nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_STANDARD_MODE,	nsnull },
-
-  { "/Style/_Widget Render Mode",		nsnull,	nsnull,			0,			"<Branch>" },
-  { "/Style/Widget Render Mode/Native",	nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_NATIVE_WIDGET_MODE,	nsnull },
-  { "/Style/Widget Render Mode/Gfx",	nsnull,	(GIFC)gtk_ifactory_cb,	VIEWER_GFX_WIDGET_MODE,	nsnull },
-//#endif
-
-  { "/_Tools",                                nsnull, nsnull,                 0,              "<Branch>" },
-  { "/Tools/_JavaScript Console",	nsnull,	(GIFC)gtk_ifactory_cb,	JS_CONSOLE,	nsnull },
-  { "/Tools/_Editor Mode",		nsnull,	(GIFC)gtk_ifactory_cb,	EDITOR_MODE,	nsnull }
-};
-
-void CreateViewerMenus(nsIWidget *   aParent, 
-                       gpointer      data,
-                       GtkWidget **  aMenuBarOut) 
-{
-  NS_ASSERTION(nsnull != aParent,"null parent.");
-  NS_ASSERTION(nsnull != aMenuBarOut,"null out param.");
-
-  GtkItemFactory *item_factory;
-  GtkWidget *menubar;
-
-  GdkSuperWin *gdkSuperWin;
-  GtkWidget   *mozBox;
-
-  gdkSuperWin = (GdkSuperWin*)aParent->GetNativeData(NS_NATIVE_WIDGET);
-  
-  int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
-  item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", nsnull);
-
-  gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, data);
-
-  menubar = gtk_item_factory_get_widget (item_factory, "<main>");
-
-  gtk_menu_bar_set_shadow_type (GTK_MENU_BAR(menubar), GTK_SHADOW_NONE);
-
-  NS_ASSERTION(GDK_IS_SUPERWIN(gdkSuperWin), "code assumes a gdksuperwin.");
-  mozBox = gtk_mozbox_new(gdkSuperWin->bin_window);
-  NS_ASSERTION((mozBox != NULL), "failed to create mozBox.");
-
-  gtk_container_add(GTK_CONTAINER(mozBox), menubar);
-  gtk_mozbox_set_position(GTK_MOZBOX(mozBox), 0, 0 );
-  gtk_widget_show(mozBox);
-  gtk_widget_show(menubar);
-
-  *aMenuBarOut = menubar;
-}

mozilla/widget/src/gtk/Makefile.in

@@ -1,100 +0,0 @@
-#
-# 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
-
-LIBRARY_NAME	= widget_gtk
-
-REQUIRES	= util img xpcom raptor netlib
-
-CPPSRCS		= \
-		nsAppShell.cpp \
-		nsButton.cpp \
-		nsCheckButton.cpp \
-		nsClipboard.cpp \
-		nsComboBox.cpp \
-		nsContextMenu.cpp \
-		nsDragService.cpp \
-		nsFilePicker.cpp \
-		nsFileWidget.cpp \
-		nsFontRetrieverService.cpp \
-		nsFontSizeIterator.cpp \
-		nsGtkEventHandler.cpp \
-		nsGtkUtils.cpp \
-		nsLabel.cpp \
-		nsListBox.cpp \
-		nsLookAndFeel.cpp \
-		nsMenu.cpp \
-		nsMenuBar.cpp \
-		nsMenuItem.cpp \
-		nsPopUpMenu.cpp \
-		nsRadioButton.cpp \
-		nsScrollbar.cpp \
-		nsSound.cpp \
-		nsTextAreaWidget.cpp \
-		nsTextHelper.cpp \
-		nsTextWidget.cpp \
-		nsToolkit.cpp \
-		nsWidget.cpp \
-		nsWidgetFactory.cpp \
-		nsWindow.cpp \
-		$(NULL)
-
-SHARED_LIBRARY_LIBS = $(DIST)/lib/libraptorbasewidget_s.a
-
-EXTRA_DSO_LDOPTS = \
-		$(MKSHLIB_FORCE_ALL) \
-		$(SHARED_LIBRARY_LIBS) \
-		$(MKSHLIB_UNFORCE_ALL) \
-		$(MOZ_COMPONENT_LIBS) \
-		-lraptorgfx \
-		$(NULL)
-
-ifndef MOZ_MONOLITHIC_TOOLKIT
-EXTRA_DSO_LDOPTS +=  -L$(DIST)/lib -lgtksuperwin $(MOZ_GTK_LDFLAGS)
-else
-EXTRA_DSO_LDOPTS += $(TK_LIBS)
-endif
-
-include $(topsrcdir)/config/rules.mk
-
-ifndef MOZ_MONOLITHIC_TOOLKIT
-CXXFLAGS	+= $(MOZ_GTK_CFLAGS)
-CFLAGS		+= $(MOZ_GTK_CFLAGS)
-else
-CXXFLAGS	+= $(TK_CFLAGS)
-CFLAGS		+= $(TK_CFLAGS)
-endif
-
-DEFINES		+= -D_IMPL_NS_WIDGET -DUSE_XIM
-
-ifeq ($(OS_ARCH), Linux)
-DEFINES		+= -D_BSD_SOURCE
-endif
-
-INCLUDES	+= \
-		-I$(srcdir)/../xpwidgets \
-		-I$(srcdir) \
-		$(NULL)
-
-$(LIBRARY) $(SHARED_LIBRARY): $(SHARED_LIBRARY_LIBS) Makefile
-

mozilla/widget/src/gtk/mozicon.xpm

@@ -1,292 +0,0 @@
-/* XPM */
-static char * mozilla_icon_xpm[] = {
-"32 32 257 2",
-"  	c None",
-". 	c #AA7303",
-"+ 	c #A67003",
-"@ 	c #B77C03",
-"# 	c #8D6003",
-"$ 	c #8D6004",
-"% 	c #6C4A04",
-"& 	c #3A2804",
-"* 	c #6B4802",
-"= 	c #9B6903",
-"- 	c #5A2C04",
-"; 	c #411B04",
-"> 	c #9D6A03",
-", 	c #7A5203",
-"' 	c #510D04",
-") 	c #6B1104",
-"! 	c #7D5503",
-"~ 	c #674604",
-"{ 	c #C21E04",
-"] 	c #C21D04",
-"^ 	c #523804",
-"/ 	c #513702",
-"( 	c #552904",
-"_ 	c #DD2204",
-": 	c #DF2204",
-"< 	c #582904",
-"[ 	c #5F3F02",
-"} 	c #6B2504",
-"| 	c #FE2604",
-"1 	c #AB7303",
-"2 	c #9B6904",
-"3 	c #C31F04",
-"4 	c #FE2704",
-"5 	c #A81904",
-"6 	c #926304",
-"7 	c #4D3302",
-"8 	c #483104",
-"9 	c #C61E04",
-"0 	c #B11B04",
-"a 	c #891604",
-"b 	c #761204",
-"c 	c #614304",
-"d 	c #775102",
-"e 	c #795102",
-"f 	c #785102",
-"g 	c #C58603",
-"h 	c #642404",
-"i 	c #B21A04",
-"j 	c #1F0604",
-"k 	c #550E04",
-"l 	c #631004",
-"m 	c #402404",
-"n 	c #AF7703",
-"o 	c #3D2902",
-"p 	c #7F5602",
-"q 	c #805604",
-"r 	c #0C0904",
-"s 	c #080604",
-"t 	c #080706",
-"u 	c #090604",
-"v 	c #060404",
-"w 	c #620F04",
-"x 	c #7A1304",
-"y 	c #030204",
-"z 	c #570E04",
-"A 	c #721204",
-"B 	c #270704",
-"C 	c #080504",
-"D 	c #0A0604",
-"E 	c #533804",
-"F 	c #A56F02",
-"G 	c #B87C03",
-"H 	c #3B2804",
-"I 	c #A51904",
-"J 	c #FC2704",
-"K 	c #D62004",
-"L 	c #691004",
-"M 	c #C01E04",
-"N 	c #6D1004",
-"O 	c #9C1804",
-"P 	c #B31C04",
-"Q 	c #150404",
-"R 	c #801404",
-"S 	c #DD2304",
-"T 	c #120404",
-"U 	c #130404",
-"V 	c #500C04",
-"W 	c #CC1E04",
-"X 	c #AA1A04",
-"Y 	c #100904",
-"Z 	c #B47A03",
-"` 	c #A77103",
-" .	c #513704",
-"..	c #891704",
-"+.	c #F62604",
-"@.	c #BA1D04",
-"#.	c #3C0A04",
-"$.	c #EB2304",
-"%.	c #DE2304",
-"&.	c #560E04",
-"*.	c #E82304",
-"=.	c #FE2804",
-"-.	c #BE1D04",
-";.	c #F12404",
-">.	c #661004",
-",.	c #020204",
-"'.	c #5E0F04",
-").	c #A61A04",
-"!.	c #4A3204",
-"~.	c #BC7E03",
-"{.	c #8E6002",
-"].	c #684604",
-"^.	c #390D04",
-"/.	c #EE2404",
-"(.	c #FE2904",
-"_.	c #7D1304",
-":.	c #8C1504",
-"<.	c #200604",
-"[.	c #A81A04",
-"}.	c #E72204",
-"|.	c #DA2004",
-"1.	c #070204",
-"2.	c #280704",
-"3.	c #543904",
-"4.	c #9F6C02",
-"5.	c #674602",
-"6.	c #B47B04",
-"7.	c #311004",
-"8.	c #B11C04",
-"9.	c #AA1B04",
-"0.	c #6A1104",
-"a.	c #801504",
-"b.	c #2B0704",
-"c.	c #09090A",
-"d.	c #450B04",
-"e.	c #360904",
-"f.	c #DC2204",
-"g.	c #EE2504",
-"h.	c #C11D04",
-"i.	c #6F1104",
-"j.	c #704B04",
-"k.	c #9C6902",
-"l.	c #A56F03",
-"m.	c #5F4004",
-"n.	c #8D1604",
-"o.	c #440A04",
-"p.	c #1A0504",
-"q.	c #931604",
-"r.	c #621004",
-"s.	c #7F1404",
-"t.	c #921704",
-"u.	c #F82504",
-"v.	c #F52504",
-"w.	c #981804",
-"x.	c #241804",
-"y.	c #5B3E04",
-"z.	c #D82204",
-"A.	c #D02004",
-"B.	c #DA2104",
-"C.	c #D52104",
-"D.	c #2A1A04",
-"E.	c #AC7403",
-"F.	c #2B1C04",
-"G.	c #D04004",
-"H.	c #FC3C04",
-"I.	c #F94E04",
-"J.	c #881504",
-"K.	c #FC2604",
-"L.	c #792804",
-"M.	c #AC7503",
-"N.	c #9A6803",
-"O.	c #782804",
-"P.	c #F66504",
-"Q.	c #F94B04",
-"R.	c #F46804",
-"S.	c #F46604",
-"T.	c #F76504",
-"U.	c #FB4204",
-"V.	c #C13D04",
-"W.	c #5D0E04",
-"X.	c #DA2204",
-"Y.	c #741604",
-"Z.	c #8C5E03",
-"`.	c #885B03",
-" +	c #8B1904",
-".+	c #DE2204",
-"++	c #D22D04",
-"@+	c #C42D04",
-"#+	c #580E04",
-"$+	c #9F1804",
-"%+	c #895D04",
-"&+	c #D62204",
-"*+	c #371904",
-"=+	c #2C1A04",
-"-+	c #4A0C04",
-";+	c #140404",
-">+	c #AB1A04",
-",+	c #DA2304",
-"'+	c #6A4702",
-")+	c #754F02",
-"!+	c #821404",
-"~+	c #462B04",
-"{+	c #B37A03",
-"]+	c #B17803",
-"^+	c #714C04",
-"/+	c #580F04",
-"(+	c #E32204",
-"_+	c #DD2104",
-":+	c #611D04",
-"<+	c #BA7F03",
-"[+	c #B27803",
-"}+	c #6F1D04",
-"|+	c #FD2704",
-"1+	c #F22504",
-"2+	c #634304",
-"3+	c #875B03",
-"4+	c #734F02",
-"5+	c #805704",
-"6+	c #1D0504",
-"7+	c #DB2204",
-"8+	c #EA2404",
-"9+	c #2E0804",
-"0+	c #815803",
-"a+	c #941704",
-"b+	c #C11E04",
-"c+	c #391B04",
-"d+	c #A77104",
-"e+	c #B67C04",
-"f+	c #371D04",
-"g+	c #360A04",
-"h+	c #573A04",
-"i+	c #372604",
-"j+	c #3E2104",
-"k+	c #B57A03",
-"l+	c #B57B03",
-"m+	c #603F04",
-"n+	c #430A04",
-"o+	c #351904",
-"p+	c #A36E03",
-"q+	c #BE8103",
-"r+	c #1D1404",
-"s+	c #483004",
-"t+	c #A26E03",
-"u+	c #6D4B02",
-"v+	c #825804",
-"w+	c #0B0804",
-"x+	c #976603",
-"y+	c #815703",
-"z+	c #926404",
-"A+	c #895D03",
-"B+	c #614202",
-"C+	c #9A6804",
-"D+	c #C88704",
-"E+	c #C18303",
-"F+	c #654302",
-"G+	c #744F02",
-"H+	c #704B02",
-"                                                                ",
-"                                .                               ",
-"                              + @                               ",
-"                              # $                               ",
-"                              % & *                             ",
-"                            = - ; >                             ",
-"                            , ' ) !                             ",
-"                            ~ { ] ^                             ",
-"                          / ( _ : < [                           ",
-"                          . } | | } 1                           ",
-"                          2 3 | 4 5 6                           ",
-"                        7 8 9 0 a b c                           ",
-"  d e f f f d d d d d d g h i j k l m n d d d d d d d d d d d o ",
-"  p q r s s s s t s s u v w x y z A B C D D D D D s s s s E F   ",
-"      G H I J 4 | 4 | K L L M N O P Q R | S T U V W X Y Z       ",
-"        `  ...+.| 4 @.#.$.4 | %.&.*.4 =.-.;.>.,.'.).!.~.        ",
-"          {.].^./.(.X _.;.| :.T <.[.| }.z | |.1.2.3.4.          ",
-"            5.6.7.8.9.0.a.b.c.d.e.f.g.h.&.| i.u j.k.            ",
-"                l.m.n.o.p.q._.r.a.s.t.u.v.w.x.Z                 ",
-"                  {.y.P z.R A.v.x j B.| C.D.E.                  ",
-"                    F.G.H.I.4 | 4 t.J.f.K.L.M.                  ",
-"                  N.O.P.Q.R.S.T.U.V.W.X.4 Y.Z.                  ",
-"                  `. +4 =.| | .+++@+#+$+| K %+                  ",
-"                  %+&+| | | I *+=+-+;+>+,+&+x.'+                ",
-"                )+=+X.=.| !+~+{+]+^+,./+(+_+:+<+                ",
-"                [+}+|+1+) 2+3+    4+5+6+7+8+9+0+                ",
-"                $ a+b+c+d+            e+f+0.g+h+                ",
-"                i+A j+k+                l+m+n+o+p+              ",
-"              q+r+s+t+                    u+v+w+x+              ",
-"              y+z+A+                        B+C+2               ",
-"              D+                                E+F+            ",
-"            G+                                    H+            "};

mozilla/widget/src/gtk/mozicon50.xpm

@@ -1,63 +0,0 @@
-/* XPM */
-static char * mozicon50_xpm[] = {
-"50 51 9 1",
-" 	c None",
-".	c #000000",
-"+	c #FF0000",
-"@	c #808000",
-"#	c #800000",
-"$	c #FF6633",
-"%	c #990066",
-"&	c #FF00FF",
-"*	c #222222",
-"                                                  ",
-"                         @                        ",
-"                        $@                        ",
-"                        @@                        ",
-"                        @@$                       ",
-"                       $@*@                       ",
-"                       @@.@                       ",
-"                       @..@                       ",
-"                      $@..@@                      ",
-"                      $@##*@                      ",
-"                      @*#+.@                      ",
-"                      @.++.@$                     ",
-"                     $@.++.@$                     ",
-"                     @*#++#*@                     ",
-"                     @.++++.@                     ",
-"                    $@.++++.@$                    ",
-"                    @*#++++**@                    ",
-"                    @.#++++#.@                    ",
-"                   $@.++####.@                    ",
-"                   @@*+#*##*.@@                   ",
-"*@@@@@@@@@@@@@@@@@@@.#+..*##*#@@@@@@@@@@@@@@@@@@@*",
-" *@@*................+#..*###.................@@* ",
-"  %@@@.#++++++++++++#**#*#++.###++*...#+++#.*@@*  ",
-"    *@@.#+++++++++#.##++#+#+*.#+++#..##++#.@@@%   ",
-"      $@..+++++++.#++++++##++++#++#...++*.@@$     ",
-"       @@*.#+++++.#+++++*.#++++##++#.*...@@       ",
-"        $@@.#+++#*++++#....#+++*#+++...*@$        ",
-"         *@@..++#*++#**.*.*+++#.#++*..@@$         ",
-"           $@*.++******#+++++#+#+++..@@           ",
-"            $@@.##..*$#**#+#*#++++..@@            ",
-"             $@@.#+#***##...#++++.*@@             ",
-"              %@@*++++++++#.#++++.@@              ",
-"               @.#+++++++++.##+++.@$              ",
-"               @.+$$$$$+$$$#*#+++*@@              ",
-"              $@*+$$$$$$$+$#.#+++#.@              ",
-"              @*#+++++++++++.#++++.@              ",
-"              @.#+++++++#*++.##+++.@$             ",
-"             $@.+++++++....#..+#++*@@             ",
-"             @@*+++++#.*@@@...*+++#.@             ",
-"             @.#++++#.@@@ @@..#++++.@             ",
-"             @.++++*.@@$  %@@..+++#.@@            ",
-"            $@.+++..@@*     $@*.#+#**@            ",
-"            @@#+#.*@$%       $@@.##..@            ",
-"            @.##.@@            @@..#.@$           ",
-"           $@.*.@@$             @@**.@$           ",
-"           $@.*@@               %$@@.*@           ",
-"           @.@@$                  *@@.@           ",
-"           @@@$                    %@@@$          ",
-"          $@@%                      %@@@          ",
-"          @@                          $@          ",
-"          $                            *          "};

mozilla/widget/src/gtk/nsAppShell.cpp

@@ -1,459 +0,0 @@
-/* -*- Mode: c++; tab-width: 2; indent-tabs-mode: nil; -*- */
-/*
- * 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): 
- */
-
-#include "prmon.h"
-#include "nsCOMPtr.h"
-#include "nsAppShell.h"
-#include "nsIAppShell.h"
-#include "nsIServiceManager.h"
-#include "nsIEventQueueService.h"
-#include "nsICmdLineService.h"
-#include "nsGtkEventHandler.h"
-#include <stdlib.h>
-
-#ifdef MOZ_GLE
-#include <gle/gle.h>
-#endif
-
-#include "nsIWidget.h"
-#include "nsIPref.h"
-
-
-#include "glib.h"
-
-struct OurGdkIOClosure {
-  GdkInputFunction  function;
-  gpointer          data;
-};
-
-static gboolean
-our_gdk_io_invoke(GIOChannel* source, GIOCondition condition, gpointer data)
-{
-  OurGdkIOClosure* ioc = (OurGdkIOClosure*) data;
-  if (ioc) {
-    (*ioc->function)(ioc->data, g_io_channel_unix_get_fd(source),
-                     GDK_INPUT_READ);
-  }
-  return TRUE;
-}
-
-static void
-our_gdk_io_destroy(gpointer data)
-{
-  OurGdkIOClosure* ioc = (OurGdkIOClosure*) data;
-  if (ioc) {
-    g_free(ioc);
-  }
-}
-
-static gint
-our_gdk_input_add (gint              source,
-                   GdkInputFunction  function,
-                   gpointer          data,
-                   gint              priority)
-{
-  guint result;
-  OurGdkIOClosure *closure = g_new (OurGdkIOClosure, 1);
-  GIOChannel *channel;
-
-  closure->function = function;
-  closure->data = data;
-
-  channel = g_io_channel_unix_new (source);
-  result = g_io_add_watch_full (channel, priority, G_IO_IN,
-                                our_gdk_io_invoke,
-                                closure, our_gdk_io_destroy);
-  g_io_channel_unref (channel);
-
-  return result;
-}
-
-
-//-------------------------------------------------------------------------
-//
-// XPCOM CIDs
-//
-//-------------------------------------------------------------------------
-static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
-static NS_DEFINE_CID(kCmdLineServiceCID, NS_COMMANDLINE_SERVICE_CID);
-static NS_DEFINE_CID(kPrefServiceCID, NS_PREF_CID);
-
-// a linked, ordered list of event queues and their tokens
-class EventQueueToken {
-public:
-  EventQueueToken(nsIEventQueue *aQueue, const gint aToken);
-  virtual ~EventQueueToken();  
-  nsIEventQueue   *mQueue;
-  gint mToken;
-  EventQueueToken *mNext;
-};
-
-EventQueueToken::EventQueueToken(nsIEventQueue *aQueue, const gint aToken) {
-  mQueue = aQueue;
-  NS_IF_ADDREF(mQueue);
-  mToken = aToken;
-  mNext = 0;
-}
-
-EventQueueToken::~EventQueueToken(){
- NS_IF_RELEASE(mQueue);
-}
-
-class EventQueueTokenQueue {
-public:
-  EventQueueTokenQueue();
-  virtual ~EventQueueTokenQueue();
-  nsresult PushToken(nsIEventQueue *aQueue, gint aToken);
-  PRBool PopToken(nsIEventQueue *aQueue, gint *aToken);
-
-private:
-  EventQueueToken *mHead;
-};
-
-EventQueueTokenQueue::EventQueueTokenQueue() {
-  mHead = 0;
-}
-
-EventQueueTokenQueue::~EventQueueTokenQueue() {
-
-  // if we reach this point with an empty token queue, well, fab. however,
-  // we expect the first event queue to still be active. so we take
-  // special care to unhook that queue (not that failing to do so seems
-  // to hurt anything). more queues than that would be an error.
-//NS_ASSERTION(!mHead || !mHead->mNext, "event queue token list deleted when not empty");
-  // (and skip the assertion for now. we're leaking event queues because they
-  // are referenced by things that leak, so this assertion goes off a lot.)
-  if (mHead) {
-    gdk_input_remove(mHead->mToken);
-    delete mHead;
-    // and leak the rest. it's an error, anyway
-  }
-}
-
-nsresult EventQueueTokenQueue::PushToken(nsIEventQueue *aQueue, gint aToken) {
-  EventQueueToken *newToken = new EventQueueToken(aQueue, aToken);
-  NS_ASSERTION(newToken, "couldn't allocate token queue element");
-  if (!newToken)
-    return NS_ERROR_OUT_OF_MEMORY;
-
-  newToken->mNext = mHead;
-  mHead = newToken;
-  return NS_OK;
-}
-
-PRBool EventQueueTokenQueue::PopToken(nsIEventQueue *aQueue, gint *aToken) {
-  EventQueueToken *token, *lastToken;
-  PRBool          found = PR_FALSE;
-  NS_ASSERTION(mHead, "attempt to retrieve event queue token from empty queue");
-  if (mHead)
-    NS_ASSERTION(mHead->mQueue == aQueue, "retrieving event queue from past head of queue queue");
-
-  token = mHead;
-  lastToken = 0;
-  while (token && token->mQueue != aQueue) {
-    lastToken = token;
-    token = token->mNext;
-  }
-  if (token) {
-    if (lastToken)
-      lastToken->mNext = token->mNext;
-    else
-      mHead = token->mNext;
-    found = PR_TRUE;
-    *aToken = token->mToken;
-    delete token;
-  }
-  return found;
-}
-
-//-------------------------------------------------------------------------
-//
-// nsAppShell constructor
-//
-//-------------------------------------------------------------------------
-nsAppShell::nsAppShell()
-{
-  NS_INIT_REFCNT();
-  mDispatchListener = 0;
-  mEventQueueTokens = new EventQueueTokenQueue();
-  // throw on error would really be civilized here
-  NS_ASSERTION(mEventQueueTokens, "couldn't allocate event queue token queue");
-}
-
-//-------------------------------------------------------------------------
-//
-// nsAppShell destructor
-//
-//-------------------------------------------------------------------------
-nsAppShell::~nsAppShell()
-{
-  delete mEventQueueTokens;
-}
-
-//-------------------------------------------------------------------------
-//
-// nsISupports implementation macro
-//
-//-------------------------------------------------------------------------
-
-NS_IMPL_ISUPPORTS1(nsAppShell, nsIAppShell)
-
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsAppShell::SetDispatchListener(nsDispatchListener* aDispatchListener)
-{
-  mDispatchListener = aDispatchListener;
-  return NS_OK;
-}
-
-static void event_processor_callback(gpointer data,
-                                     gint source,
-                                     GdkInputCondition condition)
-{
-  nsIEventQueue *eventQueue = (nsIEventQueue*)data;
-  if (eventQueue)
-    eventQueue->ProcessPendingEvents();
-}
-
-#define PREF_NCOLS "browser.ncols"
-#define PREF_INSTALLCMAP "browser.installcmap"
-
-static void
-HandleColormapPrefs( void )
-{
-	PRInt32 ivalue = 0;
-        PRBool bvalue;
-	nsresult rv;
-
-	/* The default is to do nothing. INSTALLCMAP has precedence over
-	   NCOLS. Ignore the fact we can't do this if it fails, as it is
-	   not critical */
- 
-	NS_WITH_SERVICE(nsIPref, prefs, kPrefServiceCID, &rv);
-	if (NS_FAILED(rv) || (!prefs)) 
-		return;
-       
-	/* first check ncols */
- 
-	rv = prefs->GetIntPref(PREF_NCOLS, &ivalue);
-	if (NS_SUCCEEDED(rv) && ivalue >= 0 && ivalue <= 255 ) {
-		gdk_rgb_set_min_colors( ivalue );
-		return;
-	}
-
-	/* next check installcmap */
-
-	rv = prefs->GetBoolPref(PREF_INSTALLCMAP, &bvalue);
-	if (NS_SUCCEEDED(rv)) {
-		if ( PR_TRUE == bvalue )
-			gdk_rgb_set_min_colors( 255 );	// force it
-		else
-			gdk_rgb_set_min_colors( 0 );
-	}
-}
-	
-//-------------------------------------------------------------------------
-//
-// Create the application shell
-//
-//-------------------------------------------------------------------------
-
-NS_IMETHODIMP nsAppShell::Create(int *bac, char **bav)
-{
-  gchar *home=nsnull;
-  gchar *path=nsnull;
-
-  int argc = bac ? *bac : 0;
-  char **argv = bav;
-#if 1
-  nsresult rv;
-
-  NS_WITH_SERVICE(nsICmdLineService, cmdLineArgs, kCmdLineServiceCID, &rv);
-  if (NS_SUCCEEDED(rv))
-  {
-    rv = cmdLineArgs->GetArgc(&argc);
-    if(NS_FAILED(rv))
-      argc = bac ? *bac : 0;
-
-    rv = cmdLineArgs->GetArgv(&argv);
-    if(NS_FAILED(rv))
-      argv = bav;
-  }
-#endif
-
-  gtk_set_locale ();
-
-  gtk_init (&argc, &argv);
-
-  // It is most convenient for us to intercept our events after
-  // they have been converted to GDK, but before GTK+ gets them
-  gdk_event_handler_set (handle_gdk_event, NULL, NULL);
-
-#ifdef MOZ_GLE
-  gle_init (&argc, &argv);
-#endif
-
-  // delete the cmdLineArgs thing?
-
-  HandleColormapPrefs();
-  gdk_rgb_init();
-
-  home = g_get_home_dir();
-  if ((char*)nsnull != home) {
-    path = g_strdup_printf("%s%c%s", home, G_DIR_SEPARATOR, ".gtkrc");
-    if ((char *)nsnull != path) {
-      gtk_rc_parse(path);
-      g_free(path);
-    }
-  }
-
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-//
-// Spinup - do any preparation necessary for running a message loop
-//
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsAppShell::Spinup()
-{
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-//
-// Spindown - do any cleanup necessary for finishing a message loop
-//
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsAppShell::Spindown()
-{
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-//
-// Run
-//
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsAppShell::Run()
-{
-  NS_ADDREF_THIS();
-  nsresult   rv = NS_OK;
-  nsIEventQueue * EQueue = nsnull;
-
-  // Get the event queue service 
-  NS_WITH_SERVICE(nsIEventQueueService, eventQService, kEventQueueServiceCID, &rv);
-  if (NS_FAILED(rv)) {
-    NS_ASSERTION("Could not obtain event queue service", PR_FALSE);
-    return rv;
-  }
-
-#ifdef DEBUG
-  printf("Got the event queue from the service\n");
-#endif /* DEBUG */
-
-  //Get the event queue for the thread.
-  rv = eventQService->GetThreadEventQueue(PR_GetCurrentThread(), &EQueue);
-
-  // If a queue already present use it.
-  if (EQueue)
-    goto done;
-
-  // Create the event queue for the thread
-  rv = eventQService->CreateThreadEventQueue();
-  if (NS_OK != rv) {
-    NS_ASSERTION("Could not create the thread event queue", PR_FALSE);
-    return rv;
-  }
-  //Get the event queue for the thread
-  rv = eventQService->GetThreadEventQueue(PR_GetCurrentThread(), &EQueue);
-  if (NS_OK != rv) {
-    NS_ASSERTION("Could not obtain the thread event queue", PR_FALSE);
-    return rv;
-  }    
-
-
-done:
-
-#ifdef DEBUG
-  printf("Calling gdk_input_add with event queue\n");
-#endif /* DEBUG */
-
-  // (has to be called explicitly for this, the primordial appshell, because
-  // of startup ordering problems.)
-  ListenToEventQueue(EQueue, PR_TRUE);
-
-  gtk_main();
-
-  NS_IF_RELEASE(EQueue);
-  Release();
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-//
-// Exit a message handler loop
-//
-//-------------------------------------------------------------------------
-
-NS_IMETHODIMP nsAppShell::Exit()
-{
-  gtk_main_quit ();
-
-  return NS_OK;
-}
-
-// does nothing. used by xp code with non-gtk expectations.
-// this method will be removed once xp eventloops are working.
-NS_IMETHODIMP nsAppShell::GetNativeEvent(PRBool &aRealEvent, void *& aEvent)
-{
-  aRealEvent = PR_FALSE;
-  aEvent = 0;
-  return NS_OK;
-}
-
-// simply executes one iteration of the event loop. used by xp code with
-// non-gtk expectations.
-// this method will be removed once xp eventloops are working.
-NS_IMETHODIMP nsAppShell::DispatchNativeEvent(PRBool aRealEvent, void *aEvent)
-{
-  g_main_iteration(PR_TRUE);
-  return NS_OK;
-}
-
-NS_IMETHODIMP nsAppShell::ListenToEventQueue(nsIEventQueue *aQueue,
-                                             PRBool aListen)
-{
-  // tell gdk to listen to the event queue or not
-
-  gint queueToken;
-  if (aListen) {
-    queueToken = our_gdk_input_add(aQueue->GetEventQueueSelectFD(),
-                                   event_processor_callback,
-                                   aQueue, G_PRIORITY_DEFAULT_IDLE);
-    mEventQueueTokens->PushToken(aQueue, queueToken);
-  } else {
-    if (mEventQueueTokens->PopToken(aQueue, &queueToken))
-      gdk_input_remove(queueToken);
-  }
-  return NS_OK;
-}
-

mozilla/widget/src/gtk/nsAppShell.h

@@ -1,50 +0,0 @@
-/* -*- Mode: c++; tab-width: 2; indent-tabs-mode: nil; -*- */
-/*
- * 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): 
- */
-
-#ifndef nsAppShell_h__
-#define nsAppShell_h__
-
-#include "nsIAppShell.h"
-#include <gtk/gtk.h>
-
-/**
- * Native GTK+ Application shell wrapper
- */
-
-class  EventQueueTokenQueue;
-
-class nsAppShell : public nsIAppShell
-{
-public:
-  nsAppShell();
-  virtual ~nsAppShell();
-
-  NS_DECL_ISUPPORTS
-  NS_DECL_NSIAPPSHELL
-
-private:
-  nsDispatchListener   *mDispatchListener;
-  EventQueueTokenQueue *mEventQueueTokens;
-};
-
-#endif // nsAppShell_h__
-

mozilla/widget/src/gtk/nsButton.cpp

@@ -1,156 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * 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): 
- */
-
-#include <gtk/gtk.h>
-
-#include "nsGtkEventHandler.h"
-
-#include "nsButton.h"
-#include "nsString.h"
-
-NS_IMPL_ADDREF_INHERITED(nsButton, nsWidget)
-NS_IMPL_RELEASE_INHERITED(nsButton, nsWidget)
-NS_IMPL_QUERY_INTERFACE2(nsButton, nsIButton, nsIWidget)
-
-//-------------------------------------------------------------------------
-//
-// nsButton constructor
-//
-//-------------------------------------------------------------------------
-nsButton::nsButton() : nsWidget() , nsIButton()
-{
-}
-
-//-------------------------------------------------------------------------
-//
-// Create the native Button widget
-//
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsButton::CreateNative(GtkObject *parentWindow)
-{
-#ifdef USE_SUPERWIN
-    if (!GDK_IS_SUPERWIN(parentWindow)) {
-    g_print("Damn, brother.  That's not a superwin.\n");
-    return NS_ERROR_FAILURE;
-  }
-  
-  GdkSuperWin *superwin = GDK_SUPERWIN(parentWindow);
-
-  mMozBox = gtk_mozbox_new(superwin->bin_window);
-
-#endif
-
-  mWidget = gtk_button_new_with_label("");
-  gtk_widget_set_name(mWidget, "nsButton");
-
-#ifdef USE_SUPERWIN
-
-  // make sure that we put the scrollbar into the mozbox
-
-  gtk_container_add(GTK_CONTAINER(mMozBox), mWidget);
-
-#endif /* USE_SUPERWIN */
-
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-//
-// nsButton destructor
-//
-//-------------------------------------------------------------------------
-nsButton::~nsButton()
-{
-}
-
-void nsButton::InitCallbacks(char * aName)
-{
-  InstallButtonPressSignal(mWidget);
-  InstallButtonReleaseSignal(mWidget);
-
-  InstallEnterNotifySignal(mWidget);
-  InstallLeaveNotifySignal(mWidget);
-
-  // These are needed so that the events will go to us and not our parent.
-  AddToEventMask(mWidget,
-                 GDK_BUTTON_PRESS_MASK |
-                 GDK_BUTTON_RELEASE_MASK |
-                 GDK_ENTER_NOTIFY_MASK |
-                 GDK_EXPOSURE_MASK |
-                 GDK_FOCUS_CHANGE_MASK |
-                 GDK_KEY_PRESS_MASK |
-                 GDK_KEY_RELEASE_MASK |
-                 GDK_LEAVE_NOTIFY_MASK |
-                 GDK_POINTER_MOTION_MASK);
-}
-
-//-------------------------------------------------------------------------
-//
-// Set this button label
-//
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsButton::SetLabel(const nsString& aText)
-{
-  NS_ALLOC_STR_BUF(label, aText, 256);
-
-  gtk_label_set(GTK_LABEL(GTK_BIN (mWidget)->child), label);
-
-  NS_FREE_STR_BUF(label);
-  return (NS_OK);
-}
-
-//-------------------------------------------------------------------------
-//
-// Get this button label
-//
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsButton::GetLabel(nsString& aBuffer)
-{
-  char * text;
-
-  gtk_label_get(GTK_LABEL(GTK_BIN (mWidget)->child), &text);
-  aBuffer.SetLength(0);
-  aBuffer.Append(text);
-
-  return (NS_OK);
-
-}
-
-//-------------------------------------------------------------------------
-//
-// set font for button
-//
-//-------------------------------------------------------------------------
-/* virtual */
-void nsButton::SetFontNative(GdkFont *aFont)
-{
-  GtkStyle *style = gtk_style_copy(GTK_BIN (mWidget)->child->style);
-  // gtk_style_copy ups the ref count of the font
-  gdk_font_unref (style->font);
-  
-  style->font = aFont;
-  gdk_font_ref(style->font);
-  
-  gtk_widget_set_style(GTK_BIN (mWidget)->child, style);
-  
-  gtk_style_unref(style);
-}

mozilla/widget/src/gtk/nsButton.h

@@ -1,53 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * 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): 
- */
-
-#ifndef nsButton_h__
-#define nsButton_h__
-
-#include "nsWidget.h"
-#include "nsIButton.h"
-
-/**
- * Native GTK+ button wrapper
- */
-class nsButton : public nsWidget,
-                 public nsIButton
-{
-
-public:
-  nsButton();
-  virtual ~nsButton();
-
-  NS_DECL_ISUPPORTS_INHERITED
-
-  // nsIButton part
-  NS_IMETHOD     SetLabel(const nsString& aText);
-  NS_IMETHOD     GetLabel(nsString& aBuffer);
-
-  virtual void SetFontNative(GdkFont *aFont);
-
-protected:
-  NS_METHOD CreateNative(GtkObject *parentWindow);
-  virtual void InitCallbacks(char * aName = nsnull);
-};
-
-#endif // nsButton_h__

mozilla/widget/src/gtk/nsCheckButton.cpp

@@ -1,250 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * 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): 
- */
-
-#include "nsCheckButton.h"
-#include "nsString.h"
-
-NS_IMPL_ADDREF_INHERITED(nsCheckButton, nsWidget)
-NS_IMPL_RELEASE_INHERITED(nsCheckButton, nsWidget)
-NS_IMPL_QUERY_INTERFACE2(nsCheckButton, nsICheckButton, nsIWidget)
-
-//-------------------------------------------------------------------------
-//
-// nsCheckButton constructor
-//
-//-------------------------------------------------------------------------
-nsCheckButton::nsCheckButton() : nsWidget() , nsICheckButton()
-{
-  NS_INIT_REFCNT();
-  mLabel = nsnull;
-  mCheckButton = nsnull;
-  mState = PR_FALSE;
-}
-
-//-------------------------------------------------------------------------
-//
-// nsCheckButton destructor
-//
-//-------------------------------------------------------------------------
-nsCheckButton::~nsCheckButton()
-{
-}
-
-void
-nsCheckButton::OnDestroySignal(GtkWidget* aGtkWidget)
-{
-  if (aGtkWidget == mCheckButton) {
-    mCheckButton = nsnull;
-  }
-  else if (aGtkWidget == mLabel) {
-    mLabel = nsnull;
-  }
-  else {
-    nsWidget::OnDestroySignal(aGtkWidget);
-  }
-}
-
-//-------------------------------------------------------------------------
-//
-// Create the native CheckButton widget
-//
-//-------------------------------------------------------------------------
-NS_METHOD  nsCheckButton::CreateNative(GtkObject *parentWindow)
-{
-  mWidget = gtk_event_box_new();
-  mCheckButton = gtk_check_button_new();
-
-  gtk_container_add(GTK_CONTAINER(mWidget), mCheckButton);
-
-  gtk_widget_show(mCheckButton);
-
-  gtk_widget_set_name(mWidget, "nsCheckButton");
-
-  return NS_OK;
-}
-
-void nsCheckButton::InitCallbacks(char * aName)
-{
-  InstallButtonPressSignal(mCheckButton);
-  InstallButtonReleaseSignal(mCheckButton);
-
-  InstallEnterNotifySignal(mWidget);
-  InstallLeaveNotifySignal(mWidget);
-
-  // These are needed so that the events will go to us and not our parent.
-  AddToEventMask(mWidget,
-                 GDK_BUTTON_PRESS_MASK |
-                 GDK_BUTTON_RELEASE_MASK |
-                 GDK_ENTER_NOTIFY_MASK |
-                 GDK_EXPOSURE_MASK |
-                 GDK_FOCUS_CHANGE_MASK |
-                 GDK_KEY_PRESS_MASK |
-                 GDK_KEY_RELEASE_MASK |
-                 GDK_LEAVE_NOTIFY_MASK |
-                 GDK_POINTER_MOTION_MASK);
-
-  // Add in destroy callback
-  gtk_signal_connect(GTK_OBJECT(mCheckButton),
-                     "destroy",
-                     GTK_SIGNAL_FUNC(DestroySignal),
-                     this);
-
-  InstallSignal((GtkWidget *)mCheckButton,
-                (gchar *)"toggled",
-                GTK_SIGNAL_FUNC(nsCheckButton::ToggledSignal));
-}
-
-//-------------------------------------------------------------------------
-//
-// Set this button label
-//
-//-------------------------------------------------------------------------
-NS_METHOD nsCheckButton::SetState(const PRBool aState)
-{
-  mState = aState;
-
-  if (mWidget && mCheckButton) 
-  {
-    GtkToggleButton * item = GTK_TOGGLE_BUTTON(mCheckButton);
-
-    item->active = (gboolean) mState;
-
-    gtk_widget_queue_draw(GTK_WIDGET(item));
-  }
-
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-//
-// Set this button label
-//
-//-------------------------------------------------------------------------
-NS_METHOD nsCheckButton::GetState(PRBool& aState)
-{
-  aState = mState;
-    
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-//
-// Set this Checkbox label
-//
-//-------------------------------------------------------------------------
-NS_METHOD nsCheckButton::SetLabel(const nsString& aText)
-{
-  if (mWidget) {
-    NS_ALLOC_STR_BUF(label, aText, 256);
-    if (mLabel) {
-      gtk_label_set(GTK_LABEL(mLabel), label);
-    } else {
-      mLabel = gtk_label_new(label);
-      gtk_misc_set_alignment (GTK_MISC (mLabel), 0.0, 0.5);
-      gtk_container_add(GTK_CONTAINER(mCheckButton), mLabel);
-      gtk_widget_show(mLabel);
-      gtk_signal_connect(GTK_OBJECT(mLabel),
-                         "destroy",
-                         GTK_SIGNAL_FUNC(DestroySignal),
-                         this);
-    }
-    NS_FREE_STR_BUF(label);
-  }
-  return NS_OK;
-}
-
-
-//-------------------------------------------------------------------------
-//
-// Get this button label
-//
-//-------------------------------------------------------------------------
-NS_METHOD nsCheckButton::GetLabel(nsString& aBuffer)
-{
-  aBuffer.SetLength(0);
-  if (mWidget) {
-    char * text;
-    if (mLabel) {
-      gtk_label_get(GTK_LABEL(mLabel), &text);
-      aBuffer.Append(text);
-    }
-  }
-  return NS_OK;
-}
-
-/* virtual */ void
-nsCheckButton::OnToggledSignal(const gboolean aState)
-{
-  // Untoggle the sonofabitch
-  if (mWidget && mCheckButton) 
-  {
-    GtkToggleButton * item = GTK_TOGGLE_BUTTON(mCheckButton);
-
-    item->active = !item->active;
-
-    gtk_widget_queue_draw(GTK_WIDGET(item));
-  }
-}
-//////////////////////////////////////////////////////////////////////
-
-/* static */ gint 
-nsCheckButton::ToggledSignal(GtkWidget *      aWidget, 
-                             gpointer         aData)
-{
-  NS_ASSERTION( nsnull != aWidget, "widget is null");
-
-  nsCheckButton * button = (nsCheckButton *) aData;
-
-  NS_ASSERTION( nsnull != button, "instance pointer is null");
-
-  button->OnToggledSignal(GTK_TOGGLE_BUTTON(aWidget)->active);
-
-  return PR_TRUE;
-}
-
-//////////////////////////////////////////////////////////////////////
-// SetBackgroundColor for CheckButton
-/*virtual*/
-void nsCheckButton::SetBackgroundColorNative(GdkColor *aColorNor,
-                                        GdkColor *aColorBri,
-                                        GdkColor *aColorDark)
-{
-  // use same style copy as SetFont
-  GtkStyle *style = gtk_style_copy(GTK_WIDGET (g_list_nth_data(gtk_container_children(GTK_CONTAINER (mWidget)),0))->style);
-  
-  style->bg[GTK_STATE_NORMAL]=*aColorNor;
-  
-  // Mouse over button
-  style->bg[GTK_STATE_PRELIGHT]=*aColorBri;
-
-  // Button is down
-  style->bg[GTK_STATE_ACTIVE]=*aColorDark;
-
-  // other states too? (GTK_STATE_ACTIVE, GTK_STATE_PRELIGHT,
-  //               GTK_STATE_SELECTED, GTK_STATE_INSENSITIVE)
-  gtk_widget_set_style(GTK_WIDGET (g_list_nth_data(gtk_container_children(GTK_CONTAINER (mWidget)),0)), style);
-  // set style for eventbox too
-  gtk_widget_set_style(mWidget, style);
-
-  gtk_style_unref(style);
-}
-

mozilla/widget/src/gtk/nsCheckButton.h

@@ -1,75 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * 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): 
- */
-
-#ifndef nsCheckButton_h__
-#define nsCheckButton_h__
-
-#include "nsWidget.h"
-#include "nsICheckButton.h"
-
-/**
- * Native GTK+ Checkbox wrapper
- */
-
-
-class nsCheckButton : public nsWidget,
-                      public nsICheckButton
-{
-
-public:
-  nsCheckButton();
-  virtual                 ~nsCheckButton();
-
-  NS_DECL_ISUPPORTS_INHERITED
-
-  // nsICheckButton part
-  NS_IMETHOD SetLabel(const nsString &aText);
-  NS_IMETHOD GetLabel(nsString &aBuffer);
-  NS_IMETHOD SetState(const PRBool aState);
-  NS_IMETHOD GetState(PRBool& aState);
-
-  virtual void OnToggledSignal(const gboolean aState);
-
-protected:
-  NS_IMETHOD CreateNative(GtkObject *parentWindow);
-  virtual void InitCallbacks(char * aName = nsnull);
-  virtual void OnDestroySignal(GtkWidget* aGtkWidget);
-
-  // Sets background for checkbutton
-  virtual void SetBackgroundColorNative(GdkColor *aColorNor,
-                                        GdkColor *aColorBri,
-                                        GdkColor *aColorDark);
-
-  GtkWidget *mLabel;
-  GtkWidget *mCheckButton;
-
-  // We need to maintain our own state to be in sync with the
-  // gecko check controlling frame.
-  PRBool     mState;
-
-private:
-
-  static gint ToggledSignal(GtkWidget *      aWidget, 
-                            gpointer         aData);
-};
-
-#endif // nsCheckButton_h__

mozilla/widget/src/gtk/nsClipboard.cpp

@@ -1,872 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * 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): 
- */
-
-#include "nsClipboard.h"
-
-#include "nsCOMPtr.h"
-
-#include "nsISupportsArray.h"
-#include "nsIClipboardOwner.h"
-#include "nsITransferable.h"   // kTextMime
-#include "nsISupportsPrimitives.h"
-
-#include "nsIWidget.h"
-#include "nsIComponentManager.h"
-#include "nsIServiceManager.h"
-#include "nsWidgetsCID.h"
-#include "nsXPIDLString.h"
-#include "nsPrimitiveHelpers.h"
-
-#include "nsVoidArray.h"
-
-
-// The class statics:
-GtkWidget* nsClipboard::sWidget = 0;
-
-
-#if defined(DEBUG_mcafee) || defined(DEBUG_pavlov)
-#define DEBUG_CLIPBOARD
-#endif
- 
-enum {
-  TARGET_NONE,
-  TARGET_TEXT_PLAIN,
-  TARGET_TEXT_XIF,
-  TARGET_TEXT_UNICODE,
-  TARGET_TEXT_HTML,
-  TARGET_AOLMAIL,
-  TARGET_IMAGE_PNG,
-  TARGET_IMAGE_JPEG,
-  TARGET_IMAGE_GIF,
-  // compatibility types
-  TARGET_UTF8,
-  TARGET_UNKNOWN,
-  TARGET_LAST
-};
-
-static GdkAtom sSelTypes[TARGET_LAST];
-
-
-//-------------------------------------------------------------------------
-//
-// nsClipboard constructor
-//
-//-------------------------------------------------------------------------
-nsClipboard::nsClipboard() : nsBaseClipboard()
-{
-#ifdef DEBUG_CLIPBOARD
-  g_print("nsClipboard::nsClipboard()\n");
-#endif /* DEBUG_CLIPBOARD */
-
-  //NS_INIT_REFCNT();
-  mIgnoreEmptyNotification = PR_FALSE;
-  mClipboardOwner = nsnull;
-  mTransferable   = nsnull;
-  mSelectionData.data = nsnull;
-  mSelectionData.length = 0;
-
-  // initialize the widget, etc we're binding to
-  Init();
-}
-
-// XXX if GTK's internal code changes this isn't going to work
-// copied from gtk code because it is a static function we can't get to it.
-// need to bug owen taylor about getting this code public.
-
-typedef struct _GtkSelectionTargetList GtkSelectionTargetList;
-
-struct _GtkSelectionTargetList {
-  GdkAtom selection;
-  GtkTargetList *list;
-};
-
-static const char *gtk_selection_handler_key = "gtk-selection-handlers";
-
-void __gtk_selection_target_list_remove (GtkWidget *widget)
-{
-  GtkSelectionTargetList *sellist;
-  GList *tmp_list;
-  GList *lists;
-  lists = (GList*)gtk_object_get_data (GTK_OBJECT (widget), gtk_selection_handler_key);
-  tmp_list = lists;
-  while (tmp_list)
-    {
-      sellist = (GtkSelectionTargetList*)tmp_list->data;
-      gtk_target_list_unref (sellist->list);
-      g_free (sellist);
-      tmp_list = tmp_list->next;
-    }
-  g_list_free (lists);
-  gtk_object_set_data (GTK_OBJECT (widget), gtk_selection_handler_key, NULL);
-}
-
-//-------------------------------------------------------------------------
-//
-// nsClipboard destructor
-//
-//-------------------------------------------------------------------------
-nsClipboard::~nsClipboard()
-{
-#ifdef DEBUG_CLIPBOARD
-  printf("nsClipboard::~nsClipboard()\n");  
-#endif /* DEBUG_CLIPBOARD */
-
-  // Remove all our event handlers:
-  if (sWidget &&
-      (gdk_selection_owner_get(GDK_SELECTION_PRIMARY) == sWidget->window))
-    gtk_selection_remove_all(sWidget);
-
-  // free the selection data, if any
-  if (mSelectionData.data != nsnull)
-    g_free(mSelectionData.data);
-
-  nsClipboard *cb = (nsClipboard*)gtk_object_get_data(GTK_OBJECT(sWidget), "cb");
-  if (cb != nsnull)
-  {
-    NS_RELEASE(cb);
-    gtk_object_remove_data(GTK_OBJECT(sWidget), "cb");
-  }
-
-  if (sWidget)
-  {
-    gtk_widget_destroy(sWidget);
-    sWidget = nsnull;
-  }
-}
-
-
-// 
-// GTK Weirdness!
-// This is here in the hope of being able to call
-//  gtk_selection_add_targets(w, GDK_SELECTION_PRIMARY,
-//                            targets,
-//                            1);
-// instead of
-//   gtk_selection_add_target(sWidget, 
-//                            GDK_SELECTION_PRIMARY,
-//                            GDK_SELECTION_TYPE_STRING,
-//                            GDK_SELECTION_TYPE_STRING);
-// but it turns out that this changes the whole gtk selection model;
-// when calling add_targets copy uses selection_clear_event and the
-// data structure needs to be filled in in a way that we haven't
-// figured out; when using add_target copy uses selection_get and
-// the data structure is already filled in as much as it needs to be.
-// Some gtk internals wizard will need to solve this mystery before
-// we can use add_targets().
-//static GtkTargetEntry targets[] = {
-//  { "strings n stuff", GDK_SELECTION_TYPE_STRING, GDK_SELECTION_TYPE_STRING }
-//};
-//
-
-//-------------------------------------------------------------------------
-void nsClipboard::Init(void)
-{
-#ifdef DEBUG_CLIPBOARD
-  g_print("nsClipboard::Init\n");
-#endif
-
-  sSelTypes[TARGET_NONE]          = GDK_NONE;
-  sSelTypes[TARGET_TEXT_PLAIN]    = gdk_atom_intern(kTextMime, FALSE);
-  sSelTypes[TARGET_TEXT_XIF]      = gdk_atom_intern(kXIFMime, FALSE);
-  sSelTypes[TARGET_TEXT_UNICODE]  = gdk_atom_intern(kUnicodeMime, FALSE);
-  sSelTypes[TARGET_UTF8]          = gdk_atom_intern("UTF8", FALSE);
-  sSelTypes[TARGET_TEXT_HTML]     = gdk_atom_intern(kHTMLMime, FALSE);
-  sSelTypes[TARGET_AOLMAIL]       = gdk_atom_intern(kAOLMailMime, FALSE);
-  sSelTypes[TARGET_IMAGE_PNG]     = gdk_atom_intern(kPNGImageMime, FALSE);
-  sSelTypes[TARGET_IMAGE_JPEG]    = gdk_atom_intern(kJPEGImageMime, FALSE);
-  sSelTypes[TARGET_IMAGE_GIF]     = gdk_atom_intern(kGIFImageMime, FALSE);
-  // compatibility with other apps
-
-
-  // create invisible widget to use for the clipboard
-  sWidget = gtk_invisible_new();
-
-  // add the clipboard pointer to the widget so we can get it.
-  gtk_object_set_data(GTK_OBJECT(sWidget), "cb", this);
-
-  NS_ADDREF_THIS();
-
-  // Handle selection requests if we called gtk_selection_add_target:
-  gtk_signal_connect(GTK_OBJECT(sWidget), "selection_get",
-                     GTK_SIGNAL_FUNC(nsClipboard::SelectionGetCB),
-                     nsnull);
-
-  // When someone else takes the selection away:
-  gtk_signal_connect(GTK_OBJECT(sWidget), "selection_clear_event",
-                     GTK_SIGNAL_FUNC(nsClipboard::SelectionClearCB),
-                     nsnull);
-
-  // Set up the paste handler:
-  gtk_signal_connect(GTK_OBJECT(sWidget), "selection_received",
-                     GTK_SIGNAL_FUNC(nsClipboard::SelectionReceivedCB),
-                     nsnull);
-}
-
-
-//-------------------------------------------------------------------------
-NS_IMETHODIMP nsClipboard::SetNativeClipboardData()
-{
-  mIgnoreEmptyNotification = PR_TRUE;
-
-#ifdef DEBUG_CLIPBOARD
-  printf("  nsClipboard::SetNativeClipboardData()\n");
-#endif /* DEBUG_CLIPBOARD */
-
-  // make sure we have a good transferable
-  if (nsnull == mTransferable) {
-    printf("nsClipboard::SetNativeClipboardData(): no transferable!\n");
-    return NS_ERROR_FAILURE;
-  }
-
-  // are we already the owner?
-  if (gdk_selection_owner_get(GDK_SELECTION_PRIMARY) == sWidget->window)
-  {
-    // if so, clear all the targets
-    __gtk_selection_target_list_remove(sWidget);
-    //    gtk_selection_remove_all(sWidget);
-  }
-
-  // we arn't already the owner, so we will become it
-  gint have_selection = gtk_selection_owner_set(sWidget,
-                                                GDK_SELECTION_PRIMARY,
-                                                GDK_CURRENT_TIME);
-  if (have_selection == 0)
-    return NS_ERROR_FAILURE;
-
-  // get flavor list that includes all flavors that can be written (including ones 
-  // obtained through conversion)
-  nsCOMPtr<nsISupportsArray> flavorList;
-  nsresult errCode = mTransferable->FlavorsTransferableCanExport ( getter_AddRefs(flavorList) );
-  if ( NS_FAILED(errCode) )
-    return NS_ERROR_FAILURE;
-
-  PRUint32 cnt;
-  flavorList->Count(&cnt);
-  for ( PRUint32 i=0; i<cnt; ++i )
-  {
-    nsCOMPtr<nsISupports> genericFlavor;
-    flavorList->GetElementAt ( i, getter_AddRefs(genericFlavor) );
-    nsCOMPtr<nsISupportsString> currentFlavor ( do_QueryInterface(genericFlavor) );
-    if ( currentFlavor ) {
-      nsXPIDLCString flavorStr;
-      currentFlavor->ToString(getter_Copies(flavorStr));
-      gint format = GetFormat(flavorStr);
-
-      // add these types as selection targets
-      RegisterFormat(format);
-    }
-  }
-
-  mIgnoreEmptyNotification = PR_FALSE;
-
-  return NS_OK;
-}
-
-void nsClipboard::AddTarget(GdkAtom aAtom)
-{
-  gtk_selection_add_target(sWidget,
-                           GDK_SELECTION_PRIMARY,
-                           aAtom, aAtom);
-}
-
-gint nsClipboard::GetFormat(const char* aMimeStr)
-{
-  gint type = TARGET_NONE;
-  nsCAutoString mimeStr ( CBufDescriptor(NS_CONST_CAST(char*,aMimeStr), PR_TRUE, PL_strlen(aMimeStr)+1) );
-#ifdef DEBUG_CLIPBOARD
-  g_print("  nsClipboard::GetFormat(%s)\n", aMimeStr);
-#endif
-  if (mimeStr.Equals(kTextMime)) {
-    type = TARGET_TEXT_PLAIN;
-  } else if (mimeStr.Equals("STRING")) {
-    type = TARGET_TEXT_PLAIN;
-  } else if (mimeStr.Equals(kXIFMime)) {
-    type = TARGET_TEXT_XIF;
-  } else if (mimeStr.Equals(kUnicodeMime)) {
-    type = TARGET_TEXT_UNICODE;
-  } else if (mimeStr.Equals(kHTMLMime)) {
-    type = TARGET_TEXT_HTML;
-  } else if (mimeStr.Equals(kAOLMailMime)) {
-    type = TARGET_AOLMAIL;
-  } else if (mimeStr.Equals(kPNGImageMime)) {
-    type = TARGET_IMAGE_PNG;
-  } else if (mimeStr.Equals(kJPEGImageMime)) {
-    type = TARGET_IMAGE_JPEG;
-  } else if (mimeStr.Equals(kGIFImageMime)) {
-    type = TARGET_IMAGE_GIF;
-  }
-
-#ifdef WE_DO_DND
-  else if (mimeStr.Equals(kDropFilesMime)) {
-    format = CF_HDROP;
-  } else {
-    format = ::RegisterClipboardFormat(aMimeStr);
-  }
-#endif
-  return type;
-}
-
-void nsClipboard::RegisterFormat(gint format)
-{
-#ifdef DEBUG_CLIPBOARD
-  g_print("  nsClipboard::RegisterFormat(%s)\n", gdk_atom_name(sSelTypes[format]));
-#endif
-
-  /* when doing the selection_add_target, each case should have the same last parameter
-     which matches the case match */
-  switch(format)
-  {
-  case TARGET_TEXT_PLAIN:
-    // text/plain (default)
-    AddTarget(sSelTypes[format]);
-
-    // STRING (what X uses)
-    AddTarget(GDK_SELECTION_TYPE_STRING);
-    break;
-
-
-  case TARGET_TEXT_XIF:
-    // text/xif (default)
-    AddTarget(sSelTypes[format]);
-    break;
-
-
-  case TARGET_TEXT_UNICODE:
-    // text/unicode (default)
-    AddTarget(sSelTypes[format]);
-
-    // UTF8 (what X uses)
-    AddTarget(sSelTypes[TARGET_UTF8]);
-    break;
-
-
-  case TARGET_TEXT_HTML:
-    // text/html (default)
-    AddTarget(sSelTypes[format]);
-    break;
-
-
-  case TARGET_AOLMAIL:
-    // text/aolmail (default)
-    AddTarget(sSelTypes[format]);
-    break;
-
-
-  case TARGET_IMAGE_PNG:
-    // image/png (default)
-    AddTarget(sSelTypes[format]);
-    break;
-
-
-  case TARGET_IMAGE_JPEG:
-    // image/jpeg (default)
-    AddTarget(sSelTypes[format]);
-    break;
-
-
-  case TARGET_IMAGE_GIF:
-    // image/gif (default)
-    AddTarget(sSelTypes[format]);
-    break;
-
-
-  default:
-    // if we don't match something above, then just add it like its something we know about...
-    AddTarget(sSelTypes[format]);
-  }
-}
-
-PRBool nsClipboard::DoRealConvert(GdkAtom type)
-{
-#ifdef DEBUG_CLIPBOARD
-  g_print("    nsClipboard::DoRealConvert(%li)\n    {\n", type);
-#endif
-  int e = 0;
-  // Set a flag saying that we're blocking waiting for the callback:
-  mBlocking = PR_TRUE;
-
-  //
-  // ask X what kind of data we can get
-  //
-#ifdef DEBUG_CLIPBOARD
-  g_print("     Doing real conversion of atom type '%s'\n", gdk_atom_name(type));
-#endif
-  gtk_selection_convert(sWidget,
-                        GDK_SELECTION_PRIMARY,
-                        type,
-                        GDK_CURRENT_TIME);
-
-  // Now we need to wait until the callback comes in ...
-  // i is in case we get a runaway (yuck).
-#ifdef DEBUG_CLIPBOARD
-  printf("      Waiting for the callback... mBlocking = %d\n", mBlocking);
-#endif /* DEBUG_CLIPBOARD */
-  for (e=0; mBlocking == PR_TRUE && e < 1000; ++e)
-  {
-    gtk_main_iteration_do(PR_TRUE);
-  }
-
-#ifdef DEBUG_CLIPBOARD
-  g_print("    }\n");
-#endif
-
-  if (mSelectionData.length > 0)
-    return PR_TRUE;
-
-  return PR_FALSE;
-}
-
-/* return PR_TRUE if we have converted or PR_FALSE if we havn't and need to keep being called */
-PRBool nsClipboard::DoConvert(gint format)
-{
-#ifdef DEBUG_CLIPBOARD
-  g_print("  nsClipboard::DoConvert(%s)\n", gdk_atom_name(sSelTypes[format]));
-#endif
-
-  /* when doing the selection_add_target, each case should have the same last parameter
-     which matches the case match */
-  PRBool r = PR_FALSE;
-
-  switch(format)
-  {
-  case TARGET_TEXT_PLAIN:
-    r = DoRealConvert(sSelTypes[format]);
-    if (r) return r;
-    r = DoRealConvert(GDK_SELECTION_TYPE_STRING);
-    if (r) return r;
-    break;
-
-  case TARGET_TEXT_XIF:
-    r = DoRealConvert(sSelTypes[format]);
-    if (r) return r;
-    break;
-
-  case TARGET_TEXT_UNICODE:
-    r = DoRealConvert(sSelTypes[format]);
-    if (r) return r;
-    r = DoRealConvert(sSelTypes[TARGET_UTF8]);
-    if (r) return r;
-    break;
-
-  case TARGET_TEXT_HTML:
-    r = DoRealConvert(sSelTypes[format]);
-    if (r) return r;
-    break;
-
-  case TARGET_AOLMAIL:
-    r = DoRealConvert(sSelTypes[format]);
-    if (r) return r;
-    break;
-
-  case TARGET_IMAGE_PNG:
-    r = DoRealConvert(sSelTypes[format]);
-    if (r) return r;
-    break;
-
-  case TARGET_IMAGE_JPEG:
-    r = DoRealConvert(sSelTypes[format]);
-    if (r) return r;
-    break;
-
-  case TARGET_IMAGE_GIF:
-    r = DoRealConvert(sSelTypes[format]);
-    if (r) return r;
-    break;
-
-  default:
-    g_print("DoConvert called with bogus format\n");
-  }
-  return r;
-}
-
-//-------------------------------------------------------------------------
-//
-// The blocking Paste routine
-//
-//-------------------------------------------------------------------------
-NS_IMETHODIMP
-nsClipboard::GetNativeClipboardData(nsITransferable * aTransferable)
-{
-
-#ifdef DEBUG_CLIPBOARD
-  printf("nsClipboard::GetNativeClipboardData()\n");
-#endif /* DEBUG_CLIPBOARD */
-
-  // make sure we have a good transferable
-  if (nsnull == aTransferable) {
-    printf("  GetNativeClipboardData: Transferable is null!\n");
-    return NS_ERROR_FAILURE;
-  }
-
-  // get flavor list that includes all acceptable flavors (including ones obtained through
-  // conversion)
-  nsCOMPtr<nsISupportsArray> flavorList;
-  nsresult errCode = aTransferable->FlavorsTransferableCanImport ( getter_AddRefs(flavorList) );
-  if ( NS_FAILED(errCode) )
-    return NS_ERROR_FAILURE;
-
-  // Walk through flavors and see which flavor matches the one being pasted:
-  PRUint32 cnt;
-  flavorList->Count(&cnt);
-  nsCAutoString foundFlavor;
-  for ( PRUint32 i = 0; i < cnt; ++i ) {
-    nsCOMPtr<nsISupports> genericFlavor;
-    flavorList->GetElementAt ( i, getter_AddRefs(genericFlavor) );
-    nsCOMPtr<nsISupportsString> currentFlavor ( do_QueryInterface(genericFlavor) );
-    if ( currentFlavor ) {
-      nsXPIDLCString flavorStr;
-      currentFlavor->ToString ( getter_Copies(flavorStr) );
-      gint format = GetFormat(flavorStr);
-      if (DoConvert(format)) {
-        foundFlavor = flavorStr;
-        break;
-      }
-    }
-  }
-
-#ifdef DEBUG_CLIPBOARD
-  printf("  Got the callback: '%s', %d\n",
-         mSelectionData.data, mSelectionData.length);
-#endif /* DEBUG_CLIPBOARD */
-
-  // We're back from the callback, no longer blocking:
-  mBlocking = PR_FALSE;
-
-  // 
-  // Now we have data in mSelectionData.data.
-  // We just have to copy it to the transferable.
-  // 
-
-#if 0  
-// pinkerton - we have the flavor already from above, so we don't need
-// to re-derrive it.
-  nsString *name = new nsString((const char*)gdk_atom_name(mSelectionData.type));
-  int format = GetFormat(*name);
-  df->SetString((const char*)gdk_atom_name(sSelTypes[format]));
-#endif
-
-  nsCOMPtr<nsISupports> genericDataWrapper;
-  nsPrimitiveHelpers::CreatePrimitiveForData ( foundFlavor, mSelectionData.data, mSelectionData.length, getter_AddRefs(genericDataWrapper) );
-  aTransferable->SetTransferData(foundFlavor,
-                                 genericDataWrapper,
-                                 mSelectionData.length);
-
-//delete name;
-  
-  // transferable is now copying the data, so we can free it.
-  //  g_free(mSelectionData.data);
-  mSelectionData.data = nsnull;
-  mSelectionData.length = 0;
-
-  return NS_OK;
-}
-
-/**
- * Called when the data from a paste comes in (recieved from gdk_selection_convert)
- *
- * @param  aWidget the widget
- * @param  aSelectionData gtk selection stuff
- * @param  aTime time the selection was requested
- */
-void
-nsClipboard::SelectionReceivedCB (GtkWidget        *aWidget,
-                                  GtkSelectionData *aSelectionData,
-                                  guint             aTime)
-{
-#ifdef DEBUG_CLIPBOARD
-  printf("      nsClipboard::SelectionReceivedCB\n      {\n");
-#endif /* DEBUG_CLIPBOARD */
-  nsClipboard *cb =(nsClipboard *)gtk_object_get_data(GTK_OBJECT(aWidget),
-                                                      "cb");
-  if (!cb)
-  {
-    g_print("no clipboard found.. this is bad.\n");
-    return;
-  }
-  cb->SelectionReceiver(aWidget, aSelectionData);
-#ifdef DEBUG_CLIPBOARD
-  g_print("      }\n");
-#endif
-}
-
-
-/**
- * local method (called from nsClipboard::SelectionReceivedCB)
- *
- * @param  aWidget the widget
- * @param  aSelectionData gtk selection stuff
- */
-void
-nsClipboard::SelectionReceiver (GtkWidget *aWidget,
-                                GtkSelectionData *aSD)
-{
-  gint type;
-
-  mBlocking = PR_FALSE;
-
-  if (aSD->length < 0)
-  {
-    printf("        Error retrieving selection: length was %d\n",
-           aSD->length);
-    return;
-  }
-
-  type = TARGET_NONE;
-  for (int i=0; i < TARGET_LAST; i++)
-  {
-    if (sSelTypes[i] == aSD->type)
-    {
-      type = i;
-      break;
-    }
-  }
-
-  switch (type)
-  {
-  case GDK_TARGET_STRING:
-  case TARGET_UTF8:
-  case TARGET_TEXT_PLAIN:
-  case TARGET_TEXT_XIF:
-  case TARGET_TEXT_UNICODE:
-  case TARGET_TEXT_HTML:
-#ifdef DEBUG_CLIPBOARD
-    g_print("        Copying mSelectionData pointer -- ");
-#endif
-    mSelectionData = *aSD;
-    mSelectionData.data = g_new(guchar, aSD->length + 1);
-#ifdef DEBUG_CLIPBOARD
-    g_print("        Data = %s\n    Length = %i\n", aSD->data, aSD->length);
-#endif
-    memcpy(mSelectionData.data,
-           aSD->data,
-           aSD->length);
-    // Null terminate in case anyone cares,
-    // and so we can print the string for debugging:
-    mSelectionData.data[aSD->length] = '\0';
-    mSelectionData.length = aSD->length;
-    return;
-
-  default:
-    mSelectionData = *aSD;
-    mSelectionData.data = g_new(guchar, aSD->length + 1);
-    memcpy(mSelectionData.data,
-           aSD->data,
-           aSD->length);
-    mSelectionData.length = aSD->length;
-    return;
-  }
-}
-
-
-
-/**
- * Some platforms support deferred notification for putting data on the clipboard
- * This method forces the data onto the clipboard in its various formats
- * This may be used if the application going away.
- *
- * @result NS_OK if successful.
- */
-NS_IMETHODIMP nsClipboard::ForceDataToClipboard()
-{
-#ifdef DEBUG_CLIPBOARD
-  printf("  nsClipboard::ForceDataToClipboard()\n");
-#endif /* DEBUG_CLIPBOARD */
-
-  // make sure we have a good transferable
-  if (nsnull == mTransferable) {
-    return NS_ERROR_FAILURE;
-  }
-
-  return NS_OK;
-}
-
-NS_IMETHODIMP
-nsClipboard::HasDataMatchingFlavors(nsISupportsArray* aFlavorList, PRBool * outResult)
-{
-  *outResult = PR_TRUE;  // say we always do.
-  return NS_OK;
-}
-
-
-/**
- * This is the callback which is called when another app
- * requests the selection.
- *
- * @param  widget The widget
- * @param  aSelectionData Selection data
- * @param  info Value passed in from the callback init
- * @param  time Time when the selection request came in
- */
-void nsClipboard::SelectionGetCB(GtkWidget        *widget,
-                                 GtkSelectionData *aSelectionData,
-                                 guint            aInfo,
-                                 guint            aTime)
-{ 
-#ifdef DEBUG_CLIPBOARD
-  printf("nsClipboard::SelectionGetCB\n"); 
-#endif /* DEBUG_CLIPBOARD */
-
-  nsClipboard *cb = (nsClipboard *)gtk_object_get_data(GTK_OBJECT(widget),
-                                                       "cb");
-
-  void     *clipboardData;
-  PRUint32 dataLength;
-  nsresult rv;
-
-  // Make sure we have a transferable:
-  if (!cb->mTransferable) {
-    printf("Clipboard has no transferable!\n");
-    return;
-  }
-
-#ifdef DEBUG_CLIPBOARD
-  g_print("  aInfo == %d -", aInfo);
-#endif
-
-  char* dataFlavor = nsnull;
-
-  // switch aInfo (atom) to our enum
-  int type = (int)aInfo;
-  for (int i=0; i < TARGET_LAST; i++)
-  {
-    if (sSelTypes[i] == aInfo)
-    {
-      type = i;
-      break;
-    }
-  }
-
-  switch(type)
-    {
-    case GDK_TARGET_STRING:
-    case TARGET_TEXT_PLAIN:
-      dataFlavor = kTextMime;
-      break;
-    case TARGET_TEXT_XIF:
-      dataFlavor = kXIFMime;
-      break;
-    case TARGET_TEXT_UNICODE:
-    case TARGET_UTF8:
-      dataFlavor = kUnicodeMime;
-      break;
-    case TARGET_TEXT_HTML:
-      dataFlavor = kHTMLMime;
-      break;
-    case TARGET_AOLMAIL:
-      dataFlavor = kAOLMailMime;
-      break;
-    case TARGET_IMAGE_PNG:
-      dataFlavor = kPNGImageMime;
-      break;
-    case TARGET_IMAGE_JPEG:
-      dataFlavor = kJPEGImageMime;
-      break;
-    case TARGET_IMAGE_GIF:
-      dataFlavor = kGIFImageMime;
-      break;
-    default:
-      {
-        /* handle outside things */
-      }
-    }
-#ifdef DEBUG_CLIPBOARD
-  g_print("- aInfo is for %s\n", gdk_atom_name(aInfo));
-#endif
-
-  // Get data out of transferable.
-  nsCOMPtr<nsISupports> genericDataWrapper;
-  rv = cb->mTransferable->GetTransferData(dataFlavor, 
-                                          getter_AddRefs(genericDataWrapper),
-                                          &dataLength);
-  nsPrimitiveHelpers::CreateDataFromPrimitive ( dataFlavor, genericDataWrapper, &clipboardData, dataLength );
-  if (NS_SUCCEEDED(rv) && clipboardData && dataLength > 0) {
-    size_t size = 1;
-    // find the number of bytes in the data for the below thing
-    //    size_t size = sizeof((void*)((unsigned char)clipboardData[0]));
-    //    g_print("************  *****************      ******************* %i\n", size);
-
-    gtk_selection_data_set(aSelectionData,
-                           aInfo, size*8,
-                           (unsigned char *)clipboardData,
-                           dataLength);
-    nsCRT::free ( NS_REINTERPRET_CAST(char*, clipboardData) );
-  }
-  else
-    printf("Transferable didn't support the data flavor\n");
-}
-
-
-/**
- * Called when another app requests selection ownership
- *
- * @param  aWidget the widget
- * @param  aEvent the GdkEvent for the selection
- * @param  aData value passed in from the callback init
- */
-void nsClipboard::SelectionClearCB(GtkWidget *aWidget,
-                                   GdkEventSelection *aEvent,
-                                   gpointer aData)
-{
-#ifdef DEBUG_CLIPBOARD
-  printf("  nsClipboard::SelectionClearCB\n");
-#endif /* DEBUG_CLIPBOARD */
-
-  nsClipboard *cb = (nsClipboard *)gtk_object_get_data(GTK_OBJECT(aWidget),
-                                                       "cb");
-
-  cb->EmptyClipboard();
-}
-
-
-/**
- * The routine called when another app asks for the content of the selection
- *
- * @param  aWidget the widget
- * @param  aSelectionData gtk selection stuff
- * @param  aData value passed in from the callback init
- */
-void
-nsClipboard::SelectionRequestCB (GtkWidget *aWidget,
-                                 GtkSelectionData *aSelectionData,
-                                 gpointer aData)
-{
-#ifdef DEBUG_CLIPBOARD
-  printf("  nsClipboard::SelectionRequestCB\n");
-#endif /* DEBUG_CLIPBOARD */
-}
-
-/**
- * ...
- *
- * @param  aWidget the widget
- * @param  aSelectionData gtk selection stuff
- * @param  aData value passed in from the callback init
- */
-void
-nsClipboard::SelectionNotifyCB (GtkWidget *aWidget,
-                                GtkSelectionData *aSelectionData,
-                                gpointer aData)
-{
-#ifdef DEBUG_CLIPBOARD
-  printf("  nsClipboard::SelectionNotifyCB\n");
-#endif /* DEBUG_CLIPBOARD */
-}

mozilla/widget/src/gtk/nsClipboard.h

@@ -1,132 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * 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): 
- */
-
-#ifndef nsClipboard_h__
-#define nsClipboard_h__
-
-#include "nsBaseClipboard.h"
-#include <gtk/gtk.h>
-#include <gtk/gtkinvisible.h>
-
-class nsITransferable;
-class nsIClipboardOwner;
-class nsIWidget;
-
-/**
- * Native Gtk Clipboard wrapper
- */
-
-class nsClipboard : public nsBaseClipboard
-{
-
-public:
-  nsClipboard();
-  virtual ~nsClipboard();
-
-  // nsIClipboard  
-  NS_IMETHOD ForceDataToClipboard();
-  NS_IMETHOD HasDataMatchingFlavors(nsISupportsArray* aFlavorList, PRBool * outResult);
-
-  // invisible widget.  also used by dragndrop
-  static GtkWidget *sWidget;
-
-protected:
-  NS_IMETHOD SetNativeClipboardData();
-  NS_IMETHOD GetNativeClipboardData(nsITransferable * aTransferable);
-
-  PRBool  mIgnoreEmptyNotification;
-
-  void AddTarget(GdkAtom aAtom);
-
-  gint GetFormat(const char* aMimeStr);
-  void RegisterFormat(gint format);
-
-
-  PRBool DoRealConvert(GdkAtom type);
-  PRBool DoConvert(gint format);
-
-  void Init(void);
-
-  // Used for communicating pasted data
-  // from the asynchronous X routines back to a blocking paste:
-  GtkSelectionData mSelectionData;
-  PRBool mBlocking;
-
-  void SelectionReceiver(GtkWidget *aWidget,
-                         GtkSelectionData *aSD);
-
-  /**
-   * This is the callback which is called when another app
-   * requests the selection.
-   *
-   * @param  widget The widget
-   * @param  aSelectionData Selection data
-   * @param  info Value passed in from the callback init
-   * @param  time Time when the selection request came in
-   */
-  static void SelectionGetCB(GtkWidget *aWidget, 
-                             GtkSelectionData *aSelectionData,
-                             guint      /*info*/,
-                             guint      /*time*/);
-
-  /**
-   * Called when another app requests selection ownership
-   *
-   * @param  aWidget the widget
-   * @param  aEvent the GdkEvent for the selection
-   * @param  aData value passed in from the callback init
-   */
-  static void SelectionClearCB(GtkWidget *aWidget, 
-                               GdkEventSelection *aEvent,
-                               gpointer aData);
-
-  /**
-   * The routine called when another app asks for the content of the selection
-   *
-   * @param  aWidget the widget
-   * @param  aSelectionData gtk selection stuff
-   * @param  aData value passed in from the callback init
-   */
-  static void SelectionRequestCB(GtkWidget *aWidget,
-                                 GtkSelectionData *aSelectionData,
-                                 gpointer data);
-  
-  /**
-   * Called when the data from a paste comes in
-   *
-   * @param  aWidget the widget
-   * @param  aSelectionData gtk selection stuff
-   * @param  aTime time the selection was requested
-   */
-  static void SelectionReceivedCB(GtkWidget *aWidget,
-                                  GtkSelectionData *aSelectionData,
-                                  guint aTime);
-
-
-  static void SelectionNotifyCB(GtkWidget *aWidget,
-                                GtkSelectionData *aSelectionData,
-                                gpointer aData);
-  
-
-};
-
-#endif // nsClipboard_h__

mozilla/widget/src/gtk/nsComboBox.cpp

@@ -1,357 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * 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): 
- */
-
-#include <gtk/gtk.h>
-
-#include "nsComboBox.h"
-#include "nsGUIEvent.h"
-#include "nsString.h"
-
-#define DBG 0
-
-#define INITIAL_MAX_ITEMS 128
-#define ITEMS_GROWSIZE    128
-
-NS_IMPL_ADDREF_INHERITED(nsComboBox, nsWidget)
-NS_IMPL_RELEASE_INHERITED(nsComboBox, nsWidget)
-NS_IMPL_QUERY_INTERFACE3(nsComboBox, nsIComboBox, nsIListWidget, nsIWidget)
-
-//-------------------------------------------------------------------------
-//
-// nsComboBox constructor
-//
-//-------------------------------------------------------------------------
-nsComboBox::nsComboBox() : nsWidget(), nsIListWidget(), nsIComboBox()
-{
-  NS_INIT_REFCNT();
-  mMultiSelect = PR_FALSE;
-  mItems = nsnull;
-  mNumItems = 0;
-}
-
-//-------------------------------------------------------------------------
-//
-// nsComboBox:: destructor
-//
-//-------------------------------------------------------------------------
-nsComboBox::~nsComboBox()
-{
-  if (mItems) {
-    for (GList *items = mItems; items; items = (GList*) g_list_next(items)){
-      g_free(items->data);
-    }
-    g_list_free(mItems);
-  }
-  gtk_widget_destroy(mCombo);
-}
-
-void nsComboBox::InitCallbacks(char * aName)
-{
-  InstallButtonPressSignal(mWidget);
-  InstallButtonReleaseSignal(mWidget);
-
-  InstallEnterNotifySignal(mWidget);
-  InstallLeaveNotifySignal(mWidget);
-   
-  // These are needed so that the events will go to us and not our parent.
-  AddToEventMask(mWidget,
-                 GDK_BUTTON_PRESS_MASK |
-                 GDK_BUTTON_RELEASE_MASK |
-                 GDK_ENTER_NOTIFY_MASK |
-                 GDK_EXPOSURE_MASK |
-                 GDK_FOCUS_CHANGE_MASK |
-                 GDK_KEY_PRESS_MASK |
-                 GDK_KEY_RELEASE_MASK |
-                 GDK_LEAVE_NOTIFY_MASK |  
-                 GDK_POINTER_MOTION_MASK);
-}
-
-
-//-------------------------------------------------------------------------
-//
-//  initializer
-//
-//-------------------------------------------------------------------------
-
-NS_METHOD nsComboBox::SetMultipleSelection(PRBool aMultipleSelections)
-{
-  mMultiSelect = aMultipleSelections;
-  return NS_OK;
-}
-
-
-//-------------------------------------------------------------------------
-//
-//  AddItemAt
-//
-//-------------------------------------------------------------------------
-
-NS_METHOD nsComboBox::AddItemAt(nsString &aItem, PRInt32 aPosition)
-{
-  NS_ALLOC_STR_BUF(val, aItem, 256);
-  mItems = g_list_insert( mItems, g_strdup(val), aPosition );
-  mNumItems++;
-  if (mCombo) {
-    gtk_combo_set_popdown_strings( GTK_COMBO( mCombo ), mItems );
-  }
-  NS_FREE_STR_BUF(val);
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-//
-//  Finds an item at a postion
-//
-//-------------------------------------------------------------------------
-PRInt32  nsComboBox::FindItem(nsString &aItem, PRInt32 aStartPos)
-{
-  NS_ALLOC_STR_BUF(val, aItem, 256);
-  int i;
-  PRInt32 inx = -1;
-  GList *items = g_list_nth(mItems, aStartPos);
-  for(i=0; items != NULL; items = (GList *) g_list_next(items), i++ )
-    {
-      if(!strcmp(val, (gchar *) items->data))
-        {
-          inx = i;
-          break;
-        }
-    }
-  NS_FREE_STR_BUF(val);
-  return inx;
-}
-
-//-------------------------------------------------------------------------
-//
-//  CountItems - Get Item Count
-//
-//-------------------------------------------------------------------------
-PRInt32  nsComboBox::GetItemCount()
-{
-  return (PRInt32)mNumItems;
-}
-
-//-------------------------------------------------------------------------
-//
-//  Removes an Item at a specified location
-//
-//-------------------------------------------------------------------------
-PRBool  nsComboBox::RemoveItemAt(PRInt32 aPosition)
-{ 
-  if (aPosition >= 0 && aPosition < mNumItems) {
-
-    g_free(g_list_nth(mItems, aPosition)->data);
-    mItems = g_list_remove_link(mItems, g_list_nth(mItems, aPosition));
-    mNumItems--;
-    if (mCombo) {
-      gtk_combo_set_popdown_strings(GTK_COMBO( mCombo ), mItems);
-    }
-    return PR_TRUE;
-  }
-  else
-    return PR_FALSE;
-}
-
-//-------------------------------------------------------------------------
-//
-//  Removes an Item at a specified location
-//
-//-------------------------------------------------------------------------
-PRBool nsComboBox::GetItemAt(nsString& anItem, PRInt32 aPosition)
-{
-  if (aPosition >= 0 && aPosition < mNumItems) {
-    anItem = (gchar *) g_list_nth(mItems, aPosition)->data;
-    return PR_TRUE;
-  }
-  return PR_FALSE;
-}
-
-//-------------------------------------------------------------------------
-//
-//  Gets the selected of selected item
-//
-//-------------------------------------------------------------------------
-NS_METHOD nsComboBox::GetSelectedItem(nsString& aItem)
-{
-  aItem.Truncate();
-  if (mCombo) {
-    aItem = gtk_entry_get_text (GTK_ENTRY (GTK_COMBO(mCombo)->entry));
-  }
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-//
-//  Gets the list of selected otems
-//
-//-------------------------------------------------------------------------
-PRInt32 nsComboBox::GetSelectedIndex()
-{
-  nsString nsstring;
-  GetSelectedItem(nsstring);
-  return FindItem(nsstring, 0);
-}
-
-//-------------------------------------------------------------------------
-//
-//  SelectItem
-//
-//-------------------------------------------------------------------------
-NS_METHOD nsComboBox::SelectItem(PRInt32 aPosition)
-{
-  GList *pos;
-  if (!mItems)
-    return NS_ERROR_FAILURE;
-
-  pos = g_list_nth(mItems, aPosition);
-  if (!pos)
-    return NS_ERROR_FAILURE;
-
-  if (mCombo) {
-    gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(mCombo)->entry),
-                       (gchar *) pos->data);
-  }
-
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-//
-//  GetSelectedCount
-//
-//-------------------------------------------------------------------------
-PRInt32 nsComboBox::GetSelectedCount()
-{
-  if (!mMultiSelect) {
-    PRInt32 inx = GetSelectedIndex();
-    return (inx == -1? 0 : 1);
-  } else {
-    return 0;
-  }
-}
-
-//-------------------------------------------------------------------------
-//
-//  GetSelectedIndices
-//
-//-------------------------------------------------------------------------
-NS_METHOD nsComboBox::GetSelectedIndices(PRInt32 aIndices[], PRInt32 aSize)
-{
-  // this is an error
-  return NS_ERROR_FAILURE;
-}
-
-//-------------------------------------------------------------------------
-//
-//  Deselect
-//
-//-------------------------------------------------------------------------
-NS_METHOD nsComboBox::Deselect()
-{
-  if (mMultiSelect) {
-    return NS_ERROR_FAILURE;
-  }
-
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-//
-// Create the native GtkCombo widget
-//
-//-------------------------------------------------------------------------
-NS_METHOD  nsComboBox::CreateNative(GtkObject *parentWindow)
-{
-  mWidget = ::gtk_event_box_new();
-
-  ::gtk_widget_set_name(mWidget, "nsComboBox");
-  mCombo = ::gtk_combo_new();
-  gtk_widget_show(mCombo);
-
-  /* make the stuff uneditable */
-  gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(mCombo)->entry), PR_FALSE);
-
-  gtk_signal_connect(GTK_OBJECT(mCombo),
-                     "destroy",
-                     GTK_SIGNAL_FUNC(DestroySignal),
-                     this);
-  gtk_signal_connect(GTK_OBJECT(GTK_COMBO(mCombo)->popwin),
-                     "unmap",
-                     GTK_SIGNAL_FUNC(UnmapSignal),
-                     this);
-
-  gtk_container_add(GTK_CONTAINER(mWidget), mCombo);
-
-  return NS_OK;
-}
-
-void
-nsComboBox::OnDestroySignal(GtkWidget* aGtkWidget)
-{
-  if (aGtkWidget == mCombo) {
-    mCombo = nsnull;
-  }
-  else {
-    nsWidget::OnDestroySignal(aGtkWidget);
-  }
-}
-
-gint
-nsComboBox::UnmapSignal(GtkWidget* aGtkWidget, nsComboBox* aCombo)
-{
-  if (!aCombo) return PR_FALSE;
-  aCombo->OnUnmapSignal(aGtkWidget);
-  return PR_TRUE;
-}
-
-void
-nsComboBox::OnUnmapSignal(GtkWidget * aWidget)
-{
-  if (!aWidget) return;
-
-  // Generate a NS_CONTROL_CHANGE event and send it to the frame
-  nsGUIEvent event;
-  event.eventStructType = NS_GUI_EVENT;
-  nsPoint point(0,0);
-  InitEvent(event, NS_CONTROL_CHANGE, &point);
-  DispatchWindowEvent(&event);
-}
-
-//-------------------------------------------------------------------------
-//
-// Get handle for style
-//
-//-------------------------------------------------------------------------
-/*virtual*/
-void nsComboBox::SetFontNative(GdkFont *aFont)
-{
-  GtkStyle *style = gtk_style_copy(GTK_WIDGET (g_list_nth_data(gtk_container_children(GTK_CONTAINER (mWidget)),0))->style);
-  // gtk_style_copy ups the ref count of the font
-  gdk_font_unref (style->font);
-  
-  style->font = aFont;
-  gdk_font_ref(style->font);
-  
-  gtk_widget_set_style(GTK_BIN (mWidget)->child, style);
-  
-  gtk_style_unref(style);
-}

mozilla/widget/src/gtk/nsComboBox.h

@@ -1,75 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * 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): 
- */
-
-#ifndef nsComboBox_h__
-#define nsComboBox_h__
-
-#include "nsWidget.h"
-#include "nsIComboBox.h"
-
-/**
- * Native GTK+ Listbox wrapper
- */
-
-class nsComboBox : public nsWidget,
-                   public nsIListWidget,
-                   public nsIComboBox
-{
-
-public:
-  nsComboBox();
-  virtual ~nsComboBox();
-
-  NS_DECL_ISUPPORTS_INHERITED
-
-  // nsIComboBox interface
-  NS_IMETHOD      AddItemAt(nsString &aItem, PRInt32 aPosition);
-  virtual PRInt32 FindItem(nsString &aItem, PRInt32 aStartPos);
-  virtual PRInt32 GetItemCount();
-  virtual PRBool  RemoveItemAt(PRInt32 aPosition);
-  virtual PRBool  GetItemAt(nsString& anItem, PRInt32 aPosition);
-  NS_IMETHOD      GetSelectedItem(nsString& aItem);
-  virtual PRInt32 GetSelectedIndex();
-  NS_IMETHOD      SelectItem(PRInt32 aPosition);
-  NS_IMETHOD      Deselect() ;
-
-  // nsIComboBox interface
-  NS_IMETHOD      SetMultipleSelection(PRBool aMultipleSelections);
-  PRInt32         GetSelectedCount();
-  NS_IMETHOD      GetSelectedIndices(PRInt32 aIndices[], PRInt32 aSize);
-
-  virtual void SetFontNative(GdkFont *aFont);
-
-protected:
-  NS_IMETHOD  CreateNative(GtkObject *parentWindow);
-  virtual void InitCallbacks(char * aName = nsnull);
-  virtual void OnDestroySignal(GtkWidget* aGtkWidget);
-  virtual void OnUnmapSignal(GtkWidget* aWidget);
-  static gint UnmapSignal(GtkWidget* aGtkWidget, nsComboBox* aCombo);
-
-  GtkWidget  *mCombo;  /* workaround for gtkcombo bug */
-  GList *mItems;
-  PRBool  mMultiSelect;
-  int     mNumItems;
-};
-
-#endif // nsComboBox_h__

mozilla/widget/src/gtk/nsContextMenu.cpp

@@ -1,744 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * 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): 
- */
-
-#include <gtk/gtk.h>
-
-#include "nsContextMenu.h"
-#include "nsIComponentManager.h"
-#include "nsIDOMElement.h"
-#include "nsIDOMNode.h"
-#include "nsIMenuBar.h"
-#include "nsIMenuItem.h"
-#include "nsIMenuListener.h"
-#include "nsString.h"
-#include "nsGtkEventHandler.h"
-#include "nsCOMPtr.h"
-#include "nsWidgetsCID.h"
-
-static NS_DEFINE_CID(kMenuCID,             NS_MENU_CID);
-static NS_DEFINE_CID(kMenuItemCID,         NS_MENUITEM_CID);
-
-static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
-
-//-------------------------------------------------------------------------
-nsresult nsContextMenu::QueryInterface(REFNSIID aIID, void** aInstancePtr)
-{
-  if (NULL == aInstancePtr) {
-    return NS_ERROR_NULL_POINTER;
-  }
-
-  *aInstancePtr = NULL;
-
-  if (aIID.Equals(nsIMenu::GetIID())) {
-    *aInstancePtr = (void*)(nsIMenu*) this;
-    NS_ADDREF_THIS();
-    return NS_OK;
-  }
-  if (aIID.Equals(kISupportsIID)) {
-    *aInstancePtr = (void*)(nsISupports*)(nsIMenu*)this;
-    NS_ADDREF_THIS();
-    return NS_OK;
-  }
-  if (aIID.Equals(nsIMenuListener::GetIID())) {
-    *aInstancePtr = (void*)(nsIMenuListener*)this;
-    NS_ADDREF_THIS();
-    return NS_OK;
-  }
-  return NS_NOINTERFACE;
-}
-
-//-------------------------------------------------------------------------
-NS_IMPL_ADDREF(nsContextMenu)
-NS_IMPL_RELEASE(nsContextMenu)
-
-//-------------------------------------------------------------------------
-//
-// nsContextMenu constructor
-//
-//-------------------------------------------------------------------------
-nsContextMenu::nsContextMenu()
-{
-  NS_INIT_REFCNT();
-  mNumMenuItems  = 0;
-  mMenu          = nsnull;
-  mParent        = nsnull;
-  mListener      = nsnull;
-  mConstructCalled = PR_FALSE;
-  
-  mDOMNode       = nsnull;
-  mWebShell      = nsnull;
-  mDOMElement    = nsnull;
-
-  mAlignment      = "topleft";
-  mAnchorAlignment = "none";
-}
-
-//-------------------------------------------------------------------------
-//
-// nsContextMenu destructor
-//
-//-------------------------------------------------------------------------
-nsContextMenu::~nsContextMenu()
-{
-
-}
-
-
-//-------------------------------------------------------------------------
-//
-// Create the proper widget
-//
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::Create(nsISupports *aParent,
-                                const nsString& anAlignment,
-                                const nsString& anAnchorAlignment)
-{
-  if(aParent)
-  {
-    nsIWidget *parent = nsnull;
-    aParent->QueryInterface(nsIWidget::GetIID(), (void**) &parent);
-    if(parent)
-    {
-      mParent = parent;
-      NS_RELEASE(parent);
-    }
-  }
-
-  mAlignment       = anAlignment;
-  mAnchorAlignment = anAnchorAlignment;
-
-  mMenu = gtk_menu_new();
-
-  gtk_signal_connect (GTK_OBJECT (mMenu), "map",
-                      GTK_SIGNAL_FUNC(menu_map_handler),
-                      this);
-  gtk_signal_connect (GTK_OBJECT (mMenu), "unmap",
-                      GTK_SIGNAL_FUNC(menu_unmap_handler),
-                      this);
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::GetParent(nsISupports*& aParent)
-{
-  aParent = nsnull;
-  if (nsnull != mParent) {
-    return mParent->QueryInterface(kISupportsIID,
-                                   (void**)&aParent);
-  }
-
-  return NS_ERROR_FAILURE;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::AddItem(nsISupports * aItem)
-{
-  if(aItem)
-  {
-    nsIMenuItem * menuitem = nsnull;
-    aItem->QueryInterface(nsIMenuItem::GetIID(),
-                          (void**)&menuitem);
-    if(menuitem)
-    {
-      AddMenuItem(menuitem); // nsMenu now owns this
-      NS_RELEASE(menuitem);
-    }
-    else
-    {
-      nsIMenu * menu = nsnull;
-      aItem->QueryInterface(nsIMenu::GetIID(),
-                            (void**)&menu);
-      if(menu)
-      {
-        AddMenu(menu); // nsMenu now owns this
-        NS_RELEASE(menu);
-      }
-    }
-  }
-
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::AddMenuItem(nsIMenuItem * aMenuItem)
-{
-  GtkWidget *widget;
-  void      *voidData;
-  
-  aMenuItem->GetNativeData(voidData);
-  widget = GTK_WIDGET(voidData);
-
-  gtk_menu_shell_append (GTK_MENU_SHELL (mMenu), widget);
-
-  // XXX add aMenuItem to internal data structor list
-  // Need to be adding an nsISupports *, not nsIMenuItem *
-  nsISupports * supports = nsnull;
-  aMenuItem->QueryInterface(kISupportsIID,
-                            (void**)&supports);
-  {
-    mMenuItemVoidArray.AppendElement(supports);
-    mNumMenuItems++;
-  }
-  
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::AddMenu(nsIMenu * aMenu)
-{
-  nsString Label;
-  GtkWidget *newmenu=nsnull;
-  char *labelStr;
-  void *voidData=NULL;
-  
-  aMenu->GetLabel(Label);
-  labelStr = Label.ToNewCString();
-
-  // Create nsMenuItem
-  nsIMenuItem * pnsMenuItem = nsnull;
-  nsresult rv = nsComponentManager::CreateInstance(kMenuItemCID,
-                                                   nsnull,
-                                                   nsIMenuItem::GetIID(),
-                                                   (void**)&pnsMenuItem);
-  if (NS_OK == rv) {
-    nsISupports * supports = nsnull;
-    QueryInterface(kISupportsIID, (void**) &supports);
-    pnsMenuItem->Create(supports, labelStr, PR_FALSE); //PR_TRUE); 
-    NS_RELEASE(supports);               
-    
-    pnsMenuItem->QueryInterface(kISupportsIID, (void**) &supports);
-    AddItem(supports); // Parent should now own menu item
-    NS_RELEASE(supports);
-          
-    void * menuitem = nsnull;
-    pnsMenuItem->GetNativeData(menuitem);
-  
-    voidData = NULL;
-    aMenu->GetNativeData(&voidData);
-    newmenu = GTK_WIDGET(voidData);
-
-    gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), newmenu);
-  
-    NS_RELEASE(pnsMenuItem);
-  } 
-
-  nsCRT::free(labelStr);
-
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::AddSeparator() 
-{
-  // Create nsMenuItem
-  nsIMenuItem * pnsMenuItem = nsnull;
-  nsresult rv = nsComponentManager::CreateInstance(
-    kMenuItemCID, nsnull, nsIMenuItem::GetIID(), (void**)&pnsMenuItem);
-  if (NS_OK == rv) {
-    nsString tmp = "separator";
-    nsISupports * supports = nsnull;
-    QueryInterface(kISupportsIID, (void**) &supports);
-    pnsMenuItem->Create(supports, tmp, PR_TRUE);  
-    NS_RELEASE(supports);
-    
-    pnsMenuItem->QueryInterface(kISupportsIID, (void**) &supports);
-    AddItem(supports); // Parent should now own menu item
-    NS_RELEASE(supports); 
-          
-    NS_RELEASE(pnsMenuItem);
-  } 
-  
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::GetItemCount(PRUint32 &aCount)
-{
-  // this should be right.. does it need to be +1 ?
-  aCount = g_list_length(GTK_MENU_SHELL(mMenu)->children);
-  //g_print("nsMenu::GetItemCount = %i\n", aCount);
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::GetItemAt(const PRUint32 aCount, nsISupports *& aMenuItem)
-{
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::InsertItemAt(const PRUint32 aCount, nsISupports * aMenuItem)
-{
-  return NS_OK;
-}
-
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::InsertSeparator(const PRUint32 aCount)
-{
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::RemoveItem(const PRUint32 aCount)
-{
-#if 0
-  // this may work here better than Removeall(), but i'm not sure how to test this one
-  nsISupports *item = mMenuItemVoidArray[aPos];
-  delete item;
-  mMenuItemVoidArray.RemoveElementAt(aPos);
-#endif
-  /*
-  gtk_menu_shell_remove (GTK_MENU_SHELL (mMenu), item);
-
-  nsCRT::free(labelStr);
-
-  voidData = NULL;
-
-  aMenu->GetNativeData(&voidData);
-  newmenu = GTK_WIDGET(voidData);
-
-  gtk_menu_item_remove_submenu (GTK_MENU_ITEM (item));
-  */
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::RemoveAll()
-{
-  //g_print("nsMenu::RemoveAll()\n");
-#undef DEBUG_pavlov
-#ifdef DEBUG_pavlov
-  // this doesn't work quite right, but this is about all that should really be needed
-  int i=0;
-  nsIMenu *menu = nsnull;
-  nsIMenuItem *menuitem = nsnull;
-  nsISupports *item = nsnull;
-
-  for (i=mMenuItemVoidArray.Count(); i>0; i--)
-  {
-    item = (nsISupports*)mMenuItemVoidArray[i-1];
-
-    if(nsnull != item)
-    {
-      if (NS_OK == item->QueryInterface(nsIMenuItem::GetIID(), (void**)&menuitem))
-      {
-        // we do this twice because we have to do it once for QueryInterface,
-        // then we want to get rid of it.
-        // g_print("remove nsMenuItem\n");
-        NS_RELEASE(menuitem);
-        NS_RELEASE(item);
-        menuitem = nsnull;
-      } else if (NS_OK == item->QueryInterface(nsIMenu::GetIID(), (void**)&menu)) {
-#ifdef NOISY_MENUS
-        g_print("remove nsMenu\n");
-#endif
-        NS_RELEASE(menu);
-        NS_RELEASE(item);
-        menu = nsnull;
-      }
-      // mMenuItemVoidArray.RemoveElementAt(i-1);
-    }
-  }
-  mMenuItemVoidArray.Clear();
-
-  return NS_OK;
-#else
-  for (int i = mMenuItemVoidArray.Count(); i > 0; i--) {
-    if(nsnull != mMenuItemVoidArray[i-1]) {
-      nsIMenuItem * menuitem = nsnull;
-      ((nsISupports*)mMenuItemVoidArray[i-1])->QueryInterface(nsIMenuItem::GetIID(),
-                                                              (void**)&menuitem);
-      if(menuitem) {
-        void *gtkmenuitem = nsnull;
-        menuitem->GetNativeData(gtkmenuitem);
-        if (gtkmenuitem) {
-          gtk_widget_ref(GTK_WIDGET(gtkmenuitem));
-          //gtk_widget_destroy(GTK_WIDGET(gtkmenuitem));
-          g_print("%p, %p\n",
-                  GTK_WIDGET(GTK_CONTAINER(GTK_MENU_SHELL(GTK_MENU(mMenu)))),
-                  GTK_WIDGET(GTK_WIDGET(gtkmenuitem)->parent));
-          gtk_container_remove(GTK_CONTAINER(GTK_MENU_SHELL(GTK_MENU(mMenu))),
-                               GTK_WIDGET(gtkmenuitem));
-        }
- 
-      } else {
- 
-        nsIMenu * menu= nsnull;
-        ((nsISupports*)mMenuItemVoidArray[i-1])->QueryInterface(nsIMenu::GetIID(),
-                                                                (void**)&menu);
-        if(menu)
-          {
-            void * gtkmenu = nsnull;
-            menu->GetNativeData(&gtkmenu);
- 
-            if(gtkmenu){
-              g_print("nsMenu::RemoveAll() trying to remove nsMenu");
- 
-              //gtk_menu_item_remove_submenu (GTK_MENU_ITEM (item));
-            }
-          }
- 
-      }
-    }
-  }
-//g_print("end RemoveAll\n");
-  return NS_OK;
-#endif
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::GetNativeData(void ** aData)
-{
-  *aData = (void *)mMenu;
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::AddMenuListener(nsIMenuListener * aMenuListener)
-{
-  mListener = aMenuListener;
-  NS_ADDREF(mListener);
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::RemoveMenuListener(nsIMenuListener * aMenuListener)
-{
-  if (aMenuListener == mListener) {
-    NS_IF_RELEASE(mListener);
-  }
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-// nsIMenuListener interface
-//-------------------------------------------------------------------------
-nsEventStatus nsContextMenu::MenuItemSelected(const nsMenuEvent & aMenuEvent)
-{
-  if (nsnull != mListener) {
-    mListener->MenuSelected(aMenuEvent);
-  }
-  return nsEventStatus_eIgnore;
-}
-
-void menu_popup_position(GtkMenu *menu,
-                         gint *x,
-                         gint *y,
-                         gpointer data)
-{
-  nsContextMenu *cm = (nsContextMenu*)data;
-  *x = cm->GetX();
-  *y = cm->GetY();
-}
-
-nsEventStatus nsContextMenu::MenuSelected(const nsMenuEvent & aMenuEvent)
-{
-  MenuConstruct(aMenuEvent,
-                mParent,
-                mDOMNode,
-                mWebShell);
-
-  //GtkWidget *parent = GTK_WIDGET(mParent->GetNativeData(NS_NATIVE_WIDGET));
-  gtk_menu_popup (GTK_MENU(mMenu),
-                  (GtkWidget*)nsnull, (GtkWidget*)nsnull,
-                  menu_popup_position,
-                  this, 1, GDK_CURRENT_TIME);
-  /*
-  if (nsnull != mListener) {
-    mListener->MenuSelected(aMenuEvent);
-  }
-  */
-  return nsEventStatus_eIgnore;
-}
-
-//-------------------------------------------------------------------------
-nsIMenuItem * nsContextMenu::FindMenuItem(nsIContextMenu * aMenu, PRUint32 aId)
-{
-  return nsnull;
-}
-
-//-------------------------------------------------------------------------
-nsEventStatus nsContextMenu::MenuDeselected(const nsMenuEvent & aMenuEvent)
-{
-  if (nsnull != mListener) {
-    mListener->MenuDeselected(aMenuEvent);
-  }
-  return nsEventStatus_eIgnore;
-}
-
-//-------------------------------------------------------------------------
-nsEventStatus nsContextMenu::MenuConstruct(const nsMenuEvent &aMenuEvent,
-                                           nsIWidget         *aParentWindow, 
-                                           void              *menuNode,
-                                           void              *aWebShell)
-{
-  //g_print("nsMenu::MenuConstruct called \n");
-  if(menuNode){
-    SetDOMNode((nsIDOMNode*)menuNode);
-  }
-  
-  if(!aWebShell){
-    aWebShell = mWebShell;
-  }
-
-  // First open the menu.
-  nsCOMPtr<nsIDOMElement> domElement = do_QueryInterface(mDOMNode);
-  if (domElement)
-    domElement->SetAttribute("open", "true");
-
-   // Begin menuitem inner loop
-    nsCOMPtr<nsIDOMNode> menuitemNode;
-    ((nsIDOMNode*)mDOMNode)->GetFirstChild(getter_AddRefs(menuitemNode));
- 
-    unsigned short menuIndex = 0;
-
-    while (menuitemNode) {
-      nsCOMPtr<nsIDOMElement> menuitemElement(do_QueryInterface(menuitemNode));
-      if (menuitemElement) {
-        nsString menuitemNodeType;
-        nsString menuitemName;
-        menuitemElement->GetNodeName(menuitemNodeType);
-        if (menuitemNodeType.Equals("menuitem")) {
-          // LoadMenuItem
-          LoadMenuItem(this,
-                       menuitemElement,
-                       menuitemNode,
-                       menuIndex,
-                       (nsIWebShell*)aWebShell);
-        } else if (menuitemNodeType.Equals("separator")) {
-          AddSeparator();
-        } else if (menuitemNodeType.Equals("menu")) {
-          // Load a submenu
-          LoadSubMenu(this, menuitemElement, menuitemNode);
-        }
-      }
-      
-      ++menuIndex;
-      
-      nsCOMPtr<nsIDOMNode> oldmenuitemNode(menuitemNode);
-      oldmenuitemNode->GetNextSibling(getter_AddRefs(menuitemNode));
-    } // end menu item innner loop
-  return nsEventStatus_eIgnore;
-}
-
-//-------------------------------------------------------------------------
-nsEventStatus nsContextMenu::MenuDestruct(const nsMenuEvent & aMenuEvent)
-{
-  // Close the node.
-  nsCOMPtr<nsIDOMElement> domElement = do_QueryInterface(mDOMNode);
-  if (domElement)
-    domElement->RemoveAttribute("open");
-
-  //g_print("nsMenu::MenuDestruct called \n");
-  mConstructCalled = PR_FALSE;
-  RemoveAll();
-  return nsEventStatus_eIgnore;
-}
-
-//----------------------------------------
-void nsContextMenu::LoadMenuItem(nsIMenu        *pParentMenu,
-                                 nsIDOMElement  *menuitemElement,
-                                 nsIDOMNode     *menuitemNode,
-                                 unsigned short  menuitemIndex,
-                                 nsIWebShell    *aWebShell)
-{
-  static const char* NS_STRING_TRUE = "true";
-  nsString disabled;
-  nsString menuitemName;
-  nsString menuitemCmd;
-
-  menuitemElement->GetAttribute(nsAutoString("disabled"), disabled);
-  menuitemElement->GetAttribute(nsAutoString("name"), menuitemName);
-  menuitemElement->GetAttribute(nsAutoString("cmd"), menuitemCmd);
-      
-  // Create nsMenuItem
-  nsIMenuItem * pnsMenuItem = nsnull;
-  nsresult rv = nsComponentManager::CreateInstance(kMenuItemCID,
-                                                   nsnull, 
-                                                   nsIMenuItem::GetIID(), 
-                                                   (void**)&pnsMenuItem);
-  if (NS_OK == rv) {
-    pnsMenuItem->Create(pParentMenu, menuitemName, PR_FALSE);
-                     
-    nsISupports * supports = nsnull;
-    pnsMenuItem->QueryInterface(kISupportsIID, (void**) &supports);
-    pParentMenu->AddItem(supports); // Parent should now own menu item
-    NS_RELEASE(supports);
-            
-    if(disabled == NS_STRING_TRUE) {
-      pnsMenuItem->SetEnabled(PR_FALSE);
-    }
-  
-    // Create MenuDelegate - this is the intermediator inbetween 
-    // the DOM node and the nsIMenuItem
-    // The nsWebShellWindow wacthes for Document changes and then notifies the 
-    // the appropriate nsMenuDelegate object
-    nsCOMPtr<nsIDOMElement> domElement(do_QueryInterface(menuitemNode));
-    if (!domElement) {
-      //return NS_ERROR_FAILURE;
-		return;
-    }
-    
-    nsAutoString cmdAtom("onclick");
-    nsString cmdName;
-
-    domElement->GetAttribute(cmdAtom, cmdName);
-
-    pnsMenuItem->SetCommand(cmdName);
-   // DO NOT use passed in webshell because of messed up windows dynamic loading
-      // code. 
-    pnsMenuItem->SetWebShell(mWebShell);
-    pnsMenuItem->SetDOMElement(domElement);
-
-    NS_RELEASE(pnsMenuItem);
-    
-  } 
-  return;
-}
-
-//----------------------------------------
-void nsContextMenu::LoadSubMenu(nsIMenu         *pParentMenu,
-                                nsIDOMElement   *menuElement,
-                                nsIDOMNode      *menuNode)
-{
-  nsString menuName;
-  menuElement->GetAttribute(nsAutoString("name"), menuName);
-  //printf("Creating Menu [%s] \n", menuName.ToNewCString()); // this leaks
-
-  // Create nsMenu
-  nsIMenu * pnsMenu = nsnull;
-  nsresult rv = nsComponentManager::CreateInstance(kMenuCID,
-                                                   nsnull,
-                                                   nsIMenu::GetIID(),
-                                                   (void**)&pnsMenu);
-  if (NS_OK == rv) {
-    // Call Create
-    nsISupports * supports = nsnull;
-    pParentMenu->QueryInterface(kISupportsIID, (void**) &supports);
-    pnsMenu->Create(supports, menuName);
-    NS_RELEASE(supports); // Balance QI
-
-    // Set nsMenu Name
-    pnsMenu->SetLabel(menuName); 
-
-    supports = nsnull;
-    pnsMenu->QueryInterface(kISupportsIID, (void**) &supports);
-    pParentMenu->AddItem(supports); // parent takes ownership
-    NS_RELEASE(supports);
-
-    pnsMenu->SetWebShell(mWebShell);
-    pnsMenu->SetDOMNode(menuNode);
-
-    /*
-    // Begin menuitem inner loop
-    unsigned short menuIndex = 0;
-
-    nsCOMPtr<nsIDOMNode> menuitemNode;
-    menuNode->GetFirstChild(getter_AddRefs(menuitemNode));
-    while (menuitemNode) {
-      nsCOMPtr<nsIDOMElement> menuitemElement(do_QueryInterface(menuitemNode));
-      if (menuitemElement) {
-        nsString menuitemNodeType;
-        menuitemElement->GetNodeName(menuitemNodeType);
-
-#ifdef DEBUG_saari
-        printf("Type [%s] %d\n", menuitemNodeType.ToNewCString(), menuitemNodeType.Equals("separator"));
-#endif
-
-        if (menuitemNodeType.Equals("menuitem")) {
-          // Load a menuitem
-          LoadMenuItem(pnsMenu, menuitemElement, menuitemNode, menuIndex, mWebShell);
-        } else if (menuitemNodeType.Equals("separator")) {
-          pnsMenu->AddSeparator();
-        } else if (menuitemNodeType.Equals("menu")) {
-          // Add a submenu
-          LoadSubMenu(pnsMenu, menuitemElement, menuitemNode);
-        }
-      }
-	  ++menuIndex;
-      nsCOMPtr<nsIDOMNode> oldmenuitemNode(menuitemNode);
-      oldmenuitemNode->GetNextSibling(getter_AddRefs(menuitemNode));
-    } // end menu item innner loop
-    */
-  }     
-}
-
-//----------------------------------------
-void nsContextMenu::LoadMenuItem(nsIContextMenu *pParentMenu,
-                                 nsIDOMElement  *menuitemElement,
-                                 nsIDOMNode     *menuitemNode,
-                                 unsigned short  menuitemIndex,
-                                 nsIWebShell    *aWebShell)
-{
-
-}
-
-//----------------------------------------
-void nsContextMenu::LoadSubMenu(nsIContextMenu  *pParentMenu,
-                                nsIDOMElement   *menuElement,
-                                nsIDOMNode      *menuNode)
-{
-
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::SetLocation(PRInt32 aX, PRInt32 aY)
-{
-  mX = aX;
-  mY = aY;
-  return NS_OK;
-}
-
-
-// local methods
-gint nsContextMenu::GetX(void)
-{
-  return mX;
-}
-
-gint nsContextMenu::GetY(void)
-{
-  return mY;
-}
-// end silly local methods
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::SetDOMNode(nsIDOMNode *aMenuNode)
-{
-  mDOMNode = aMenuNode;
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::SetDOMElement(nsIDOMElement *aMenuElement)
-{
-  mDOMElement = aMenuElement;
-  return NS_OK;
-}
-
-//-------------------------------------------------------------------------
-NS_METHOD nsContextMenu::SetWebShell(nsIWebShell *aWebShell)
-{
-  mWebShell = aWebShell;
-  return NS_OK;
-}

mozilla/widget/src/gtk/nsContextMenu.h

@@ -1,139 +0,0 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
- *
- * 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): 
- */
-
-#ifndef nsContextMenu_h__
-#define nsContextMenu_h__
-
-#include "nsIContextMenu.h"
-#include "nsISupportsArray.h"
-#include "nsVoidArray.h"
-
-#include "nsIDOMElement.h"
-#include "nsIWebShell.h"
-
-class nsIMenuListener;
-
-/**
- * Native Win32 button wrapper
- */
-
-class nsContextMenu : public nsIContextMenu, public nsIMenuListener
-{
-
-public:
-  nsContextMenu();
-  virtual ~nsContextMenu();
-
-  NS_DECL_ISUPPORTS
-  
-  //nsIMenuListener interface
-  nsEventStatus MenuItemSelected(const nsMenuEvent & aMenuEvent);
-  nsEventStatus MenuSelected(const nsMenuEvent & aMenuEvent);
-  nsEventStatus MenuDeselected(const nsMenuEvent & aMenuEvent);
-  nsEventStatus MenuConstruct(const nsMenuEvent & aMenuEvent,
-                              nsIWidget         * aParentWindow, 
-                              void              * menubarNode,
-                              void              * aWebShell);
-  nsEventStatus MenuDestruct(const nsMenuEvent & aMenuEvent);
-
-  // nsIMenu Methods
-  NS_IMETHOD Create(nsISupports * aParent,
-                    const nsString& anAlignment,
-                    const nsString& aAnchorAlign);
-  NS_IMETHOD GetParent(nsISupports *&aParent);
-
-  NS_IMETHOD AddItem(nsISupports * aItem);
-
-  NS_IMETHOD AddSeparator();
-  NS_IMETHOD GetItemCount(PRUint32 &aCount);
-  NS_IMETHOD GetItemAt(const PRUint32 aPos, nsISupports *& aMenuItem);
-  NS_IMETHOD InsertItemAt(const PRUint32 aPos, nsISupports * aMenuItem);
-  NS_IMETHOD RemoveItem(const PRUint32 aPos);
-  NS_IMETHOD RemoveAll();
-  NS_IMETHOD GetNativeData(void** aData);
-
-  NS_IMETHOD AddMenuListener(nsIMenuListener * aMenuListener);
-  NS_IMETHOD RemoveMenuListener(nsIMenuListener * aMenuListener);
-
-  //
-  NS_IMETHOD AddMenuItem(nsIMenuItem * aMenuItem);
-  NS_IMETHOD AddMenu(nsIMenu * aMenu);
-  NS_IMETHOD InsertSeparator(const PRUint32 aCount);
-
-  NS_IMETHOD SetDOMNode(nsIDOMNode * menuNode);
-  NS_IMETHOD SetDOMElement(nsIDOMElement * menuElement);
-  NS_IMETHOD SetWebShell(nsIWebShell * aWebShell);
-  NS_IMETHOD SetLocation(PRInt32 aX, PRInt32 aY);
-
-  gint GetX(void);
-  gint GetY(void);
-
-
-protected:
-  nsIMenuBar * GetMenuBar(nsIMenu * aMenu);
-  nsIWidget *  GetParentWidget();
-  char* GetACPString(nsString& aStr);
-
-  void LoadMenuItem(nsIMenu       * pParentMenu,
-                    nsIDOMElement * menuitemElement,
-                    nsIDOMNode    * menuitemNode,
-                    unsigned short  menuitemIndex,
-                    nsIWebShell   * aWebShell);
-  
-  void LoadSubMenu(nsIMenu       * pParentMenu,
-                   nsIDOMElement * menuElement,
-                   nsIDOMNode    * menuNode);
-
-  void LoadMenuItem(nsIContextMenu * pParentMenu,
-                    nsIDOMElement  * menuitemElement,
-                    nsIDOMNode     * menuitemNode,
-                    unsigned short   menuitemIndex,
-                    nsIWebShell    * aWebShell);
-  
-  void LoadSubMenu(nsIContextMenu * pParentMenu,
-                   nsIDOMElement  * menuElement,
-                   nsIDOMNode     * menuNode);
-
-  nsIMenuItem * FindMenuItem(nsIContextMenu * aMenu, PRUint32 aId);
-
-  nsString   mLabel;
-  PRUint32   mNumMenuItems;
-  GtkWidget  *mMenu;
-  
-  nsVoidArray mMenuItemVoidArray;
-
-  nsIWidget  *mParent;
-  nsIMenuListener * mListener;
-  
-  PRBool mConstructCalled;
-  nsIDOMNode    * mDOMNode;
-  nsIWebShell   * mWebShell;
-  nsIDOMElement * mDOMElement;
-
-  nsString        mAlignment;
-  nsString        mAnchorAlignment;
-
-  PRInt32         mX;
-  PRInt32         mY;
-};
-
-#endif // nsContextMenu_h__