Bug 1273661 part 2. Add a way to trace a RefPtr<T> or OwningNonNull<T> via a Rooted. r=terrence,smaug

dom/bindings/BindingDeclarations.h

@@ -17,11 +17,11 @@
 #include "js/Value.h"
 
 #include "mozilla/Maybe.h"
-#include "mozilla/OwningNonNull.h"
+#include "mozilla/RootedOwningNonNull.h"
+#include "mozilla/RootedRefPtr.h"
 
 #include "mozilla/dom/DOMString.h"
 
-#include "nsAutoPtr.h" // for nsRefPtr member variables
 #include "nsCOMPtr.h"
 #include "nsStringGlue.h"
 #include "nsTArray.h"

dom/bindings/RootedOwningNonNull.h

@@ -0,0 +1,73 @@
+/* -*- 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/. */
+
+/**
+ * An implementation of Rooted for OwningNonNull<T>.  This works by assuming
+ * that T has a Trace() method defined on it which will trace whatever things
+ * inside the T instance need tracing.
+ *
+ * This implementation has one serious drawback: operator= doesn't work right
+ * because it's declared on Rooted directly and expects the type Rooted is
+ * templated over.
+ */
+
+#ifndef mozilla_RootedOwningNonNull_h__
+#define mozilla_RootedOwningNonNull_h__
+
+#include "mozilla/OwningNonNull.h"
+#include "js/GCPolicyAPI.h"
+#include "js/RootingAPI.h"
+
+namespace JS {
+template<typename T>
+struct GCPolicy<mozilla::OwningNonNull<T>>
+{
+  typedef mozilla::OwningNonNull<T> SmartPtrType;
+
+  static SmartPtrType initial()
+  {
+    return SmartPtrType();
+  }
+
+  static void trace(JSTracer* trc, SmartPtrType* tp,
+                    const char* name)
+  {
+    // We have to be very careful here.  Normally, OwningNonNull can't be null.
+    // But binding code can end up in a situation where it sets up a
+    // Rooted<OwningNonNull> and then before it gets a chance to assign to it
+    // (e.g. from the constructor of the thing being assigned) a GC happens.  So
+    // we can land here when *tp stores a null pointer because it's not
+    // initialized.
+    //
+    // So we need to check for that before jumping.
+    if ((*tp).isInitialized()) {
+      (*tp)->Trace(trc);
+    }
+  }
+};
+} // namespace JS
+
+namespace js {
+template<typename T>
+struct RootedBase<mozilla::OwningNonNull<T>>
+{
+  typedef mozilla::OwningNonNull<T> SmartPtrType;
+
+  operator SmartPtrType& () const
+  {
+    auto& self = *static_cast<const JS::Rooted<SmartPtrType>*>(this);
+    return self.get();
+  }
+
+  operator T& () const
+  {
+    auto& self = *static_cast<const JS::Rooted<SmartPtrType>*>(this);
+    return self.get();
+  }
+};
+} // namespace js
+
+#endif /* mozilla_RootedOwningNonNull_h__ */

dom/bindings/RootedRefPtr.h

@@ -0,0 +1,59 @@
+/* -*- 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/. */
+
+/**
+ * An implementation of Rooted for RefPtr<T>.  This works by assuming that T has
+ * a Trace() method defined on it which will trace whatever things inside the T
+ * instance need tracing.
+ *
+ * This implementation has one serious drawback: operator= doesn't work right
+ * because it's declared on Rooted directly and expects the type Rooted is
+ * templated over.
+ */
+
+#ifndef mozilla_RootedRefPtr_h__
+#define mozilla_RootedRefPtr_h__
+
+#include "mozilla/RefPtr.h"
+#include "js/GCPolicyAPI.h"
+#include "js/RootingAPI.h"
+
+namespace JS {
+template<typename T>
+struct GCPolicy<RefPtr<T>>
+{
+  static RefPtr<T> initial() {
+    return RefPtr<T>();
+  }
+
+  static void trace(JSTracer* trc, RefPtr<T>* tp, const char* name)
+  {
+    if (*tp) {
+      (*tp)->Trace(trc);
+    }
+  }
+};
+} // namespace JS
+
+namespace js {
+template<typename T>
+struct RootedBase<RefPtr<T>>
+{
+  operator RefPtr<T>& () const
+  {
+    auto& self = *static_cast<const JS::Rooted<RefPtr<T>>*>(this);
+    return self.get();
+  }
+
+  operator T*() const
+  {
+    auto& self = *static_cast<const JS::Rooted<RefPtr<T>>*>(this);
+    return self.get();
+  }
+};
+} // namespace js
+
+#endif /* mozilla_RootedRefPtr_h__ */

dom/bindings/moz.build

@@ -12,6 +12,8 @@ EXPORTS.ipc += [
 
 EXPORTS.mozilla += [
     'ErrorResult.h',
+    'RootedOwningNonNull.h',
+    'RootedRefPtr.h',
 ]
 
 EXPORTS.mozilla.dom += [

xpcom/base/OwningNonNull.h

@@ -126,6 +126,18 @@ public:
   void swap(U& aOther)
   {
     mPtr.swap(aOther);
+#ifdef DEBUG
+    mInited = mPtr;
+#endif
+  }
+
+  // We have some consumers who want to check whether we're inited in non-debug
+  // builds as well.  Luckily, we have the invariant that we're inited precisely
+  // when mPtr is non-null.
+  bool isInitialized() const
+  {
+    MOZ_ASSERT(!!mPtr == mInited, "mInited out of sync with mPtr?");
+    return mPtr;
   }
 
 protected: