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

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

mozilla/netwerk/cache/public/MANIFEST

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

mozilla/netwerk/cache/public/Makefile.in

@@ -0,0 +1,56 @@
+#
+# 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@
+
+MODULE		= nkcache
+XPIDL_MODULE	= necko_cache
+
+include $(DEPTH)/config/autoconf.mk
+
+XPIDLSRCS	= \
+		nsICachedNetData.idl          \
+	        nsINetDataCacheManager.idl    \
+		nsINetDataCache.idl           \
+		nsINetDataCacheRecord.idl     \
+	        nsINetDataDiskCache.idl       \
+		nsIStreamAsFile.idl           \
+		$(NULL)
+
+
+ifdef MOZ_NEW_CACHE
+XPIDLSRCS	+= \
+		nsICache.idl		      \
+		nsICacheEntryDescriptor.idl   \
+		nsICacheListener.idl	      \
+		nsICacheService.idl           \
+		nsICacheSession.idl           \
+		nsICacheVisitor.idl           \
+	        $(NULL)
+endif
+
+EXPORTS		:= $(addprefix $(srcdir)/, $(EXPORTS))
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/public/Makefile.win

@@ -0,0 +1,51 @@
+#!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 = necko
+XPIDL_MODULE = necko_cache
+
+DEPTH = ..\..\..
+include <$(DEPTH)/config/config.mak>
+
+
+EXPORTS =                   \
+        $(NULL)
+
+XPIDLSRCS =                             \
+        .\nsICachedNetData.idl          \
+        .\nsINetDataCacheManager.idl    \
+        .\nsINetDataCache.idl           \
+        .\nsINetDataCacheRecord.idl     \
+        .\nsINetDataDiskCache.idl       \
+        .\nsIStreamAsFile.idl           \
+!ifdef MOZ_NEW_CACHE
+	.\nsICache.idl		        \
+	.\nsICacheEntryDescriptor.idl   \
+	.\nsICacheListener.idl		\
+	.\nsICacheService.idl		\
+	.\nsICacheSession.idl           \
+	.\nsICacheVisitor.idl           \
+!endif
+        $(NULL)
+
+include <$(DEPTH)/config/rules.mak>
+
+

mozilla/netwerk/cache/public/nsICache.idl

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

mozilla/netwerk/cache/public/nsICacheEntryDescriptor.idl

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

mozilla/netwerk/cache/public/nsICacheListener.idl

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

mozilla/netwerk/cache/public/nsICacheService.idl

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

mozilla/netwerk/cache/public/nsICacheSession.idl

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

mozilla/netwerk/cache/public/nsICacheVisitor.idl

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

mozilla/netwerk/cache/public/nsICachedNetData.idl

@@ -0,0 +1,240 @@
+/* -*- 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 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 partialFlag;
+
+    /**
+     * 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;
+
+    /**
+     * inUse is set if any existing channels are associated with this cache
+     * entry or if the updateInProgess flag is set.  This can be used to
+     * prevent writing to a cache entry by a protocol handler if it's being
+     * read or written elsewhere.
+     */
+    readonly attribute boolean inUse;
+
+    /**
+     * 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;
+
+    readonly attribute PRTime lastUpdateTime;
+
+    /**
+     * Number of times this record has been accessed since it was first stored.
+     */
+    readonly attribute PRUint16 numberAccesses;
+
+    /**
+     * Accessor methods for opaque meta-data which can be read and updated
+     * independently of the content data.
+     *
+     * The aTag argument can be used to accommodate multiple clients of the
+     * cache API, each of which wants to store its own private meta-data into
+     * the cache.  For example, there could be a "headers" tag that the HTTP
+     * protocol handler uses to store http response headers and a "image size"
+     * tag used to store the image dimensions of a GIF file.  The aData
+     * argument refers to an opaque blob of arbitrary bytes.
+     *
+     * IMPORTANT: If aData does not contain byte-oriented data, i.e. it's not a
+     *            string, the contents of aData must be byte-swapped by the,
+     *            caller, so as to make the cache files endian-independent.
+     */
+    void getAnnotation(in string aTag, 
+                       out PRUint32 aLength, [size_is(aLength), retval] out string aData);
+    void setAnnotation(in string aTag,
+                       in  PRUint32 aLength, [size_is(aLength)] in string aData);
+
+    /**
+     * 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;
+
+	/**
+	 * Length of stored content, which may be less than storage consumed if
+     * compression is used
+	 */
+	readonly attribute PRUint32 logicalLength;
+
+	/**
+	 * Opaque security info associated with the cache entry; it can't be serialized
+	 * to disk, so it'll only make sense with memory cache
+	 */
+	attribute nsISupports securityInfo;
+
+    /** 
+     * Notify any observers associated with this cache entry of the deletion
+     * request.  If all observers drop their reference to the cache entry,
+     * 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 aLoadGroup);
+
+    /**
+     * 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,
+                                         in PRUint32 aStartOffset);
+};

mozilla/netwerk/cache/public/nsINetDataCache.idl

@@ -0,0 +1,142 @@
+/* -*- 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;
+
+/**
+ * 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;
+
+    /**
+     * 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++
+// ContractID prefix for Components that implement this interface
+#define NS_NETWORK_CACHE_CONTRACTID "@mozilla.org/network/cache;1"
+#define NS_NETWORK_MEMORY_CACHE_CONTRACTID NS_NETWORK_CACHE_CONTRACTID "?name=memory-cache"
+#define NS_NETWORK_FLAT_CACHE_CONTRACTID   NS_NETWORK_CACHE_CONTRACTID "?name=flat-cache"
+#define NS_NETWORK_FILE_CACHE_CONTRACTID   NS_NETWORK_CACHE_CONTRACTID "?name=file-cache"
+%}

mozilla/netwerk/cache/public/nsINetDataCacheManager.idl

@@ -0,0 +1,169 @@
+/* -*- 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 "nsINetDataCache.idl"
+
+interface nsISimpleEnumerator;
+interface nsICachedNetData;
+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.
+ *
+ * @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;
+
+	/**
+		These enum's are used for the ClearCache calls. 
+	*/
+	const unsigned long ALL_CACHES = 1;
+	const unsigned long MEM_CACHE = 1<<1;
+	const unsigned long FILE_CACHE = 1<<2;
+	const unsigned long FLAT_CACHE = 1<<3;
+    /**
+     * Fetch the cache entry record for the given URI.  If one does not exist,
+     * create a new, empty record.  The normal search order for caches is:
+     *   + 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 string 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 string 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();
+    
+    /**
+      *	Clears the specified cache
+      */
+    void clear( in PRUint32 aCacheToClear );
+
+    /**
+     * 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;
+};
+
+%{ C++
+// ContractID prefix for Components that implement this interface
+#define NS_NETWORK_CACHE_MANAGER_CONTRACTID NS_NETWORK_CACHE_CONTRACTID "?name=manager"
+%}

mozilla/netwerk/cache/public/nsINetDataCacheRecord.idl

@@ -0,0 +1,131 @@
+/* -*- 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 nsIFile;
+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;
+
+	/**
+	 * Opaque security info associated with the cache entry; it can't be serialized
+	 * to disk, so it'll only make sense with memory cache
+	 */
+	attribute nsISupports securityInfo;
+
+    /** 
+     * Delete this cache entry and its associated content.
+     */
+    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 nsIFile file;
+};

mozilla/netwerk/cache/public/nsINetDataDiskCache.idl

@@ -0,0 +1,41 @@
+/* -*- 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 "nsINetDataCache.idl"
+
+interface nsIFile;
+
+/**
+ * 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.
+ */
+[scriptable, uuid(6408e390-6f13-11d3-90c8-000064657374)]
+interface nsINetDataDiskCache : nsINetDataCache
+{
+	/**
+	 * This attribute must be set before calling any other methods of this
+	 * interface.
+	 */
+    attribute nsIFile diskCacheFolder;
+};
+

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 nsIFile;
+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 nsIFile file;
+
+    /**
+     * 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 observeStreamAsFile() 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/src/Makefile.in

@@ -0,0 +1,70 @@
+#
+# 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) 2001 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+
+DEPTH		= ../../..
+topsrcdir	= @top_srcdir@
+srcdir		= @srcdir@
+VPATH		= @srcdir@
+
+include $(DEPTH)/config/autoconf.mk
+
+MODULE		= nkcache
+LIBRARY_NAME	= nkcache
+SHORT_LIBNAME	= nkcache
+IS_COMPONENT	= 1
+REQUIRES	= xpcom string necko pref
+
+EXPORTS		= \
+		nsCacheService.h \
+		$(NULL)
+
+CPPSRCS		= \
+	nsANSIFileStreams.cpp \
+	nsCache.cpp \
+	nsCacheEntry.cpp \
+	nsCacheEntryDescriptor.cpp \
+	nsCacheMetaData.cpp \
+	nsCacheModule.cpp \
+	nsCacheService.cpp \
+	nsCacheSession.cpp \
+	nsDiskCacheDevice.cpp \
+	nsDiskCacheEntry.cpp \
+	nsDiskCacheMap.cpp \
+	nsMemoryCacheDevice.cpp \
+	$(NULL)
+
+include $(topsrcdir)/config/config.mk
+
+EXTRA_LIBS	+= \
+		$(XPCOM_LIBS) \
+		$(NSPR_LIBS) \
+		$(NULL)
+
+#EXTRA_LIBS	= $(NSPR_LIBS)
+
+
+# we don't want the shared lib, but we want to force the creation of a
+# static lib.
+#override NO_SHARED_LIB=1
+#override NO_STATIC_LIB=
+
+include $(topsrcdir)/config/rules.mk
+

mozilla/netwerk/cache/src/makefile.win

@@ -0,0 +1,68 @@
+#
+# The contents of this file are subject to the Netscape Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/NPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Original Code is mozilla.org code.
+#
+# The Initial Developer of the Original Code is Netscape
+# Communications Corporation.  Portions created by Netscape are
+# Copyright (C) 1998 Netscape Communications Corporation. All
+# Rights Reserved.
+#
+# Contributor(s): 
+#
+
+DEPTH = ..\..\..
+include <$(DEPTH)/config/config.mak>
+
+MODULE = nkcache
+DLLNAME=nkcache
+
+DLL=.\$(OBJDIR)\$(DLLNAME).dll
+
+MAKE_OBJ_TYPE=DLL
+
+LCFLAGS = -DWIN32_LEAN_AND_MEAN -D_IMPL_NS_NET
+
+EXPORTS = \
+		nsCacheService.h    \
+		$(NULL)
+
+CPP_OBJS = \
+	.\$(OBJDIR)\nsCache.obj                         \
+	.\$(OBJDIR)\nsCacheEntry.obj			\
+	.\$(OBJDIR)\nsCacheEntryDescriptor.obj          \
+	.\$(OBJDIR)\nsCacheMetaData.obj			\
+	.\$(OBJDIR)\nsCacheModule.obj			\
+	.\$(OBJDIR)\nsCacheService.obj			\
+	.\$(OBJDIR)\nsCacheSession.obj			\
+	.\$(OBJDIR)\nsDiskCacheDevice.obj		\
+	.\$(OBJDIR)\nsDiskCacheEntry.obj		\
+	.\$(OBJDIR)\nsDiskCacheMap.obj			\
+	.\$(OBJDIR)\nsANSIFileStreams.obj		\
+	.\$(OBJDIR)\nsMemoryCacheDevice.obj		\
+	$(NULL)
+
+
+LLIBS	= \
+	$(LIBNSPR) \
+	$(DIST)\lib\xpcom.lib \
+	$(NULL)
+
+include <$(DEPTH)/config/rules.mak>
+
+install:: $(DLL)
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).dll $(DIST)\bin\components
+	$(MAKE_INSTALL) .\$(OBJDIR)\$(DLLNAME).lib $(DIST)\lib
+
+
+clobber::
+        $(RM) $(DIST)\bin\components\$(DLLNAME).dll
+	$(RM) $(DIST)\lib\$(DLLNAME).lib 

mozilla/netwerk/cache/src/nsANSIFileStreams.cpp

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

mozilla/netwerk/cache/src/nsANSIFileStreams.h

@@ -0,0 +1,54 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is nsANSIFileStreams.h, released March 23, 2001.
+ * 
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 2001 Netscape Communications Corporation.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *    Patrick C. Beard <beard@netscape.com>
+ */
+
+#ifndef _nsANSIFileStreams_h_
+#define _nsANSIFileStreams_h_
+
+#include <stdio.h>
+
+#include "nsIFileStreams.h"
+
+class nsANSIInputStream : public nsIInputStream, public nsISeekableStream {
+    FILE*       mFile;
+    PRUint32    mSize;
+public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIINPUTSTREAM
+    NS_DECL_NSISEEKABLESTREAM
+    
+    nsANSIInputStream(FILE* file);
+    virtual ~nsANSIInputStream();
+};
+
+class nsANSIOutputStream : public nsIOutputStream, public nsISeekableStream {
+    FILE* mFile;
+public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIOUTPUTSTREAM
+    NS_DECL_NSISEEKABLESTREAM
+    
+    nsANSIOutputStream(FILE* file);
+    virtual ~nsANSIOutputStream();
+};
+
+#endif // _nsANSIFileStreams_h_

mozilla/netwerk/cache/src/nsCache.cpp

@@ -0,0 +1,131 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is nsCache.cpp, released March 18, 2001.
+ * 
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 2001 Netscape Communications Corporation.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *    Gordon Sheridan  <gordon@netscape.com>
+ *    Patrick C. Beard <beard@netscape.com>
+ *    Darin Fisher     <darin@netscape.com>
+ */
+
+#include "nsCache.h"
+#include "nsReadableUtils.h"
+
+/**
+ * Cache Service Utility Functions
+ */
+
+#if 0
+// time conversion utils from nsCachedNetData.cpp
+// Convert PRTime to unix-style time_t, i.e. seconds since the epoch
+PRUint32
+ConvertPRTimeToSeconds(PRTime time64)
+{
+    double fpTime;
+    LL_L2D(fpTime, time64);
+    return (PRUint32)(fpTime * 1e-6 + 0.5);
+}
+
+
+// Convert unix-style time_t, i.e. seconds since the epoch, to PRTime
+PRTime
+ConvertSecondsToPRTime(PRUint32 seconds)
+{
+    PRInt64 t64;
+    LL_I2L(t64, seconds);
+    PRInt64 mil;
+    LL_I2L(mil, 1000000);
+    LL_MUL(t64, t64, mil);
+    return t64;
+}
+#endif
+
+PRUint32
+SecondsFromPRTime(PRTime prTime)
+{
+  PRInt64  microSecondsPerSecond, intermediateResult;
+  PRUint32 seconds;
+
+  LL_I2L(microSecondsPerSecond, PR_USEC_PER_SEC);
+  LL_DIV(intermediateResult, prTime, microSecondsPerSecond);
+  LL_L2UI(seconds, intermediateResult);
+  return seconds;
+}
+
+
+PRTime
+PRTimeFromSeconds(PRUint32 seconds)
+{
+  PRInt64 microSecondsPerSecond, intermediateResult;
+  PRTime  prTime;
+
+  LL_I2L(microSecondsPerSecond, PR_USEC_PER_SEC);
+  LL_UI2L(intermediateResult, seconds);
+  LL_MUL(prTime, intermediateResult, microSecondsPerSecond);
+  return prTime;
+}
+
+
+nsresult
+ClientIDFromCacheKey(const nsAReadableCString&  key, char ** result)
+{
+    nsresult  rv = NS_OK;
+    *result = nsnull;
+
+    nsReadingIterator<char> colon;
+    key.BeginReading(colon);
+        
+    nsReadingIterator<char> start;
+    key.BeginReading(start);
+        
+    nsReadingIterator<char> end;
+    key.EndReading(end);
+        
+    if (FindCharInReadable(':', colon, end)) {
+        *result = ToNewCString( Substring(start, colon));
+        if (!*result) rv = NS_ERROR_OUT_OF_MEMORY;
+    } else {
+        NS_ASSERTION(PR_FALSE, "FindCharInRead failed to find ':'");
+        rv = NS_ERROR_UNEXPECTED;
+    }
+    return rv;
+}
+
+
+nsresult
+ClientKeyFromCacheKey(const nsAReadableCString& key, char ** result)
+{
+    nsresult  rv = NS_OK;
+    *result = nsnull;
+
+    nsReadingIterator<char> start;
+    key.BeginReading(start);
+        
+    nsReadingIterator<char> end;
+    key.EndReading(end);
+        
+    if (FindCharInReadable(':', start, end)) {
+        ++start;  // advance past clientID ':' delimiter
+        *result = ToNewCString( Substring(start, end));
+        if (!*result) rv = NS_ERROR_OUT_OF_MEMORY;
+    } else {
+        NS_ASSERTION(PR_FALSE, "FindCharInRead failed to find ':'");
+        rv = NS_ERROR_UNEXPECTED;
+    }
+    return rv;
+}

mozilla/netwerk/cache/src/nsCache.h

@@ -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 Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is nsCache.h, released March 18, 2001.
+ * 
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 2001 Netscape Communications Corporation.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *    Gordon Sheridan  <gordon@netscape.com>
+ *    Patrick C. Beard <beard@netscape.com>
+ *    Darin Fisher     <darin@netscape.com>
+ */
+
+/**
+ * Cache Service Utility Functions
+ */
+
+#ifndef _nsCache_h_
+#define _nsCache_h_
+
+#include "nsAReadableString.h"
+#include "prtime.h"
+#include "nsError.h"
+
+#if 0
+          // Convert PRTime to unix-style time_t, i.e. seconds since the epoch
+PRUint32  ConvertPRTimeToSeconds(PRTime time64);
+
+          // Convert unix-style time_t, i.e. seconds since the epoch, to PRTime
+PRTime    ConvertSecondsToPRTime(PRUint32 seconds);
+#endif
+
+
+extern PRUint32  SecondsFromPRTime(PRTime prTime);
+extern PRTime    PRTimeFromSeconds(PRUint32 seconds);
+
+
+extern nsresult  ClientIDFromCacheKey(const nsAReadableCString&  key, char ** result);
+extern nsresult  ClientKeyFromCacheKey(const nsAReadableCString& key, char ** result);
+
+#endif // _nsCache_h

mozilla/netwerk/cache/src/nsCacheDevice.h

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

mozilla/netwerk/cache/src/nsCacheEntry.cpp

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

mozilla/netwerk/cache/src/nsCacheEntry.h

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

mozilla/netwerk/cache/src/nsCacheEntryDescriptor.cpp

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

mozilla/netwerk/cache/src/nsCacheEntryDescriptor.h

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

mozilla/netwerk/cache/src/nsCacheMetaData.cpp

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

mozilla/netwerk/cache/src/nsCacheMetaData.h

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

mozilla/netwerk/cache/src/nsCacheModule.cpp

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

mozilla/netwerk/cache/src/nsCacheRequest.h

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

mozilla/netwerk/cache/src/nsCacheService.h

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

mozilla/netwerk/cache/src/nsCacheSession.cpp

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

mozilla/netwerk/cache/src/nsCacheSession.h

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

mozilla/netwerk/cache/src/nsDiskCache.h

@@ -0,0 +1,199 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is nsCacheDevice.h, released March 9, 2001.
+ * 
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 2001 Netscape Communications Corporation.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *    Patrick Beard   <beard@netscape.com>
+ *    Gordon Sheridan <gordon@netscape.com>
+ */
+
+
+#ifndef _nsDiskCache_h_
+#define _nsDiskCache_h_
+
+#include "prtypes.h"
+#include "prnetdb.h"
+#include "nsDebug.h"
+
+class nsDiskCacheRecord {
+    enum {
+        eEvictionRankMask       = 0xFF000000,
+        eLocationSelectorMask   = 0x00C00000,
+
+        eExtraBlocksMask        = 0x00300000,
+        eBlockNumberMask        = 0x000FFFFF,
+
+        eFileReservedMask       = 0x003F0000,
+        eFileGenerationMask     = 0x0000FFFF
+    };
+
+public:
+    nsDiskCacheRecord()
+        :   mHashNumber(0), mEvictionRank(0), mLocation(0), mUnused(0)
+    {
+    }
+    
+    PRUint32   HashNumber()
+    {
+        return mHashNumber;
+    }
+    
+    void       SetHashNumber(PRUint32 hashNumber)
+    {
+        mHashNumber = hashNumber;
+    }
+
+    PRUint32   EvictionRank()
+    {
+        return mEvictionRank;
+    }
+
+    void       SetEvictionRank(PRUint32 rank)
+    {
+        mEvictionRank = rank;
+    }
+
+    PRUint32   LocationSelector()
+    {
+        return (PRUint32)(mLocation & eLocationSelectorMask) >> 22;
+    }
+
+    void       SetLocationSelector(PRUint32 selector)
+    {
+        mLocation &= ~eLocationSelectorMask; // clear location selector bits
+        mLocation |= (selector & eLocationSelectorMask) << 22;
+    }
+
+    PRUint32   BlockCount()
+    {
+        return (PRUint32)((mLocation & eExtraBlocksMask) >> 20) + 1;
+    }
+
+    void       SetBlockCount(PRUint32 count)
+    {
+        NS_ASSERTION( (count>=1) && (count<=4),"invalid block count");
+        count = --count;
+        mLocation &= ~eExtraBlocksMask; // clear extra blocks bits
+        mLocation |= (count & eExtraBlocksMask) << 20;
+    }
+
+    PRUint32   BlockNumber()
+    {
+        return (mLocation & eBlockNumberMask);
+    }
+
+    void       SetBlockNumber(PRUint32  blockNumber)
+    {
+        mLocation &= ~eBlockNumberMask;  // clear block number bits
+        mLocation |= blockNumber & eBlockNumberMask;
+    }
+
+    PRUint16   FileGeneration()
+    {
+        return (mLocation & eFileGenerationMask);
+    }
+
+    void       SetFileGeneration(PRUint16 generation)
+    {
+        mLocation &= ~eFileGenerationMask;  // clear file generation bits
+        mLocation |= generation & eFileGenerationMask;
+    }
+
+    void        Swap()
+    {
+        mHashNumber = ::PR_htonl(mHashNumber);
+        mEvictionRank = ::PR_htonl(mEvictionRank);
+        mLocation = ::PR_htonl(mLocation);
+        mUnused = ::PR_htonl(mUnused);
+    }
+    
+    void        Unswap()
+    {
+        mHashNumber = ::PR_ntohl(mHashNumber);
+        mEvictionRank = ::PR_ntohl(mEvictionRank);
+        mLocation = ::PR_ntohl(mLocation);
+        mUnused = ::PR_ntohl(mUnused);
+    }
+
+private:
+    PRUint32    mHashNumber;
+    PRUint32    mEvictionRank;
+    PRUint32    mLocation;
+    PRUint32    mUnused;
+};
+
+
+/*
+
+Cache Extent Table
+
+
+1111 1111 0000 0000 0000 0000 0000 0000 : eEvictionRankMask
+0000 0000 1100 0000 0000 0000 0000 0000 : eLocationSelectorMask   (0-3)
+0000 0000 0011 0000 0000 0000 0000 0000 : number of extra contiguous blocks 1-4
+0000 0000 0000 1111 1111 1111 1111 1111 : block#  0-1,048,575
+
+0000 0000 0011 1111 0000 0000 0000 0000 : eFileReservedMask
+0000 0000 0000 0000 1111 1111 1111 1111 : eFileGenerationMask
+
+0  file
+1   256 bytes
+2  1024
+3  4096
+
+
+	log2 of seconds = 5 bits
+
+log2	minutes	hours	days   years
+00000	   1
+00001	   2
+00010	   4
+00011	   8
+00100	  16
+00101	  32
+00110	  64	  1
+00111	 128	  2
+01000	 256	  4
+01001	 512	  8.5
+01010	1024	 17
+01011	2048	 34
+01100		 68
+01101		136
+01110		273	 11
+01111			 22
+10000			 45.5
+10001			 91
+10010			182
+10011			364	1
+10100				2
+10101				3
+10110				4
+10111
+11000
+11001
+11010
+11011
+11100
+11101
+11110
+11111
+
+*/
+
+
+#endif // _nsDiskCache_h_

