workaround for bug=30927

git-svn-id: svn://10.0.0.236/branches/M15-patch@72213 18797224-902f-48f8-a5cc-f745e15eee43

mozilla/java/dom/jni/javaDOMGlobals.h

@@ -0,0 +1,105 @@
+/* 
+ The contents of this file are subject to the Mozilla Public
+ License Version 1.1 (the "License"); you may not use this file
+ except in compliance with the License. You may obtain a copy of
+ the License at http://www.mozilla.org/MPL/
+
+ Software distributed under the License is distributed on an "AS
+ IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ implied. See the License for the specific language governing
+ rights and limitations under the License.
+
+ The Original Code is mozilla.org code.
+
+ The Initial Developer of the Original Code is Sun Microsystems,
+ Inc. Portions created by Sun are
+ Copyright (C) 1999 Sun Microsystems, Inc. All
+ Rights Reserved.
+
+ Contributor(s): 
+*/
+
+#ifndef __JavaDOMGlobals_h__
+#define __JavaDOMGlobals_h__
+
+#include "jni.h"
+#include "prclist.h"
+#include "nsError.h"
+
+#ifdef ERROR
+#undef ERROR
+#endif
+
+class nsISupports;
+class nsIDOMNode;
+struct PRLogModuleInfo;
+struct PRLock;
+
+class JavaDOMGlobals {
+
+ public:
+  static jclass attrClass;
+  static jclass cDataSectionClass;
+  static jclass commentClass;
+  static jclass documentClass;
+  static jclass documentFragmentClass;
+  static jclass documentTypeClass;
+  static jclass domImplementationClass;
+  static jclass elementClass;
+  static jclass entityClass;
+  static jclass entityReferenceClass;
+  static jclass namedNodeMapClass;
+  static jclass nodeClass;
+  static jclass nodeListClass;
+  static jclass notationClass;
+  static jclass processingInstructionClass;
+  static jclass textClass;
+
+  static jfieldID nodePtrFID;
+  static jfieldID nodeListPtrFID;
+  static jfieldID domImplementationPtrFID;
+
+  static jfieldID nodeTypeAttributeFID;
+  static jfieldID nodeTypeCDataSectionFID;
+  static jfieldID nodeTypeCommentFID;
+  static jfieldID nodeTypeDocumentFragmentFID;
+  static jfieldID nodeTypeDocumentFID;
+  static jfieldID nodeTypeDocumentTypeFID;
+  static jfieldID nodeTypeElementFID;
+  static jfieldID nodeTypeEntityFID;
+  static jfieldID nodeTypeEntityReferenceFID;
+  static jfieldID nodeTypeNotationFID;
+  static jfieldID nodeTypeProcessingInstructionFID;
+  static jfieldID nodeTypeTextFID;
+
+  static jclass domExceptionClass;
+  static jmethodID domExceptionInitMID;
+  static jclass runtimeExceptionClass;
+  static jmethodID runtimeExceptionInitMID;
+
+  static const char* const DOM_EXCEPTION_MESSAGE[];
+
+  typedef enum ExceptionType { EXCEPTION_RUNTIME, 
+			       EXCEPTION_DOM } ExceptionType;
+  
+  static PRLogModuleInfo* log;
+  static PRCList garbage;
+  static PRLock* garbageLock;
+
+  static PRInt32 javaMaxInt;
+
+  static void Initialize(JNIEnv *env);
+  static void Destroy(JNIEnv *env);
+  static jobject CreateNodeSubtype(JNIEnv *env, 
+				   nsIDOMNode *node);
+
+  static void AddToGarbage(nsISupports* domObject);
+  static void TakeOutGarbage();
+
+  static void ThrowException(JNIEnv *env,
+                             const char * message = NULL,
+                             nsresult rv = NS_OK,
+                             ExceptionType exceptionType = EXCEPTION_RUNTIME);
+};
+  
+#endif /* __JavaDOMGlobals_h__ */

