Bug 953296 - Implement mozilla::UniquePtr. r=jcranmer
authorJeff Walden <jwalden@mit.edu>
Mon, 30 Dec 2013 13:34:15 -0600
changeset 213750 93e619d0d2a433d0376120d17cd545b9818fea61
parent 213749 12d48efc89eb9dbf4e5dffb5053f8d21ae3285a1
child 213751 a5045c3bc58159eb86108e10c796dee69947ad47
push id3857
push userraliiev@mozilla.com
push dateTue, 02 Sep 2014 16:39:23 +0000
treeherdermozilla-beta@5638b907b505 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjcranmer
bugs953296
milestone33.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 953296 - Implement mozilla::UniquePtr. r=jcranmer
mfbt/UniquePtr.h
mfbt/moz.build
mfbt/tests/TestUniquePtr.cpp
mfbt/tests/moz.build
new file mode 100644
--- /dev/null
+++ b/mfbt/UniquePtr.h
@@ -0,0 +1,574 @@
+/* -*- 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/. */
+
+/* Smart pointer managing sole ownership of a resource. */
+
+#ifndef mozilla_UniquePtr_h
+#define mozilla_UniquePtr_h
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Attributes.h"
+#include "mozilla/Compiler.h"
+#include "mozilla/Move.h"
+#include "mozilla/NullPtr.h"
+#include "mozilla/Pair.h"
+#include "mozilla/TypeTraits.h"
+
+namespace mozilla {
+
+template<typename T> class DefaultDelete;
+template<typename T, class D = DefaultDelete<T>> class UniquePtr;
+
+} // namespace mozilla
+
+namespace mozilla {
+
+/**
+ * UniquePtr is a smart pointer that wholly owns a resource.  Ownership may be
+ * transferred out of a UniquePtr through explicit action, but otherwise the
+ * resource is destroyed when the UniquePtr is destroyed.
+ *
+ * UniquePtr is similar to C++98's std::auto_ptr, but it improves upon auto_ptr
+ * in one crucial way: it's impossible to copy a UniquePtr.  Copying an auto_ptr
+ * obviously *can't* copy ownership of its singly-owned resource.  So what
+ * happens if you try to copy one?  Bizarrely, ownership is implicitly
+ * *transferred*, preserving single ownership but breaking code that assumes a
+ * copy of an object is identical to the original.  (This is why auto_ptr is
+ * prohibited in STL containers.)
+ *
+ * UniquePtr solves this problem by being *movable* rather than copyable.
+ * Instead of passing a |UniquePtr u| directly to the constructor or assignment
+ * operator, you pass |Move(u)|.  In doing so you indicate that you're *moving*
+ * ownership out of |u|, into the target of the construction/assignment.  After
+ * the transfer completes, |u| contains |nullptr| and may be safely destroyed.
+ * This preserves single ownership but also allows UniquePtr to be moved by
+ * algorithms that have been made move-safe.  (Note: if |u| is instead a
+ * temporary expression, don't use |Move()|: just pass the expression, because
+ * it's already move-ready.  For more information see Move.h.)
+ *
+ * UniquePtr is also better than std::auto_ptr in that the deletion operation is
+ * customizable.  An optional second template parameter specifies a class that
+ * (through its operator()(T*)) implements the desired deletion policy.  If no
+ * policy is specified, mozilla::DefaultDelete<T> is used -- which will either
+ * |delete| or |delete[]| the resource, depending whether the resource is an
+ * array.  Custom deletion policies ideally should be empty classes (no member
+ * fields, no member fields in base classes, no virtual methods/inheritance),
+ * because then UniquePtr can be just as efficient as a raw pointer.
+ *
+ * Use of UniquePtr proceeds like so:
+ *
+ *   UniquePtr<int> g1; // initializes to nullptr
+ *   g1.reset(new int); // switch resources using reset()
+ *   g1 = nullptr; // clears g1, deletes the int
+ *
+ *   UniquePtr<int> g2(new int); // owns that int
+ *   int* p = g2.release(); // g2 leaks its int -- still requires deletion
+ *   delete p; // now freed
+ *
+ *   struct S { int x; S(int x) : x(x) {} };
+ *   UniquePtr<S> g3, g4(new S(5));
+ *   g3 = Move(g4); // g3 owns the S, g4 cleared
+ *   S* p = g3.get(); // g3 still owns |p|
+ *   assert(g3->x == 5); // operator-> works (if .get() != nullptr)
+ *   assert((*g3).x == 5); // also operator* (again, if not cleared)
+ *   Swap(g3, g4); // g4 now owns the S, g3 cleared
+ *   g3.swap(g4);  // g3 now owns the S, g4 cleared
+ *   UniquePtr<S> g5(Move(g3)); // g5 owns the S, g3 cleared
+ *   g5.reset(); // deletes the S, g5 cleared
+ *
+ *   struct FreePolicy { void operator()(void* p) { free(p); } };
+ *   UniquePtr<int, FreePolicy> g6(static_cast<int*>(malloc(sizeof(int))));
+ *   int* ptr = g6.get();
+ *   g6 = nullptr; // calls free(ptr)
+ *
+ * Now, carefully note a few things you *can't* do:
+ *
+ *   UniquePtr<int> b1;
+ *   b1 = new int; // BAD: can only assign another UniquePtr
+ *   int* ptr = b1; // BAD: no auto-conversion to pointer, use get()
+ *
+ *   UniquePtr<int> b2(b1); // BAD: can't copy a UniquePtr
+ *   UniquePtr<int> b3 = b1; // BAD: can't copy-assign a UniquePtr
+ *
+ * A few miscellaneous notes:
+ *
+ * UniquePtr, when not instantiated for an array type, can be move-constructed
+ * and move-assigned, not only from itself but from "derived" UniquePtr<U, E>
+ * instantiations where U converts to T and E converts to D.  If you want to use
+ * this, you're going to have to specify a deletion policy for both UniquePtr
+ * instantations, and T pretty much has to have a virtual destructor.  In other
+ * words, this doesn't work:
+ *
+ *   struct Base { virtual ~Base() {} };
+ *   struct Derived : Base {};
+ *
+ *   UniquePtr<Base> b1;
+ *   // BAD: DefaultDelete<Base> and DefaultDelete<Derived> don't interconvert
+ *   UniquePtr<Derived> d1(Move(b));
+ *
+ *   UniquePtr<Base> b2;
+ *   UniquePtr<Derived, DefaultDelete<Base>> d2(Move(b2)); // okay
+ *
+ * UniquePtr is specialized for array types.  Specializing with an array type
+ * creates a smart-pointer version of that array -- not a pointer to such an
+ * array.
+ *
+ *   UniquePtr<int[]> arr(new int[5]);
+ *   arr[0] = 4;
+ *
+ * What else is different?  Deletion of course uses |delete[]|.  An operator[]
+ * is provided.  Functionality that doesn't make sense for arrays is removed.
+ * The constructors and mutating methods only accept array pointers (not T*, U*
+ * that converts to T*, or UniquePtr<U[]> or UniquePtr<U>) or |nullptr|.
+ *
+ * It's perfectly okay to return a UniquePtr from a method to assure the related
+ * resource is properly deleted.  You'll need to use |Move()| when returning a
+ * local UniquePtr.  Otherwise you can return |nullptr|, or you can return
+ * |UniquePtr(ptr)|.
+ *
+ * UniquePtr will commonly be a member of a class, with lifetime equivalent to
+ * that of that class.  If you want to expose the related resource, you could
+ * expose a raw pointer via |get()|, but ownership of a raw pointer is
+ * inherently unclear.  So it's better to expose a |const UniquePtr&| instead.
+ * This prohibits mutation but still allows use of |get()| when needed (but
+ * operator-> is preferred).  Of course, you can only use this smart pointer as
+ * long as the enclosing class instance remains live -- no different than if you
+ * exposed the |get()| raw pointer.
+ *
+ * To pass a UniquePtr-managed resource as a pointer, use a |const UniquePtr&|
+ * argument.  To specify an inout parameter (where the method may or may not
+ * take ownership of the resource, or reset it), or to specify an out parameter
+ * (where simply returning a |UniquePtr| isn't possible), use a |UniquePtr&|
+ * argument.  To unconditionally transfer ownership of a UniquePtr
+ * into a method, use a |UniquePtr| argument.  To conditionally transfer
+ * ownership of a resource into a method, should the method want it, use a
+ * |UniquePtr&&| argument.
+ */
+template<typename T, class D>
+class UniquePtr
+{
+  public:
+    typedef T* Pointer;
+    typedef T ElementType;
+    typedef D DeleterType;
+
+  private:
+    Pair<Pointer, DeleterType> tuple;
+
+    Pointer& ptr() { return tuple.first(); }
+    const Pointer& ptr() const { return tuple.first(); }
+
+    DeleterType& del() { return tuple.second(); }
+    const DeleterType& del() const { return tuple.second(); }
+
+  public:
+    /**
+     * Construct a UniquePtr containing |nullptr|.
+     */
+    MOZ_CONSTEXPR UniquePtr()
+      : tuple(static_cast<Pointer>(nullptr), DeleterType())
+    {
+      static_assert(!IsPointer<D>::value, "must provide a deleter instance");
+      static_assert(!IsReference<D>::value, "must provide a deleter instance");
+    }
+
+    /**
+     * Construct a UniquePtr containing |p|.
+     */
+    explicit UniquePtr(Pointer p)
+      : tuple(p, DeleterType())
+    {
+      static_assert(!IsPointer<D>::value, "must provide a deleter instance");
+      static_assert(!IsReference<D>::value, "must provide a deleter instance");
+    }
+
+    UniquePtr(Pointer p,
+              typename Conditional<IsReference<D>::value,
+                                   D,
+                                   const D&>::Type d1)
+      : tuple(p, d1)
+    {}
+
+    // If you encounter an error with MSVC10 about RemoveReference below, along
+    // the lines that "more than one partial specialization matches the template
+    // argument list": don't use UniquePtr<T, reference to function>!  Ideally
+    // you should make deletion use the same function every time, using a
+    // deleter policy:
+    //
+    //   // BAD, won't compile with MSVC10, deleter doesn't need to be a
+    //   // variable at all
+    //   typedef void (&FreeSignature)(void*);
+    //   UniquePtr<int, FreeSignature> ptr((int*) malloc(sizeof(int)), free);
+    //
+    //   // GOOD, compiles with MSVC10, deletion behavior statically known and
+    //   // optimizable
+    //   struct DeleteByFreeing
+    //   {
+    //     void operator()(void* ptr) { free(ptr); }
+    //   };
+    //
+    // If deletion really, truly, must be a variable: you might be able to work
+    // around this with a deleter class that contains the function reference.
+    // But this workaround is untried and untested, because variable deletion
+    // behavior really isn't something you should use.
+    UniquePtr(Pointer p,
+              typename RemoveReference<D>::Type&& d2)
+      : tuple(p, Move(d2))
+    {
+      static_assert(!IsReference<D>::value,
+                    "rvalue deleter can't be stored by reference");
+    }
+
+    UniquePtr(UniquePtr&& other)
+      : tuple(other.release(), Forward<DeleterType>(other.getDeleter()))
+    {}
+
+    template<typename N>
+    UniquePtr(N,
+              typename EnableIf<IsNullPointer<N>::value, int>::Type dummy = 0)
+      : tuple(static_cast<Pointer>(nullptr), DeleterType())
+    {
+      static_assert(!IsPointer<D>::value, "must provide a deleter instance");
+      static_assert(!IsReference<D>::value, "must provide a deleter instance");
+    }
+
+    template<typename U, class E>
+    UniquePtr(UniquePtr<U, E>&& other,
+              typename EnableIf<IsConvertible<typename UniquePtr<U, E>::Pointer,
+                                              Pointer>::value &&
+                                !IsArray<U>::value &&
+                                (IsReference<D>::value
+                                 ? IsSame<D, E>::value
+                                 : IsConvertible<E, D>::value),
+                                int>::Type dummy = 0)
+      : tuple(other.release(), Forward<E>(other.getDeleter()))
+    {
+    }
+
+    ~UniquePtr() {
+      reset(nullptr);
+    }
+
+    UniquePtr& operator=(UniquePtr&& other) {
+      reset(other.release());
+      getDeleter() = Forward<DeleterType>(other.getDeleter());
+      return *this;
+    }
+
+    template<typename U, typename E>
+    UniquePtr& operator=(UniquePtr<U, E>&& other)
+    {
+      static_assert(IsConvertible<typename UniquePtr<U, E>::Pointer, Pointer>::value,
+                    "incompatible UniquePtr pointees");
+      static_assert(!IsArray<U>::value,
+                    "can't assign from UniquePtr holding an array");
+
+      reset(other.release());
+      getDeleter() = Forward<E>(other.getDeleter());
+      return *this;
+    }
+
+    UniquePtr& operator=(NullptrT n) {
+      MOZ_ASSERT(n == nullptr);
+      reset(nullptr);
+      return *this;
+    }
+
+    T& operator*() const { return *get(); }
+    Pointer operator->() const {
+      MOZ_ASSERT(get(), "dereferencing a UniquePtr containing nullptr");
+      return get();
+    }
+
+    Pointer get() const { return ptr(); }
+
+    DeleterType& getDeleter() { return del(); }
+    const DeleterType& getDeleter() const { return del(); }
+
+  private:
+    typedef void (UniquePtr::* ConvertibleToBool)(double, char);
+    void nonNull(double, char) {}
+
+  public:
+    operator ConvertibleToBool() const {
+      return get() != nullptr ? &UniquePtr::nonNull : nullptr;
+    }
+
+    Pointer release() {
+      Pointer p = ptr();
+      ptr() = nullptr;
+      return p;
+    }
+
+    void reset(Pointer p = Pointer()) {
+      Pointer old = ptr();
+      ptr() = p;
+      if (old != nullptr)
+        getDeleter()(old);
+    }
+
+    void swap(UniquePtr& other) {
+      tuple.swap(other.tuple);
+    }
+
+  private:
+    UniquePtr(const UniquePtr& other) MOZ_DELETE; // construct using Move()!
+    void operator=(const UniquePtr& other) MOZ_DELETE; // assign using Move()!
+};
+
+// In case you didn't read the comment by the main definition (you should!): the
+// UniquePtr<T[]> specialization exists to manage array pointers.  It deletes
+// such pointers using delete[], it will reject construction and modification
+// attempts using U* or U[].  Otherwise it works like the normal UniquePtr.
+template<typename T, class D>
+class UniquePtr<T[], D>
+{
+  public:
+    typedef T* Pointer;
+    typedef T ElementType;
+    typedef D DeleterType;
+
+  private:
+    Pair<Pointer, DeleterType> tuple;
+
+  public:
+    /**
+     * Construct a UniquePtr containing nullptr.
+     */
+    MOZ_CONSTEXPR UniquePtr()
+      : tuple(static_cast<Pointer>(nullptr), DeleterType())
+    {
+      static_assert(!IsPointer<D>::value, "must provide a deleter instance");
+      static_assert(!IsReference<D>::value, "must provide a deleter instance");
+    }
+
+    /**
+     * Construct a UniquePtr containing |p|.
+     */
+    explicit UniquePtr(Pointer p)
+      : tuple(p, DeleterType())
+    {
+      static_assert(!IsPointer<D>::value, "must provide a deleter instance");
+      static_assert(!IsReference<D>::value, "must provide a deleter instance");
+    }
+
+  private:
+    // delete[] knows how to handle *only* an array of a single class type.  For
+    // delete[] to work correctly, it must know the size of each element, the
+    // fields and base classes of each element requiring destruction, and so on.
+    // So forbid all overloads which would end up invoking delete[] on a pointer
+    // of the wrong type.
+    template<typename U>
+    UniquePtr(U&& u,
+              typename EnableIf<IsPointer<U>::value &&
+                                IsConvertible<U, Pointer>::value,
+                                int>::Type dummy = 0)
+    MOZ_DELETE;
+
+  public:
+    UniquePtr(Pointer p,
+              typename Conditional<IsReference<D>::value,
+                                   D,
+                                   const D&>::Type d1)
+      : tuple(p, d1)
+    {}
+
+    // If you encounter an error with MSVC10 about RemoveReference below, along
+    // the lines that "more than one partial specialization matches the template
+    // argument list": don't use UniquePtr<T[], reference to function>!  See the
+    // comment by this constructor in the non-T[] specialization above.
+    UniquePtr(Pointer p,
+              typename RemoveReference<D>::Type&& d2)
+      : tuple(p, Move(d2))
+    {
+      static_assert(!IsReference<D>::value,
+                    "rvalue deleter can't be stored by reference");
+    }
+
+  private:
+    // Forbidden for the same reasons as stated above.
+    template<typename U, typename V>
+    UniquePtr(U&& u, V&& v,
+              typename EnableIf<IsPointer<U>::value &&
+                                IsConvertible<U, Pointer>::value,
+                                int>::Type dummy = 0)
+    MOZ_DELETE;
+
+  public:
+    UniquePtr(UniquePtr&& other)
+      : tuple(other.release(), Forward<DeleterType>(other.getDeleter()))
+    {}
+
+    template<typename N>
+    UniquePtr(N,
+              typename EnableIf<IsNullPointer<N>::value, int>::Type dummy = 0)
+      : tuple(static_cast<Pointer>(nullptr), DeleterType())
+    {
+      static_assert(!IsPointer<D>::value, "must provide a deleter instance");
+      static_assert(!IsReference<D>::value, "must provide a deleter instance");
+    }
+
+    ~UniquePtr() {
+      reset(nullptr);
+    }
+
+    UniquePtr& operator=(UniquePtr&& other) {
+      reset(other.release());
+      getDeleter() = Forward<DeleterType>(other.getDeleter());
+      return *this;
+    }
+
+    UniquePtr& operator=(NullptrT) {
+      reset();
+      return *this;
+    }
+
+    T& operator[](decltype(sizeof(int)) i) const { return get()[i]; }
+    Pointer get() const { return tuple.first(); }
+
+    DeleterType& getDeleter() { return tuple.second(); }
+    const DeleterType& getDeleter() const { return tuple.second(); }
+
+  private:
+    typedef void (UniquePtr::* ConvertibleToBool)(double, char);
+    void nonNull(double, char) {}
+
+  public:
+    operator ConvertibleToBool() const {
+      return get() != nullptr ? &UniquePtr::nonNull : nullptr;
+    }
+
+    Pointer release() {
+      Pointer p = tuple.first();
+      tuple.first() = nullptr;
+      return p;
+    }
+
+    void reset(Pointer p = Pointer()) {
+      Pointer old = tuple.first();
+      tuple.first() = p;
+      if (old != nullptr)
+        tuple.second()(old);
+    }
+
+  private:
+    // Kill off all remaining overloads that aren't true nullptr (the overload
+    // above should handle that) or emulated nullptr (which acts like int/long
+    // on gcc 4.4/4.5).
+    template<typename U>
+    void reset(U,
+               typename EnableIf<!IsNullPointer<U>::value &&
+                                 !IsSame<U,
+                                         Conditional<(sizeof(int) == sizeof(void*)),
+                                                     int,
+                                                     long>::Type>::value,
+                                 int>::Type dummy = 0)
+    MOZ_DELETE;
+
+  public:
+    void swap(UniquePtr& other) {
+      tuple.swap(other.tuple);
+    }
+
+  private:
+    UniquePtr(const UniquePtr& other) MOZ_DELETE; // construct using Move()!
+    void operator=(const UniquePtr& other) MOZ_DELETE; // assign using Move()!
+};
+
+/** A default deletion policy using plain old operator delete. */
+template<typename T>
+class DefaultDelete
+{
+  public:
+    MOZ_CONSTEXPR DefaultDelete() {}
+
+    template<typename U>
+    DefaultDelete(const DefaultDelete<U>& other,
+                  typename EnableIf<mozilla::IsConvertible<U*, T*>::value,
+                                    int>::Type dummy = 0)
+    {}
+
+    void operator()(T* ptr) const {
+      static_assert(sizeof(T) > 0, "T must be complete");
+      delete ptr;
+    }
+};
+
+/** A default deletion policy using operator delete[]. */
+template<typename T>
+class DefaultDelete<T[]>
+{
+  public:
+    MOZ_CONSTEXPR DefaultDelete() {}
+
+    void operator()(T* ptr) const {
+      static_assert(sizeof(T) > 0, "T must be complete");
+      delete[] ptr;
+    }
+
+  private:
+    template<typename U>
+    void operator()(U* ptr) const MOZ_DELETE;
+};
+
+template<typename T, class D>
+void
+Swap(UniquePtr<T, D>& x, UniquePtr<T, D>& y)
+{
+  x.swap(y);
+}
+
+template<typename T, class D, typename U, class E>
+bool
+operator==(const UniquePtr<T, D>& x, const UniquePtr<U, E>& y)
+{
+  return x.get() == y.get();
+}
+
+template<typename T, class D, typename U, class E>
+bool
+operator!=(const UniquePtr<T, D>& x, const UniquePtr<U, E>& y)
+{
+  return x.get() != y.get();
+}
+
+template<typename T, class D>
+bool
+operator==(const UniquePtr<T, D>& x, NullptrT n)
+{
+  MOZ_ASSERT(n == nullptr);
+  return !x;
+}
+
+template<typename T, class D>
+bool
+operator==(NullptrT n, const UniquePtr<T, D>& x)
+{
+  MOZ_ASSERT(n == nullptr);
+  return !x;
+}
+
+template<typename T, class D>
+bool
+operator!=(const UniquePtr<T, D>& x, NullptrT n)
+{
+  MOZ_ASSERT(n == nullptr);
+  return bool(x);
+}
+
+template<typename T, class D>
+bool
+operator!=(NullptrT n, const UniquePtr<T, D>& x)
+{
+  MOZ_ASSERT(n == nullptr);
+  return bool(x);
+}
+
+// No operator<, operator>, operator<=, operator>= for now because simplicity.
+
+} // namespace mozilla
+
+#endif /* mozilla_UniquePtr_h */
--- a/mfbt/moz.build
+++ b/mfbt/moz.build
@@ -64,16 +64,17 @@ EXPORTS.mozilla = [
     'TemplateLib.h',
     'ThreadLocal.h',
     'ToString.h',
     'TypedEnum.h',
     'TypedEnumBits.h',
     'TypedEnumInternal.h',
     'Types.h',
     'TypeTraits.h',
+    'UniquePtr.h',
     'Vector.h',
     'WeakPtr.h',
 ]
 
 if CONFIG['OS_ARCH'] == 'WINNT':
     EXPORTS.mozilla += [
         'WindowsVersion.h',
     ]