mozilla/netwerk/cache/src/nsDiskCacheDevice.h

@@ -0,0 +1,116 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is nsDiskCacheDevice.h, released February 20, 2001.
+ * 
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 2001 Netscape Communications Corporation.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *    Gordon Sheridan <gordon@netscape.com>
+ *    Patrick C. Beard <beard@netscape.com>
+ */
+
+#ifndef _nsDiskCacheDevice_h_
+#define _nsDiskCacheDevice_h_
+
+#include "nsCacheDevice.h"
+#include "nsDiskCacheEntry.h"
+
+#include "nsILocalFile.h"
+#include "nsIObserver.h"
+
+class nsDiskCacheEntry;
+class nsDiskCacheMap;
+class nsDiskCacheRecord;
+
+class nsISupportsArray;
+class nsIInputStream;
+class nsIOutputStream;
+
+class nsDiskCacheDevice : public nsCacheDevice {
+public:
+    nsDiskCacheDevice();
+    virtual ~nsDiskCacheDevice();
+
+    static nsresult         Create(nsCacheDevice **result);
+
+    virtual nsresult        Init();
+    virtual nsresult        Shutdown();
+
+    virtual const char *    GetDeviceID(void);
+    virtual nsCacheEntry *  FindEntry(nsCString * key);
+    virtual nsresult        DeactivateEntry(nsCacheEntry * entry);
+    virtual nsresult        BindEntry(nsCacheEntry * entry);
+    virtual void            DoomEntry( nsCacheEntry * entry );
+
+    virtual nsresult        GetTransportForEntry(nsCacheEntry * entry,
+                                          nsCacheAccessMode mode,
+                                          nsITransport ** result);
+
+    virtual nsresult        GetFileForEntry(nsCacheEntry *    entry,
+                                            nsIFile **        result);
+
+    virtual nsresult        OnDataSizeChange(nsCacheEntry * entry, PRInt32 deltaSize);
+    
+    virtual nsresult        Visit(nsICacheVisitor * visitor);
+
+    virtual nsresult        EvictEntries(const char * clientID);
+
+/* private: */
+    void                    setPrefsObserver(nsIObserver* observer);
+    void                    getPrefsObserver(nsIObserver ** result);
+    void                    setCacheDirectory(nsILocalFile* directory);
+    void                    setCacheCapacity(PRUint32 capacity);
+    PRUint32                getCacheCapacity();
+    PRUint32                getCacheSize();
+    PRUint32                getEntryCount();
+
+    nsresult getFileForHashNumber(PLDHashNumber hashNumber, PRBool meta, PRUint32 generation, nsIFile ** result);
+    nsresult getFileForKey(const char* key, PRBool meta, PRUint32 generation, nsIFile ** result);
+    nsresult getFileForDiskCacheEntry(nsDiskCacheEntry * diskEntry, PRBool meta, nsIFile ** result);
+
+    static nsresult getTransportForFile(nsIFile* file, nsCacheAccessMode mode, nsITransport ** result);
+    static nsresult openInputStream(nsIFile* file, nsIInputStream ** result);
+    static nsresult openOutputStream(nsIFile* file, nsIOutputStream ** result);
+
+    nsresult visitEntries(nsICacheVisitor * visitory);
+    
+    nsresult readDiskCacheEntry(const char * key, nsDiskCacheEntry ** diskEntry);
+
+    nsresult updateDiskCacheEntries();
+    nsresult updateDiskCacheEntry(nsDiskCacheEntry * diskEntry);
+    nsresult deleteDiskCacheEntry(nsDiskCacheEntry * diskEntry);
+    
+    nsresult scavengeDiskCacheEntries(nsDiskCacheEntry * diskEntry);
+
+    nsresult scanDiskCacheEntries(nsISupportsArray ** result);
+    nsresult evictDiskCacheEntries();
+    
+    nsresult readCacheMap();
+    nsresult writeCacheMap();
+
+    nsresult updateCacheMap(nsDiskCacheEntry * diskEntry);
+    nsresult evictDiskCacheRecord(nsDiskCacheRecord * record);
+    
+private:
+    PRBool                      mInitialized;
+    nsCOMPtr<nsIObserver>       mPrefsObserver;
+    nsCOMPtr<nsILocalFile>      mCacheDirectory;
+    nsDiskCacheEntryHashTable   mBoundEntries;
+    PRUint32                    mCacheCapacity;
+    nsDiskCacheMap*             mCacheMap;
+};
+
+#endif // _nsDiskCacheDevice_h_

mozilla/netwerk/cache/src/nsDiskCacheEntry.cpp

@@ -0,0 +1,213 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is nsMemoryCacheDevice.cpp, released February 22, 2001.
+ * 
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 2001 Netscape Communications Corporation.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *    Patrick C. Beard <beard@netscape.com>
+ */
+
+#include <limits.h>
+
+#include "nsDiskCacheEntry.h"
+
+NS_IMPL_ISUPPORTS0(nsDiskCacheEntry);
+
+PLDHashNumber
+nsDiskCacheEntry::Hash(const char* key)
+{
+    PLDHashNumber h = 0;
+    for (const PRUint8* s = (PRUint8*) key; *s != '\0'; ++s)
+        h = (h >> (PL_DHASH_BITS - 4)) ^ (h << 4) ^ *s;
+    return (h == 0 ? ULONG_MAX : h);
+}
+
+/******************************************************************************
+ *  nsCacheEntryHashTable
+ *****************************************************************************/
+
+PLDHashTableOps nsDiskCacheEntryHashTable::ops =
+{
+    PL_DHashAllocTable,
+    PL_DHashFreeTable,
+    GetKey,
+    HashKey,
+    MatchEntry,
+    MoveEntry,
+    ClearEntry,
+    Finalize
+};
+
+nsDiskCacheEntryHashTable::nsDiskCacheEntryHashTable()
+    : initialized(PR_FALSE)
+{
+}
+
+
+nsDiskCacheEntryHashTable::~nsDiskCacheEntryHashTable()
+{
+    if (initialized)
+        PL_DHashTableFinish(&table);
+}
+
+
+nsresult
+nsDiskCacheEntryHashTable::Init()
+{
+    nsresult rv = NS_OK;
+    initialized = PL_DHashTableInit(&table, &ops, nsnull,
+                                    sizeof(HashTableEntry), 512);
+
+    if (!initialized) rv = NS_ERROR_OUT_OF_MEMORY;
+    
+    return rv;
+}
+
+
+nsDiskCacheEntry *
+nsDiskCacheEntryHashTable::GetEntry(const char * key)
+{
+    return GetEntry(nsDiskCacheEntry::Hash(key));
+}
+
+
+nsDiskCacheEntry *
+nsDiskCacheEntryHashTable::GetEntry(PLDHashNumber key)
+{
+    nsDiskCacheEntry * result = nsnull;
+    NS_ASSERTION(initialized, "nsDiskCacheEntryHashTable not initialized");
+    HashTableEntry * hashEntry;
+    hashEntry = (HashTableEntry*) PL_DHashTableOperate(&table, (void*) key, PL_DHASH_LOOKUP);
+    if (PL_DHASH_ENTRY_IS_BUSY(hashEntry)) {
+        result = hashEntry->mDiskCacheEntry;
+    }
+    return result;
+}
+
+
+nsresult
+nsDiskCacheEntryHashTable::AddEntry(nsDiskCacheEntry * entry)
+{
+    NS_ENSURE_ARG_POINTER(entry);
+    NS_ASSERTION(initialized, "nsDiskCacheEntryHashTable not initialized");
+
+    HashTableEntry * hashEntry;
+    hashEntry = (HashTableEntry *) PL_DHashTableOperate(&table,
+                                                        (void*) entry->getHashNumber(),
+                                                        PL_DHASH_ADD);
+    if (!hashEntry) return NS_ERROR_OUT_OF_MEMORY;
+    
+    NS_ADDREF(hashEntry->mDiskCacheEntry = entry);
+
+    return NS_OK;
+}
+
+
+void
+nsDiskCacheEntryHashTable::RemoveEntry(nsDiskCacheEntry * entry)
+{
+    NS_ASSERTION(initialized, "nsDiskCacheEntryHashTable not initialized");
+    NS_ASSERTION(entry, "### cacheEntry == nsnull");
+
+    (void) PL_DHashTableOperate(&table, (void*) entry->getHashNumber(), PL_DHASH_REMOVE);
+}
+
+
+void
+nsDiskCacheEntryHashTable::VisitEntries(Visitor *visitor)
+{
+    PL_DHashTableEnumerate(&table, VisitEntry, visitor);
+}
+
+
+PLDHashOperator PR_CALLBACK
+nsDiskCacheEntryHashTable::VisitEntry(PLDHashTable *        table,
+                                      PLDHashEntryHdr *     header,
+                                      PRUint32              number,
+                                      void *                arg)
+{
+    HashTableEntry* hashEntry = (HashTableEntry *) header;
+    Visitor *visitor = (Visitor*) arg;
+    return (visitor->VisitEntry(hashEntry->mDiskCacheEntry) ? PL_DHASH_NEXT : PL_DHASH_STOP);
+}
+
+/**
+ *  hash table operation callback functions
+ */
+const void * PR_CALLBACK
+nsDiskCacheEntryHashTable::GetKey(PLDHashTable * /*table*/, PLDHashEntryHdr * header)
+{
+    HashTableEntry * hashEntry = (HashTableEntry *) header;
+    return (void*) hashEntry->mDiskCacheEntry->getHashNumber();
+}
+
+
+PLDHashNumber PR_CALLBACK
+nsDiskCacheEntryHashTable::HashKey( PLDHashTable *table, const void *key)
+{
+    return (PLDHashNumber) key;
+}
+
+PRBool PR_CALLBACK
+nsDiskCacheEntryHashTable::MatchEntry(PLDHashTable *             /* table */,
+                                      const PLDHashEntryHdr *       header,
+                                      const void *                  key)
+{
+    HashTableEntry * hashEntry = (HashTableEntry *) header;
+    return (hashEntry->mDiskCacheEntry->getHashNumber() == (PLDHashNumber) key);
+}
+
+void PR_CALLBACK
+nsDiskCacheEntryHashTable::MoveEntry(PLDHashTable *              /* table */,
+                                 const PLDHashEntryHdr *            fromHeader,
+                                 PLDHashEntryHdr       *            toHeader)
+{
+    HashTableEntry * fromEntry = (HashTableEntry *) fromHeader;
+    HashTableEntry * toEntry = (HashTableEntry *) toHeader;
+    toEntry->keyHash = fromEntry->keyHash;
+    toEntry->mDiskCacheEntry = fromEntry->mDiskCacheEntry;
+    fromEntry->mDiskCacheEntry = nsnull;
+}
+
+
+void PR_CALLBACK
+nsDiskCacheEntryHashTable::ClearEntry(PLDHashTable *             /* table */,
+                                      PLDHashEntryHdr *             header)
+{
+    HashTableEntry* hashEntry = (HashTableEntry *) header;
+    hashEntry->keyHash = 0;
+    NS_IF_RELEASE(hashEntry->mDiskCacheEntry);
+}
+
+
+void PR_CALLBACK
+nsDiskCacheEntryHashTable::Finalize(PLDHashTable * table)
+{
+    (void) PL_DHashTableEnumerate(table, FreeCacheEntries, nsnull);
+}
+
+
+PLDHashOperator PR_CALLBACK
+nsDiskCacheEntryHashTable::FreeCacheEntries(PLDHashTable *             /* table */,
+                                            PLDHashEntryHdr *             header,
+                                            PRUint32                      number,
+                                            void *                        arg)
+{
+    HashTableEntry *entry = (HashTableEntry *) header;
+    NS_IF_RELEASE(entry->mDiskCacheEntry);
+    return PL_DHASH_NEXT;
+}

mozilla/netwerk/cache/src/nsDiskCacheEntry.h

@@ -0,0 +1,165 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is nsMemoryCacheDevice.cpp, released February 22, 2001.
+ * 
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 2001 Netscape Communications Corporation.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *    Patrick C. Beard <beard@netscape.com>
+ */
+
+#ifndef _nsDiskCacheEntry_h_
+#define _nsDiskCacheEntry_h_
+
+#include "nspr.h"
+#include "pldhash.h"
+
+#include "nsISupports.h"
+#include "nsCacheEntry.h"
+
+#ifdef MOZ_NEW_CACHE_REUSE_TRANSPORTS
+#include "nsITransport.h"
+#endif
+
+class nsDiskCacheEntry : public nsISupports, public PRCList {
+public:
+    NS_DECL_ISUPPORTS
+
+    nsDiskCacheEntry(nsCacheEntry* entry)
+        :   mCacheEntry(entry),
+            mGeneration(0)
+    {
+        NS_INIT_ISUPPORTS();
+        PR_INIT_CLIST(this);
+        mHashNumber = Hash(entry->Key()->get());
+    }
+
+    virtual ~nsDiskCacheEntry()
+    {
+        PR_REMOVE_LINK(this);
+    }
+
+#ifdef MOZ_NEW_CACHE_REUSE_TRANSPORTS
+    /**
+     * Maps a cache access mode to a cached nsITransport for that access
+     * mode. We keep these cached to avoid repeated trips to the
+     * file transport service.
+     */
+    nsCOMPtr<nsITransport>& getTransport(nsCacheAccessMode mode)
+    {
+        return mTransports[mode - 1];
+    }
+    
+    nsCOMPtr<nsITransport>& getMetaTransport(nsCacheAccessMode mode)
+    {
+        return mMetaTransports[mode - 1];
+    }
+#endif
+    
+    nsCacheEntry* getCacheEntry()
+    {
+        return mCacheEntry;
+    }
+    
+    PRUint32 getGeneration()
+    {
+        return mGeneration;
+    }
+    
+    void setGeneration(PRUint32 generation)
+    {
+        mGeneration = generation;
+    }
+    
+    PLDHashNumber getHashNumber()
+    {
+        return mHashNumber;
+    }
+    
+    static PLDHashNumber Hash(const char* key);
+    
+private:
+#ifdef MOZ_NEW_CACHE_REUSE_TRANSPORTS
+    nsCOMPtr<nsITransport>  mTransports[3];
+    nsCOMPtr<nsITransport>  mMetaTransports[3];
+#endif
+    nsCacheEntry*           mCacheEntry;
+    PRUint32                mGeneration;
+    PLDHashNumber           mHashNumber;
+};
+
+class nsDiskCacheEntryHashTable {
+public:
+    nsDiskCacheEntryHashTable();
+    ~nsDiskCacheEntryHashTable();
+
+    nsresult                Init();
+
+    nsDiskCacheEntry *      GetEntry(const char *               key);
+    nsDiskCacheEntry *      GetEntry(PLDHashNumber              key);
+    nsresult                AddEntry(nsDiskCacheEntry *         entry);
+    void                    RemoveEntry(nsDiskCacheEntry *      entry);
+    
+    class Visitor {
+    public:
+        virtual PRBool      VisitEntry(nsDiskCacheEntry *       entry) = 0;
+    };
+    
+    void                    VisitEntries(Visitor *              visitor);
+    
+private:
+    struct HashTableEntry : PLDHashEntryHdr {
+        nsDiskCacheEntry *  mDiskCacheEntry;                    // STRONG ref?
+    };
+
+    // PLDHashTable operation callbacks
+    static const void *     PR_CALLBACK GetKey(PLDHashTable *               table,
+                                               PLDHashEntryHdr *            entry);
+
+    static PLDHashNumber    PR_CALLBACK HashKey(PLDHashTable *              table,
+                                                const void *                key);
+
+    static PRBool           PR_CALLBACK MatchEntry(PLDHashTable *           table,
+                                                   const PLDHashEntryHdr *  entry,
+                                                   const void *             key);
+
+    static void             PR_CALLBACK MoveEntry(PLDHashTable *            table,
+                                                  const PLDHashEntryHdr *   from,
+                                                  PLDHashEntryHdr       *   to);
+
+    static void             PR_CALLBACK ClearEntry(PLDHashTable *           table,
+                                                   PLDHashEntryHdr *        entry);
+
+    static void             PR_CALLBACK Finalize(PLDHashTable *table);
+
+    static
+    PLDHashOperator         PR_CALLBACK FreeCacheEntries(PLDHashTable *     table,
+                                                         PLDHashEntryHdr *  hdr,
+                                                         PRUint32           number,
+                                                         void *             arg);
+    static
+    PLDHashOperator         PR_CALLBACK VisitEntry(PLDHashTable *           table,
+                                                   PLDHashEntryHdr *        hdr,
+                                                   PRUint32                 number,
+                                                   void *                   arg);
+                                     
+    // member variables
+    static PLDHashTableOps ops;
+    PLDHashTable           table;
+    PRBool                 initialized;
+};
+
+#endif /* _nsDiskCacheEntry_h_ */

mozilla/netwerk/cache/src/nsDiskCacheMap.cpp

@@ -0,0 +1,163 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is nsDiskCacheMap.cpp, released March 23, 2001.
+ * 
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 2001 Netscape Communications Corporation.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *    Patrick C. Beard <beard@netscape.com>
+ */
+
+#include "nsDiskCacheMap.h"
+#include "nsIFileStreams.h"
+
+#include <string.h>
+
+nsDiskCacheMap::nsDiskCacheMap()
+{
+}
+
+nsDiskCacheMap::~nsDiskCacheMap()
+{
+}
+
+nsDiskCacheRecord* nsDiskCacheMap::GetRecord(PRUint32 hashNumber)
+{
+    nsDiskCacheBucket& bucket = mBuckets[(hashNumber & (kBucketsPerTable - 1))];
+    nsDiskCacheRecord* oldestRecord = &bucket.mRecords[0];
+
+    for (int r = 0; r < kRecordsPerBucket; ++r) {
+        nsDiskCacheRecord* record = &bucket.mRecords[r];
+        if (record->HashNumber() == 0 || record->HashNumber() == hashNumber)
+            return record;
+        if (record->EvictionRank() < oldestRecord->EvictionRank())
+            oldestRecord = record;
+    }
+    // if we don't find an empty record, return the oldest record for eviction.
+    return oldestRecord;
+}
+
+void nsDiskCacheMap::DeleteRecord(PRUint32 hashNumber)
+{
+    nsDiskCacheBucket& bucket = mBuckets[(hashNumber & (kBucketsPerTable - 1))];
+    for (int r = 0; r < kRecordsPerBucket; ++r) {
+        nsDiskCacheRecord* record = &bucket.mRecords[r];
+        if (record->HashNumber() == hashNumber) {
+            nsDiskCacheRecord* deletedRecord = record;
+            nsDiskCacheRecord* lastRecord = nsnull;
+            // XXX use binary search to find the end, much quicker.
+            // find the last record, to fill in the deleted record.
+            for (int j = r + 1; j < kRecordsPerBucket; ++j) {
+                record = &bucket.mRecords[j];
+                if (record->HashNumber() == 0) {
+                    lastRecord = record - 1;
+                    break;
+                }
+            }
+            // copy the last record, to the newly deleted record.
+            if (lastRecord && deletedRecord != lastRecord) {
+                *deletedRecord = *lastRecord;
+                deletedRecord = lastRecord;
+            }
+            // mark record as free.
+            deletedRecord->SetHashNumber(0);
+            break;
+        }
+    }
+}
+
+nsresult nsDiskCacheMap::Read(nsIInputStream* input)
+{
+    nsresult rv;
+    PRUint32 count;
+
+    // read the header.
+    rv = input->Read((char*)&mHeader, sizeof(mHeader), &count);
+    if (NS_FAILED(rv)) return rv;
+    mHeader.Unswap();
+    
+    // validate the version.
+    if (mHeader.mVersion != nsDiskCacheHeader::kCurrentVersion) return NS_ERROR_FAILURE;
+
+    // seek to beginning of first bucket.
+    nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(input, &rv);
+    if (NS_FAILED(rv)) return rv;
+    rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, sizeof(nsDiskCacheBucket));
+    if (NS_FAILED(rv)) return rv;
+
+    // read the buckets.
+    rv = input->Read((char*)&mBuckets[1], sizeof(mBuckets) - sizeof(nsDiskCacheBucket), &count);
+    if (NS_FAILED(rv)) return rv;
+    
+    // unswap all of the active records.
+    for (int b = 1; b < kBucketsPerTable; ++b) {
+        nsDiskCacheBucket& bucket = mBuckets[b];
+        for (int r = 0; r < kRecordsPerBucket; ++r) {
+            nsDiskCacheRecord* record = &bucket.mRecords[r];
+            if (record->HashNumber() == 0)
+                break;
+            record->Unswap();
+        }
+    }
+    
+    return NS_OK;
+}
+
+nsresult nsDiskCacheMap::Write(nsIOutputStream* output)
+{
+    nsresult rv;
+    PRUint32 count;
+    int b;
+    
+    // swap all of the active records.
+    for (b = 1; b < kBucketsPerTable; ++b) {
+        nsDiskCacheBucket& bucket = mBuckets[b];
+        for (int r = 0; r < kRecordsPerBucket; ++r) {
+            nsDiskCacheRecord* record = &bucket.mRecords[r];
+            if (record->HashNumber() == 0)
+                break;
+            record->Swap();
+        }
+    }
+    
+    // write the buckets.
+    rv = output->Write((char*)&mBuckets, sizeof(mBuckets), &count);
+
+    // unswap all of the active records.
+    for (b = 1; b < kBucketsPerTable; ++b) {
+        nsDiskCacheBucket& bucket = mBuckets[b];
+        for (int r = 0; r < kRecordsPerBucket; ++r) {
+            nsDiskCacheRecord* record = &bucket.mRecords[r];
+            if (record->HashNumber() == 0)
+                break;
+            record->Unswap();
+        }
+    }
+    if (NS_FAILED(rv)) return rv;
+
+    // seek back to beginning of file.
+    nsCOMPtr<nsISeekableStream> seekable = do_QueryInterface(output, &rv);
+    if (NS_FAILED(rv)) return rv;
+    rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET, 0);
+    if (NS_FAILED(rv)) return rv;
+    
+    // write the header.
+    mHeader.Swap();
+    rv = output->Write((char*)&mHeader, sizeof(mHeader), &count);
+    mHeader.Unswap();
+    
+    return rv;
+}