mozilla/netwerk/cache/public/MANIFEST

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

mozilla/netwerk/cache/public/Makefile.in

@@ -1,56 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#
-
-DEPTH		= ../../..
-topsrcdir	= @top_srcdir@
-srcdir		= @srcdir@
-VPATH		= @srcdir@
-
-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

@@ -1,51 +0,0 @@
-#!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

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

@@ -1,121 +0,0 @@
-/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsICacheEntryDescriptor.idl, released
- * February 10, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan <gordon@netscape.com>
- *    Patrick Beard   <beard@netscape.com>
- *    Darin Fisher    <darin@netscape.com>
- */
-
-#include "nsICacheVisitor.idl"
-#include "nsICache.idl"
-
-interface nsISimpleEnumerator;
-interface nsICacheListener;
-interface nsITransport;
-interface nsIFile;
-
-[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

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

mozilla/netwerk/cache/public/nsICacheService.idl

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

mozilla/netwerk/cache/public/nsICacheSession.idl

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

@@ -1,137 +0,0 @@
-/* -*- Mode: IDL; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is 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

@@ -1,240 +0,0 @@
-/* -*- 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

@@ -1,142 +0,0 @@
-/* -*- 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

@@ -1,169 +0,0 @@
-/* -*- 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

@@ -1,131 +0,0 @@
-/* -*- 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

@@ -1,41 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the 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

@@ -1,106 +0,0 @@
-/* -*- 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

@@ -1,70 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 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

@@ -1,68 +0,0 @@
-#
-# The contents of this file are subject to the Netscape Public
-# License Version 1.1 (the "License"); you may not use this file
-# except in compliance with the License. You may obtain a copy of
-# the License at http://www.mozilla.org/NPL/
-#
-# Software distributed under the License is distributed on an "AS
-# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# rights and limitations under the License.
-#
-# The Original Code is mozilla.org code.
-#
-# The Initial Developer of the Original Code is Netscape
-# Communications Corporation.  Portions created by Netscape are
-# Copyright (C) 1998 Netscape Communications Corporation. All
-# Rights Reserved.
-#
-# Contributor(s): 
-#
-
-DEPTH = ..\..\..
-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

@@ -1,206 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsANSIFileStreams.cpp, released March 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Patrick C. Beard <beard@netscape.com>
- */
-
-#include "nsANSIFileStreams.h"
-
-NS_IMPL_ISUPPORTS2(nsANSIInputStream, nsIInputStream, nsISeekableStream);
-
-nsANSIInputStream::nsANSIInputStream(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

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

@@ -1,131 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCache.cpp, released March 18, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan  <gordon@netscape.com>
- *    Patrick C. Beard <beard@netscape.com>
- *    Darin Fisher     <darin@netscape.com>
- */
-
-#include "nsCache.h"
-#include "nsReadableUtils.h"
-
-/**
- * Cache Service Utility Functions
- */
-
-#if 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

@@ -1,53 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCache.h, released March 18, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan  <gordon@netscape.com>
- *    Patrick C. Beard <beard@netscape.com>
- *    Darin Fisher     <darin@netscape.com>
- */
-
-/**
- * Cache Service Utility Functions
- */
-
-#ifndef _nsCache_h_
-#define _nsCache_h_
-
-#include "nsAReadableString.h"
-#include "prtime.h"
-#include "nsError.h"
-
-#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

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

mozilla/netwerk/cache/src/nsCacheEntry.cpp

@@ -1,569 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheEntry.cpp, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-
-#include "nspr.h"
-#include "nsCacheEntry.h"
-#include "nsCacheEntryDescriptor.h"
-#include "nsCacheMetaData.h"
-#include "nsCacheRequest.h"
-#include "nsError.h"
-#include "nsICacheService.h"
-#include "nsCache.h"
-
-
-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

@@ -1,312 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheEntry.h, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-#ifndef _nsCacheEntry_h_
-#define _nsCacheEntry_h_
-
-#include "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

@@ -1,654 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheEntryDescriptor.cpp, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-#include "nsICache.h"
-#include "nsCache.h"
-#include "nsCacheService.h"
-#include "nsCacheEntryDescriptor.h"
-#include "nsCacheEntry.h"
-#include "nsReadableUtils.h"
-#include "nsIOutputStream.h"
-
-NS_IMPL_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

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

mozilla/netwerk/cache/src/nsCacheMetaData.cpp

@@ -1,301 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheMetaData.cpp, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-#include "nsCacheMetaData.h"
-#include "nsString.h"
-
-
-/*
- *  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

@@ -1,110 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheMetaData.h, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-#ifndef _nsCacheMetaData_h_
-#define _nsCacheMetaData_h_
-
-#include "nspr.h"
-#include "pldhash.h"
-#include "nscore.h"
-// #include "nsCOMPtr.h"
-#include "nsString.h"
-// #include "nsAReadableString.h"
-
-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

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

mozilla/netwerk/cache/src/nsCacheRequest.h

@@ -1,171 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheRequest.h, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 22-February-2001
- */
-
-#ifndef _nsCacheRequest_h_
-#define _nsCacheRequest_h_
-
-#include "nspr.h"
-#include "nsCOMPtr.h"
-#include "nsICache.h"
-#include "nsICacheListener.h"
-#include "nsIEventQueue.h"
-#include "nsCacheSession.h"
-
-
-class nsCacheRequest : public PRCList
-{
-private:
-    friend class nsCacheService;
-    friend class nsCacheEntry;
-
-    nsCacheRequest( nsCString *           key, 
-                    nsICacheListener *    listener,
-                    nsCacheAccessMode     accessRequested,
-                    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

@@ -1,181 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheService.h, released February 10, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan  <gordon@netscape.com>
- *    Patrick C. Beard <beard@netscape.com>
- *    Darin Fisher     <darin@netscape.com>
- */
-
-
-#ifndef _nsCacheService_h_
-#define _nsCacheService_h_
-
-#include "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

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

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

mozilla/netwerk/cache/src/nsDiskCache.h

@@ -1,199 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsCacheDevice.h, released March 9, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Patrick Beard   <beard@netscape.com>
- *    Gordon Sheridan <gordon@netscape.com>
- */
-
-
-#ifndef _nsDiskCache_h_
-#define _nsDiskCache_h_
-
-#include "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

@@ -1,116 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsDiskCacheDevice.h, released February 20, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan <gordon@netscape.com>
- *    Patrick C. Beard <beard@netscape.com>
- */
-
-#ifndef _nsDiskCacheDevice_h_
-#define _nsDiskCacheDevice_h_
-
-#include "nsCacheDevice.h"
-#include "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

@@ -1,213 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsMemoryCacheDevice.cpp, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    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

@@ -1,165 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsMemoryCacheDevice.cpp, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    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

@@ -1,163 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsDiskCacheMap.cpp, released March 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Patrick C. Beard <beard@netscape.com>
- */
-
-#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

@@ -1,90 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsDiskCacheMap.h, released March 23, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Patrick C. Beard <beard@netscape.com>
- */
-
-#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

@@ -1,413 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
- *
- * The contents of this file are subject to the Mozilla Public
- * License Version 1.1 (the "License"); you may not use this file
- * except in compliance with the License. You may obtain a copy of
- * the License at http://www.mozilla.org/MPL/
- * 
- * Software distributed under the License is distributed on an "AS
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
- * implied. See the License for the specific language governing
- * rights and limitations under the License.
- * 
- * The Original Code is nsMemoryCacheDevice.cpp, released February 22, 2001.
- * 
- * The Initial Developer of the Original Code is Netscape Communications
- * Corporation.  Portions created by Netscape are
- * Copyright (C) 2001 Netscape Communications Corporation.  All
- * Rights Reserved.
- * 
- * Contributor(s): 
- *    Gordon Sheridan, 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

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