From eff749c61254c56a23846d85265ceddf1571bf9e Mon Sep 17 00:00:00 2001
From: Terrence Cole <terrence@mozilla.com>
Date: Mon, 28 Dec 2015 10:11:40 -0800
Subject: [PATCH] Bug 1234862 - Part 1: Rename GCMethods to BarrierMethods;
 r=sfink

--HG--
extra : rebase_source : a773cf25e8e9986a154b8a8b0d04c6b9267545b8
---
 dom/xbl/nsXBLMaybeCompiled.h | 22 +++++++-----
 js/public/Debug.h            |  2 +-
 js/public/Id.h               |  7 +++-
 js/public/RootingAPI.h       | 34 +++++++++++--------
 js/public/Value.h            |  7 ++--
 js/src/gc/Barrier.cpp        |  8 ++---
 js/src/gc/Barrier.h          | 66 ++++++++++++++++++------------------
 js/src/gc/Marking.cpp        |  8 ++---
 js/src/vm/Interpreter.cpp    |  4 +--
 js/src/vm/TaggedProto.cpp    | 11 +++---
 js/src/vm/TaggedProto.h      |  6 ++--
 11 files changed, 96 insertions(+), 79 deletions(-)

diff --git a/dom/xbl/nsXBLMaybeCompiled.h b/dom/xbl/nsXBLMaybeCompiled.h
index e478a3a23fd4..63c1b24ce607 100644
--- a/dom/xbl/nsXBLMaybeCompiled.h
+++ b/dom/xbl/nsXBLMaybeCompiled.h
@@ -79,18 +79,22 @@ private:
     JSObject* mCompiled;
   };
 
-  friend struct js::GCMethods<nsXBLMaybeCompiled<UncompiledT>>;
+  friend struct js::BarrierMethods<nsXBLMaybeCompiled<UncompiledT>>;
 };
 
 /* Add support for JS::Heap<nsXBLMaybeCompiled>. */
 namespace js {
 
 template <class UncompiledT>
-struct GCMethods<nsXBLMaybeCompiled<UncompiledT> >
+struct GCPolicy<nsXBLMaybeCompiled<UncompiledT>>
 {
-  typedef struct GCMethods<JSObject *> Base;
-
   static nsXBLMaybeCompiled<UncompiledT> initial() { return nsXBLMaybeCompiled<UncompiledT>(); }
+};
+
+template <class UncompiledT>
+struct BarrierMethods<nsXBLMaybeCompiled<UncompiledT>>
+{
+  typedef struct BarrierMethods<JSObject *> Base;
 
   static void postBarrier(nsXBLMaybeCompiled<UncompiledT>* functionp,
                           nsXBLMaybeCompiled<UncompiledT> prev,
@@ -109,14 +113,14 @@ struct GCMethods<nsXBLMaybeCompiled<UncompiledT> >
 };
 
 template <class UncompiledT>
-class HeapBase<nsXBLMaybeCompiled<UncompiledT> >
+class HeapBase<nsXBLMaybeCompiled<UncompiledT>>
 {
-  const JS::Heap<nsXBLMaybeCompiled<UncompiledT> >& wrapper() const {
-    return *static_cast<const JS::Heap<nsXBLMaybeCompiled<UncompiledT> >*>(this);
+  const JS::Heap<nsXBLMaybeCompiled<UncompiledT>>& wrapper() const {
+    return *static_cast<const JS::Heap<nsXBLMaybeCompiled<UncompiledT>>*>(this);
   }
 
-  JS::Heap<nsXBLMaybeCompiled<UncompiledT> >& wrapper() {
-    return *static_cast<JS::Heap<nsXBLMaybeCompiled<UncompiledT> >*>(this);
+  JS::Heap<nsXBLMaybeCompiled<UncompiledT>>& wrapper() {
+    return *static_cast<JS::Heap<nsXBLMaybeCompiled<UncompiledT>>*>(this);
   }
 
   const nsXBLMaybeCompiled<UncompiledT>* extract() const {
diff --git a/js/public/Debug.h b/js/public/Debug.h
index aefe40b603e6..9fc2c03f93d9 100644
--- a/js/public/Debug.h
+++ b/js/public/Debug.h
@@ -150,7 +150,7 @@ class Builder {
         // A rooted reference to our value.
         PersistentRooted<T> value;
 
-        BuiltThing(JSContext* cx, Builder& owner_, T value_ = js::GCMethods<T>::initial())
+        BuiltThing(JSContext* cx, Builder& owner_, T value_ = js::GCPolicy<T>::initial())
           : owner(owner_), value(cx, value_)
         {
             owner.assertBuilt(value_);
diff --git a/js/public/Id.h b/js/public/Id.h
index d5ddef9bab94..bb3c58124483 100644
--- a/js/public/Id.h
+++ b/js/public/Id.h
@@ -169,9 +169,14 @@ extern JS_PUBLIC_DATA(const JS::HandleId) JSID_EMPTYHANDLE;
 namespace js {
 
 template <>
-struct GCMethods<jsid>
+struct GCPolicy<jsid>
 {
     static jsid initial() { return JSID_VOID; }
+};
+
+template <>
+struct BarrierMethods<jsid>
+{
     static void postBarrier(jsid* idp, jsid prev, jsid next) {}
 };
 
diff --git a/js/public/RootingAPI.h b/js/public/RootingAPI.h
index 4e925cba0475..4a22b70c1863 100644
--- a/js/public/RootingAPI.h
+++ b/js/public/RootingAPI.h
@@ -105,7 +105,11 @@
 namespace js {
 
 template <typename T>
-struct GCMethods {
+struct BarrierMethods {
+};
+
+template <typename T>
+struct GCPolicy {
     static T initial() { return T(); }
 };
 
@@ -221,7 +225,7 @@ class Heap : public js::HeapBase<T>
     Heap() {
         static_assert(sizeof(T) == sizeof(Heap<T>),
                       "Heap<T> must be binary compatible with T.");
-        init(js::GCMethods<T>::initial());
+        init(js::GCPolicy<T>::initial());
     }
     explicit Heap(T p) { init(p); }
 
@@ -234,7 +238,7 @@ class Heap : public js::HeapBase<T>
     explicit Heap(const Heap<T>& p) { init(p.ptr); }
 
     ~Heap() {
-        post(ptr, js::GCMethods<T>::initial());
+        post(ptr, js::GCPolicy<T>::initial());
     }
 
     DECLARE_POINTER_CONSTREF_OPS(T);
@@ -258,7 +262,7 @@ class Heap : public js::HeapBase<T>
   private:
     void init(T newPtr) {
         ptr = newPtr;
-        post(js::GCMethods<T>::initial(), ptr);
+        post(js::GCPolicy<T>::initial(), ptr);
     }
 
     void set(T newPtr) {
@@ -268,7 +272,7 @@ class Heap : public js::HeapBase<T>
     }
 
     void post(const T& prev, const T& next) {
-        js::GCMethods<T>::postBarrier(&ptr, prev, next);
+        js::BarrierMethods<T>::postBarrier(&ptr, prev, next);
     }
 
     enum {
@@ -527,7 +531,7 @@ struct RootKind<T*>
 };
 
 template <typename T>
-struct GCMethods<T*>
+struct BarrierMethods<T*>
 {
     static T* initial() { return nullptr; }
     static void postBarrier(T** vp, T* prev, T* next) {
@@ -538,7 +542,7 @@ struct GCMethods<T*>
 };
 
 template <>
-struct GCMethods<JSObject*>
+struct BarrierMethods<JSObject*>
 {
     static JSObject* initial() { return nullptr; }
     static gc::Cell* asGCThingOrNull(JSObject* v) {
@@ -553,7 +557,7 @@ struct GCMethods<JSObject*>
 };
 
 template <>
-struct GCMethods<JSFunction*>
+struct BarrierMethods<JSFunction*>
 {
     static JSFunction* initial() { return nullptr; }
     static void postBarrier(JSFunction** vp, JSFunction* prev, JSFunction* next) {
@@ -703,7 +707,7 @@ class MOZ_RAII Rooted : public js::RootedBase<T>
   public:
     template <typename RootingContext>
     explicit Rooted(const RootingContext& cx)
-      : ptr(js::GCMethods<T>::initial())
+      : ptr(js::GCPolicy<T>::initial())
     {
         registerWithRootLists(js::RootListsForRootingContext(cx));
     }
@@ -808,7 +812,7 @@ class MOZ_RAII FakeRooted : public RootedBase<T>
 {
   public:
     template <typename CX>
-    explicit FakeRooted(CX* cx) : ptr(GCMethods<T>::initial()) {}
+    explicit FakeRooted(CX* cx) : ptr(GCPolicy<T>::initial()) {}
 
     template <typename CX>
     FakeRooted(CX* cx, T initial) : ptr(initial) {}
@@ -1025,11 +1029,11 @@ class PersistentRooted : public js::PersistentRootedBase<T>,
     }
 
   public:
-    PersistentRooted() : ptr(js::GCMethods<T>::initial()) {}
+    PersistentRooted() : ptr(js::GCPolicy<T>::initial()) {}
 
     template <typename RootingContext>
     explicit PersistentRooted(const RootingContext& cx)
-      : ptr(js::GCMethods<T>::initial())
+      : ptr(js::GCPolicy<T>::initial())
     {
         registerWithRootLists(js::RootListsForRootingContext(cx));
     }
@@ -1062,7 +1066,7 @@ class PersistentRooted : public js::PersistentRootedBase<T>,
 
     template <typename RootingContext>
     void init(const RootingContext& cx) {
-        init(cx, js::GCMethods<T>::initial());
+        init(cx, js::GCPolicy<T>::initial());
     }
 
     template <typename RootingContext, typename U>
@@ -1073,7 +1077,7 @@ class PersistentRooted : public js::PersistentRootedBase<T>,
 
     void reset() {
         if (initialized()) {
-            set(js::GCMethods<T>::initial());
+            set(js::GCPolicy<T>::initial());
             ListBase::remove();
         }
     }
@@ -1162,7 +1166,7 @@ CallTraceCallbackOnNonHeap(T* v, const TraceCallbacks& aCallbacks, const char* a
 {
     static_assert(sizeof(T) == sizeof(JS::Heap<T>), "T and Heap<T> must be compatible.");
     MOZ_ASSERT(v);
-    mozilla::DebugOnly<Cell*> cell = GCMethods<T>::asGCThingOrNull(*v);
+    mozilla::DebugOnly<Cell*> cell = BarrierMethods<T>::asGCThingOrNull(*v);
     MOZ_ASSERT(cell);
     MOZ_ASSERT(!IsInsideNursery(cell));
     JS::Heap<T>* asHeapT = reinterpret_cast<JS::Heap<T>*>(v);
diff --git a/js/public/Value.h b/js/public/Value.h
index 20a441ad3264..15d4eb4b94c9 100644
--- a/js/public/Value.h
+++ b/js/public/Value.h
@@ -1699,14 +1699,15 @@ JS_PUBLIC_API(void) HeapValuePostBarrier(Value* valuep, const Value& prev, const
 
 namespace js {
 
-template <> struct GCMethods<const JS::Value>
+template <>
+struct GCPolicy<JS::Value>
 {
     static JS::Value initial() { return JS::UndefinedValue(); }
 };
 
-template <> struct GCMethods<JS::Value>
+template <>
+struct BarrierMethods<JS::Value>
 {
-    static JS::Value initial() { return JS::UndefinedValue(); }
     static gc::Cell* asGCThingOrNull(const JS::Value& v) {
         return v.isMarkable() ? v.toGCThing() : nullptr;
     }
diff --git a/js/src/gc/Barrier.cpp b/js/src/gc/Barrier.cpp
index 699bc3aec21f..f2b007e65f49 100644
--- a/js/src/gc/Barrier.cpp
+++ b/js/src/gc/Barrier.cpp
@@ -90,7 +90,7 @@ template <typename T>
 void
 ReadBarrierFunctor<S>::operator()(T* t)
 {
-    InternalGCMethods<T*>::readBarrier(t);
+    InternalBarrierMethods<T*>::readBarrier(t);
 }
 template void ReadBarrierFunctor<JS::Value>::operator()<JS::Symbol>(JS::Symbol*);
 template void ReadBarrierFunctor<JS::Value>::operator()<JSObject>(JSObject*);
@@ -101,7 +101,7 @@ template <typename T>
 void
 PreBarrierFunctor<S>::operator()(T* t)
 {
-    InternalGCMethods<T*>::preBarrier(t);
+    InternalBarrierMethods<T*>::preBarrier(t);
 }
 template void PreBarrierFunctor<JS::Value>::operator()<JS::Symbol>(JS::Symbol*);
 template void PreBarrierFunctor<JS::Value>::operator()<JSObject>(JSObject*);
@@ -170,12 +170,12 @@ JS_PUBLIC_API(void)
 JS::HeapObjectPostBarrier(JSObject** objp, JSObject* prev, JSObject* next)
 {
     MOZ_ASSERT(objp);
-    js::InternalGCMethods<JSObject*>::postBarrier(objp, prev, next);
+    js::InternalBarrierMethods<JSObject*>::postBarrier(objp, prev, next);
 }
 
 JS_PUBLIC_API(void)
 JS::HeapValuePostBarrier(JS::Value* valuep, const Value& prev, const Value& next)
 {
     MOZ_ASSERT(valuep);
-    js::InternalGCMethods<JS::Value>::postBarrier(valuep, prev, next);
+    js::InternalBarrierMethods<JS::Value>::postBarrier(valuep, prev, next);
 }
diff --git a/js/src/gc/Barrier.h b/js/src/gc/Barrier.h
index a2131f03f2de..3124d8d1a63e 100644
--- a/js/src/gc/Barrier.h
+++ b/js/src/gc/Barrier.h
@@ -156,23 +156,23 @@
  * via:
  *
  * WriteBarrieredBase<T>::pre
- *  -> InternalGCMethods<T*>::preBarrier
+ *  -> InternalBarrierMethods<T*>::preBarrier
  *      -> T::writeBarrierPre
- *  -> InternalGCMethods<Value>::preBarrier
- *  -> InternalGCMethods<jsid>::preBarrier
- *      -> InternalGCMethods<T*>::preBarrier
+ *  -> InternalBarrierMethods<Value>::preBarrier
+ *  -> InternalBarrierMethods<jsid>::preBarrier
+ *      -> InternalBarrierMethods<T*>::preBarrier
  *          -> T::writeBarrierPre
  *
  * HeapPtr<T>::post and RelocatablePtr<T>::post
- *  -> InternalGCMethods<T*>::postBarrier
+ *  -> InternalBarrierMethods<T*>::postBarrier
  *      -> T::writeBarrierPost
- *  -> InternalGCMethods<Value>::postBarrier
+ *  -> InternalBarrierMethods<Value>::postBarrier
  *      -> StoreBuffer::put
  *
  * These classes are designed to be used by the internals of the JS engine.
  * Barriers designed to be used externally are provided in js/RootingAPI.h.
  * These external barriers call into the same post-barrier implementations at
- * InternalGCMethods<T>::post via an indirect call to Heap(.+)Barrier.
+ * InternalBarrierMethods<T>::post via an indirect call to Heap(.+)Barrier.
  */
 
 class JSAtom;
@@ -240,10 +240,10 @@ void MarkIdForBarrier(JSTracer* trc, jsid* idp, const char* name);
 } // namespace gc
 
 template <typename T>
-struct InternalGCMethods {};
+struct InternalBarrierMethods {};
 
 template <typename T>
-struct InternalGCMethods<T*>
+struct InternalBarrierMethods<T*>
 {
     static bool isMarkable(T* v) { return v != nullptr; }
 
@@ -265,7 +265,7 @@ template <typename S> struct ReadBarrierFunctor : public VoidDefaultAdaptor<S> {
 };
 
 template <>
-struct InternalGCMethods<Value>
+struct InternalBarrierMethods<Value>
 {
     static bool isMarkable(Value v) { return v.isMarkable(); }
     static bool isMarkableTaggedPointer(Value v) { return isMarkable(v); }
@@ -301,7 +301,7 @@ struct InternalGCMethods<Value>
 };
 
 template <>
-struct InternalGCMethods<jsid>
+struct InternalBarrierMethods<jsid>
 {
     static bool isMarkable(jsid id) { return JSID_IS_STRING(id) || JSID_IS_SYMBOL(id); }
     static bool isMarkableTaggedPointer(jsid id) { return isMarkable(id); }
@@ -368,11 +368,11 @@ class WriteBarrieredBase : public BarrieredBase<T>
     void unsafeSet(T v) { this->value = v; }
 
     // For users who need to manually barrier the raw types.
-    static void writeBarrierPre(const T& v) { InternalGCMethods<T>::preBarrier(v); }
+    static void writeBarrierPre(const T& v) { InternalBarrierMethods<T>::preBarrier(v); }
 
   protected:
-    void pre() { InternalGCMethods<T>::preBarrier(this->value); }
-    void post(T prev, T next) { InternalGCMethods<T>::postBarrier(&this->value, prev, next); }
+    void pre() { InternalBarrierMethods<T>::preBarrier(this->value); }
+    void post(T prev, T next) { InternalBarrierMethods<T>::postBarrier(&this->value, prev, next); }
 };
 
 /*
@@ -385,7 +385,7 @@ template <class T>
 class PreBarriered : public WriteBarrieredBase<T>
 {
   public:
-    PreBarriered() : WriteBarrieredBase<T>(GCMethods<T>::initial()) {}
+    PreBarriered() : WriteBarrieredBase<T>(GCPolicy<T>::initial()) {}
     /*
      * Allow implicit construction for use in generic contexts, such as DebuggerWeakMap::markKeys.
      */
@@ -430,12 +430,12 @@ template <class T>
 class HeapPtr : public WriteBarrieredBase<T>
 {
   public:
-    HeapPtr() : WriteBarrieredBase<T>(GCMethods<T>::initial()) {}
+    HeapPtr() : WriteBarrieredBase<T>(GCPolicy<T>::initial()) {}
     explicit HeapPtr(T v) : WriteBarrieredBase<T>(v) {
-        this->post(GCMethods<T>::initial(), v);
+        this->post(GCPolicy<T>::initial(), v);
     }
     explicit HeapPtr(const HeapPtr<T>& v) : WriteBarrieredBase<T>(v) {
-        this->post(GCMethods<T>::initial(), v);
+        this->post(GCPolicy<T>::initial(), v);
     }
 #ifdef DEBUG
     ~HeapPtr() {
@@ -447,7 +447,7 @@ class HeapPtr : public WriteBarrieredBase<T>
 
     void init(T v) {
         this->value = v;
-        this->post(GCMethods<T>::initial(), v);
+        this->post(GCPolicy<T>::initial(), v);
     }
 
     DECLARE_POINTER_ASSIGN_OPS(HeapPtr, T);
@@ -482,11 +482,11 @@ template <class T>
 class RelocatablePtr : public WriteBarrieredBase<T>
 {
   public:
-    RelocatablePtr() : WriteBarrieredBase<T>(GCMethods<T>::initial()) {}
+    RelocatablePtr() : WriteBarrieredBase<T>(GCPolicy<T>::initial()) {}
 
     // Implicitly adding barriers is a reasonable default.
     MOZ_IMPLICIT RelocatablePtr(const T& v) : WriteBarrieredBase<T>(v) {
-        this->post(GCMethods<T>::initial(), this->value);
+        this->post(GCPolicy<T>::initial(), this->value);
     }
 
     /*
@@ -496,17 +496,17 @@ class RelocatablePtr : public WriteBarrieredBase<T>
      * simply omit the rvalue variant.
      */
     MOZ_IMPLICIT RelocatablePtr(const RelocatablePtr<T>& v) : WriteBarrieredBase<T>(v) {
-        this->post(GCMethods<T>::initial(), this->value);
+        this->post(GCPolicy<T>::initial(), this->value);
     }
 
     ~RelocatablePtr() {
         this->pre();
-        this->post(this->value, GCMethods<T>::initial());
+        this->post(this->value, GCPolicy<T>::initial());
     }
 
     void init(T v) {
         this->value = v;
-        this->post(GCMethods<T>::initial(), this->value);
+        this->post(GCPolicy<T>::initial(), this->value);
     }
 
     DECLARE_POINTER_ASSIGN_OPS(RelocatablePtr, T);
@@ -540,8 +540,8 @@ class ReadBarrieredBase : public BarrieredBase<T>
     explicit ReadBarrieredBase(T v) : BarrieredBase<T>(v) {}
 
   protected:
-    void read() const { InternalGCMethods<T>::readBarrier(this->value); }
-    void post(T prev, T next) { InternalGCMethods<T>::postBarrier(&this->value, prev, next); }
+    void read() const { InternalBarrierMethods<T>::readBarrier(this->value); }
+    void post(T prev, T next) { InternalBarrierMethods<T>::postBarrier(&this->value, prev, next); }
 };
 
 // Incremental GC requires that weak pointers have read barriers. This is mostly
@@ -561,16 +561,16 @@ template <typename T>
 class ReadBarriered : public ReadBarrieredBase<T>
 {
   public:
-    ReadBarriered() : ReadBarrieredBase<T>(GCMethods<T>::initial()) {}
+    ReadBarriered() : ReadBarrieredBase<T>(GCPolicy<T>::initial()) {}
 
     // It is okay to add barriers implicitly.
     MOZ_IMPLICIT ReadBarriered(const T& v) : ReadBarrieredBase<T>(v) {
-        this->post(GCMethods<T>::initial(), v);
+        this->post(GCPolicy<T>::initial(), v);
     }
 
     // Copy is creating a new edge, so we must read barrier the source edge.
     explicit ReadBarriered(const ReadBarriered& v) : ReadBarrieredBase<T>(v) {
-        this->post(GCMethods<T>::initial(), v.get());
+        this->post(GCPolicy<T>::initial(), v.get());
     }
 
     // Move retains the lifetime status of the source edge, so does not fire
@@ -578,11 +578,11 @@ class ReadBarriered : public ReadBarrieredBase<T>
     ReadBarriered(ReadBarriered&& v)
       : ReadBarrieredBase<T>(mozilla::Forward<ReadBarriered<T>>(v))
     {
-        this->post(GCMethods<T>::initial(), v.value);
+        this->post(GCPolicy<T>::initial(), v.value);
     }
 
     ~ReadBarriered() {
-        this->post(this->value, GCMethods<T>::initial());
+        this->post(this->value, GCPolicy<T>::initial());
     }
 
     ReadBarriered& operator=(const ReadBarriered& v) {
@@ -593,8 +593,8 @@ class ReadBarriered : public ReadBarrieredBase<T>
     }
 
     const T get() const {
-        if (!InternalGCMethods<T>::isMarkable(this->value))
-            return GCMethods<T>::initial();
+        if (!InternalBarrierMethods<T>::isMarkable(this->value))
+            return GCPolicy<T>::initial();
         this->read();
         return this->value;
     }
diff --git a/js/src/gc/Marking.cpp b/js/src/gc/Marking.cpp
index d0833d5d1de0..786852d739c9 100644
--- a/js/src/gc/Marking.cpp
+++ b/js/src/gc/Marking.cpp
@@ -403,7 +403,7 @@ JS_PUBLIC_API(void)
 JS::TraceEdge(JSTracer* trc, JS::Heap<T>* thingp, const char* name)
 {
     MOZ_ASSERT(thingp);
-    if (InternalGCMethods<T>::isMarkable(thingp->get()))
+    if (InternalBarrierMethods<T>::isMarkable(thingp->get()))
         DispatchToTracer(trc, ConvertToBase(thingp->unsafeGet()), name);
 }
 
@@ -463,7 +463,7 @@ void
 js::TraceNullableRoot(JSTracer* trc, T* thingp, const char* name)
 {
     AssertRootMarkingPhase(trc);
-    if (InternalGCMethods<T>::isMarkableTaggedPointer(*thingp))
+    if (InternalBarrierMethods<T>::isMarkableTaggedPointer(*thingp))
         DispatchToTracer(trc, ConvertToBase(thingp), name);
 }
 
@@ -488,7 +488,7 @@ js::TraceRange(JSTracer* trc, size_t len, WriteBarrieredBase<T>* vec, const char
 {
     JS::AutoTracingIndex index(trc);
     for (auto i : MakeRange(len)) {
-        if (InternalGCMethods<T>::isMarkable(vec[i].get()))
+        if (InternalBarrierMethods<T>::isMarkable(vec[i].get()))
             DispatchToTracer(trc, ConvertToBase(vec[i].unsafeUnbarrieredForTracing()), name);
         ++index;
     }
@@ -501,7 +501,7 @@ js::TraceRootRange(JSTracer* trc, size_t len, T* vec, const char* name)
     AssertRootMarkingPhase(trc);
     JS::AutoTracingIndex index(trc);
     for (auto i : MakeRange(len)) {
-        if (InternalGCMethods<T>::isMarkable(vec[i]))
+        if (InternalBarrierMethods<T>::isMarkable(vec[i]))
             DispatchToTracer(trc, ConvertToBase(&vec[i]), name);
         ++index;
     }
diff --git a/js/src/vm/Interpreter.cpp b/js/src/vm/Interpreter.cpp
index 95136e46b239..bfdbcc8aa979 100644
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -1482,11 +1482,11 @@ class ReservedRooted : public ReservedRootedBase<T>
     }
 
     explicit ReservedRooted(Rooted<T>* root) : savedRoot(root) {
-        *root = js::GCMethods<T>::initial();
+        *root = js::GCPolicy<T>::initial();
     }
 
     ~ReservedRooted() {
-        *savedRoot = js::GCMethods<T>::initial();
+        *savedRoot = js::GCPolicy<T>::initial();
     }
 
     void set(const T& p) const { *savedRoot = p; }
diff --git a/js/src/vm/TaggedProto.cpp b/js/src/vm/TaggedProto.cpp
index f00f07d31c93..725c3bc64e0d 100644
--- a/js/src/vm/TaggedProto.cpp
+++ b/js/src/vm/TaggedProto.cpp
@@ -14,18 +14,19 @@
 namespace js {
 
 /* static */ void
-InternalGCMethods<TaggedProto>::preBarrier(TaggedProto& proto)
+InternalBarrierMethods<TaggedProto>::preBarrier(TaggedProto& proto)
 {
-    InternalGCMethods<JSObject*>::preBarrier(proto.toObjectOrNull());
+    InternalBarrierMethods<JSObject*>::preBarrier(proto.toObjectOrNull());
 }
 
 /* static */ void
-InternalGCMethods<TaggedProto>::postBarrier(TaggedProto* vp, TaggedProto prev, TaggedProto next)
+InternalBarrierMethods<TaggedProto>::postBarrier(TaggedProto* vp, TaggedProto prev,
+                                                 TaggedProto next)
 {
     JSObject* prevObj = prev.isObject() ? prev.toObject() : nullptr;
     JSObject* nextObj = next.isObject() ? next.toObject() : nullptr;
-    InternalGCMethods<JSObject*>::postBarrier(reinterpret_cast<JSObject**>(vp), prevObj,
-                                              nextObj);
+    InternalBarrierMethods<JSObject*>::postBarrier(reinterpret_cast<JSObject**>(vp), prevObj,
+                                                   nextObj);
 }
 
 } // namespace js
diff --git a/js/src/vm/TaggedProto.h b/js/src/vm/TaggedProto.h
index 72538802535e..412961a08bdf 100644
--- a/js/src/vm/TaggedProto.h
+++ b/js/src/vm/TaggedProto.h
@@ -52,12 +52,14 @@ class TaggedProto : public JS::Traceable
     JSObject* proto;
 };
 
-template <> struct GCMethods<TaggedProto>
+template <>
+struct GCPolicy<TaggedProto>
 {
     static TaggedProto initial() { return TaggedProto(); }
 };
 
-template <> struct InternalGCMethods<TaggedProto>
+template <>
+struct InternalBarrierMethods<TaggedProto>
 {
     static void preBarrier(TaggedProto& proto);