diff -r 000000000000 -r 6474c204b198 mfbt/WeakPtr.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mfbt/WeakPtr.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,200 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+/* Weak pointer functionality, implemented as a mixin for use with any class. */
+
+/**
+ * SupportsWeakPtr lets you have a pointer to an object 'Foo' without affecting
+ * its lifetime. It works by creating a single shared reference counted object
+ * (WeakReference) that each WeakPtr will access 'Foo' through. This lets 'Foo'
+ * clear the pointer in the WeakReference without having to know about all of
+ * the WeakPtrs to it and allows the WeakReference to live beyond the lifetime
+ * of 'Foo'.
+ *
+ * PLEASE NOTE: This weak pointer implementation is not thread-safe.
+ *
+ * Note that when deriving from SupportsWeakPtr you should add
+ * MOZ_DECLARE_REFCOUNTED_TYPENAME(ClassName) to the public section of your
+ * class, where ClassName is the name of your class.
+ *
+ * The overhead of WeakPtr is that accesses to 'Foo' becomes an additional
+ * dereference, and an additional heap allocated pointer sized object shared
+ * between all of the WeakPtrs.
+ *
+ * Example of usage:
+ *
+ *   // To have a class C support weak pointers, inherit from SupportsWeakPtr<C>.
+ *   class C : public SupportsWeakPtr<C>
+ *   {
+ *    public:
+ *      MOZ_DECLARE_REFCOUNTED_TYPENAME(C)
+ *      int num;
+ *      void act();
+ *   };
+ *
+ *   C* ptr =  new C();
+ *
+ *   // Get weak pointers to ptr. The first time asWeakPtr is called
+ *   // a reference counted WeakReference object is created that
+ *   // can live beyond the lifetime of 'ptr'. The WeakReference
+ *   // object will be notified of 'ptr's destruction.
+ *   WeakPtr<C> weak = ptr->asWeakPtr();
+ *   WeakPtr<C> other = ptr->asWeakPtr();
+ *
+ *   // Test a weak pointer for validity before using it.
+ *   if (weak) {
+ *     weak->num = 17;
+ *     weak->act();
+ *   }
+ *
+ *   // Destroying the underlying object clears weak pointers to it.
+ *   delete ptr;
+ *
+ *   MOZ_ASSERT(!weak, "Deleting |ptr| clears weak pointers to it.");
+ *   MOZ_ASSERT(!other, "Deleting |ptr| clears all weak pointers to it.");
+ *
+ * WeakPtr is typesafe and may be used with any class. It is not required that
+ * the class be reference-counted or allocated in any particular way.
+ *
+ * The API was loosely inspired by Chromium's weak_ptr.h:
+ * http://src.chromium.org/svn/trunk/src/base/memory/weak_ptr.h
+ */
+
+#ifndef mozilla_WeakPtr_h
+#define mozilla_WeakPtr_h
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/NullPtr.h"
+#include "mozilla/RefPtr.h"
+#include "mozilla/TypeTraits.h"
+
+#include <string.h>
+
+namespace mozilla {
+
+template <typename T, class WeakReference> class WeakPtrBase;
+template <typename T, class WeakReference> class SupportsWeakPtrBase;
+
+namespace detail {
+
+// This can live beyond the lifetime of the class derived from SupportsWeakPtrBase.
+template<class T>
+class WeakReference : public ::mozilla::RefCounted<WeakReference<T> >
+{
+  public:
+    explicit WeakReference(T* p) : ptr(p) {}
+    T* get() const {
+      return ptr;
+    }
+
+#ifdef MOZ_REFCOUNTED_LEAK_CHECKING
+#ifdef XP_WIN
+#define snprintf _snprintf
+#endif
+    const char* typeName() const {
+      static char nameBuffer[1024];
+      const char* innerType = ptr->typeName();
+      // We could do fancier length checks at runtime, but innerType is
+      // controlled by us so we can ensure that this never causes a buffer
+      // overflow by this assertion.
+      MOZ_ASSERT(strlen(innerType) + sizeof("WeakReference<>") < ArrayLength(nameBuffer),
+                 "Exceedingly large type name");
+      snprintf(nameBuffer, ArrayLength(nameBuffer), "WeakReference<%s>", innerType);
+      // This is usually not OK, but here we are returning a pointer to a static
+      // buffer which will immediately be used by the caller.
+      return nameBuffer;
+    }
+    size_t typeSize() const {
+      return sizeof(*this);
+    }
+#undef snprintf
+#endif
+
+  private:
+    friend class WeakPtrBase<T, WeakReference<T> >;
+    friend class SupportsWeakPtrBase<T, WeakReference<T> >;
+    void detach() {
+      ptr = nullptr;
+    }
+    T* ptr;
+};
+
+} // namespace detail
+
+template <typename T, class WeakReference>
+class SupportsWeakPtrBase
+{
+  public:
+    WeakPtrBase<T, WeakReference> asWeakPtr() {
+      if (!weakRef)
+        weakRef = new WeakReference(static_cast<T*>(this));
+      return WeakPtrBase<T, WeakReference>(weakRef);
+    }
+
+  protected:
+    ~SupportsWeakPtrBase() {
+      static_assert(IsBaseOf<SupportsWeakPtrBase<T, WeakReference>, T>::value,
+                    "T must derive from SupportsWeakPtrBase<T, WeakReference>");
+      if (weakRef)
+        weakRef->detach();
+    }
+
+  private:
+    friend class WeakPtrBase<T, WeakReference>;
+
+    RefPtr<WeakReference> weakRef;
+};
+
+template <typename T>
+class SupportsWeakPtr : public SupportsWeakPtrBase<T, detail::WeakReference<T> >
+{
+};
+
+template <typename T, class WeakReference>
+class WeakPtrBase
+{
+  public:
+    WeakPtrBase(const WeakPtrBase<T, WeakReference>& o) : ref(o.ref) {}
+    // Ensure that ref is dereferenceable in the uninitialized state
+    WeakPtrBase() : ref(new WeakReference(nullptr)) {}
+
+    operator T*() const {
+      return ref->get();
+    }
+    T& operator*() const {
+      return *ref->get();
+    }
+
+    T* operator->() const {
+      return ref->get();
+    }
+
+    T* get() const {
+      return ref->get();
+    }
+
+  private:
+    friend class SupportsWeakPtrBase<T, WeakReference>;
+
+    explicit WeakPtrBase(const RefPtr<WeakReference> &o) : ref(o) {}
+
+    RefPtr<WeakReference> ref;
+};
+
+template <typename T>
+class WeakPtr : public WeakPtrBase<T, detail::WeakReference<T> >
+{
+    typedef WeakPtrBase<T, detail::WeakReference<T> > Base;
+  public:
+    WeakPtr(const WeakPtr<T>& o) : Base(o) {}
+    WeakPtr(const Base& o) : Base(o) {}
+    WeakPtr() {}
+};
+
+} // namespace mozilla
+
+#endif /* mozilla_WeakPtr_h */