mozilla/netwerk/cache/src/nsDiskCacheMap.h

@@ -0,0 +1,90 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is nsDiskCacheMap.h, released March 23, 2001.
+ * 
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 2001 Netscape Communications Corporation.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *    Patrick C. Beard <beard@netscape.com>
+ */
+
+#ifndef _nsDiskCacheMap_h_
+
+#include "nsDiskCache.h"
+#include "nsError.h"
+
+class nsIInputStream;
+class nsIOutputStream;
+
+struct nsDiskCacheHeader {
+    enum { kCurrentVersion = 0x00010000 };
+
+    PRUint32    mVersion;                           // cache version.
+    PRUint32    mDataSize;                          // size of cache in bytes.
+    PRUint32    mEntryCount;                        // number of entries stored in cache.
+    // XXX need a bitmap?
+    
+    nsDiskCacheHeader()
+        :   mVersion(kCurrentVersion), mDataSize(0), mEntryCount(0)
+    {
+    }
+
+    void        Swap()
+    {
+        mVersion = ::PR_htonl(mVersion);
+        mDataSize = ::PR_htonl(mDataSize);
+        mEntryCount = ::PR_htonl(mEntryCount);
+    }
+    
+    void        Unswap()
+    {
+        mVersion = ::PR_ntohl(mVersion);
+        mDataSize = ::PR_ntohl(mDataSize);
+        mEntryCount = ::PR_ntohl(mEntryCount);
+    }
+};
+
+// XXX initial capacity, enough for 8192 distint entries.
+class nsDiskCacheMap {
+public:
+    nsDiskCacheMap();
+    ~nsDiskCacheMap();
+    
+    PRUint32& DataSize() { return mHeader.mDataSize; }
+
+    PRUint32& EntryCount() { return mHeader.mEntryCount; }
+
+    nsDiskCacheRecord* GetRecord(PRUint32 hashNumber);
+    void DeleteRecord(PRUint32 hashNumber);
+    
+    nsresult Read(nsIInputStream* input);
+    nsresult Write(nsIOutputStream* output);
+    
+    enum {
+        kRecordsPerBucket = 256,
+        kBucketsPerTable = (1 << 5)                 // must be a power of 2!
+    };
+    
+private:
+    struct nsDiskCacheBucket {
+        nsDiskCacheRecord   mRecords[kRecordsPerBucket];
+    };
+    
+    nsDiskCacheHeader       mHeader;
+    nsDiskCacheBucket       mBuckets[kBucketsPerTable];
+};
+
+#endif // _nsDiskCacheMap_h_

mozilla/netwerk/cache/src/nsMemoryCacheDevice.cpp

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

mozilla/netwerk/cache/src/nsMemoryCacheDevice.h

@@ -0,0 +1,110 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Mozilla Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/MPL/
+ * 
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ * 
+ * The Original Code is nsMemoryCacheDevice.h, released February 20, 2001.
+ * 
+ * The Initial Developer of the Original Code is Netscape Communications
+ * Corporation.  Portions created by Netscape are
+ * Copyright (C) 2001 Netscape Communications Corporation.  All
+ * Rights Reserved.
+ * 
+ * Contributor(s): 
+ *    Gordon Sheridan, 20-February-2001
+ */
+
+#ifndef _nsMemoryCacheDevice_h_
+#define _nsMemoryCacheDevice_h_
+
+#include "nsCacheDevice.h"
+#include "pldhash.h"
+#include "nsCacheEntry.h"
+
+
+class nsMemoryCacheDeviceInfo;
+
+/******************************************************************************
+ * nsMemoryCacheDevice
+ ******************************************************************************/
+class nsMemoryCacheDevice : public nsCacheDevice
+{
+public:
+    nsMemoryCacheDevice();
+    virtual ~nsMemoryCacheDevice();
+
+    virtual nsresult        Init();
+    virtual nsresult        Shutdown();
+
+    virtual const char *    GetDeviceID(void);
+
+    virtual nsresult        BindEntry( nsCacheEntry * entry );
+    virtual nsCacheEntry *  FindEntry( nsCString * key );
+    virtual void            DoomEntry( nsCacheEntry * entry );
+    virtual nsresult        DeactivateEntry( nsCacheEntry * entry );
+
+    virtual nsresult GetTransportForEntry( nsCacheEntry * entry,
+                                           nsCacheAccessMode mode,
+                                           nsITransport **transport );
+
+    virtual nsresult GetFileForEntry( nsCacheEntry *    entry,
+                                      nsIFile **        result );
+
+    virtual nsresult OnDataSizeChange( nsCacheEntry * entry, PRInt32 deltaSize );
+
+    virtual nsresult Visit( nsICacheVisitor * visitor );
+
+    virtual nsresult        EvictEntries(const char * clientID);
+    
+    static int PR_CALLBACK MemoryCacheSizeChanged(const char * pref, void * closure);
+ 
+private:
+    friend class nsMemoryCacheDeviceInfo;
+    void      AdjustMemoryLimits(PRUint32  softLimit, PRUint32  hardLimit);
+    void      EvictEntriesIfNecessary(void);
+
+    nsCacheEntryHashTable   mMemCacheEntries;
+    PRCList                 mEvictionList;
+
+    PRUint32                mHardLimit;
+    PRUint32                mSoftLimit;
+
+    PRUint32                mTotalSize;
+    PRUint32                mInactiveSize;
+
+    PRUint32                mEntryCount;
+
+    PRUint32                mMaxEntryCount;
+    // XXX what other stats do we want to keep?
+};
+
+
+/******************************************************************************
+ * nsMemoryCacheDeviceInfo - used to call nsIVisitor for about:cache
+ ******************************************************************************/
+class nsMemoryCacheDeviceInfo : public nsICacheDeviceInfo {
+public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSICACHEDEVICEINFO
+
+    nsMemoryCacheDeviceInfo(nsMemoryCacheDevice* device)
+        :   mDevice(device)
+    {
+        NS_INIT_ISUPPORTS();
+    }
+
+    virtual ~nsMemoryCacheDeviceInfo() {}
+    
+private:
+    nsMemoryCacheDevice* mDevice;
+};
+
+
+#endif // _nsMemoryCacheDevice_h_

mozilla/tools/tinderbox-configs/firefox/linux/mozconfig

@@ -1,26 +0,0 @@
-#
-## hostname: fx-linux-tbox
-## uname: Linux fx-linux-tbox.build.mozilla.org 2.6.18-8.el5 #1 SMP Thu Mar 15 19:57:35 EDT 2007 i686 i686 i386 GNU/Linux
-#
-
-export CFLAGS="-gstabs+"
-export CXXFLAGS="-gstabs+"
-
-mk_add_options MOZ_CO_PROJECT=browser
-mk_add_options PROFILE_GEN_SCRIPT=@TOPSRCDIR@/build/profile_pageloader.pl
-mk_add_options MOZ_CO_MODULE="mozilla/tools/update-packaging"
-mk_add_options MOZ_MAKE_FLAGS="-j1"
-
-ac_add_options --enable-application=browser
-ac_add_options --enable-update-channel=release
-ac_add_options --enable-update-packaging
-
-# Don't add explicit optimize flags here, set them in configure.in, see bug 407794.
-ac_add_options --enable-optimize
-ac_add_options --disable-debug
-ac_add_options --disable-tests
-
-ac_add_options --enable-official-branding
-
-CC=/tools/gcc/bin/gcc
-CXX=/tools/gcc/bin/g++

mozilla/tools/tinderbox-configs/firefox/linux/tinder-config.pl

@@ -1,268 +0,0 @@
-#
-## hostname: fx-linux-tbox
-## uname: Linux fx-linux-tbox.build.mozilla.org 2.6.18-8.el5 #1 SMP Thu Mar 15 19:57:35 EDT 2007 i686 i686 i386 GNU/Linux
-#
-
-#- tinder-config.pl - Tinderbox configuration file.
-#-    Uncomment the variables you need to set.
-#-    The default values are the same as the commented variables.
-
-$ENV{CVS_RSH} = "ssh";
-$ENV{MOZ_CRASHREPORTER_NO_REPORT} = '1';
-
-# To ensure Talkback client builds properly on some Linux boxen where LANG
-# is set to "en_US.UTF-8" by default, override that setting here by setting
-# it to "en_US.iso885915" (the setting on ocean).  Proper fix is to update
-# where xrestool is called in the build system so that 'LANG=C' in its
-# environment, according to bryner.
-$ENV{LANG} = "en_US.iso885915";
-
-# $ENV{MOZ_PACKAGE_MSI}
-#-----------------------------------------------------------------------------
-#  Default: 0
-#   Values: 0 | 1
-#  Purpose: Controls whether a MSI package is made.
-# Requires: Windows and a local MakeMSI installation.
-#$ENV{MOZ_PACKAGE_MSI} = 0;
-
-# $ENV{MOZ_SYMBOLS_TRANSFER_TYPE}
-#-----------------------------------------------------------------------------
-#  Default: scp
-#   Values: scp | rsync
-#  Purpose: Use scp or rsync to transfer symbols to the Talkback server.
-# Requires: The selected type requires the command be available both locally
-#           and on the Talkback server.
-#$ENV{MOZ_SYMBOLS_TRANSFER_TYPE} = "scp";
-
-#- PLEASE FILL THIS IN WITH YOUR PROPER EMAIL ADDRESS
-$BuildAdministrator = 'build@mozilla.org';
-#$BuildAdministrator = "$ENV{USER}\@$ENV{HOST}";
-#$BuildAdministrator = ($ENV{USER} || "cltbld") . "\@" . ($ENV{HOST} || "dhcp");
-
-#- You'll need to change these to suit your machine's needs
-$DisplayServer = ':0.0';
-
-#- Default values of command-line opts
-#-
-#$BuildDepend       = 1;      # Depend or Clobber
-#$BuildDebug        = 0;      # Debug or Opt (Darwin)
-#$ReportStatus      = 1;      # Send results to server, or not
-#$ReportFinalStatus = 1;      # Finer control over $ReportStatus.
-$UseTimeStamp      = 0;      # Use the CVS 'pull-by-timestamp' option, or not
-#$BuildOnce         = 0;      # Build once, don't send results to server
-#$TestOnly          = 0;      # Only run tests, don't pull/build
-#$BuildEmbed        = 0;      # After building seamonkey, go build embed app.
-#$SkipMozilla       = 0;      # Use to debug post-mozilla.pl scripts.
-#$BuildLocales      = 0;      # Do l10n packaging?
-
-# Tests
-$CleanProfile             = 1;
-#$ResetHomeDirForTests     = 1;
-$ProductName              = "Firefox";
-$VendorName               = 'Mozilla';
-
-$RunMozillaTests          = 1;  # Allow turning off of all tests if needed.
-$RegxpcomTest             = 1;
-$AliveTest                = 1;
-#$JavaTest                 = 0;
-#$ViewerTest               = 0;
-#$BloatTest                = 0;  # warren memory bloat test
-#$BloatTest2               = 0;  # dbaron memory bloat test, require tracemalloc
-#$DomToTextConversionTest  = 0;  
-#$XpcomGlueTest            = 0;
-$CodesizeTest             = 0;  # Z,  require mozilla/tools/codesighs
-$EmbedCodesizeTest        = 0;  # mZ, require mozilla/tools/codesigns
-#$MailBloatTest            = 0;
-#$EmbedTest                = 0;  # Assumes you wanted $BuildEmbed=1
-$LayoutPerformanceTest    = 0;  # Tp
-$DHTMLPerformanceTest     = 0;  # Tdhtml
-#$QATest                   = 0;  
-#$XULWindowOpenTest        = 0;  # Txul
-$StartupPerformanceTest   = 0;  # Ts
-
-$TestsPhoneHome           = 0;  # Should test report back to server?
-$GraphNameOverride        = 'fx-linux-tbox';
-
-# $results_server
-#----------------------------------------------------------------------------
-# Server on which test results will be accessible.  This was originally tegu,
-# then became axolotl.  Once we moved services from axolotl, it was time
-# to give this service its own hostname to make future transitions easier.
-# - cmp@mozilla.org
-#$results_server           = "build-graphs.mozilla.org";
-
-#$pageload_server          = "spider";  # localhost
-$pageload_server      = "pageload.build.mozilla.org";
-
-
-#
-# Timeouts, values are in seconds.
-#
-#$CVSCheckoutTimeout               = 3600;
-#$CreateProfileTimeout             = 45;
-#$RegxpcomTestTimeout              = 120;
-
-#$AliveTestTimeout                 = 45;
-#$ViewerTestTimeout                = 45;
-#$EmbedTestTimeout                 = 45;
-#$BloatTestTimeout                 = 120;   # seconds
-#$MailBloatTestTimeout             = 120;   # seconds
-#$JavaTestTimeout                  = 45;
-#$DomTestTimeout	                  = 45;    # seconds
-#$XpcomGlueTestTimeout             = 15;
-#$CodesizeTestTimeout              = 900;     # seconds
-#$CodesizeTestType                 = "auto";  # {"auto"|"base"}
-#$LayoutPerformanceTestTimeout     = 1200;  # entire test, seconds
-#$DHTMLPerformanceTestTimeout      = 1200;  # entire test, seconds
-#$QATestTimeout                    = 1200;   # entire test, seconds
-#$LayoutPerformanceTestPageTimeout = 30000; # each page, ms
-#$StartupPerformanceTestTimeout    = 15;    # seconds
-#$XULWindowOpenTestTimeout	      = 150;   # seconds
-
-
-#$MozConfigFileName = 'mozconfig';
-
-#$UseMozillaProfile = 1;
-#$MozProfileName = 'default';
-
-#- Set these to what makes sense for your system
-#$Make          = 'gmake';       # Must be GNU make
-#$MakeOverrides = '';
-#$mail          = '/bin/mail';
-#$CVS           = 'cvs -q';
-#$CVSCO         = 'checkout -P';
-
-# win32 usually doesn't have /bin/mail
-#$blat           = 'c:/nstools/bin/blat';
-#$use_blat       = 0;
-
-# Set moz_cvsroot to something like:
-# :pserver:$ENV{USER}%netscape.com\@cvs.mozilla.org:/cvsroot
-# :pserver:anonymous\@cvs-mirror.mozilla.org:/cvsroot
-#
-# Note that win32 may not need \@, depends on ' or ".
-# :pserver:$ENV{USER}%netscape.com@cvs.mozilla.org:/cvsroot
-
-#$moz_cvsroot   = $ENV{CVSROOT};
-# CONFIG: $moz_cvsroot   = '%mozillaCvsroot%';
-$moz_cvsroot   = 'cltbld@cvs.mozilla.org:/cvsroot';
-
-#- Set these proper values for your tinderbox server
-#$Tinderbox_server = 'tinderbox-daemon@tinderbox.mozilla.org';
-
-# Allow for non-client builds, e.g. camino.
-#$moz_client_mk = 'client.mk';
-
-#- Set if you want to build in a separate object tree
-$ObjDir = 'obj-fx-trunk';
-
-# Extra build name, if needed.
-$BuildNameExtra = 'Release';
-
-# User comment, eg. ip address for dhcp builds.
-# ex: $UserComment = "ip = 208.12.36.108";
-#$UserComment = 0;
-
-#-
-#- The rest should not need to be changed
-#-
-
-#- Minimum wait period from start of build to start of next build in minutes.
-#$BuildSleep = 10;
-
-#- Until you get the script working. When it works,
-#- change to the tree you're actually building
-# CONFIG: $BuildTree  = '%buildTree%';
-$BuildTree  = 'MozillaRelease';
-
-#$BuildName = '';
-# CONFIG: $BuildTag = '%productTag%_RELEASE';
-$BuildTag = 'FIREFOX_3_0_19_RELEASE';
-#$BuildConfigDir = 'mozilla/config';
-#$Topsrcdir = 'mozilla';
-
-$BinaryName = 'firefox-bin';
-
-#
-# For embedding app, use:
-#$EmbedBinaryName = 'TestGtkEmbed';
-#$EmbedDistDir    = 'dist/bin'
-
-
-#$ShellOverride = ''; # Only used if the default shell is too stupid
-#$ConfigureArgs = '';
-#$ConfigureEnvArgs = '';
-#$Compiler = 'gcc';
-#$NSPRArgs = '';
-#$ShellOverride = '';
-
-# Release build options
-$ReleaseBuild  = 1;
-$shiptalkback  = 0;
-$ReleaseToLatest = 0; # Push the release to latest-<milestone>?
-$ReleaseToDated = 1; # Push the release to YYYY-MM-DD-HH-<milestone>?
-$build_hour    = 4;
-$package_creation_path = "/browser/installer";
-# needs setting for mac + talkback: $mac_bundle_path = "/browser/app";
-$ssh_version   = "2";
-# CONFIG: $ssh_user      = "%sshUser%";
-$ssh_user      = "cltbld";
-# CONFIG: $ssh_server    = "%sshServer%";
-$ssh_server    = "stage-old.mozilla.org";
-$ftp_path      = "/home/ftp/pub/firefox/nightly";
-$url_path      = "http://ftp.mozilla.org/pub/mozilla.org/firefox/nightly";
-$tbox_ftp_path = "/home/ftp/pub/firefox/tinderbox-builds";
-$tbox_url_path = "http://ftp.mozilla.org/pub/mozilla.org/firefox/tinderbox-builds";
-# CONFIG: $milestone     = "firefox%version%";
-$milestone     = "firefox3.0.19";
-$notify_list   = 'build-announce@mozilla.org';
-$stub_installer = 0;
-$sea_installer = 0;
-$archive       = 1;
-$push_raw_xpis = 0;
-$update_pushinfo = 0;
-$update_package = 1;
-$update_product = "Firefox";
-$update_version = "trunk";
-$update_platform = "Linux_x86-gcc3";
-$update_hash = "sha1";
-$update_filehost = 'ftp.mozilla.org';
-$update_ver_file = 'browser/config/version.txt';
-$crashreporter_buildsymbols = 1;
-$crashreporter_pushsymbols = 1;
-# CONFIG: $ENV{'SYMBOL_SERVER_HOST'}    = '%symbolServer%';
-$ENV{'SYMBOL_SERVER_HOST'}    = 'dm-symbolpush01.mozilla.org';
-# CONFIG: $ENV{'SYMBOL_SERVER_USER'}    = '%symbolServerUser%';
-$ENV{'SYMBOL_SERVER_USER'}    = 'ffxbld';
-# CONFIG: $ENV{'SYMBOL_SERVER_PATH'}    = '%symbolServerPath%';
-$ENV{'SYMBOL_SERVER_PATH'}    = '/mnt/netapp/breakpad/symbols_ffx';
-# CONFIG: $ENV{'SYMBOL_SERVER_SSH_KEY'} = '%symbolServerKey%';
-$ENV{'SYMBOL_SERVER_SSH_KEY'} = '/home/cltbld/.ssh/ffxbld_dsa';
-
-# Reboot the OS at the end of build-and-test cycle. This is primarily
-# intended for Win9x, which can't last more than a few cycles before
-# locking up (and testing would be suspect even after a couple of cycles).
-# Right now, there is only code to force the reboot for Win9x, so even
-# setting this to 1, will not have an effect on other platforms. Setting
-# up win9x to automatically logon and begin running tinderbox is left 
-# as an exercise to the reader. 
-#$RebootSystem = 0;
-
-# LogCompression specifies the type of compression used on the log file.
-# Valid options are 'gzip', and 'bzip2'. Please make sure the binaries
-# for 'gzip' or 'bzip2' are in the user's path before setting this
-# option.
-#$LogCompression = '';
-
-# LogEncoding specifies the encoding format used for the logs. Valid
-# options are 'base64', and 'uuencode'. If $LogCompression is set above,
-# this needs to be set to 'base64' or 'uuencode' to ensure that the
-# binary data is transferred properly.
-#$LogEncoding = '';
-
-# Prevent Extension Manager from spawning child processes during tests
-# - processes that tbox scripts cannot kill. 
-#$ENV{NO_EM_RESTART} = '1';
-
-# Do not build XForms
-$BuildXForms = 0;

mozilla/tools/tinderbox-configs/firefox/macosx/mozconfig

@@ -1,26 +0,0 @@
-#
-## hostname: bm-xserve08.build.mozilla.org
-## uname: Darwin bm-xserve08.build.mozilla.org 8.8.4 Darwin Kernel Version 8.8.4: Sun Oct 29 15:26:54 PST 2006; root:xnu-792.16.4.obj~1/RELEASE_I386 i386 i386
-#
-
-# symbols for breakpad
-export CFLAGS="-g -gfull"
-export CXXFLAGS="-g -gfull"
-
-. $topsrcdir/build/macosx/universal/mozconfig
-
-mk_add_options MOZ_MAKE_FLAGS="-j1"
-mk_add_options MOZ_CO_MODULE="mozilla/tools/update-packaging"
-mk_add_options MOZ_CO_PROJECT="browser"
-mk_add_options MOZ_OBJDIR=@TOPSRCDIR@/../build/universal
-
-ac_add_options --enable-application=browser
-ac_add_options --enable-update-channel=release
-# Don't add explicit optimize flags here, set them in configure.in, see bug 407794.
-ac_add_options --enable-optimize
-ac_add_options --disable-debug
-ac_add_options --disable-tests
-ac_add_options --enable-update-packaging
-
-ac_add_options --enable-official-branding
-ac_add_app_options ppc --enable-prebinding

mozilla/tools/tinderbox-configs/firefox/macosx/tinder-config.pl

@@ -1,267 +0,0 @@
-#
-## hostname: bm-xserve08.build.mozilla.org
-## uname: Darwin bm-xserve08.build.mozilla.org 8.8.4 Darwin Kernel Version 8.8.4: Sun Oct 29 15:26:54 PST 2006; root:xnu-792.16.4.obj~1/RELEASE_I386 i386 i386
-#
-
-#- tinder-config.pl - Tinderbox configuration file.
-#-    Uncomment the variables you need to set.
-#-    The default values are the same as the commented variables.
-
-$ENV{NO_EM_RESTART} = "1";
-$ENV{DYLD_NO_FIX_PREBINDING} = "1";
-$ENV{LD_PREBIND_ALLOW_OVERLAP} = "1";
-$ENV{CVS_RSH} = "ssh";
-
-$MacUniversalBinary = 1;
-
-# $ENV{MOZ_PACKAGE_MSI}
-#-----------------------------------------------------------------------------
-#  Default: 0
-#   Values: 0 | 1
-#  Purpose: Controls whether a MSI package is made.
-# Requires: Windows and a local MakeMSI installation.
-#$ENV{MOZ_PACKAGE_MSI} = 0;
-
-# $ENV{MOZ_SYMBOLS_TRANSFER_TYPE}
-#-----------------------------------------------------------------------------
-#  Default: scp
-#   Values: scp | rsync
-#  Purpose: Use scp or rsync to transfer symbols to the Talkback server.
-# Requires: The selected type requires the command be available both locally
-#           and on the Talkback server.
-#$ENV{MOZ_SYMBOLS_TRANSFER_TYPE} = "scp";
-
-#- PLEASE FILL THIS IN WITH YOUR PROPER EMAIL ADDRESS
-$BuildAdministrator = 'build@mozilla.org';
-#$BuildAdministrator = "$ENV{USER}\@$ENV{HOST}";
-#$BuildAdministrator = ($ENV{USER} || "cltbld") . "\@" . ($ENV{HOST} || "dhcp");
-
-#- You'll need to change these to suit your machine's needs
-#$DisplayServer = ':0.0';
-
-#- Default values of command-line opts
-#-
-#$BuildDepend       = 1;      # Depend or Clobber
-#$BuildDebug        = 0;      # Debug or Opt (Darwin)
-#$ReportStatus      = 1;      # Send results to server, or not
-#$ReportFinalStatus = 1;      # Finer control over $ReportStatus.
-$UseTimeStamp      = 0;      # Use the CVS 'pull-by-timestamp' option, or not
-#$BuildOnce         = 0;      # Build once, don't send results to server
-#$TestOnly          = 0;      # Only run tests, don't pull/build
-#$BuildEmbed        = 0;      # After building seamonkey, go build embed app.
-#$SkipMozilla       = 0;      # Use to debug post-mozilla.pl scripts.
-#$BuildLocales      = 0;      # Do l10n packaging?
-
-# Tests
-$CleanProfile             = 1;
-#$ResetHomeDirForTests     = 1;
-$ProductName              = 'Firefox';
-$VendorName               = "Mozilla";
-
-$RunMozillaTests          = 1;  # Allow turning off of all tests if needed.
-$RegxpcomTest             = 1;
-$AliveTest                = 1;
-#$JavaTest                 = 0;
-#$ViewerTest               = 0;
-#$BloatTest                = 0;  # warren memory bloat test
-#$BloatTest2               = 0;  # dbaron memory bloat test, require tracemalloc
-#$DomToTextConversionTest  = 0;  
-#$XpcomGlueTest            = 0;
-$CodesizeTest             = 0;  # Z,  require mozilla/tools/codesighs
-$EmbedCodesizeTest        = 0;  # mZ, require mozilla/tools/codesigns
-#$MailBloatTest            = 0;
-#$EmbedTest                = 0;  # Assumes you wanted $BuildEmbed=1
-$LayoutPerformanceTest    = 0;  # Tp
-$LayoutPerformanceLocalTest   = 0;  # Tp2
-$DHTMLPerformanceTest     = 0;  # Tdhtml
-#$QATest                   = 0;  
-$XULWindowOpenTest        = 0;  # Txul
-$StartupPerformanceTest   = 0;  # Ts
-
-$TestsPhoneHome           = 0;  # Should test report back to server?
-
-$GraphNameOverride        = 'xserve08.build.mozilla.org_Fx-Trunk';
-
-# $results_server
-#----------------------------------------------------------------------------
-# Server on which test results will be accessible.  This was originally tegu,
-# then became axolotl.  Once we moved services from axolotl, it was time
-# to give this service its own hostname to make future transitions easier.
-# - cmp@mozilla.org
-#$results_server           = "build-graphs.mozilla.org";
-
-#$pageload_server          = "spider";  # localhost
-$pageload_server          = "pageload.build.mozilla.org";  # localhost
-
-#
-# Timeouts, values are in seconds.
-#
-#$CVSCheckoutTimeout               = 3600;
-#$CreateProfileTimeout             = 45;
-#$RegxpcomTestTimeout              = 120;
-
-$AliveTestTimeout                 = 10;
-#$ViewerTestTimeout                = 45;
-#$EmbedTestTimeout                 = 45;
-#$BloatTestTimeout                 = 120;   # seconds
-#$MailBloatTestTimeout             = 120;   # seconds
-#$JavaTestTimeout                  = 45;
-#$DomTestTimeout	                  = 45;    # seconds
-#$XpcomGlueTestTimeout             = 15;
-#$CodesizeTestTimeout              = 900;     # seconds
-#$CodesizeTestType                 = "auto";  # {"auto"|"base"}
-$LayoutPerformanceTestTimeout     = 300;  # entire test, seconds
-$LayoutPerformanceLocalTestTimeout     = 180;  # entire test, seconds
-$DHTMLPerformanceTestTimeout      = 180;  # entire test, seconds
-#$QATestTimeout                    = 1200;   # entire test, seconds
-#$LayoutPerformanceTestPageTimeout = 30000; # each page, ms
-#$StartupPerformanceTestTimeout    = 15;    # seconds
-#$XULWindowOpenTestTimeout	      = 150;   # seconds
-
-
-#$MozConfigFileName = 'mozconfig';
-
-#$UseMozillaProfile = 1;
-#$MozProfileName = 'default';
-
-#- Set these to what makes sense for your system
-#$Make          = 'gmake';       # Must be GNU make
-#$MakeOverrides = '';
-#$mail          = '/bin/mail';
-#$CVS           = 'cvs -q';
-#$CVSCO         = 'checkout -P';
-
-# win32 usually doesn't have /bin/mail
-#$blat           = 'c:/nstools/bin/blat';
-#$use_blat       = 0;
-
-# Set moz_cvsroot to something like:
-# :pserver:$ENV{USER}%netscape.com\@cvs.mozilla.org:/cvsroot
-# :pserver:anonymous\@cvs-mirror.mozilla.org:/cvsroot
-#
-# Note that win32 may not need \@, depends on ' or ".
-# :pserver:$ENV{USER}%netscape.com@cvs.mozilla.org:/cvsroot
-
-# CONFIG: $moz_cvsroot   = '%mozillaCvsroot%';
-$moz_cvsroot   = 'cltbld@cvs.mozilla.org:/cvsroot';
-
-#- Set these proper values for your tinderbox server
-#$Tinderbox_server = 'tinderbox-daemon@tinderbox.mozilla.org';
-
-# Allow for non-client builds, e.g. camino.
-#$moz_client_mk = 'client.mk';
-
-#- Set if you want to build in a separate object tree
-$ObjDir = '../build/universal';
-
-# Extra build name, if needed.
-$BuildNameExtra = 'Release';
-
-# User comment, eg. ip address for dhcp builds.
-# ex: $UserComment = "ip = 208.12.36.108";
-#$UserComment = 0;
-
-#-
-#- The rest should not need to be changed
-#-
-
-#- Minimum wait period from start of build to start of next build in minutes.
-#$BuildSleep = 10;
-
-#- Until you get the script working. When it works,
-#- change to the tree you're actually building
-# CONFIG: $BuildTree  = '%buildTree%';
-$BuildTree  = 'MozillaRelease';
-
-#$BuildName = '';
-# CONFIG: $BuildTag = '%productTag%_RELEASE';
-$BuildTag = 'FIREFOX_3_0_19_RELEASE';
-#$BuildConfigDir = 'mozilla/config';
-#$Topsrcdir = 'mozilla';
-
-$BinaryName = 'firefox-bin';
-
-#
-# For embedding app, use:
-#$EmbedBinaryName = 'TestGtkEmbed';
-#$EmbedDistDir    = 'dist/bin'
-
-
-#$ShellOverride = ''; # Only used if the default shell is too stupid
-#$ConfigureArgs = '';
-#$ConfigureEnvArgs = '';
-#$Compiler = 'gcc';
-#$NSPRArgs = '';
-#$ShellOverride = '';
-
-# Release build options
-$ReleaseBuild  = 1;
-$shiptalkback  = 0;
-$ReleaseToLatest = 0; # Push the release to latest-<milestone>?
-$ReleaseToDated = 1; # Push the release to YYYY-MM-DD-HH-<milestone>?
-$build_hour    = "4";
-$package_creation_path = "/browser/installer";
-# needs setting for mac + talkback: $mac_bundle_path = "/browser/app";
-$mac_bundle_path = "/browser/app";
-$ssh_version   = "2";
-# CONFIG: $ssh_user      = "%sshUser%";
-$ssh_user      = "cltbld";
-# CONFIG: $ssh_server    = "%sshServer%";
-$ssh_server    = "stage-old.mozilla.org";
-$ftp_path      = "/home/ftp/pub/firefox/nightly";
-$url_path      = "http://ftp.mozilla.org/pub/mozilla.org/firefox/nightly";
-$tbox_ftp_path = "/home/ftp/pub/firefox/tinderbox-builds";
-$tbox_url_path = "http://ftp.mozilla.org/pub/mozilla.org/firefox/tinderbox-builds";
-# CONFIG: $milestone     = 'firefox%version%';
-$milestone     = 'firefox3.0.19';
-$notify_list   = "build-announce\@mozilla.org";
-$stub_installer = 0;
-$sea_installer = 0;
-$archive       = 1;
-$push_raw_xpis = 0;
-$update_package = 1;
-$update_product = "Firefox";
-$update_version = "trunk";
-$update_platform = "Darwin_Universal-gcc3";
-$update_hash = "sha1";
-$update_filehost = "ftp.mozilla.org";
-$update_ver_file = 'browser/config/version.txt';
-$update_pushinfo = 0;
-$crashreporter_buildsymbols = 1;
-$crashreporter_pushsymbols = 1;
-# CONFIG: $ENV{'SYMBOL_SERVER_HOST'}    = '%symbolServer%';
-$ENV{'SYMBOL_SERVER_HOST'}    = 'dm-symbolpush01.mozilla.org';
-# CONFIG: $ENV{'SYMBOL_SERVER_USER'}    = '%symbolServerUser%';
-$ENV{'SYMBOL_SERVER_USER'}    = 'ffxbld';
-# CONFIG: $ENV{'SYMBOL_SERVER_PATH'}    = '%symbolServerPath%';
-$ENV{'SYMBOL_SERVER_PATH'}    = '/mnt/netapp/breakpad/symbols_ffx';
-# CONFIG: $ENV{'SYMBOL_SERVER_SSH_KEY'} = '%symbolServerKey%';
-$ENV{'SYMBOL_SERVER_SSH_KEY'} = '/Users/cltbld/.ssh/ffxbld_dsa';
-
-# Reboot the OS at the end of build-and-test cycle. This is primarily
-# intended for Win9x, which can't last more than a few cycles before
-# locking up (and testing would be suspect even after a couple of cycles).
-# Right now, there is only code to force the reboot for Win9x, so even
-# setting this to 1, will not have an effect on other platforms. Setting
-# up win9x to automatically logon and begin running tinderbox is left 
-# as an exercise to the reader. 
-#$RebootSystem = 0;
-
-# LogCompression specifies the type of compression used on the log file.
-# Valid options are 'gzip', and 'bzip2'. Please make sure the binaries
-# for 'gzip' or 'bzip2' are in the user's path before setting this
-# option.
-#$LogCompression = '';
-
-# LogEncoding specifies the encoding format used for the logs. Valid
-# options are 'base64', and 'uuencode'. If $LogCompression is set above,
-# this needs to be set to 'base64' or 'uuencode' to ensure that the
-# binary data is transferred properly.
-#$LogEncoding = '';
-
-# Prevent Extension Manager from spawning child processes during tests
-# - processes that tbox scripts cannot kill. 
-#$ENV{NO_EM_RESTART} = '1';
-
-# Do not build XForms
-$BuildXForms = 0;

mozilla/tools/tinderbox-configs/firefox/win32/mozconfig

@@ -1,22 +0,0 @@
-#
-## hostname: fx-win32-tbox
-## uname: MINGW32_NT-5.2 FX-WIN32-TBOX 1.0.11(0.46/3/2) 2007-01-12 12:05 i686 Msys
-#
-export CFLAGS="-GL -wd4624 -wd4952"
-export CXXFLAGS="-GL -wd4624 -wd4952"
-export LDFLAGS="-LTCG"
-
-mk_add_options MOZ_CO_PROJECT=browser
-mk_add_options MOZ_MAKE_FLAGS="-j1"
-mk_add_options MOZ_CO_MODULE="mozilla/tools/update-packaging"
-mk_add_options PROFILE_GEN_SCRIPT='$(PYTHON) $(MOZ_OBJDIR)/_profile/pgo/profileserver.py'
-
-ac_add_options --enable-application=browser
-ac_add_options --enable-update-channel=release
-ac_add_options --enable-optimize
-ac_add_options --disable-debug
-ac_add_options --disable-tests
-ac_add_options --enable-update-packaging
-ac_add_options --enable-official-branding
-ac_add_options --enable-jemalloc
-ac_add_options --with-crashreporter-enable-percent=10

mozilla/tools/tinderbox-configs/firefox/win32/tinder-config.pl

