diff -r 000000000000 -r 6474c204b198 xpcom/ds/nsHashtable.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/xpcom/ds/nsHashtable.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,217 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * This Original Code has been modified by IBM Corporation.
+ * Modifications made by IBM described herein are
+ * Copyright (c) International Business Machines
+ * Corporation, 2000
+ *
+ * Modifications to Mozilla code or documentation
+ * identified per MPL Section 3.3
+ *
+ * Date         Modified by     Description of modification
+ * 04/20/2000   IBM Corp.       Added PR_CALLBACK for Optlink use in OS2
+ */
+
+/**
+ * nsHashtable is OBSOLETE. Use nsTHashtable or a derivative instead.
+ */
+
+#ifndef nsHashtable_h__
+#define nsHashtable_h__
+
+#include "pldhash.h"
+#include "nscore.h"
+#include "nsISupports.h"
+#include "nsISupportsImpl.h"
+#include "nsStringFwd.h"
+
+class nsIObjectInputStream;
+class nsIObjectOutputStream;
+
+struct PRLock;
+
+class nsHashKey {
+  protected:
+    nsHashKey(void) {
+#ifdef DEBUG
+        mKeyType = UnknownKey;
+#endif
+        MOZ_COUNT_CTOR(nsHashKey);
+    }
+
+
+  public:
+    // Virtual destructor because all hash keys are |delete|d via a
+    // nsHashKey pointer.
+
+    virtual ~nsHashKey(void);
+    virtual uint32_t HashCode(void) const = 0;
+    virtual bool Equals(const nsHashKey *aKey) const = 0;
+    virtual nsHashKey *Clone() const = 0;
+    virtual nsresult Write(nsIObjectOutputStream* aStream) const;
+
+#ifdef DEBUG
+  public:
+    // used for verification that we're casting to the correct key type
+    enum nsHashKeyType {
+        UnknownKey,
+        SupportsKey,
+        PRUint32Key,
+        VoidKey,
+        IDKey,
+        CStringKey,
+        StringKey
+    };
+    nsHashKeyType GetKeyType() const { return mKeyType; }
+  protected:
+    nsHashKeyType mKeyType;
+#endif
+};
+
+// Enumerator and Read/Write callback functions.
+
+// Return values for nsHashtableEnumFunc
+enum {
+    kHashEnumerateStop      = false,
+    kHashEnumerateNext      = true
+};
+
+typedef bool
+(* nsHashtableEnumFunc)(nsHashKey *aKey, void *aData, void* aClosure);
+
+typedef nsresult
+(* nsHashtableReadEntryFunc)(nsIObjectInputStream *aStream, nsHashKey **aKey,
+                             void **aData);
+
+// NB: may be called with null aKey or aData, to free just one of the two.
+typedef void
+(* nsHashtableFreeEntryFunc)(nsIObjectInputStream *aStream, nsHashKey *aKey,
+                             void *aData);
+
+typedef nsresult
+(* nsHashtableWriteDataFunc)(nsIObjectOutputStream *aStream, void *aData);
+
+class nsHashtable {
+  protected:
+    // members
+    PRLock*         mLock;
+    PLDHashTable    mHashtable;
+    bool            mEnumerating;
+
+  public:
+    nsHashtable(uint32_t aSize = 16, bool aThreadSafe = false);
+    virtual ~nsHashtable();
+
+    int32_t Count(void) { return mHashtable.entryCount; }
+    bool Exists(nsHashKey *aKey);
+    void *Put(nsHashKey *aKey, void *aData);
+    void *Get(nsHashKey *aKey);
+    void *Remove(nsHashKey *aKey);
+    nsHashtable *Clone();
+    void Enumerate(nsHashtableEnumFunc aEnumFunc, void* aClosure = nullptr);
+    void Reset();
+    void Reset(nsHashtableEnumFunc destroyFunc, void* aClosure = nullptr);
+
+    nsHashtable(nsIObjectInputStream* aStream,
+                nsHashtableReadEntryFunc aReadEntryFunc,
+                nsHashtableFreeEntryFunc aFreeEntryFunc,
+                nsresult *aRetVal);
+    nsresult Write(nsIObjectOutputStream* aStream,
+                   nsHashtableWriteDataFunc aWriteDataFunc) const;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// nsObjectHashtable: an nsHashtable where the elements are C++ objects to be
+// deleted
+
+typedef void* (* nsHashtableCloneElementFunc)(nsHashKey *aKey, void *aData, void* aClosure);
+
+class nsObjectHashtable : public nsHashtable {
+  public:
+    nsObjectHashtable(nsHashtableCloneElementFunc cloneElementFun,
+                      void* cloneElementClosure,
+                      nsHashtableEnumFunc destroyElementFun,
+                      void* destroyElementClosure,
+                      uint32_t aSize = 16, bool threadSafe = false);
+    ~nsObjectHashtable();
+
+    nsHashtable *Clone();
+    void Reset();
+    bool RemoveAndDelete(nsHashKey *aKey);
+
+  protected:
+    static PLDHashOperator CopyElement(PLDHashTable* table,
+                                       PLDHashEntryHdr* hdr,
+                                       uint32_t i, void *arg);
+
+    nsHashtableCloneElementFunc mCloneElementFun;
+    void*                       mCloneElementClosure;
+    nsHashtableEnumFunc         mDestroyElementFun;
+    void*                       mDestroyElementClosure;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+class nsPRUint32Key : public nsHashKey {
+protected:
+    uint32_t mKey;
+public:
+    nsPRUint32Key(uint32_t key) {
+#ifdef DEBUG
+        mKeyType = PRUint32Key;
+#endif
+        mKey = key;
+    }
+
+    uint32_t HashCode(void) const {
+        return mKey;
+    }
+
+    bool Equals(const nsHashKey *aKey) const {
+        return mKey == ((const nsPRUint32Key *) aKey)->mKey;
+    }
+    nsHashKey *Clone() const {
+        return new nsPRUint32Key(mKey);
+    }
+    uint32_t GetValue() { return mKey; }
+};
+
+// for null-terminated c-strings
+class nsCStringKey : public nsHashKey {
+  public:
+
+    // NB: when serializing, NEVER_OWN keys are deserialized as OWN.
+    enum Ownership {
+        NEVER_OWN,  // very long lived, even clones don't need to copy it.
+        OWN_CLONE,  // as long lived as this key. But clones make a copy.
+        OWN         // to be free'd in key dtor. Clones make their own copy.
+    };
+
+    nsCStringKey(const nsCStringKey& aStrKey);
+    nsCStringKey(const char* str, int32_t strLen = -1, Ownership own = OWN_CLONE);
+    nsCStringKey(const nsAFlatCString& str);
+    nsCStringKey(const nsACString& str);
+    ~nsCStringKey(void);
+
+    uint32_t HashCode(void) const;
+    bool Equals(const nsHashKey* aKey) const;
+    nsHashKey* Clone() const;
+    nsCStringKey(nsIObjectInputStream* aStream, nsresult *aResult);
+    nsresult Write(nsIObjectOutputStream* aStream) const;
+
+    // For when the owner of the hashtable wants to peek at the actual
+    // string in the key. No copy is made, so be careful.
+    const char* GetString() const { return mStr; }
+    uint32_t GetStringLength() const { return mStrLen; }
+
+  protected:
+    char*       mStr;
+    uint32_t    mStrLen;
+    Ownership   mOwnership;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+#endif // nsHashtable_h__