src/third_party/mozjs-45/js/src/gc/Marking.cpp.rej

--- Marking.cpp
+++ Marking.cpp
@@ -587,68 +587,70 @@ DispatchToTracer(JSTracer* trc, T* thing
     DoCallback(trc->asCallbackTracer(), thingp, name);
 }
 
 
 /*** GC Marking Interface *************************************************************************/
 
 namespace js {
 
+typedef bool DoNothingMarkingType;
+
 template <typename T>
 struct LinearlyMarkedEphemeronKeyType {
-    typedef bool Type; // used to instantiate a do-nothing markPotentialEphemeronKeyHelper
+    typedef DoNothingMarkingType Type;
 };
 
 // For now, we only handle JSObject* keys, but the linear time algorithm can be
-// easily extended by adding in more types here, then having them call
-// markPotentialEphemeronKey in their GCMarker::traverse instantiation.
+// easily extended by adding in more types here, then instantiating a
+// GCMarker::traverse method that calls markPotentialEphemeronKey.
 template <>
 struct LinearlyMarkedEphemeronKeyType<JSObject*> {
     typedef JSObject* Type;
 };
 
 // Iterate over the vector. It should not be appended to during iteration
 // because the key is already marked, and even in cases where we have a
 // multipart key, we should only be inserting entries for the unmarked
 // portions.
 void
-GCMarker::markEphemeronValues(gc::Cell* oldKey, WeakEntryVector& values)
+GCMarker::markEphemeronValues(gc::Cell* markedCell, WeakEntryVector& values)
 {
     size_t initialLen = values.length();
     for (size_t i = 0; i < initialLen; i++)
-        values[i]->maybeMarkEntry(this, oldKey);
+        values[i].weakmap->maybeMarkEntry(this, markedCell, values[i].key);
     MOZ_ASSERT(values.length() == initialLen);
 }
 
 template <typename T>
 void
-GCMarker::markPotentialEphemeronKeyHelper(T oldThing)
+GCMarker::markPotentialEphemeronKeyHelper(T markedThing)
 {
     if (!isWeakMarkingTracer())
         return;
 
-    auto weakValues = weakKeys.get(JS::GCCellPtr(oldThing));
+    auto weakValues = weakKeys.get(JS::GCCellPtr(markedThing));
     if (!weakValues)
         return;
 
-    markEphemeronValues(oldThing, weakValues->value);
+    markEphemeronValues(markedThing, weakValues->value);
     weakValues->value.clear(); // If key address is reused, it should do nothing
 }
 
 template <>
 void
 GCMarker::markPotentialEphemeronKeyHelper(bool)
 {
 }
 
 template <typename T>
 void
-GCMarker::markPotentialEphemeronKey(T* oldThing)
+GCMarker::markPotentialEphemeronKey(T* thing)
 {
-    markPotentialEphemeronKeyHelper<typename LinearlyMarkedEphemeronKeyType<T*>::Type>(oldThing);
+    markPotentialEphemeronKeyHelper<typename LinearlyMarkedEphemeronKeyType<T*>::Type>(thing);
 }
 
 } // namespace js
 
 template <typename T>
 static inline bool
 MustSkipMarking(T thing)
 {