@@ -1,267 +0,0 @@
-#
-## hostname: fx-win32-tbox
-## uname: MINGW32_NT-5.2 FX-WIN32-TBOX 1.0.11(0.46/3/2) 2007-01-12 12:05 i686 Msys
-#
-
-#- tinder-config.pl - Tinderbox configuration file.
-#-    Uncomment the variables you need to set.
-#-    The default values are the same as the commented variables.
-
-$ENV{NO_EM_RESTART} = '1';
-$ENV{CVS_RSH} = "ssh";
-$ENV{MOZ_CRASHREPORTER_NO_REPORT} = '1';
-# Both these two variables are for source server support
-$ENV{PDBSTR_PATH} = 'C:\\Program Files\\Debugging Tools for Windows\\sdk\\srcsrv\\pdbstr.exe';
-$ENV{SRCSRV_ROOT} = ':pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot';
-
-# $ENV{MOZ_PACKAGE_MSI}
-#-----------------------------------------------------------------------------
-#  Default: 0
-#   Values: 0 | 1
-#  Purpose: Controls whether a MSI package is made.
-# Requires: Windows and a local MakeMSI installation.
-#$ENV{MOZ_PACKAGE_MSI} = 0;
-
-# $ENV{MOZ_SYMBOLS_TRANSFER_TYPE}
-#-----------------------------------------------------------------------------
-#  Default: scp
-#   Values: scp | rsync
-#  Purpose: Use scp or rsync to transfer symbols to the Talkback server.
-# Requires: The selected type requires the command be available both locally
-#           and on the Talkback server.
-#$ENV{MOZ_SYMBOLS_TRANSFER_TYPE} = "scp";
-
-#- PLEASE FILL THIS IN WITH YOUR PROPER EMAIL ADDRESS
-$BuildAdministrator = 'build@mozilla.org';
-#$BuildAdministrator = "$ENV{USER}\@$ENV{HOST}";
-#$BuildAdministrator = ($ENV{USER} || "cltbld") . "\@" . ($ENV{HOST} || "dhcp");
-
-#- You'll need to change these to suit your machine's needs
-#$DisplayServer = ':0.0';
-
-#- Default values of command-line opts
-#-
-#$BuildDepend       = 1;      # Depend or Clobber
-#$BuildDebug        = 0;      # Debug or Opt (Darwin)
-#$ReportStatus      = 1;      # Send results to server, or not
-#$ReportFinalStatus = 1;      # Finer control over $ReportStatus.
-$UseTimeStamp      = 0;      # Use the CVS 'pull-by-timestamp' option, or not
-#$BuildOnce         = 0;      # Build once, don't send results to server
-#$TestOnly          = 0;      # Only run tests, don't pull/build
-#$BuildEmbed        = 0;      # After building seamonkey, go build embed app.
-#$SkipMozilla       = 0;      # Use to debug post-mozilla.pl scripts.
-#$BuildLocales      = 0;      # Do l10n packaging?
-
-# Tests
-$CleanProfile             = 1;
-#$ResetHomeDirForTests     = 1;
-$ProductName              = "Firefox";
-$VendorName               = "Mozilla";
-
-$RunMozillaTests          = 1;  # Allow turning off of all tests if needed.
-$RegxpcomTest             = 1;
-$AliveTest                = 1;
-$JavaTest                 = 0;
-$ViewerTest               = 0;
-$BloatTest                = 0;  # warren memory bloat test
-$BloatTest2               = 0;  # dbaron memory bloat test, require tracemalloc
-$DomToTextConversionTest  = 0;  
-$XpcomGlueTest            = 0;
-$CodesizeTest             = 0;  # Z,  require mozilla/tools/codesighs
-$EmbedCodesizeTest        = 0;  # mZ, require mozilla/tools/codesigns
-$MailBloatTest            = 0;
-$EmbedTest                = 0;  # Assumes you wanted $BuildEmbed=1
-$LayoutPerformanceTest    = 0;  # Tp
-$DHTMLPerformanceTest     = 0;  # Tdhtml
-$QATest                   = 0;  
-$XULWindowOpenTest        = 0;  # Txul
-$StartupPerformanceTest   = 0;  # Ts
-$NeckoUnitTest            = 0;
-$RenderPerformanceTest    = 0;  # Tgfx
-
-$TestsPhoneHome           = 0;  # Should test report back to server?
-$GraphNameOverride        = 'fx-win32-tbox';
-
-# $results_server
-#----------------------------------------------------------------------------
-# Server on which test results will be accessible.  This was originally tegu,
-# then became axolotl.  Once we moved services from axolotl, it was time
-# to give this service its own hostname to make future transitions easier.
-# - cmp@mozilla.org
-#$results_server           = "build-graphs.mozilla.org";
-
-$pageload_server          = "pageload.build.mozilla.org";  # localhost
-
-#
-# Timeouts, values are in seconds.
-#
-#$CVSCheckoutTimeout               = 3600;
-#$CreateProfileTimeout             = 45;
-#$RegxpcomTestTimeout              = 120;
-
-#$AliveTestTimeout                 = 30;
-#$ViewerTestTimeout                = 45;
-#$EmbedTestTimeout                 = 45;
-#$BloatTestTimeout                 = 120;   # seconds
-#$MailBloatTestTimeout             = 120;   # seconds
-#$JavaTestTimeout                  = 45;
-#$DomTestTimeout	                  = 45;    # seconds
-#$XpcomGlueTestTimeout             = 15;
-#$CodesizeTestTimeout              = 900;     # seconds
-#$CodesizeTestType                 = "auto";  # {"auto"|"base"}
-$LayoutPerformanceTestTimeout     = 800;  # entire test, seconds
-#$DHTMLPerformanceTestTimeout      = 1200;  # entire test, seconds
-#$QATestTimeout                    = 1200;   # entire test, seconds
-#$LayoutPerformanceTestPageTimeout = 30000; # each page, ms
-#$StartupPerformanceTestTimeout    = 20;    # seconds
-#$XULWindowOpenTestTimeout	      = 90;   # seconds
-#$NeckoUnitTestTimeout             = 30;    # seconds
-$RenderPerformanceTestTimeout     = 1800;  # seconds
-
-#$MozConfigFileName = 'mozconfig';
-
-#$UseMozillaProfile = 1;
-#$MozProfileName = 'default';
-
-#- Set these to what makes sense for your system
-$Make          = 'make';       # Must be GNU make
-#$MakeOverrides = '';
-#$mail          = '/bin/mail';
-#$CVS           = 'cvs -q';
-#$CVSCO         = 'checkout -P';
-
-# win32 usually doesn't have /bin/mail
-$blat           = '/d/mozilla-build/blat261/full/blat';
-#$use_blat       = 1;
-
-# Set moz_cvsroot to something like:
-# :pserver:$ENV{USER}%netscape.com\@cvs.mozilla.org:/cvsroot
-# :pserver:anonymous\@cvs-mirror.mozilla.org:/cvsroot
-#
-# Note that win32 may not need \@, depends on ' or ".
-# :pserver:$ENV{USER}%netscape.com@cvs.mozilla.org:/cvsroot
-
-# CONFIG: $moz_cvsroot = '%mozillaCvsroot%';
-$moz_cvsroot = 'cltbld@cvs.mozilla.org:/cvsroot';
-
-#- Set these proper values for your tinderbox server
-#$Tinderbox_server = 'tinderbox-daemon@tinderbox.mozilla.org';
-
-# Allow for non-client builds, e.g. camino.
-#$moz_client_mk = 'client.mk';
-
-#- Set if you want to build in a separate object tree
-$ObjDir = 'obj-fx-trunk';
-
-# Extra build name, if needed.
-$BuildNameExtra = 'Release';
-
-# User comment, eg. ip address for dhcp builds.
-# ex: $UserComment = "ip = 208.12.36.108";
-#$UserComment = 0;
-
-#-
-#- The rest should not need to be changed
-#-
-
-#- Minimum wait period from start of build to start of next build in minutes.
-#$BuildSleep = 10;
-
-#- Until you get the script working. When it works,
-#- change to the tree you're actually building
-#$BuildTree  = 'MozillaTest';
-# CONFIG: $BuildTree  = '%buildTree%';
-$BuildTree  = 'MozillaRelease';
-
-#$BuildName = '';
-# CONFIG: $BuildTag = '%productTag%_RELEASE';
-$BuildTag = 'FIREFOX_3_0_19_RELEASE';
-#$BuildConfigDir = 'mozilla/config';
-#$Topsrcdir = 'mozilla';
-
-$BinaryName = 'firefox.exe';
-
-#
-# For embedding app, use:
-#$EmbedBinaryName = 'TestGtkEmbed';
-#$EmbedDistDir    = 'dist/bin'
-
-
-#$ShellOverride = ''; # Only used if the default shell is too stupid
-#$ConfigureArgs = '';
-#$ConfigureEnvArgs = '';
-#$Compiler = 'gcc';
-#$NSPRArgs = '';
-#$ShellOverride = '';
-
-$ProfiledBuild = 1;
-# Release build options
-$ReleaseBuild  = 1;
-$shiptalkback  = 0;
-$ReleaseToLatest = 0; # Push the release to latest-<milestone>?
-$ReleaseToDated = 1; # Push the release to YYYY-MM-DD-HH-<milestone>?
-$build_hour    = "4";
-$package_creation_path = "/browser/installer";
-# needs setting for mac + talkback: $mac_bundle_path = "/browser/app";
-$ssh_version   = "2";
-# CONFIG: $ssh_user      = "%sshUser%";
-$ssh_user      = "cltbld";
-# CONFIG: $ssh_server    = "%sshServer%";
-$ssh_server    = "stage-old.mozilla.org";
-$ftp_path      = "/home/ftp/pub/firefox/nightly";
-$url_path      = "http://ftp.mozilla.org/pub/mozilla.org/firefox/nightly";
-$tbox_ftp_path = "/home/ftp/pub/firefox/tinderbox-builds";
-$tbox_url_path = "http://ftp.mozilla.org/pub/mozilla.org/firefox/tinderbox-builds";
-# CONFIG: $milestone     = 'firefox%version%';
-$milestone     = 'firefox3.0.19';
-$notify_list   = 'build-announce@mozilla.org';
-$stub_installer = 0;
-$sea_installer = 1;
-$archive       = 1;
-$push_raw_xpis = 0;
-$update_package = 1;
-$update_product = "Firefox";
-$update_version = "trunk";
-$update_platform = "WINNT_x86-msvc";
-$update_hash = "sha1";
-$update_filehost = "ftp.mozilla.org";
-$update_ver_file = 'browser/config/version.txt';
-$update_pushinfo = 0;
-$crashreporter_buildsymbols = 1;
-$crashreporter_pushsymbols = 1;
-# CONFIG: $ENV{'SYMBOL_SERVER_HOST'}    = '%symbolServer%';
-$ENV{'SYMBOL_SERVER_HOST'}    = 'dm-symbolpush01.mozilla.org';
-# CONFIG: $ENV{'SYMBOL_SERVER_USER'}    = '%symbolServerUser%';
-$ENV{'SYMBOL_SERVER_USER'}    = 'ffxbld';
-# CONFIG: $ENV{'SYMBOL_SERVER_PATH'}    = '%symbolServerPath%';
-$ENV{'SYMBOL_SERVER_PATH'}    = '/mnt/netapp/breakpad/symbols_ffx';
-# CONFIG: $ENV{'SYMBOL_SERVER_SSH_KEY'} = '%symbolServerKey%';
-$ENV{'SYMBOL_SERVER_SSH_KEY'} = '/c/Documents and Settings/cltbld/.ssh/ffxbld_dsa';
-
-# Reboot the OS at the end of build-and-test cycle. This is primarily
-# intended for Win9x, which can't last more than a few cycles before
-# locking up (and testing would be suspect even after a couple of cycles).
-# Right now, there is only code to force the reboot for Win9x, so even
-# setting this to 1, will not have an effect on other platforms. Setting
-# up win9x to automatically logon and begin running tinderbox is left 
-# as an exercise to the reader. 
-#$RebootSystem = 0;
-
-# LogCompression specifies the type of compression used on the log file.
-# Valid options are 'gzip', and 'bzip2'. Please make sure the binaries
-# for 'gzip' or 'bzip2' are in the user's path before setting this
-# option.
-#$LogCompression = '';
-
-# LogEncoding specifies the encoding format used for the logs. Valid
-# options are 'base64', and 'uuencode'. If $LogCompression is set above,
-# this needs to be set to 'base64' or 'uuencode' to ensure that the
-# binary data is transferred properly.
-#$LogEncoding = '';
-
-# Prevent Extension Manager from spawning child processes during tests
-# - processes that tbox scripts cannot kill. 
-#$ENV{NO_EM_RESTART} = '1';
-
-# Do not build XForms
-$BuildXForms = 0;

mozilla/tools/tinderbox-configs/thunderbird/linux/CLOBBER

@@ -1 +0,0 @@
-Clobbering to force nightly due to nightly bustage from bug 428672.

mozilla/tools/tinderbox-configs/thunderbird/linux/mozconfig

@@ -1,25 +0,0 @@
-#
-## hostname: tb-linux-tbox
-## uname: Linux tb-linux-tbox.build.mozilla.org 2.6.18-8.el5 #1 SMP Thu Mar 15 19:57:35 EDT 2007 i686 athlon i386 GNU/Linux
-#
-
-# symbols for breakpad
-export CFLAGS="-gstabs+"
-export CXXFLAGS="-gstabs+"
-
-mk_add_options MOZ_CO_PROJECT=mail
-mk_add_options MOZ_MAKE_FLAGS=-j1
-mk_add_options MOZ_CO_MODULE="mozilla/tools/update-packaging"
-
-ac_add_options --enable-application=mail
-ac_add_options --enable-update-channel=beta
-ac_add_options --disable-debug
-ac_add_options --enable-update-packaging
-# Add explicit optimize flags in configure.in, not here - see bug 407794
-ac_add_options --enable-optimize
-ac_add_options --disable-tests
-ac_add_options --disable-shared
-ac_add_options --enable-static
-
-CC=/tools/gcc-4.1.1/bin/gcc
-CXX=/tools/gcc-4.1.1/bin/g++

mozilla/tools/tinderbox-configs/thunderbird/linux/tinder-config.pl

@@ -1,225 +0,0 @@
-#
-## hostname: tb-linux-tbox
-## uname: Linux tbnewref-linux-tbox.build.mozilla.org 2.6.18-8.el5 #1 SMP Thu Mar 15 19:57:35 EDT 2007 i686 athlon i386 GNU/Linux
-#
-
-#- tinder-config.pl - Tinderbox configuration file.
-#-    Uncomment the variables you need to set.
-#-    The default values are the same as the commented variables.
-
-$ENV{CVS_RSH} = "ssh";
-$ENV{MOZ_CRASHREPORTER_NO_REPORT} = '1';
-
-#- PLEASE FILL THIS IN WITH YOUR PROPER EMAIL ADDRESS
-#$BuildAdministrator = "$ENV{USER}\@$ENV{HOST}";
-#$BuildAdministrator = ($ENV{USER} || "cltbld") . "\@" . ($ENV{HOST} || "dhcp");
-
-#- You'll need to change these to suit your machine's needs
-#$DisplayServer = ':0.0';
-
-#- Default values of command-line opts
-#-
-$BuildDepend       = 0;      # Depend or Clobber
-#$BuildDebug        = 0;      # Debug or Opt (Darwin)
-#$ReportStatus      = 1;      # Send results to server, or not
-#$ReportFinalStatus = 1;      # Finer control over $ReportStatus.
-$UseTimeStamp      = 0;      # Use the CVS 'pull-by-timestamp' option, or not
-#$BuildOnce         = 0;      # Build once, don't send results to server
-#$TestOnly          = 0;      # Only run tests, don't pull/build
-#$BuildEmbed        = 0;      # After building seamonkey, go build embed app.
-#$SkipMozilla       = 0;      # Use to debug post-mozilla.pl scripts.
-
-# Tests
-$CleanProfile             = 1;
-#$ResetHomeDirForTests     = 1;
-$ProductName              = "Thunderbird";
-#$VendorName               = "";
-
-$RunMozillaTests          = 1;  # Allow turning off of all tests if needed.
-#$RegxpcomTest             = 1;
-#$AliveTest                = 1;
-#$JavaTest                 = 0;
-#$ViewerTest               = 0;
-#$BloatTest                = 0;  # warren memory bloat test
-#$BloatTest2               = 0;  # dbaron memory bloat test, require tracemalloc
-#$DomToTextConversionTest  = 0;  
-#$XpcomGlueTest            = 0;
-$CodesizeTest             = 0;  # Z,  require mozilla/tools/codesighs
-#$EmbedCodesizeTest        = 0;  # mZ, require mozilla/tools/codesigns
-#$MailBloatTest            = 0;
-#$EmbedTest                = 0;  # Assumes you wanted $BuildEmbed=1
-#$LayoutPerformanceTest    = 0;  # Tp
-#$QATest                   = 0;  
-#$XULWindowOpenTest        = 0;  # Txul
-#$StartupPerformanceTest   = 0;  # Ts
-
-$TestsPhoneHome           = 0;  # Should test report back to server?
-#$results_server           = "axolotl.mozilla.org"; # was tegu
-#$pageload_server          = "spider";  # localhost
-
-#
-# Timeouts, values are in seconds.
-#
-#$CVSCheckoutTimeout               = 3600;
-#$CreateProfileTimeout             = 45;
-#$RegxpcomTestTimeout              = 15;
-
-#$AliveTestTimeout                 = 45;
-#$ViewerTestTimeout                = 45;
-#$EmbedTestTimeout                 = 45;
-#$BloatTestTimeout                 = 120;   # seconds
-#$MailBloatTestTimeout             = 120;   # seconds
-#$JavaTestTimeout                  = 45;
-#$DomTestTimeout	                  = 45;    # seconds
-#$XpcomGlueTestTimeout             = 15;
-#$CodesizeTestTimeout              = 900;     # seconds
-#$CodesizeTestType                 = "auto";  # {"auto"|"base"}
-#$LayoutPerformanceTestTimeout     = 1200;  # entire test, seconds
-#$QATestTimeout                    = 1200;   # entire test, seconds
-#$LayoutPerformanceTestPageTimeout = 30000; # each page, ms
-#$StartupPerformanceTestTimeout    = 60;    # seconds
-#$XULWindowOpenTestTimeout	      = 150;   # seconds
-
-
-#$MozConfigFileName = 'mozconfig';
-
-#$UseMozillaProfile = 1;
-#$MozProfileName = 'default';
-
-#- Set these to what makes sense for your system
-#$Make          = 'gmake';       # Must be GNU make
-#$MakeOverrides = '';
-#$mail          = '/bin/mail';
-#$CVS           = 'cvs -q';
-#$CVSCO         = 'checkout -P';
-
-# win32 usually doesn't have /bin/mail
-#$blat           = 'c:/nstools/bin/blat';
-#$use_blat       = 0;
-
-# Set moz_cvsroot to something like:
-# :pserver:$ENV{USER}%netscape.com\@cvs.mozilla.org:/cvsroot
-# :pserver:anonymous\@cvs-mirror.mozilla.org:/cvsroot
-#
-# Note that win32 may not need \@, depends on ' or ".
-# :pserver:$ENV{USER}%netscape.com@cvs.mozilla.org:/cvsroot
-
-# CONFIG: $moz_cvsroot   = '%mozillaCvsroot%';
-$moz_cvsroot   = 'cltbld@cvs.mozilla.org:/cvsroot';
-
-#- Set these proper values for your tinderbox server
-#$Tinderbox_server = 'tinderbox-daemon@tinderbox.mozilla.org';
-
-# Allow for non-client builds, e.g. camino.
-#$moz_client_mk = 'client.mk';
-
-#- Set if you want to build in a separate object tree
-$ObjDir = 'obj-tb-trunk';
-
-# Extra build name, if needed.
-$BuildNameExtra = 'Release';
-
-# User comment, eg. ip address for dhcp builds.
-# ex: $UserComment = "ip = 208.12.36.108";
-#$UserComment = 0;
-
-#-
-#- The rest should not need to be changed
-#-
-
-#- Minimum wait period from start of build to start of next build in minutes.
-#$BuildSleep = 10;
-
-#- Until you get the script working. When it works,
-#- change to the tree you're actually building
-# CONFIG: $BuildTree  = '%buildTree%';
-$BuildTree  = 'MozillaRelease';
-
-#$BuildName = '';
-# CONFIG: $BuildTag = '%productTag%_RELEASE';
-$BuildTag = 'THUNDERBIRD_3_0a2_RELEASE';
-#$BuildConfigDir = 'mozilla/config';
-#$Topsrcdir = 'mozilla';
-
-$BinaryName = 'thunderbird-bin';
-
-#
-# For embedding app, use:
-#$EmbedBinaryName = 'TestGtkEmbed';
-#$EmbedDistDir    = 'dist/bin'
-
-
-#$ShellOverride = ''; # Only used if the default shell is too stupid
-#$ConfigureArgs = '';
-#$ConfigureEnvArgs = '';
-#$Compiler = 'gcc';
-#$NSPRArgs = '';
-#$ShellOverride = '';
-
-# allow override of timezone value (for win32 POSIX::strftime)
-#$Timezone = '';
-
-# Release build options
-$ReleaseBuild  = 1;
-$ReleaseToLatest = 0; # Push the release to latest-<milestone>?
-$ReleaseToDated = 1; # Push the release to YYYY-MM-DD-HH-<milestone>?
-$shiptalkback  = 0;
-$build_hour    = "3";
-$package_creation_path = "/mail/installer";
-$ssh_version   = "2";
-# CONFIG: $ssh_user      = "%sshUser%";
-$ssh_user      = "cltbld";
-# CONFIG: $ssh_server    = "%sshServer%";
-$ssh_server    = "stage-old.mozilla.org";
-#$ReleaseGroup  = "thunderbird";
-$ftp_path      = "/home/ftp/pub/thunderbird/nightly";
-$url_path      = "http://ftp.mozilla.org/pub/mozilla.org/thunderbird/nightly";
-$tbox_ftp_path = "/home/ftp/pub/thunderbird/tinderbox-builds";
-$tbox_url_path = "http://ftp.mozilla.org/pub/mozilla.org/thunderbird/tinderbox-builds";
-# CONFIG: $milestone     = 'thunderbird%version%';
-$milestone     = 'thunderbird3.0a2';
-$notify_list   = "build-announce\@mozilla.org";
-$stub_installer = 0;
-$sea_installer = 0;
-$archive       = 1;
-$update_package = 1;
-$update_product = "Thunderbird";
-$update_version = "trunk";
-$update_platform = "Linux_x86-gcc3";
-$update_hash = "sha1";
-$update_filehost = "ftp.mozilla.org";
-$update_ver_file = "mail/config/version.txt";
-$update_pushinfo = 0;
-$crashreporter_buildsymbols = 1;
-$crashreporter_pushsymbols = 1;
-# CONFIG: $ENV{'SYMBOL_SERVER_HOST'}    = '%symbolServer%';
-$ENV{'SYMBOL_SERVER_HOST'}    = 'dm-symbolpush01.mozilla.org';
-# CONFIG: $ENV{'SYMBOL_SERVER_USER'}    = '%symbolServerUser%';
-$ENV{'SYMBOL_SERVER_USER'}    = 'tbirdbld';
-# CONFIG: $ENV{'SYMBOL_SERVER_PATH'}    = '%symbolServerPath%';
-$ENV{'SYMBOL_SERVER_PATH'}    = '/mnt/netapp/breakpad/symbols_tbrd';
-# CONFIG: $ENV{'SYMBOL_SERVER_SSH_KEY'} = '%symbolServerKey%';
-$ENV{'SYMBOL_SERVER_SSH_KEY'} = '/home/cltbld/.ssh/tbirdbld_dsa';
-
-# Reboot the OS at the end of build-and-test cycle. This is primarily
-# intended for Win9x, which can't last more than a few cycles before
-# locking up (and testing would be suspect even after a couple of cycles).
-# Right now, there is only code to force the reboot for Win9x, so even
-# setting this to 1, will not have an effect on other platforms. Setting
-# up win9x to automatically logon and begin running tinderbox is left 
-# as an exercise to the reader. 
-#$RebootSystem = 0;
-
-# LogCompression specifies the type of compression used on the log file.
-# Valid options are 'gzip', and 'bzip2'. Please make sure the binaries
-# for 'gzip' or 'bzip2' are in the user's path before setting this
-# option.
-#$LogCompression = 'bzip2';
-
-# LogEncoding specifies the encoding format used for the logs. Valid
-# options are 'base64', and 'uuencode'. If $LogCompression is set above,
-# this needs to be set to 'base64' or 'uuencode' to ensure that the
-# binary data is transferred properly.
-#$LogEncoding = 'base64';
-
-

mozilla/tools/tinderbox-configs/thunderbird/macosx/CLOBBER

@@ -1 +0,0 @@
-Clobbering to force nightly due to nightly bustage from bug 428672.

mozilla/tools/tinderbox-configs/thunderbird/macosx/mozconfig

@@ -1,28 +0,0 @@
-#
-## hostname: bm-xserve07.build.mozilla.org
-## uname: Darwin bm-xserve07.build.mozilla.org 8.8.4 Darwin Kernel Version 8.8.4: Sun Oct 29 15:26:54 PST 2006; root:xnu-792.16.4.obj~1/RELEASE_I386 i386 i386
-#
-
-# symbols for breakpad
-export CFLAGS="-g -gfull"
-export CXXFLAGS="-g -gfull"
-
-. $topsrcdir/build/macosx/universal/mozconfig
-
-# Make flags
-mk_add_options MOZ_CO_PROJECT=mail
-mk_add_options MOZ_MAKE_FLAGS="-j1"
-mk_add_options MOZ_CO_MODULE="mozilla/tools/update-packaging"
-mk_add_options MOZ_OBJDIR=@TOPSRCDIR@/../build/universal
-
-# Configure flags
-ac_add_options --enable-application=mail
-ac_add_options --enable-update-channel=beta
-# Add explicit optimize flags in configure.in, not here - see bug 407794
-ac_add_options --enable-optimize
-ac_add_options --disable-debug
-ac_add_options --disable-tests
-ac_add_options --enable-static
-ac_add_options --disable-shared
-
-ac_add_options --enable-update-packaging

mozilla/tools/tinderbox-configs/thunderbird/macosx/tinder-config.pl