new file mode 100644
--- /dev/null
+++ b/mfbt/tests/TestUniquePtr.cpp
@@ -0,0 +1,561 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#include "mozilla/Assertions.h"
+#include "mozilla/Compiler.h"
+#include "mozilla/Move.h"
+#include "mozilla/NullPtr.h"
+#include "mozilla/TypeTraits.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Vector.h"
+
+#include <stddef.h>
+
+using mozilla::DefaultDelete;
+using mozilla::IsNullPointer;
+using mozilla::IsSame;
+using mozilla::Swap;
+using mozilla::UniquePtr;
+using mozilla::Vector;
+
+#define CHECK(c) \
+  do { \
+    bool cond = (c); \
+    MOZ_ASSERT(cond, "Failed assertion: " #c); \
+    if (!cond) \
+      return false; \
+  } while (false)
+
+typedef UniquePtr<int> NewInt;
+static_assert(sizeof(NewInt) == sizeof(int*),
+              "stored most efficiently");
+
+static size_t ADestructorCalls = 0;
+
+struct A
+{
+  public:
+    A() : x(0) {}
+    virtual ~A() {
+      ADestructorCalls++;
+    }
+
+    int x;
+};
+
+static size_t BDestructorCalls = 0;
+
+struct B : public A
+{
+  public:
+    B() : y(1) {}
+    ~B() {
+      BDestructorCalls++;
+    }
+
+    int y;
+};
+
+typedef UniquePtr<A> UniqueA;
+typedef UniquePtr<B, UniqueA::DeleterType> UniqueB; // permit interconversion
+
+static_assert(sizeof(UniqueA) == sizeof(A*),
+              "stored most efficiently");
+static_assert(sizeof(UniqueB) == sizeof(B*),
+              "stored most efficiently");
+
+struct DeleterSubclass : UniqueA::DeleterType {};
+
+typedef UniquePtr<B, DeleterSubclass> UniqueC;
+static_assert(sizeof(UniqueC) == sizeof(B*),
+              "stored most efficiently");
+
+static UniqueA
+ReturnUniqueA()
+{
+  return UniqueA(new B);
+}
+
+static UniqueA
+ReturnLocalA()
+{
+  UniqueA a(new A);
+  return Move(a);
+}
+
+static bool
+TestDefaultFreeGuts()
+{
+  static_assert(IsSame<NewInt::DeleterType, DefaultDelete<int> >::value,
+                "weird deleter?");
+
+  NewInt n1(new int);
+  CHECK(n1);
+  CHECK(n1.get() != nullptr);
+
+  n1 = nullptr;
+  CHECK(!n1);
+  CHECK(n1.get() == nullptr);
+
+  int* p1 = new int;
+  n1.reset(p1);
+  CHECK(n1);
+  NewInt n2(Move(n1));
+  CHECK(!n1);
+  CHECK(n1.get() == nullptr);
+  CHECK(n2.get() == p1);
+
+  Swap(n1, n2);
+  CHECK(n1.get() == p1);
+  CHECK(n2.get() == nullptr);
+
+  n1.swap(n2);
+  CHECK(n1.get() == nullptr);
+  CHECK(n2.get() == p1);
+  delete n2.release();
+
+  CHECK(n1.get() == nullptr);
+  CHECK(n2 == nullptr);
+  CHECK(nullptr == n2);
+
+  int* p2 = new int;
+  int* p3 = new int;
+  n1.reset(p2);
+  n2.reset(p3);
+  CHECK(n1.get() == p2);
+  CHECK(n2.get() == p3);
+
+  n1.swap(n2);
+  CHECK(n2 != nullptr);
+  CHECK(nullptr != n2);
+  CHECK(n2.get() == p2);
+  CHECK(n1.get() == p3);
+
+  UniqueA a1;
+  CHECK(a1 == nullptr);
+  a1.reset(new A);
+  CHECK(ADestructorCalls == 0);
+  CHECK(a1->x == 0);
+
+  B* bp1 = new B;
+  bp1->x = 5;
+  CHECK(BDestructorCalls == 0);
+  a1.reset(bp1);
+  CHECK(ADestructorCalls == 1);
+  CHECK(a1->x == 5);
+  a1.reset(nullptr);
+  CHECK(ADestructorCalls == 2);
+  CHECK(BDestructorCalls == 1);
+
+  B* bp2 = new B;
+  UniqueB b1(bp2);
+  UniqueA a2(nullptr);
+  a2 = Move(b1);
+  CHECK(ADestructorCalls == 2);
+  CHECK(BDestructorCalls == 1);
+
+  UniqueA a3(Move(a2));
+  a3 = nullptr;
+  CHECK(ADestructorCalls == 3);
+  CHECK(BDestructorCalls == 2);
+
+  B* bp3 = new B;
+  bp3->x = 42;
+  UniqueB b2(bp3);
+  UniqueA a4(Move(b2));
+  CHECK(b2.get() == nullptr);
+  CHECK((*a4).x == 42);
+  CHECK(ADestructorCalls == 3);
+  CHECK(BDestructorCalls == 2);
+
+  UniqueA a5(new A);
+  UniqueB b3(new B);
+  a5 = Move(b3);
+  CHECK(ADestructorCalls == 4);
+  CHECK(BDestructorCalls == 2);
+
+  ReturnUniqueA();
+  CHECK(ADestructorCalls == 5);
+  CHECK(BDestructorCalls == 3);
+
+  ReturnLocalA();
+  CHECK(ADestructorCalls == 6);
+  CHECK(BDestructorCalls == 3);
+
+  UniqueA a6(ReturnLocalA());
+  a6 = nullptr;
+  CHECK(ADestructorCalls == 7);
+  CHECK(BDestructorCalls == 3);
+
+  UniqueC c1(new B);
+  UniqueA a7(new B);
+  a7 = Move(c1);
+  CHECK(ADestructorCalls == 8);
+  CHECK(BDestructorCalls == 4);
+
+  c1.reset(new B);
+
+  UniqueA a8(Move(c1));
+  CHECK(ADestructorCalls == 8);
+  CHECK(BDestructorCalls == 4);
+
+  // These smart pointers still own B resources.
+  CHECK(a4);
+  CHECK(a5);
+  CHECK(a7);
+  CHECK(a8);
+  return true;
+}
+
+static bool
+TestDefaultFree()
+{
+  CHECK(TestDefaultFreeGuts());
+  CHECK(ADestructorCalls == 12);
+  CHECK(BDestructorCalls == 8);
+  return true;
+}
+
+static size_t FreeClassCounter = 0;
+
+struct FreeClass
+{
+  public:
+    FreeClass() {}
+
+    void operator()(int* ptr) {
+      FreeClassCounter++;
+      delete ptr;
+    }
+};
+
+typedef UniquePtr<int, FreeClass> NewIntCustom;
+static_assert(sizeof(NewIntCustom) == sizeof(int*),
+              "stored most efficiently");
+
+static bool
+TestFreeClass()
+{
+  CHECK(FreeClassCounter == 0);
+  {
+    NewIntCustom n1(new int);
+    CHECK(FreeClassCounter == 0);
+  }
+  CHECK(FreeClassCounter == 1);
+
+  NewIntCustom n2;
+  {
+    NewIntCustom n3(new int);
+    CHECK(FreeClassCounter == 1);
+    n2 = Move(n3);
+  }
+  CHECK(FreeClassCounter == 1);
+  n2 = nullptr;
+  CHECK(FreeClassCounter == 2);
+
+  n2.reset(nullptr);
+  CHECK(FreeClassCounter == 2);
+  n2.reset(new int);
+  n2.reset();
+  CHECK(FreeClassCounter == 3);
+
+  NewIntCustom n4(new int, FreeClass());
+  CHECK(FreeClassCounter == 3);
+  n4.reset(new int);
+  CHECK(FreeClassCounter == 4);
+  n4.reset();
+  CHECK(FreeClassCounter == 5);
+
+  FreeClass f;
+  NewIntCustom n5(new int, f);
+  CHECK(FreeClassCounter == 5);
+  int* p = n5.release();
+  CHECK(FreeClassCounter == 5);
+  delete p;
+
+  return true;
+}
+
+typedef UniquePtr<int, DefaultDelete<int>&> IntDeleterRef;
+typedef UniquePtr<A, DefaultDelete<A>&> ADeleterRef;
+typedef UniquePtr<B, DefaultDelete<A>&> BDeleterRef;
+
+static_assert(sizeof(IntDeleterRef) > sizeof(int*),
+              "has to be heavier than an int* to store the reference");
+static_assert(sizeof(ADeleterRef) > sizeof(A*),
+              "has to be heavier than an A* to store the reference");
+static_assert(sizeof(BDeleterRef) > sizeof(int*),
+              "has to be heavier than a B* to store the reference");
+
+static bool
+TestReferenceDeleterGuts()
+{
+  DefaultDelete<int> delInt;
+  IntDeleterRef id1(new int, delInt);
+
+  IntDeleterRef id2(Move(id1));
+  CHECK(id1 == nullptr);
+  CHECK(nullptr != id2);
+  CHECK(&id1.getDeleter() == &id2.getDeleter());
+
+  IntDeleterRef id3(Move(id2));
+
+  DefaultDelete<A> delA;
+  ADeleterRef a1(new A, delA);
+  a1.reset(nullptr);
+  a1.reset(new B);
+  a1 = nullptr;
+
+  BDeleterRef b1(new B, delA);
+  a1 = Move(b1);
+
+  BDeleterRef b2(new B, delA);
+
+  ADeleterRef a2(Move(b2));
+
+  return true;
+}
+
+static bool
+TestReferenceDeleter()
+{
+  ADestructorCalls = 0;
+  BDestructorCalls = 0;
+
+  CHECK(TestReferenceDeleterGuts());
+
+  CHECK(ADestructorCalls == 4);
+  CHECK(BDestructorCalls == 3);
+
+  ADestructorCalls = 0;
+  BDestructorCalls = 0;
+  return true;
+}
+
+// MSVC10 miscompiles mozilla::RemoveReference<reference to function>, claiming
+// that the partial specializations RemoveReference<T&&> and RemoveReference<T&>
+// both match RemoveReference<FreeSignature> below.  Thus in Mozilla code using
+// UniquePtr with a function reference deleter is forbidden.  But it doesn't
+// hurt to run these tests when the compiler doesn't have problems with this, so
+// do so for anything non-MSVC.
+#if MOZ_IS_MSVC
+   // Technically this could be MOZ_MSVC_VERSION_AT_LEAST(11), but we're not
+   // going to support function deleters as long as we support MSVC10, so it
+   // hardly matters.  In the meantime it's not worth the potential trouble (and
+   // potential for bustage) to run these tests on MSVC>=11.
+#  define SHOULD_TEST_FUNCTION_REFERENCE_DELETER 0
+#else
+#  define SHOULD_TEST_FUNCTION_REFERENCE_DELETER 1
+#endif
+
+#if SHOULD_TEST_FUNCTION_REFERENCE_DELETER
+
+typedef void (&FreeSignature)(void*);
+
+static size_t DeleteIntFunctionCallCount = 0;
+
+static void
+DeleteIntFunction(void* ptr)
+{
+  DeleteIntFunctionCallCount++;
+  delete static_cast<int*>(ptr);
+}
+
+static void
+SetMallocedInt(UniquePtr<int, FreeSignature>& ptr, int i)
+{
+  int* newPtr = static_cast<int*>(malloc(sizeof(int)));
+  *newPtr = i;
+  ptr.reset(newPtr);
+}
+
+static UniquePtr<int, FreeSignature>
+MallocedInt(int i)
+{
+  UniquePtr<int, FreeSignature> ptr(static_cast<int*>(malloc(sizeof(int))), free);
+  *ptr = i;
+  return Move(ptr);
+}
+static bool
+TestFunctionReferenceDeleter()
+{
+  // Look for allocator mismatches and leaks to verify these bits
+  UniquePtr<int, FreeSignature> i1(MallocedInt(17));
+  CHECK(*i1 == 17);
+
+  SetMallocedInt(i1, 42);
+  CHECK(*i1 == 42);
+
+  // These bits use a custom deleter so we can instrument deletion.
+  {
+    UniquePtr<int, FreeSignature> i2 =
+      UniquePtr<int, FreeSignature>(new int(42), DeleteIntFunction);
+    CHECK(DeleteIntFunctionCallCount == 0);
+
+    i2.reset(new int(76));
+    CHECK(DeleteIntFunctionCallCount == 1);
+  }
+
+  CHECK(DeleteIntFunctionCallCount == 2);
+
+  return true;
+}
+
+#endif // SHOULD_TEST_FUNCTION_REFERENCE_DELETER
+
+template<typename T, bool = IsNullPointer<decltype(nullptr)>::value>
+struct AppendNullptrTwice;
+
+template<typename T>
+struct AppendNullptrTwice<T, false>
+{
+  AppendNullptrTwice() {}
+  bool operator()(Vector<T>& vec) {
+    CHECK(vec.append(static_cast<typename T::Pointer>(nullptr)));
+    CHECK(vec.append(static_cast<typename T::Pointer>(nullptr)));
+    return true;
+  }
+};
+
+template<typename T>
+struct AppendNullptrTwice<T, true>
+{
+  AppendNullptrTwice() {}
+  bool operator()(Vector<T>& vec) {
+    CHECK(vec.append(nullptr));
+    CHECK(vec.append(nullptr));
+    return true;
+  }
+};
+
+static size_t AAfter;
+static size_t BAfter;
+
+static bool
+TestVectorGuts()
+{
+  Vector<UniqueA> vec;
+  CHECK(vec.append(new B));
+  CHECK(vec.append(new A));
+  CHECK(AppendNullptrTwice<UniqueA>()(vec));
+  CHECK(vec.append(new B));
+
+  size_t initialLength = vec.length();
+
+  UniqueA* begin = vec.begin();
+  bool appendA = true;
+  do {
+    CHECK(appendA ? vec.append(new A) : vec.append(new B));
+    appendA = !appendA;
+  } while (begin == vec.begin());
+
+  size_t numAppended = vec.length() - initialLength;
+
+  BAfter = numAppended / 2;
+  AAfter = numAppended - numAppended / 2;
+
+  CHECK(ADestructorCalls == 0);
+  CHECK(BDestructorCalls == 0);
+  return true;
+}
+
+static bool
+TestVector()
+{
+  ADestructorCalls = 0;
+  BDestructorCalls = 0;
+
+  CHECK(TestVectorGuts());
+
+  CHECK(ADestructorCalls == 3 + AAfter + BAfter);
+  CHECK(BDestructorCalls == 2 + BAfter);
+  return true;
+}
+
+typedef UniquePtr<int[]> IntArray;
+static_assert(sizeof(IntArray) == sizeof(int*),
+              "stored most efficiently");
+
+static bool
+TestArray()
+{
+  static_assert(IsSame<IntArray::DeleterType, DefaultDelete<int[]> >::value,
+                "weird deleter?");
+
+  IntArray n1(new int[5]);
+  CHECK(n1);
+  CHECK(n1.get() != nullptr);
+
+  n1 = nullptr;
+  CHECK(!n1);
+  CHECK(n1.get() == nullptr);
+
+  int* p1 = new int[42];
+  n1.reset(p1);
+  CHECK(n1);
+  IntArray n2(Move(n1));
+  CHECK(!n1);
+  CHECK(n1.get() == nullptr);
+  CHECK(n2.get() == p1);
+
+  Swap(n1, n2);
+  CHECK(n1.get() == p1);
+  CHECK(n2.get() == nullptr);
+
+  n1.swap(n2);
+  CHECK(n1.get() == nullptr);
+  CHECK(n2.get() == p1);
+  delete[] n2.release();
+
+  CHECK(n1.get() == nullptr);
+  CHECK(n2.get() == nullptr);
+
+  int* p2 = new int[7];
+  int* p3 = new int[42];
+  n1.reset(p2);
+  n2.reset(p3);
+  CHECK(n1.get() == p2);
+  CHECK(n2.get() == p3);
+
+  n1.swap(n2);
+  CHECK(n2.get() == p2);
+  CHECK(n1.get() == p3);
+
+  n1 = Move(n2);
+  CHECK(n1.get() == p2);
+  n1 = Move(n2);
+  CHECK(n1.get() == nullptr);
+
+  UniquePtr<A[]> a1(new A[17]);
+  static_assert(sizeof(a1) == sizeof(A*),
+                "stored most efficiently");
+
+  UniquePtr<A[]> a2(new A[5], DefaultDelete<A[]>());
+  a2.reset(nullptr);
+  a2.reset(new A[17]);
+  a2 = nullptr;
+
+  UniquePtr<A[]> a3(nullptr);
+  a3.reset(new A[7]);
+
+  return true;
+}
+
+int
+main()
+{
+  if (!TestDefaultFree())
+    return 1;
+  if (!TestFreeClass())
+    return 1;
+  if (!TestReferenceDeleter())
+    return 1;
+  if (!TestFunctionReferenceDeleter())
+    return 1;
+  if (!TestVector())
+    return 1;
+  if (!TestArray())
+    return 1;
+}
--- a/mfbt/tests/moz.build
+++ b/mfbt/tests/moz.build
@@ -20,16 +20,17 @@ CPP_UNIT_TESTS += [
     'TestIntegerPrintfMacros.cpp',
     'TestMacroArgs.cpp',
     'TestMacroForEach.cpp',
     'TestPair.cpp',
     'TestRollingMean.cpp',
     'TestSHA1.cpp',
     'TestTypedEnum.cpp',
     'TestTypeTraits.cpp',
+    'TestUniquePtr.cpp',
     'TestWeakPtr.cpp',
 ]
 
 if not CONFIG['MOZ_ASAN']:
     CPP_UNIT_TESTS += [
         'TestPoisonArea.cpp',
     ]