@@ -1,262 +0,0 @@
-#
-## hostname: bm-xserve07.build.mozilla.org
-## uname: Darwin bm-xserve07.build.mozilla.org 8.8.4 Darwin Kernel Version 8.8.4: Sun Oct 29 15:26:54 PST 2006; root:xnu-792.16.4.obj~1/RELEASE_I386 i386 i386
-#
-
-#- tinder-config.pl - Tinderbox configuration file.
-#-    Uncomment the variables you need to set.
-#-    The default values are the same as the commented variables.
-
-# $ENV{NO_EM_RESTART} = "1";
-# $ENV{DYLD_NO_FIX_PREBINDING} = "1";
-# $ENV{LD_PREBIND_ALLOW_OVERLAP} = "1";
-$ENV{MOZ_CRASHREPORTER_NO_REPORT} = '1';
-
-$MacUniversalBinary = 1;
-
-# $ENV{MOZ_PACKAGE_MSI}
-#-----------------------------------------------------------------------------
-#  Default: 0
-#   Values: 0 | 1
-#  Purpose: Controls whether a MSI package is made.
-# Requires: Windows and a local MakeMSI installation.
-#$ENV{MOZ_PACKAGE_MSI} = 0;
-
-# $ENV{MOZ_SYMBOLS_TRANSFER_TYPE}
-#-----------------------------------------------------------------------------
-#  Default: scp
-#   Values: scp | rsync
-#  Purpose: Use scp or rsync to transfer symbols to the Talkback server.
-# Requires: The selected type requires the command be available both locally
-#           and on the Talkback server.
-#$ENV{MOZ_SYMBOLS_TRANSFER_TYPE} = "scp";
-
-#- PLEASE FILL THIS IN WITH YOUR PROPER EMAIL ADDRESS
-$BuildAdministrator = 'build@mozilla.org';
-#$BuildAdministrator = "$ENV{USER}\@$ENV{HOST}";
-#$BuildAdministrator = ($ENV{USER} || "cltbld") . "\@" . ($ENV{HOST} || "dhcp");
-
-#- You'll need to change these to suit your machine's needs
-#$DisplayServer = ':0.0';
-
-#- Default values of command-line opts
-#-
-#$BuildDepend       = 1;      # Depend or Clobber
-#$BuildDebug        = 0;      # Debug or Opt (Darwin)
-#$ReportStatus      = 1;      # Send results to server, or not
-#$ReportFinalStatus = 1;      # Finer control over $ReportStatus.
-$UseTimeStamp      = 0;      # Use the CVS 'pull-by-timestamp' option, or not
-#$BuildOnce         = 0;      # Build once, don't send results to server
-#$TestOnly          = 0;      # Only run tests, don't pull/build
-#$BuildEmbed        = 0;      # After building seamonkey, go build embed app.
-#$SkipMozilla       = 0;      # Use to debug post-mozilla.pl scripts.
-#$BuildLocales      = 0;      # Do l10n packaging?
-
-# Tests
-$CleanProfile             = 1;
-#$ResetHomeDirForTests     = 1;
-$ProductName              = "Thunderbird";
-#$VendorName               = 'Mozilla';
-
-$RunMozillaTests          = 1;  # Allow turning off of all tests if needed.
-$RegxpcomTest             = 1;
-$AliveTest                = 1;
-#$JavaTest                 = 0;
-#$ViewerTest               = 0;
-#$BloatTest                = 0;  # warren memory bloat test
-#$BloatTest2               = 0;  # dbaron memory bloat test, require tracemalloc
-#$DomToTextConversionTest  = 0;  
-#$XpcomGlueTest            = 0;
-$CodesizeTest             = 0;  # Z,  require mozilla/tools/codesighs
-$EmbedCodesizeTest        = 0;  # mZ, require mozilla/tools/codesigns
-#$MailBloatTest            = 0;
-#$EmbedTest                = 0;  # Assumes you wanted $BuildEmbed=1
-#$LayoutPerformanceTest    = 0;  # Tp
-#$DHTMLPerformanceTest     = 0;  # Tdhtml
-#$QATest                   = 0;  
-#$XULWindowOpenTest        = 0;  # Txul
-#$StartupPerformanceTest   = 0;  # Ts
-
-$TestsPhoneHome           = 0;  # Should test report back to server?
-
-# $results_server
-#----------------------------------------------------------------------------
-# Server on which test results will be accessible.  This was originally tegu,
-# then became axolotl.  Once we moved services from axolotl, it was time
-# to give this service its own hostname to make future transitions easier.
-# - cmp@mozilla.org
-#$results_server           = "build-graphs.mozilla.org";
-
-#$pageload_server          = "spider";  # localhost
-
-#
-# Timeouts, values are in seconds.
-#
-#$CVSCheckoutTimeout               = 3600;
-#$CreateProfileTimeout             = 45;
-#$RegxpcomTestTimeout              = 120;
-
-#$AliveTestTimeout                 = 45;
-#$ViewerTestTimeout                = 45;
-#$EmbedTestTimeout                 = 45;
-#$BloatTestTimeout                 = 120;   # seconds
-#$MailBloatTestTimeout             = 120;   # seconds
-#$JavaTestTimeout                  = 45;
-#$DomTestTimeout	                  = 45;    # seconds
-#$XpcomGlueTestTimeout             = 15;
-#$CodesizeTestTimeout              = 900;     # seconds
-#$CodesizeTestType                 = "auto";  # {"auto"|"base"}
-#$LayoutPerformanceTestTimeout     = 1200;  # entire test, seconds
-#$DHTMLPerformanceTestTimeout      = 1200;  # entire test, seconds
-#$QATestTimeout                    = 1200;   # entire test, seconds
-#$LayoutPerformanceTestPageTimeout = 30000; # each page, ms
-#$StartupPerformanceTestTimeout    = 15;    # seconds
-#$XULWindowOpenTestTimeout	      = 150;   # seconds
-
-
-#$MozConfigFileName = 'mozconfig';
-
-#$UseMozillaProfile = 1;
-#$MozProfileName = 'default';
-
-#- Set these to what makes sense for your system
-#$Make          = 'gmake';       # Must be GNU make
-#$MakeOverrides = '';
-#$mail          = '/bin/mail';
-#$CVS           = 'cvs -q';
-#$CVSCO         = 'checkout -P';
-
-# win32 usually doesn't have /bin/mail
-#$blat           = 'c:/nstools/bin/blat';
-#$use_blat       = 0;
-
-# Set moz_cvsroot to something like:
-# :pserver:$ENV{USER}%netscape.com\@cvs.mozilla.org:/cvsroot
-# :pserver:anonymous\@cvs-mirror.mozilla.org:/cvsroot
-#
-# Note that win32 may not need \@, depends on ' or ".
-# :pserver:$ENV{USER}%netscape.com@cvs.mozilla.org:/cvsroot
-
-#$moz_cvsroot   = $ENV{CVSROOT};
-# CONFIG: $moz_cvsroot   = '%mozillaCvsroot%';
-$moz_cvsroot   = 'cltbld@cvs.mozilla.org:/cvsroot';
-
-#- Set these proper values for your tinderbox server
-#$Tinderbox_server = 'tinderbox-daemon@tinderbox.mozilla.org';
-
-# Allow for non-client builds, e.g. camino.
-#$moz_client_mk = 'client.mk';
-
-#- Set if you want to build in a separate object tree
-$ObjDir = '../build/universal';
-
-# Extra build name, if needed.
-$BuildNameExtra = 'Release';
-
-# User comment, eg. ip address for dhcp builds.
-# ex: $UserComment = "ip = 208.12.36.108";
-#$UserComment = 0;
-
-#-
-#- The rest should not need to be changed
-#-
-
-#- Minimum wait period from start of build to start of next build in minutes.
-#$BuildSleep = 10;
-
-#- Until you get the script working. When it works,
-#- change to the tree you're actually building
-#$BuildTree  = 'MozillaTest';
-# CONFIG: $BuildTree  = '%buildTree%';
-$BuildTree  = 'MozillaRelease';
-
-#$BuildName = '';
-# CONFIG: $BuildTag = '%productTag%_RELEASE';
-$BuildTag = 'THUNDERBIRD_3_0a2_RELEASE';
-#$BuildConfigDir = 'mozilla/config';
-#$Topsrcdir = 'mozilla';
-
-$BinaryName = 'thunderbird-bin';
-
-#
-# For embedding app, use:
-#$EmbedBinaryName = 'TestGtkEmbed';
-#$EmbedDistDir    = 'dist/bin'
-
-
-#$ShellOverride = ''; # Only used if the default shell is too stupid
-#$ConfigureArgs = '';
-#$ConfigureEnvArgs = '';
-#$Compiler = 'gcc';
-#$NSPRArgs = '';
-#$ShellOverride = '';
-
-# Release build options
-$ReleaseBuild  = 1;
-$shiptalkback  = 0;
-$ReleaseToLatest = 0; # Push the release to latest-<milestone>?
-$ReleaseToDated = 1; # Push the release to YYYY-MM-DD-HH-<milestone>?
-$build_hour    = "3";
-$package_creation_path = "/mail/installer";
-# needs setting for mac + talkback: $mac_bundle_path = "/browser/app";
-$mac_bundle_path = "/mail/app";
-$ssh_version   = "2";
-# CONFIG: $ssh_user      = "%sshUser%";
-$ssh_user      = "cltbld";
-# CONFIG: $ssh_server    = "%sshServer%";
-$ssh_server    = "stage-old.mozilla.org";
-#$ReleaseGroup  = "thunderbird";
-$ftp_path      = "/home/ftp/pub/thunderbird/nightly";
-$url_path      = "http://ftp.mozilla.org/pub/mozilla.org/thunderbird/nightly";
-$tbox_ftp_path = "/home/ftp/pub/thunderbird/tinderbox-builds";
-$tbox_url_path = "http://ftp.mozilla.org/pub/mozilla.org/thunderbird/tinderbox-builds";
-# CONFIG: $milestone     = 'thunderbird%version%';
-$milestone     = 'thunderbird3.0a2';
-$notify_list   = "build-announce\@mozilla.org";
-$stub_installer = 0;
-$sea_installer = 0;
-$archive       = 1;
-$push_raw_xpis = 0;
-$update_package = 1;
-$update_product = "Thunderbird";
-$update_version = "trunk";
-$update_platform = "Darwin_Universal-gcc3";
-$update_hash = "sha1";
-$update_filehost = "ftp.mozilla.org";
-$update_ver_file = "mail/config/version.txt";
-$update_pushinfo = 0;
-$crashreporter_buildsymbols = 1;
-$crashreporter_pushsymbols = 1;
-# CONFIG: $ENV{'SYMBOL_SERVER_HOST'}    = '%symbolServer%';
-$ENV{'SYMBOL_SERVER_HOST'}    = 'dm-symbolpush01.mozilla.org';
-# CONFIG: $ENV{'SYMBOL_SERVER_USER'}    = '%symbolServerUser%';
-$ENV{'SYMBOL_SERVER_USER'}    = 'tbirdbld';
-# CONFIG: $ENV{'SYMBOL_SERVER_PATH'}    = '%symbolServerPath%';
-$ENV{'SYMBOL_SERVER_PATH'}    = '/mnt/netapp/breakpad/symbols_tbrd';
-# CONFIG: $ENV{'SYMBOL_SERVER_SSH_KEY'} = '%symbolServerKey%';
-$ENV{'SYMBOL_SERVER_SSH_KEY'} = '/Users/cltbld/.ssh/tbirdbld_dsa';
-
-# Reboot the OS at the end of build-and-test cycle. This is primarily
-# intended for Win9x, which can't last more than a few cycles before
-# locking up (and testing would be suspect even after a couple of cycles).
-# Right now, there is only code to force the reboot for Win9x, so even
-# setting this to 1, will not have an effect on other platforms. Setting
-# up win9x to automatically logon and begin running tinderbox is left 
-# as an exercise to the reader. 
-#$RebootSystem = 0;
-
-# LogCompression specifies the type of compression used on the log file.
-# Valid options are 'gzip', and 'bzip2'. Please make sure the binaries
-# for 'gzip' or 'bzip2' are in the user's path before setting this
-# option.
-#$LogCompression = '';
-
-# LogEncoding specifies the encoding format used for the logs. Valid
-# options are 'base64', and 'uuencode'. If $LogCompression is set above,
-# this needs to be set to 'base64' or 'uuencode' to ensure that the
-# binary data is transferred properly.
-#$LogEncoding = '';
-
-# Prevent Extension Manager from spawning child processes during tests
-# - processes that tbox scripts cannot kill. 
-#$ENV{NO_EM_RESTART} = '1';

mozilla/tools/tinderbox-configs/thunderbird/win32/CLOBBER

@@ -1 +0,0 @@
-Clobbering to force nightly due to nightly bustage from bug 428672.

mozilla/tools/tinderbox-configs/thunderbird/win32/mozconfig

@@ -1,22 +0,0 @@
-#
-## hostname: tbnewref-win32-tbox
-## MINGW32_NT-5.2 TBNEWREF-WIN32- 1.0.11(0.46/3/2) 2007-01-12 12:05 i686 Msys
-#
-
-mk_add_options MOZ_CO_PROJECT=mail
-mk_add_options MOZ_DEBUG_SYMBOLS=1
-mk_add_options MOZ_MAKE_FLAGS=-j1
-mk_add_options MOZ_CO_MODULE="mozilla/tools/update-packaging"
-
-ac_add_options --enable-application=mail
-ac_add_options --enable-update-channel=beta
-ac_add_options --disable-debug
-# Add explicit optimize flags in configure.in, not here - see bug 407794
-ac_add_options --enable-optimize
-ac_add_options --disable-tests
-ac_add_options --disable-shared
-ac_add_options --enable-static
-ac_add_options --enable-update-packaging
-
-export WIN32_REDIST_DIR="/d/msvs8/VC/redist/x86/Microsoft.VC80.CRT"
-

mozilla/tools/tinderbox-configs/thunderbird/win32/tinder-config.pl

@@ -1,235 +0,0 @@
-#
-## hostname: tbnewref-win32-tbox
-## MINGW32_NT-5.2 TBNEWREF-WIN32- 1.0.11(0.46/3/2) 2007-01-12 12:05 i686 Msys
-#
-
-#- tinder-config.pl - Tinderbox configuration file.
-#-    Uncomment the variables you need to set.
-#-    The default values are the same as the commented variables.
-
-$ENV{CVSROOT}=":ext:tbirdbld\@cvs.mozilla.org:/cvsroot";
-$ENV{MOZ_INSTALLER_USE_7ZIP}="1";
-$ENV{MOZ_PACKAGE_MSI} = 0;
-$ENV{MOZ_CRASHREPORTER_NO_REPORT} = '1';
-# Both these two variables are for source server support
-$ENV{PDBSTR_PATH} = 'C:\\Program Files\\Debugging Tools for Windows\\sdk\\srcsrv\\pdbstr.exe';
-$ENV{SRCSRV_ROOT} = ':pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot';
-
-#- PLEASE FILL THIS IN WITH YOUR PROPER EMAIL ADDRESS
-#$BuildAdministrator = "$ENV{USER}\@$ENV{HOST}";
-#$BuildAdministrator = ($ENV{USER} || "cltbld") . "\@" . ($ENV{HOST} || "dhcp");
-
-#- You'll need to change these to suit your machine's needs
-#$DisplayServer = ':0.0';
-
-#- Default values of command-line opts
-#-
-$BuildDepend       = 0;      # Depend or Clobber
-#$BuildDebug        = 0;      # Debug or Opt (Darwin)
-#$ReportStatus      = 1;      # Send results to server, or not
-#$ReportFinalStatus = 1;      # Finer control over $ReportStatus.
-$UseTimeStamp      = 0;      # Use the CVS 'pull-by-timestamp' option, or not
-#$BuildOnce         = 0;      # Build once, don't send results to server
-#$TestOnly          = 0;      # Only run tests, don't pull/build
-#$BuildEmbed        = 0;      # After building seamonkey, go build embed app.
-#$SkipMozilla       = 0;      # Use to debug post-mozilla.pl scripts.
-#$BuildLocales      = 0;      # Do l10n packaging?
-
-# Tests
-$CleanProfile             = 1;
-#$ResetHomeDirForTests     = 1;
-$ProductName              = "Thunderbird";
-#$VendorName               = '';
-
-$RunMozillaTests          = 1;  # Allow turning off of all tests if needed.
-#$RegxpcomTest             = 1;
-#$AliveTest                = 1;
-#$JavaTest                 = 0;
-#$ViewerTest               = 0;
-#$BloatTest                = 0;  # warren memory bloat test
-#$BloatTest2               = 0;  # dbaron memory bloat test, require tracemalloc
-#$DomToTextConversionTest  = 0;  
-#$XpcomGlueTest            = 0;
-#$CodesizeTest             = 0;  # Z,  require mozilla/tools/codesighs
-#$EmbedCodesizeTest        = 0;  # mZ, require mozilla/tools/codesigns
-#$MailBloatTest            = 0;
-#$EmbedTest                = 0;  # Assumes you wanted $BuildEmbed=1
-#$LayoutPerformanceTest    = 0;  # Tp
-#$DHTMLPerformanceTest     = 0;  # Tdhtml
-#$QATest                   = 0;  
-#$XULWindowOpenTest        = 0;  # Txul
-#$StartupPerformanceTest   = 0;  # Ts
-
-$TestsPhoneHome           = 0;  # Should test report back to server?
-#$results_server           = "axolotl.mozilla.org"; # was tegu
-#$pageload_server          = "spider";  # localhost
-
-#
-# Timeouts, values are in seconds.
-#
-#$CVSCheckoutTimeout               = 3600;
-#$CreateProfileTimeout             = 45;
-#$RegxpcomTestTimeout              = 120;
-
-#$AliveTestTimeout                 = 45;
-#$ViewerTestTimeout                = 45;
-#$EmbedTestTimeout                 = 45;
-#$BloatTestTimeout                 = 120;   # seconds
-#$MailBloatTestTimeout             = 120;   # seconds
-#$JavaTestTimeout                  = 45;
-#$DomTestTimeout	                  = 45;    # seconds
-#$XpcomGlueTestTimeout             = 15;
-#$CodesizeTestTimeout              = 900;     # seconds
-#$CodesizeTestType                 = "auto";  # {"auto"|"base"}
-#$LayoutPerformanceTestTimeout     = 1200;  # entire test, seconds
-#$DHTMLPerformanceTestTimeout      = 1200;  # entire test, seconds
-#$QATestTimeout                    = 1200;   # entire test, seconds
-#$LayoutPerformanceTestPageTimeout = 30000; # each page, ms
-#$StartupPerformanceTestTimeout    = 15;    # seconds
-#$XULWindowOpenTestTimeout	      = 150;   # seconds
-
-
-#$MozConfigFileName = 'mozconfig';
-
-#$UseMozillaProfile = 1;
-#$MozProfileName = 'default';
-
-#- Set these to what makes sense for your system
-$Make          = 'make';       # Must be GNU make
-#$MakeOverrides = '';
-#$mail          = '/bin/mail';
-#$CVS           = 'cvs -q';
-#$CVSCO         = 'checkout -P';
-
-# win32 usually doesn't have /bin/mail
-$blat           = '/d/mozilla-build/blat261/full/blat';
-$use_blat       = 0;
-
-# Set moz_cvsroot to something like:
-# :pserver:$ENV{USER}%netscape.com\@cvs.mozilla.org:/cvsroot
-# :pserver:anonymous\@cvs-mirror.mozilla.org:/cvsroot
-#
-# Note that win32 may not need \@, depends on ' or ".
-# :pserver:$ENV{USER}%netscape.com@cvs.mozilla.org:/cvsroot
-
-# CONFIG: $moz_cvsroot = '%mozillaCvsroot%';
-$moz_cvsroot = 'cltbld@cvs.mozilla.org:/cvsroot';
-
-#- Set these proper values for your tinderbox server
-#$Tinderbox_server = 'tinderbox-daemon@tinderbox.mozilla.org';
-
-# Allow for non-client builds, e.g. camino.
-#$moz_client_mk = 'client.mk';
-
-#- Set if you want to build in a separate object tree
-$ObjDir = 'obj-tb-trunk';
-
-# Extra build name, if needed.
-$BuildNameExtra = 'Release';
-
-# User comment, eg. ip address for dhcp builds.
-# ex: $UserComment = "ip = 208.12.36.108";
-#$UserComment = 0;
-
-#-
-#- The rest should not need to be changed
-#-
-
-#- Minimum wait period from start of build to start of next build in minutes.
-#$BuildSleep = 10;
-
-#- Until you get the script working. When it works,
-#- change to the tree you're actually building
-# CONFIG: $BuildTree  = '%buildTree%';
-$BuildTree  = 'MozillaRelease';
-
-#$BuildName = '';
-# CONFIG: $BuildTag = '%productTag%_RELEASE';
-$BuildTag = 'THUNDERBIRD_3_0a2_RELEASE';
-#$BuildConfigDir = 'mozilla/config';
-#$Topsrcdir = 'mozilla';
-
-$BinaryName = 'thunderbird.exe';
-
-#
-# For embedding app, use:
-#$EmbedBinaryName = 'TestGtkEmbed';
-#$EmbedDistDir    = 'dist/bin'
-
-
-#$ShellOverride = ''; # Only used if the default shell is too stupid
-#$ConfigureArgs = '';
-#$ConfigureEnvArgs = '';
-#$Compiler = 'gcc';
-#$NSPRArgs = '';
-#$ShellOverride = '';
-
-# Release build options
-$ReleaseBuild  = 1;
-$shiptalkback  = 0;
-$ReleaseToLatest = 0;
-$ReleaseToDated = 1;
-$build_hour    = "3";
-$package_creation_path = "/mail/installer";
-# needs setting for mac + talkback: $mac_bundle_path = "/browser/app";
-$ssh_version   = "2";
-# CONFIG: $ssh_user      = "%sshUser%";
-$ssh_user      = "cltbld";
-# CONFIG: $ssh_server    = "%sshServer%";
-$ssh_server    = "stage-old.mozilla.org";
-#$ReleaseGroup  = "thunderbird";
-$ftp_path      = "/home/ftp/pub/thunderbird/nightly";
-$url_path      = "http://ftp.mozilla.org/pub/mozilla.org/thunderbird/nightly";
-$tbox_ftp_path      = "/home/ftp/pub/thunderbird/tinderbox-builds";
-$tbox_url_path      = "http://ftp.mozilla.org/pub/mozilla.org/thunderbird/tinderbox-builds";
-# CONFIG: $milestone     = 'thunderbird%version%';
-$milestone     = 'thunderbird3.0a2';
-$notify_list   = "build-announce\@mozilla.org";
-$stub_installer = 0;
-$sea_installer = 1;
-$archive       = 1;
-$push_raw_xpis = 1;
-
-$update_package = 1;
-$update_product = "Thunderbird";
-$update_version = "trunk";
-$update_ver_file = "mail/config/version.txt";
-$update_platform = "WINNT_x86-msvc";
-$update_hash = "sha1";
-$update_filehost = "ftp.mozilla.org";
-$update_pushinfo = 0;
-$crashreporter_buildsymbols = 1;
-$crashreporter_pushsymbols = 1;
-# CONFIG: $ENV{'SYMBOL_SERVER_HOST'}    = '%symbolServer%';
-$ENV{'SYMBOL_SERVER_HOST'}    = 'dm-symbolpush01.mozilla.org';
-# CONFIG: $ENV{'SYMBOL_SERVER_USER'}    = '%symbolServerUser%';
-$ENV{'SYMBOL_SERVER_USER'}    = 'tbirdbld';
-# CONFIG: $ENV{'SYMBOL_SERVER_PATH'}    = '%symbolServerPath%';
-$ENV{'SYMBOL_SERVER_PATH'}    = '/mnt/netapp/breakpad/symbols_tbrd';
-# CONFIG: $ENV{'SYMBOL_SERVER_SSH_KEY'} = '%symbolServerKey%';
-$ENV{'SYMBOL_SERVER_SSH_KEY'} = '/c/Documents and Settings/cltbld/.ssh/tbirdbld_dsa';
-
-# Reboot the OS at the end of build-and-test cycle. This is primarily
-# intended for Win9x, which can't last more than a few cycles before
-# locking up (and testing would be suspect even after a couple of cycles).
-# Right now, there is only code to force the reboot for Win9x, so even
-# setting this to 1, will not have an effect on other platforms. Setting
-# up win9x to automatically logon and begin running tinderbox is left 
-# as an exercise to the reader. 
-#$RebootSystem = 0;
-
-# LogCompression specifies the type of compression used on the log file.
-# Valid options are 'gzip', and 'bzip2'. Please make sure the binaries
-# for 'gzip' or 'bzip2' are in the user's path before setting this
-# option.
-#$LogCompression = '';
-
-# LogEncoding specifies the encoding format used for the logs. Valid
-# options are 'base64', and 'uuencode'. If $LogCompression is set above,
-# this needs to be set to 'base64' or 'uuencode' to ensure that the
-# binary data is transferred properly.
-#$LogEncoding = '';
-
-# Prevent Extension Manager from spawning child processes during tests
-# - processes that tbox scripts cannot kill. 
-#$ENV{NO_EM_RESTART} = '1';

mozilla/tools/tinderbox-configs/xulrunner/linux/CLOBBER

@@ -1 +0,0 @@
-Clobbering to fix up checkout issues

mozilla/tools/tinderbox-configs/xulrunner/linux/mozconfig

@@ -1,17 +0,0 @@
-#
-## hostname: xr-linux-tbox
-## uname: Linux xr-linux-tbox.build.mozilla.org 2.6.18-8.el5 #1 SMP Thu Mar 15 19:57:35 EDT 2007 i686 i686 i386 GNU/Linux
-#
-
-export MOZILLA_OFFICIAL=1
-export JAVA_HOME=/tools/jdk
-mk_add_options MOZILLA_OFFICIAL=1
-
-mk_add_options MOZ_CO_PROJECT=xulrunner
-mk_add_options MOZ_MAKE_FLAGS="-j3"
-
-ac_add_options --enable-application=xulrunner
-ac_add_options --disable-tests
-
-CC=/tools/gcc-4.1.1/bin/gcc
-CXX=/tools/gcc-4.1.1/bin/g++

mozilla/tools/tinderbox-configs/xulrunner/linux/tinder-config.pl

@@ -1,262 +0,0 @@
-#
-## hostname: xr-linux-tbox
-## uname: Linux xr-linux-tbox.build.mozilla.org 2.6.18-8.el5 #1 SMP Thu Mar 15 19:57:35 EDT 2007 i686 i686 i386 GNU/Linux
-#
-
-#- tinder-config.pl - Tinderbox configuration file.
-#-    Uncomment the variables you need to set.
-#-    The default values are the same as the commented variables.
-
-$ENV{MOZ_CRASHREPORTER_NO_REPORT} = '1';
-
-# $ENV{MOZ_PACKAGE_MSI}
-#-----------------------------------------------------------------------------
-#  Default: 0
-#   Values: 0 | 1
-#  Purpose: Controls whether a MSI package is made.
-# Requires: Windows and a local MakeMSI installation.
-#$ENV{MOZ_PACKAGE_MSI} = 0;
-
-# $ENV{MOZ_SYMBOLS_TRANSFER_TYPE}
-#-----------------------------------------------------------------------------
-#  Default: scp
-#   Values: scp | rsync
-#  Purpose: Use scp or rsync to transfer symbols to the Talkback server.
-# Requires: The selected type requires the command be available both locally
-#           and on the Talkback server.
-#$ENV{MOZ_SYMBOLS_TRANSFER_TYPE} = "scp";
-
-#- PLEASE FILL THIS IN WITH YOUR PROPER EMAIL ADDRESS
-#$BuildAdministrator = "$ENV{USER}\@$ENV{HOST}";
-#$BuildAdministrator = ($ENV{USER} || "cltbld") . "\@" . ($ENV{HOST} || "dhcp");
-$BuildAdministrator = "build\@mozilla.org";
-
-#- You'll need to change these to suit your machine's needs
-#$DisplayServer = ':0.0';
-
-#- Default values of command-line opts
-#-
-#$BuildDepend       = 1;      # Depend or Clobber
-#$BuildDebug        = 0;      # Debug or Opt (Darwin)
-#$ReportStatus      = 1;      # Send results to server, or not
-#$ReportFinalStatus = 1;      # Finer control over $ReportStatus.
-$UseTimeStamp      = 0;      # Use the CVS 'pull-by-timestamp' option, or not
-#$BuildOnce         = 0;      # Build once, don't send results to server
-#$ConfigureOnly     = 0;      # Configure, but do not build.
-#$TestOnly          = 0;      # Only run tests, don't pull/build
-#$BuildEmbed        = 0;      # After building seamonkey, go build embed app.
-#$SkipMozilla       = 0;      # Use to debug post-mozilla.pl scripts.
-#$BuildLocales      = 0;      # Do l10n packaging?
-$BuildSDK           = 1;      # Build the SDK
-
-# Only used when $BuildLocales = 1
-%WGetFiles         = ();  # Pull files from the web, URL => Location
-#$WGetTimeout       = 360; # Wget timeout, in seconds
-#$BuildLocalesArgs  = "";  # Extra attributes to add to the makefile command
-                          # which builds the "installers-<locale>" target.
-                          # Typically used to set ZIP_IN and WIN32_INSTALLER_IN
-
-# Tests
-$CleanProfile             = 1;
-#$ResetHomeDirForTests     = 1;
-$ProductName              = "XULRunner";
-$VendorName               = 'Mozilla';
-
-$RunMozillaTests          = 0;  # Allow turning off of all tests if needed.
-#$RegxpcomTest             = 1;
-#$AliveTest                = 1;
-#$JavaTest                 = 0;
-#$ViewerTest               = 0;
-#$BloatTest                = 0;  # warren memory bloat test
-#$BloatTest2               = 0;  # dbaron memory bloat test, require tracemalloc
-#$DomToTextConversionTest  = 0;  
-#$XpcomGlueTest            = 0;
-#$CodesizeTest             = 0;  # Z,  require mozilla/tools/codesighs
-#$EmbedCodesizeTest        = 0;  # mZ, require mozilla/tools/codesigns
-#$MailBloatTest            = 0;
-#$EmbedTest                = 0;  # Assumes you wanted $BuildEmbed=1
-#$LayoutPerformanceTest    = 0;  # Tp
-#$DHTMLPerformanceTest     = 0;  # Tdhtml
-#$QATest                   = 0;  
-#$XULWindowOpenTest        = 0;  # Txul
-#$StartupPerformanceTest   = 0;  # Ts
-#@CompareLocaleDirs        = (); # Run compare-locales test on these directories
-# ("network","dom","toolkit","security/manager");
-#$CompareLocalesAviary     = 0;  # Should the compare-locales commands use the
-                                # aviary directory structure?
-
-#$TestsPhoneHome           = 0;  # Should test report back to server?
-
-# $results_server
-#----------------------------------------------------------------------------
-# Server on which test results will be accessible.  This was originally tegu,
-# then became axolotl.  Once we moved services from axolotl, it was time
-# to give this service its own hostname to make future transitions easier.
-# - cmp@mozilla.org
-#$results_server           = "build-graphs.mozilla.org";
-
-#$pageload_server          = "spider";  # localhost
-
-#
-# Timeouts, values are in seconds.
-#
-#$CVSCheckoutTimeout               = 3600;
-#$CreateProfileTimeout             = 45;
-#$RegxpcomTestTimeout              = 120;
-
-#$AliveTestTimeout                 = 45;
-#$ViewerTestTimeout                = 45;
-#$EmbedTestTimeout                 = 45;
-#$BloatTestTimeout                 = 120;   # seconds
-#$MailBloatTestTimeout             = 120;   # seconds
-#$JavaTestTimeout                  = 45;
-#$DomTestTimeout	                  = 45;    # seconds
-#$XpcomGlueTestTimeout             = 15;
-#$CodesizeTestTimeout              = 900;     # seconds
-#$CodesizeTestType                 = "auto";  # {"auto"|"base"}
-#$LayoutPerformanceTestTimeout     = 1200;  # entire test, seconds
-#$DHTMLPerformanceTestTimeout      = 1200;  # entire test, seconds
-#$QATestTimeout                    = 1200;   # entire test, seconds
-#$LayoutPerformanceTestPageTimeout = 30000; # each page, ms
-#$StartupPerformanceTestTimeout    = 15;    # seconds
-#$XULWindowOpenTestTimeout	      = 150;   # seconds
-
-
-#$MozConfigFileName = 'mozconfig';
-
-#$UseMozillaProfile = 1;
-#$MozProfileName = 'default';
-
-#- Set these to what makes sense for your system
-#$Make          = 'gmake';       # Must be GNU make
-#$MakeOverrides = '';
-#$mail          = '/bin/mail';
-#$CVS           = 'cvs -q';
-#$CVSCO         = 'checkout -P';
-
-# win32 usually doesn't have /bin/mail
-#$blat           = 'c:/nstools/bin/blat';
-#$use_blat       = 0;
-
-# Set moz_cvsroot to something like:
-# :pserver:$ENV{USER}%netscape.com\@cvs.mozilla.org:/cvsroot
-# :pserver:anonymous\@cvs-mirror.mozilla.org:/cvsroot
-#
-# Note that win32 may not need \@, depends on ' or ".
-# :pserver:$ENV{USER}%netscape.com@cvs.mozilla.org:/cvsroot
-
-#$moz_cvsroot   = $ENV{CVSROOT};
-# CONFIG: $moz_cvsroot   = '%mozillaCvsroot%';
-$moz_cvsroot   = 'cltbld@cvs.mozilla.org:/cvsroot';
-
-#- Set these proper values for your tinderbox server
-#$Tinderbox_server = 'tinderbox-daemon@tinderbox.mozilla.org';
-
-# Allow for non-client builds, e.g. camino.
-#$moz_client_mk = 'client.mk';
-
-#- Set if you want to build in a separate object tree
-$ObjDir = 'obj-xulrunner';
-
-# Extra build name, if needed.
-$BuildNameExtra = 'Release';
-
-# User comment, eg. ip address for dhcp builds.
-# ex: $UserComment = "ip = 208.12.36.108";
-#$UserComment = 0;
-
-#-
-#- The rest should not need to be changed
-#-
-
-#- Minimum wait period from start of build to start of next build in minutes.
-#$BuildSleep = 10;
-
-#- Until you get the script working. When it works,
-#- change to the tree you're actually building
-# CONFIG: $BuildTree  = '%buildTree%';
-$BuildTree  = 'MozillaRelease';
-
-#$BuildName = '';
-# CONFIG: $BuildTag = '%productTag%_RELEASE';
-$BuildTag = 'FIREFOX_3_0_17_RELEASE';
-#$BuildConfigDir = 'mozilla/config';
-#$Topsrcdir = 'mozilla';
-
-$BinaryName = 'xulrunner-bin';
-
-#
-# For embedding app, use:
-#$EmbedBinaryName = 'TestGtkEmbed';
-#$EmbedDistDir    = 'dist/bin'
-
-
-#$ShellOverride = ''; # Only used if the default shell is too stupid
-#$ConfigureArgs = '';
-#$ConfigureEnvArgs = '';
-#$Compiler = 'gcc';
-#$NSPRArgs = '';
-#$ShellOverride = '';
-
-# Release build options
-$ReleaseBuild  = 1;
-#$LocaleProduct = "browser";
-$shiptalkback  = 0;
-$ReleaseToLatest = 0; # Push the release to latest-<milestone>?
-$ReleaseToDated = 1; # Push the release to YYYY-MM-DD-HH-<milestone>?
-#$build_hour    = "8";
-$package_creation_path = "/xulrunner/installer";
-# needs setting for mac + talkback: $mac_bundle_path = "/browser/app";
-$ssh_version   = "2";
-# CONFIG: $ssh_user      = "%sshUser%";
-$ssh_user      = "cltbld";
-#$ssh_key       = "$ENV{HOME}/.ssh/xrbld_dsa";
-# CONFIG: $ssh_server    = "%sshServer%";
-$ssh_server    = "stage-old.mozilla.org";
-$ReleaseGroup  = "xulrunner";
-$ftp_path      = "/home/ftp/pub/xulrunner/nightly";
-$url_path      = "http://ftp.mozilla.org/pub/mozilla.org/xulrunner/nightly";
-$tbox_ftp_path = "/home/ftp/pub/xulrunner/tinderbox-builds";
-$tbox_url_path = "http://ftp.mozilla.org/pub/mozilla.org/xulrunner/tinderbox-builds";
-# CONFIG: $milestone     = "xulrunner%version%";
-$milestone     = "xulrunner1.9.0.17";
-$notify_list   = "build-announce\@mozilla.org";
-$stub_installer = 0;
-$sea_installer = 0;
-$archive       = 1;
-$push_raw_xpis = 0;
-$crashreporter_buildsymbols = 0;
-$crashreporter_pushsymbols = 0;
-# CONFIG: $ENV{'SYMBOL_SERVER_HOST'}    = '%symbolServer%';
-$ENV{'SYMBOL_SERVER_HOST'}    = 'stage-old.mozilla.org';
-# CONFIG: $ENV{'SYMBOL_SERVER_USER'}    = '%symbolServerUser%';
-$ENV{'SYMBOL_SERVER_USER'}    = 'xrbld';
-# CONFIG: $ENV{'SYMBOL_SERVER_PATH'}    = '%symbolServerPath%';
-$ENV{'SYMBOL_SERVER_PATH'}    = '/mnt/netapp/breakpad/symbols_xr';
-# CONFIG: $ENV{'SYMBOL_SERVER_SSH_KEY'} = '%symbolServerKey%';
-$ENV{'SYMBOL_SERVER_SSH_KEY'} = '/home/cltbld/.ssh/xrbld_dsa';
-
-# Reboot the OS at the end of build-and-test cycle. This is primarily
-# intended for Win9x, which can't last more than a few cycles before
-# locking up (and testing would be suspect even after a couple of cycles).
-# Right now, there is only code to force the reboot for Win9x, so even
-# setting this to 1, will not have an effect on other platforms. Setting
-# up win9x to automatically logon and begin running tinderbox is left 
-# as an exercise to the reader. 
-#$RebootSystem = 0;
-
-# LogCompression specifies the type of compression used on the log file.
-# Valid options are 'gzip', and 'bzip2'. Please make sure the binaries
-# for 'gzip' or 'bzip2' are in the user's path before setting this
-# option.
-#$LogCompression = '';
-
-# LogEncoding specifies the encoding format used for the logs. Valid
-# options are 'base64', and 'uuencode'. If $LogCompression is set above,
-# this needs to be set to 'base64' or 'uuencode' to ensure that the
-# binary data is transferred properly.
-#$LogEncoding = '';
-
-# Prevent Extension Manager from spawning child processes during tests
-# - processes that tbox scripts cannot kill. 
-#$ENV{NO_EM_RESTART} = '1';

mozilla/tools/tinderbox-configs/xulrunner/macosx/CLOBBER

@@ -1 +0,0 @@
-CLOBBERing to disable zipwriter from bug 379633

mozilla/tools/tinderbox-configs/xulrunner/macosx/mozconfig

@@ -1,20 +0,0 @@
-#
-## hostname: bm-xserve09.build.mozilla.org
-## uname: Darwin bm-xserve09.build.mozilla.org 8.8.4 Darwin Kernel Version 8.8.4: Sun Oct 29 15:26:54 PST 2006; root:xnu-792.16.4.obj~1/RELEASE_I386 i386 i386
-#
-
-. $topsrcdir/build/macosx/universal/mozconfig
-
-export MOZILLA_OFFICIAL=1
-export JAVA_HOME=/System/Library/Frameworks/JavaVM.framework/Home
-mk_add_options MOZILLA_OFFICIAL=1
-
-mk_add_options MOZ_CO_PROJECT=xulrunner
-mk_add_options MOZ_MAKE_FLAGS="-j8"
-mk_add_options MOZ_OBJDIR=@TOPSRCDIR@/../build/universal
-
-ac_add_options --enable-application=xulrunner
-ac_add_options --disable-tests
-ac_add_options --enable-svg
-ac_add_options --enable-canvas
-ac_add_app_options ppc --enable-prebinding

mozilla/tools/tinderbox-configs/xulrunner/macosx/tinder-config.pl

@@ -1,268 +0,0 @@
-#
-## hostname: bm-xserve09.build.mozilla.org
-## uname: Darwin bm-xserve09.build.mozilla.org 8.8.4 Darwin Kernel Version 8.8.4: Sun Oct 29 15:26:54 PST 2006; root:xnu-792.16.4.obj~1/RELEASE_I386 i386 i386
-#
-
-#- tinder-config.pl - Tinderbox configuration file.
-#-    Uncomment the variables you need to set.
-#-    The default values are the same as the commented variables.
-
-$MacUniversalBinary = 1;
-
-$ENV{CHOWN_ROOT} = "/builds/tinderbox/bin/chown_root";
-$ENV{REVERT_ROOT} = "/builds/tinderbox/bin/revert_root";
-$ENV{CHOWN_REVERT} = $ENV{REVERT_ROOT};
-$ENV{MOZ_CRASHREPORTER_NO_REPORT} = '1';
-
-# $ENV{MOZ_PACKAGE_MSI}
-#-----------------------------------------------------------------------------
-#  Default: 0
-#   Values: 0 | 1
-#  Purpose: Controls whether a MSI package is made.
-# Requires: Windows and a local MakeMSI installation.
-#$ENV{MOZ_PACKAGE_MSI} = 0;
-
-# $ENV{MOZ_SYMBOLS_TRANSFER_TYPE}
-#-----------------------------------------------------------------------------
-#  Default: scp
-#   Values: scp | rsync
-#  Purpose: Use scp or rsync to transfer symbols to the Talkback server.
-# Requires: The selected type requires the command be available both locally
-#           and on the Talkback server.
-#$ENV{MOZ_SYMBOLS_TRANSFER_TYPE} = "scp";
-
-#- PLEASE FILL THIS IN WITH YOUR PROPER EMAIL ADDRESS
-#$BuildAdministrator = "$ENV{USER}\@$ENV{HOST}";
-#$BuildAdministrator = ($ENV{USER} || "cltbld") . "\@" . ($ENV{HOST} || "dhcp");
-$BuildAdministrator = "build\@mozilla.org";
-
-#- You'll need to change these to suit your machine's needs
-#$DisplayServer = ':0.0';
-
-#- Default values of command-line opts
-#-
-#$BuildDepend       = 1;      # Depend or Clobber
-#$BuildDebug        = 0;      # Debug or Opt (Darwin)
-#$ReportStatus      = 1;      # Send results to server, or not
-#$ReportFinalStatus = 1;      # Finer control over $ReportStatus.
-$UseTimeStamp      = 0;      # Use the CVS 'pull-by-timestamp' option, or not
-#$BuildOnce         = 0;      # Build once, don't send results to server
-#$ConfigureOnly     = 0;      # Configure, but do not build.
-#$TestOnly          = 0;      # Only run tests, don't pull/build
-#$BuildEmbed        = 0;      # After building seamonkey, go build embed app.
-#$SkipMozilla       = 0;      # Use to debug post-mozilla.pl scripts.
-#$BuildLocales      = 0;      # Do l10n packaging?
-$BuildSDK           = 1;      # Build the SDK
-
-# Only used when $BuildLocales = 1
-%WGetFiles         = ();  # Pull files from the web, URL => Location
-#$WGetTimeout       = 360; # Wget timeout, in seconds
-#$BuildLocalesArgs  = "";  # Extra attributes to add to the makefile command
-                          # which builds the "installers-<locale>" target.
-                          # Typically used to set ZIP_IN and WIN32_INSTALLER_IN
-
-# Tests
-$CleanProfile             = 1;
-#$ResetHomeDirForTests     = 1;
-$ProductName              = "XULRunner";
-$VendorName               = 'Mozilla';
-
-$RunMozillaTests          = 0;  # Allow turning off of all tests if needed.
-#$RegxpcomTest             = 1;
-#$AliveTest                = 1;
-#$JavaTest                 = 0;
-#$ViewerTest               = 0;
-#$BloatTest                = 0;  # warren memory bloat test
-#$BloatTest2               = 0;  # dbaron memory bloat test, require tracemalloc
-#$DomToTextConversionTest  = 0;  
-#$XpcomGlueTest            = 0;
-#$CodesizeTest             = 0;  # Z,  require mozilla/tools/codesighs
-#$EmbedCodesizeTest        = 0;  # mZ, require mozilla/tools/codesigns
-#$MailBloatTest            = 0;
-#$EmbedTest                = 0;  # Assumes you wanted $BuildEmbed=1
-#$LayoutPerformanceTest    = 0;  # Tp
-#$DHTMLPerformanceTest     = 0;  # Tdhtml
-#$QATest                   = 0;  
-#$XULWindowOpenTest        = 0;  # Txul
-#$StartupPerformanceTest   = 0;  # Ts
-#@CompareLocaleDirs        = (); # Run compare-locales test on these directories
-# ("network","dom","toolkit","security/manager");
-#$CompareLocalesAviary     = 0;  # Should the compare-locales commands use the
-                                # aviary directory structure?
-
-#$TestsPhoneHome           = 0;  # Should test report back to server?
-
-# $results_server
-#----------------------------------------------------------------------------
-# Server on which test results will be accessible.  This was originally tegu,
-# then became axolotl.  Once we moved services from axolotl, it was time
-# to give this service its own hostname to make future transitions easier.
-# - cmp@mozilla.org
-#$results_server           = "build-graphs.mozilla.org";
-
-#$pageload_server          = "spider";  # localhost
-
-#
-# Timeouts, values are in seconds.
-#
-#$CVSCheckoutTimeout               = 3600;
-#$CreateProfileTimeout             = 45;
-#$RegxpcomTestTimeout              = 120;
-
-#$AliveTestTimeout                 = 45;
-#$ViewerTestTimeout                = 45;
-#$EmbedTestTimeout                 = 45;
-#$BloatTestTimeout                 = 120;   # seconds
-#$MailBloatTestTimeout             = 120;   # seconds
-#$JavaTestTimeout                  = 45;
-#$DomTestTimeout	                  = 45;    # seconds
-#$XpcomGlueTestTimeout             = 15;
-#$CodesizeTestTimeout              = 900;     # seconds
-#$CodesizeTestType                 = "auto";  # {"auto"|"base"}
-#$LayoutPerformanceTestTimeout     = 1200;  # entire test, seconds
-#$DHTMLPerformanceTestTimeout      = 1200;  # entire test, seconds
-#$QATestTimeout                    = 1200;   # entire test, seconds
-#$LayoutPerformanceTestPageTimeout = 30000; # each page, ms
-#$StartupPerformanceTestTimeout    = 15;    # seconds
-#$XULWindowOpenTestTimeout	      = 150;   # seconds
-
-
-#$MozConfigFileName = 'mozconfig';
-
-#$UseMozillaProfile = 1;
-#$MozProfileName = 'default';
-
-#- Set these to what makes sense for your system
-#$Make          = 'gmake';       # Must be GNU make
-#$MakeOverrides = '';
-#$mail          = '/bin/mail';
-#$CVS           = 'cvs -q';
-#$CVSCO         = 'checkout -P';
-
-# win32 usually doesn't have /bin/mail
-#$blat           = 'c:/nstools/bin/blat';
-#$use_blat       = 0;
-
-# Set moz_cvsroot to something like:
-# :pserver:$ENV{USER}%netscape.com\@cvs.mozilla.org:/cvsroot
-# :pserver:anonymous\@cvs-mirror.mozilla.org:/cvsroot
-#
-# Note that win32 may not need \@, depends on ' or ".
-# :pserver:$ENV{USER}%netscape.com@cvs.mozilla.org:/cvsroot
-
-# sharing bm-xserve09 with T'bird build, do all CVS pulls with that key
-# CONFIG: $moz_cvsroot   = '%mozillaCvsroot%';
-$moz_cvsroot   = 'cltbld@cvs.mozilla.org:/cvsroot';
-
-#- Set these proper values for your tinderbox server
-#$Tinderbox_server = 'tinderbox-daemon@tinderbox.mozilla.org';
-
-# Allow for non-client builds, e.g. camino.
-#$moz_client_mk = 'client.mk';
-
-#- Set if you want to build in a separate object tree
-$ObjDir = '../build/universal';
-
-# Extra build name, if needed.
-$BuildNameExtra = 'Release';
-
-# User comment, eg. ip address for dhcp builds.
-# ex: $UserComment = "ip = 208.12.36.108";
-#$UserComment = 0;
-
-#-
-#- The rest should not need to be changed
-#-
-
-#- Minimum wait period from start of build to start of next build in minutes.
-#$BuildSleep = 10;
-
-#- Until you get the script working. When it works,
-#- change to the tree you're actually building
-# CONFIG: $BuildTree  = '%buildTree%';
-$BuildTree  = 'MozillaRelease';
-
-#$BuildName = '';
-# CONFIG: $BuildTag = '%productTag%_RELEASE';
-$BuildTag = 'FIREFOX_3_0_17_RELEASE';
-#$BuildConfigDir = 'mozilla/config';
-#$Topsrcdir = 'mozilla';
-
-$BinaryName = 'xulrunner-bin';
-
-#
-# For embedding app, use:
-#$EmbedBinaryName = 'TestGtkEmbed';
-#$EmbedDistDir    = 'dist/bin'
-
-
-#$ShellOverride = ''; # Only used if the default shell is too stupid
-#$ConfigureArgs = '';
-#$ConfigureEnvArgs = '';
-#$Compiler = 'gcc';
-#$NSPRArgs = '';
-#$ShellOverride = '';
-
-# Release build options
-$ReleaseBuild  = 1;
-#$LocaleProduct = "browser";
-$shiptalkback  = 0;
-$ReleaseToLatest = 0; # Push the release to latest-<milestone>?
-$ReleaseToDated = 1; # Push the release to YYYY-MM-DD-HH-<milestone>?
-#$build_hour    = "8";
-$package_creation_path = "/xulrunner/installer";
-# needs setting for mac + talkback: $mac_bundle_path = "/browser/app";
-$mac_bundle_path = "/browser/app";
-$ssh_version   = "2";
-# CONFIG: $ssh_user      = "%sshUser%";
-$ssh_user      = "cltbld";
-#$ssh_key       = "$ENV{HOME}/.ssh/xrbld_dsa";
-# CONFIG: $ssh_server    = "%sshServer%";
-$ssh_server    = "stage-old.mozilla.org";
-$ReleaseGroup  = "xulrunner";
-$ftp_path      = "/home/ftp/pub/xulrunner/nightly";
-$url_path      = "http://ftp.mozilla.org/pub/mozilla.org/xulrunner/nightly";
-$tbox_ftp_path = "/home/ftp/pub/xulrunner/tinderbox-builds";
-$tbox_url_path = "http://ftp.mozilla.org/pub/mozilla.org/xulrunner/tinderbox-builds";
-# CONFIG: $milestone     = 'xulrunner%version%';
-$milestone     = 'xulrunner1.9.0.17';
-$notify_list   = "build-announce\@mozilla.org";
-$stub_installer = 0;
-$sea_installer = 0;
-$archive       = 1;
-$push_raw_xpis = 0;
-$crashreporter_buildsymbols = 0;
-$crashreporter_pushsymbols = 0;
-# CONFIG: $ENV{'SYMBOL_SERVER_HOST'}    = '%symbolServer%';
-$ENV{'SYMBOL_SERVER_HOST'}    = 'stage-old.mozilla.org';
-# CONFIG: $ENV{'SYMBOL_SERVER_USER'}    = '%symbolServerUser%';
-$ENV{'SYMBOL_SERVER_USER'}    = 'xrbld';
-# CONFIG: $ENV{'SYMBOL_SERVER_PATH'}    = '%symbolServerPath%';
-$ENV{'SYMBOL_SERVER_PATH'}    = '/mnt/netapp/breakpad/symbols_xr';
-# CONFIG: $ENV{'SYMBOL_SERVER_SSH_KEY'} = '%symbolServerKey%';
-$ENV{'SYMBOL_SERVER_SSH_KEY'} = '/Users/cltbld/.ssh/xrbld_dsa';
-
-# Reboot the OS at the end of build-and-test cycle. This is primarily
-# intended for Win9x, which can't last more than a few cycles before
-# locking up (and testing would be suspect even after a couple of cycles).
-# Right now, there is only code to force the reboot for Win9x, so even
-# setting this to 1, will not have an effect on other platforms. Setting
-# up win9x to automatically logon and begin running tinderbox is left 
-# as an exercise to the reader. 
-#$RebootSystem = 0;
-
-# LogCompression specifies the type of compression used on the log file.
-# Valid options are 'gzip', and 'bzip2'. Please make sure the binaries
-# for 'gzip' or 'bzip2' are in the user's path before setting this
-# option.
-#$LogCompression = '';
-
-# LogEncoding specifies the encoding format used for the logs. Valid
-# options are 'base64', and 'uuencode'. If $LogCompression is set above,
-# this needs to be set to 'base64' or 'uuencode' to ensure that the
-# binary data is transferred properly.
-#$LogEncoding = '';
-
-# Prevent Extension Manager from spawning child processes during tests
-# - processes that tbox scripts cannot kill. 
-#$ENV{NO_EM_RESTART} = '1';

mozilla/tools/tinderbox-configs/xulrunner/win32/CLOBBER

@@ -1 +0,0 @@
-Preemptive clobber for /README.txt merge conflict.

mozilla/tools/tinderbox-configs/xulrunner/win32/mozconfig

@@ -1,18 +0,0 @@
-#
-# hostname: fxexp-win32-tbox
-# uname: CYGWIN_NT-5.2 fxexp-win32-tbox 1.5.19(0.150/4/2) 2006-01-20 13:28 i686 Cygwin
-#
-
-export MOZILLA_OFFICIAL
-export JAVA_HOME=/d/jdk1.5.0_10
-
-mk_add_options MOZILLA_OFFICIAL=1
-mk_add_options MOZ_CO_PROJECT=xulrunner
-mk_add_options MOZ_MAKE_FLAGS="-j2"
-
-ac_add_options --enable-application=xulrunner
-ac_add_options --enable-jemalloc
-ac_add_options --disable-tests
-ac_add_options --enable-svg
-ac_add_options --enable-canvas
-ac_add_options --disable-installer

mozilla/tools/tinderbox-configs/xulrunner/win32/tinder-config.pl

@@ -1,255 +0,0 @@
-#
-# hostname: fxexp-win32-tbox
-# uname: CYGWIN_NT-5.2 fxexp-win32-tbox 1.5.19(0.150/4/2) 2006-01-20 13:28 i686 Cygwin
-#
-
-#- tinder-config.pl - Tinderbox configuration file.
-#-    Uncomment the variables you need to set.
-#-    The default values are the same as the commented variables.
-
-$ENV{NO_EM_RESTART} = "1";
-$ENV{MOZ_INSTALLER_USE_7ZIP} = "1";
-$ENV{CVS_RSH} = "ssh";
-$ENV{MOZ_CRASHREPORTER_NO_REPORT} = '1';
-# Both these two variables are for source server support
-$ENV{PDBSTR_PATH} = 'C:\\Program Files\\Debugging Tools for Windows\\sdk\\srcsrv\\pdbstr.exe';
-$ENV{SRCSRV_ROOT} = ':pserver:anonymous@cvs-mirror.mozilla.org:/cvsroot';
-
-# $ENV{MOZ_PACKAGE_MSI}
-#-----------------------------------------------------------------------------
-#  Default: 0
-#   Values: 0 | 1
-#  Purpose: Controls whether a MSI package is made.
-# Requires: Windows and a local MakeMSI installation.
-#$ENV{MOZ_PACKAGE_MSI} = 0;
-
-# $ENV{MOZ_SYMBOLS_TRANSFER_TYPE}
-#-----------------------------------------------------------------------------
-#  Default: scp
-#   Values: scp | rsync
-#  Purpose: Use scp or rsync to transfer symbols to the Talkback server.
-# Requires: The selected type requires the command be available both locally
-#           and on the Talkback server.
-#$ENV{MOZ_SYMBOLS_TRANSFER_TYPE} = "scp";
-
-#- PLEASE FILL THIS IN WITH YOUR PROPER EMAIL ADDRESS
-#$BuildAdministrator = "$ENV{USER}\@$ENV{HOST}";
-#$BuildAdministrator = ($ENV{USER} || "cltbld") . "\@" . ($ENV{HOST} || "dhcp");
-$BuildAdministrator = 'build@mozilla.org';
-
-#- You'll need to change these to suit your machine's needs
-#$DisplayServer = ':0.0';
-
-#- Default values of command-line opts
-#-
-#$BuildDepend       = 1;      # Depend or Clobber
-#$BuildDebug        = 0;      # Debug or Opt (Darwin)
-#$ReportStatus      = 1;      # Send results to server, or not
-#$ReportFinalStatus = 1;      # Finer control over $ReportStatus.
-$UseTimeStamp      = 0;      # Use the CVS 'pull-by-timestamp' option, or not
-#$BuildOnce         = 0;      # Build once, don't send results to server
-#$TestOnly          = 0;      # Only run tests, don't pull/build
-#$BuildEmbed        = 0;      # After building seamonkey, go build embed app.
-#$SkipMozilla       = 0;      # Use to debug post-mozilla.pl scripts.
-#$BuildLocales      = 0;      # Do l10n packaging?
-$BuildSDK           = 1;      # Build the SDK
-
-# Tests
-#$CleanProfile             = 0;
-#$ResetHomeDirForTests     = 1;
-$ProductName              = "XULRunner";
-$VendorName               = 'Mozilla';
-
-$RunMozillaTests          = 0;  # Allow turning off of all tests if needed.
-#$RegxpcomTest             = 1;
-#$AliveTest                = 1;
-#$JavaTest                 = 0;
-#$ViewerTest               = 0;
-#$BloatTest                = 0;  # warren memory bloat test
-#$BloatTest2               = 0;  # dbaron memory bloat test, require tracemalloc
-#$DomToTextConversionTest  = 0;  
-#$XpcomGlueTest            = 0;
-#$CodesizeTest             = 0;  # Z,  require mozilla/tools/codesighs
-#$EmbedCodesizeTest        = 0;  # mZ, require mozilla/tools/codesigns
-#$MailBloatTest            = 0;
-#$EmbedTest                = 0;  # Assumes you wanted $BuildEmbed=1
-#$LayoutPerformanceTest    = 0;  # Tp
-#$DHTMLPerformanceTest     = 0;  # Tdhtml
-#$QATest                   = 0;  
-#$XULWindowOpenTest        = 0;  # Txul
-#$StartupPerformanceTest   = 0;  # Ts
-
-#$TestsPhoneHome           = 0;  # Should test report back to server?
-
-# $results_server
-#----------------------------------------------------------------------------
-# Server on which test results will be accessible.  This was originally tegu,
-# then became axolotl.  Once we moved services from axolotl, it was time
-# to give this service its own hostname to make future transitions easier.
-# - cmp@mozilla.org
-#$results_server           = "build-graphs.mozilla.org";
-
-#$pageload_server          = "spider";  # localhost
-
-#
-# Timeouts, values are in seconds.
-#
-#$CVSCheckoutTimeout               = 3600;
-#$CreateProfileTimeout             = 45;
-#$RegxpcomTestTimeout              = 120;
-
-#$AliveTestTimeout                 = 45;
-#$ViewerTestTimeout                = 45;
-#$EmbedTestTimeout                 = 45;
-#$BloatTestTimeout                 = 120;   # seconds
-#$MailBloatTestTimeout             = 120;   # seconds
-#$JavaTestTimeout                  = 45;
-#$DomTestTimeout	                  = 45;    # seconds
-#$XpcomGlueTestTimeout             = 15;
-#$CodesizeTestTimeout              = 900;     # seconds
-#$CodesizeTestType                 = "auto";  # {"auto"|"base"}
-#$LayoutPerformanceTestTimeout     = 1200;  # entire test, seconds
-#$DHTMLPerformanceTestTimeout      = 1200;  # entire test, seconds
-#$QATestTimeout                    = 1200;   # entire test, seconds
-#$LayoutPerformanceTestPageTimeout = 30000; # each page, ms
-#$StartupPerformanceTestTimeout    = 15;    # seconds
-#$XULWindowOpenTestTimeout	      = 150;   # seconds
-
-
-#$MozConfigFileName = 'mozconfig';
-
-#$UseMozillaProfile = 1;
-#$MozProfileName = 'default';
-
-#- Set these to what makes sense for your system
-$Make          = 'make';       # Must be GNU make
-#$MakeOverrides = '';
-#$mail          = '/bin/mail';
-#$CVS           = 'cvs -q';
-#$CVSCO         = 'checkout -P';
-
-# win32 usually doesn't have /bin/mail
-$blat           = '/d/mozilla-build/blat261/full/blat';
-$use_blat       = 1;
-
-# Set moz_cvsroot to something like:
-# :pserver:$ENV{USER}%netscape.com\@cvs.mozilla.org:/cvsroot
-# :pserver:anonymous\@cvs-mirror.mozilla.org:/cvsroot
-#
-# Note that win32 may not need \@, depends on ' or ".
-# :pserver:$ENV{USER}%netscape.com@cvs.mozilla.org:/cvsroot
-
-#$moz_cvsroot   = $ENV{CVSROOT};
-# CONFIG: $moz_cvsroot = '%mozillaCvsroot%';
-$moz_cvsroot = 'cltbld@cvs.mozilla.org:/cvsroot';
-
-#- Set these proper values for your tinderbox server
-#$Tinderbox_server = 'tinderbox-daemon@tinderbox.mozilla.org';
-
-# Allow for non-client builds, e.g. camino.
-#$moz_client_mk = 'client.mk';
-
-#- Set if you want to build in a separate object tree
-$ObjDir = 'obj-xulrunner';
-
-# Extra build name, if needed.
-$BuildNameExtra = 'Release';
-
-# User comment, eg. ip address for dhcp builds.
-# ex: $UserComment = "ip = 208.12.36.108";
-#$UserComment = 0;
-
-#-
-#- The rest should not need to be changed
-#-
-
-#- Minimum wait period from start of build to start of next build in minutes.
-#$BuildSleep = 10;
-
-#- Until you get the script working. When it works,
-#- change to the tree you're actually building
-# CONFIG: $BuildTree  = '%buildTree%';
-$BuildTree  = 'MozillaRelease';
-
-#$BuildName = '';
-# CONFIG: $BuildTag = '%productTag%_RELEASE';
-$BuildTag = 'FIREFOX_3_0_17_RELEASE';
-#$BuildConfigDir = 'mozilla/config';
-#$Topsrcdir = 'mozilla';
-
-$BinaryName = 'xulrunner.exe';
-
-#
-# For embedding app, use:
-#$EmbedBinaryName = 'TestGtkEmbed';
-#$EmbedDistDir    = 'dist/bin'
-
-
-#$ShellOverride = ''; # Only used if the default shell is too stupid
-#$ConfigureArgs = '';
-#$ConfigureEnvArgs = '';
-#$Compiler = 'gcc';
-#$NSPRArgs = '';
-#$ShellOverride = '';
-
-# Release build options
-$ReleaseBuild  = 1;
-$shiptalkback  = 0;
-$ReleaseToLatest = 0; # Push the release to latest-<milestone>?
-$ReleaseToDated = 1; # Push the release to YYYY-MM-DD-HH-<milestone>?
-#$build_hour    = "8";
-$package_creation_path = "/xulrunner/installer";
-# needs setting for mac + talkback: $mac_bundle_path = "/browser/app";
-$ssh_version   = "2";
-# CONFIG: $ssh_user      = "%sshUser%";
-$ssh_user      = "cltbld";
-#$ssh_key       = "'$ENV{HOME}/.ssh/xrbld_dsa'";
-# CONFIG: $ssh_server    = "%sshServer%";
-$ssh_server    = "stage-old.mozilla.org";
-$ReleaseGroup  = "xulrunner";
-$ftp_path      = "/home/ftp/pub/xulrunner/nightly";
-$url_path      = "http://ftp.mozilla.org/pub/mozilla.org/xulrunner/nightly";
-$tbox_ftp_path = "/home/ftp/pub/xulrunner/tinderbox-builds";
-$tbox_url_path = "http://ftp.mozilla.org/pub/mozilla.org/xulrunner/tinderbox-builds";
-# CONFIG: $milestone     = 'xulrunner%version%';
-$milestone     = 'xulrunner1.9.0.17';
-$notify_list   = 'build-announce@mozilla.org';
-$stub_installer = 0;
-$sea_installer = 0;
-$archive       = 1;
-$push_raw_xpis = 0;
-$crashreporter_buildsymbols = 1;
-$crashreporter_pushsymbols = 1;
-# CONFIG: $ENV{'SYMBOL_SERVER_HOST'}    = '%symbolServer%';
-$ENV{'SYMBOL_SERVER_HOST'}    = 'stage-old.mozilla.org';
-# CONFIG: $ENV{'SYMBOL_SERVER_USER'}    = '%symbolServerUser%';
-$ENV{'SYMBOL_SERVER_USER'}    = 'xrbld';
-# CONFIG: $ENV{'SYMBOL_SERVER_PATH'}    = '%symbolServerPath%';
-$ENV{'SYMBOL_SERVER_PATH'}    = '/mnt/netapp/breakpad/symbols_xr';
-# CONFIG: $ENV{'SYMBOL_SERVER_SSH_KEY'} = '%symbolServerKey%';
-$ENV{'SYMBOL_SERVER_SSH_KEY'} = '/c/Documents and Settings/cltbld/.ssh/xrbld_dsa';
-
-# Reboot the OS at the end of build-and-test cycle. This is primarily
-# intended for Win9x, which can't last more than a few cycles before
-# locking up (and testing would be suspect even after a couple of cycles).
-# Right now, there is only code to force the reboot for Win9x, so even
-# setting this to 1, will not have an effect on other platforms. Setting
-# up win9x to automatically logon and begin running tinderbox is left 
-# as an exercise to the reader. 
-#$RebootSystem = 0;
-
-# LogCompression specifies the type of compression used on the log file.
-# Valid options are 'gzip', and 'bzip2'. Please make sure the binaries
-# for 'gzip' or 'bzip2' are in the user's path before setting this
-# option.
-#$LogCompression = '';
-
-# LogEncoding specifies the encoding format used for the logs. Valid
-# options are 'base64', and 'uuencode'. If $LogCompression is set above,
-# this needs to be set to 'base64' or 'uuencode' to ensure that the
-# binary data is transferred properly.
-#$LogEncoding = '';
-
-# Prevent Extension Manager from spawning child processes during tests
-# - processes that tbox scripts cannot kill. 
-#$ENV{NO_EM_RESTART} = '1';