Backed out 2 changesets (bug 1736602) for causing bug 1737399. CLOSED TREE

Backed out changeset f5ca68c50650 (bug 1736602)
Backed out changeset 4a1e6cfd73ef (bug 1736602)

js/public/GCAPI.h

@@ -481,9 +481,9 @@ typedef enum JSFinalizeStatus {
 typedef void (*JSFinalizeCallback)(JSFreeOp* fop, JSFinalizeStatus status,
                                    void* data);
 
-typedef void (*JSWeakPointerZonesCallback)(JSTracer* trc, void* data);
+typedef void (*JSWeakPointerZonesCallback)(JSContext* cx, void* data);
 
-typedef void (*JSWeakPointerCompartmentCallback)(JSTracer* trc,
+typedef void (*JSWeakPointerCompartmentCallback)(JSContext* cx,
                                                  JS::Compartment* comp,
                                                  void* data);
 

js/public/GCPolicyAPI.h

@@ -150,8 +150,8 @@ struct GCPolicy<JS::Heap<T>> {
   static void trace(JSTracer* trc, JS::Heap<T>* thingp, const char* name) {
     TraceEdge(trc, thingp, name);
   }
-  static bool traceWeak(JSTracer* trc, JS::Heap<T>* thingp) {
-    return *thingp && js::gc::TraceWeakEdge(trc, thingp);
+  static bool needsSweep(JS::Heap<T>* thingp) {
+    return *thingp && js::gc::EdgeNeedsSweep(thingp);
   }
 };
 

js/public/TracingAPI.h

@@ -510,7 +510,7 @@ namespace gc {
 
 // Return true if the given edge is not live and is about to be swept.
 template <typename T>
-extern JS_PUBLIC_API bool TraceWeakEdge(JSTracer* trc, JS::Heap<T>* thingp);
+extern JS_PUBLIC_API bool EdgeNeedsSweep(JS::Heap<T>* edgep);
 
 }  // namespace gc
 

js/src/gc/Compacting.cpp

@@ -802,7 +802,7 @@ void GCRuntime::updateZonePointersToRelocatedCells(Zone* zone) {
   // Call callbacks to get the rest of the system to fixup other untraced
   // pointers.
   for (CompartmentsInZoneIter comp(zone); !comp.done(); comp.next()) {
-    callWeakPointerCompartmentCallbacks(&trc, comp);
+    callWeakPointerCompartmentCallbacks(comp);
   }
 }
 
@@ -848,7 +848,7 @@ void GCRuntime::updateRuntimePointersToRelocatedCells(AutoGCSession& session) {
 
   // Call callbacks to get the rest of the system to fixup other untraced
   // pointers.
-  callWeakPointerZonesCallbacks(&trc);
+  callWeakPointerZonesCallbacks();
 }
 
 void GCRuntime::clearRelocatedArenas(Arena* arenaList, JS::GCReason reason) {

js/src/gc/GC.cpp

@@ -1295,9 +1295,10 @@ void GCRuntime::removeWeakPointerZonesCallback(
   EraseCallback(updateWeakPointerZonesCallbacks.ref(), callback);
 }
 
-void GCRuntime::callWeakPointerZonesCallbacks(JSTracer* trc) const {
+void GCRuntime::callWeakPointerZonesCallbacks() const {
+  JSContext* cx = rt->mainContextFromOwnThread();
   for (auto const& p : updateWeakPointerZonesCallbacks.ref()) {
-    p.op(trc, p.data);
+    p.op(cx, p.data);
   }
 }
 
@@ -1313,9 +1314,10 @@ void GCRuntime::removeWeakPointerCompartmentCallback(
 }
 
 void GCRuntime::callWeakPointerCompartmentCallbacks(
-    JSTracer* trc, JS::Compartment* comp) const {
+    JS::Compartment* comp) const {
+  JSContext* cx = rt->mainContextFromOwnThread();
   for (auto const& p : updateWeakPointerCompartmentCallbacks.ref()) {
-    p.op(trc, comp, p.data);
+    p.op(cx, comp, p.data);
   }
 }
 

js/src/gc/GCRuntime.h

@@ -893,9 +893,8 @@ class GCRuntime {
 #endif
 
   void callFinalizeCallbacks(JSFreeOp* fop, JSFinalizeStatus status) const;
-  void callWeakPointerZonesCallbacks(JSTracer* trc) const;
-  void callWeakPointerCompartmentCallbacks(JSTracer* trc,
-                                           JS::Compartment* comp) const;
+  void callWeakPointerZonesCallbacks() const;
+  void callWeakPointerCompartmentCallbacks(JS::Compartment* comp) const;
   void callDoCycleCollectionCallback(JSContext* cx);
 
  public:

js/src/gc/Marking.cpp

@@ -2883,9 +2883,8 @@ namespace js {
 namespace gc {
 
 template <typename T>
-JS_PUBLIC_API bool TraceWeakEdge(JSTracer* trc, JS::Heap<T>* thingp) {
-  return TraceEdgeInternal(trc, gc::ConvertToBase(thingp->unsafeGet()),
-                           "JS::Heap edge");
+JS_PUBLIC_API bool EdgeNeedsSweep(JS::Heap<T>* thingp) {
+  return IsAboutToBeFinalizedInternal(ConvertToBase(thingp->unsafeGet()));
 }
 
 template <typename T>
@@ -2894,9 +2893,8 @@ JS_PUBLIC_API bool EdgeNeedsSweepUnbarrieredSlow(T* thingp) {
 }
 
 // Instantiate a copy of the Tracing templates for each public GC type.
-#define INSTANTIATE_ALL_VALID_HEAP_TRACE_FUNCTIONS(type)            \
-  template JS_PUBLIC_API bool TraceWeakEdge<type>(JSTracer * trc,   \
-                                                  JS::Heap<type>*); \
+#define INSTANTIATE_ALL_VALID_HEAP_TRACE_FUNCTIONS(type)             \
+  template JS_PUBLIC_API bool EdgeNeedsSweep<type>(JS::Heap<type>*); \
   template JS_PUBLIC_API bool EdgeNeedsSweepUnbarrieredSlow<type>(type*);
 JS_FOR_EACH_PUBLIC_GC_POINTER_TYPE(INSTANTIATE_ALL_VALID_HEAP_TRACE_FUNCTIONS)
 JS_FOR_EACH_PUBLIC_TAGGED_GC_POINTER_TYPE(

js/src/gc/Sweeping.cpp

@@ -495,6 +495,7 @@ void GCRuntime::freeFromBackgroundThread(AutoLockHelperThreadState& lock) {
 
 void GCRuntime::waitBackgroundFreeEnd() { freeTask.join(); }
 
+
 template <class ZoneIterT>
 IncrementalProgress GCRuntime::markWeakReferences(
     SliceBudget& incrementalBudget) {
@@ -1451,13 +1452,13 @@ void GCRuntime::sweepEmbeddingWeakPointers(JSFreeOp* fop) {
   callFinalizeCallbacks(fop, JSFINALIZE_GROUP_PREPARE);
   {
     AutoPhase ap2(stats(), PhaseKind::WEAK_ZONES_CALLBACK);
-    callWeakPointerZonesCallbacks(&sweepingTracer);
+    callWeakPointerZonesCallbacks();
   }
   {
     AutoPhase ap2(stats(), PhaseKind::WEAK_COMPARTMENT_CALLBACK);
     for (SweepGroupZonesIter zone(this); !zone.done(); zone.next()) {
       for (CompartmentsInZoneIter comp(zone); !comp.done(); comp.next()) {
-        callWeakPointerCompartmentCallbacks(&sweepingTracer, comp);
+        callWeakPointerCompartmentCallbacks(comp);
       }
     }
   }

js/xpconnect/src/XPCJSRuntime.cpp

@@ -924,7 +924,7 @@ void XPCJSRuntime::FinalizeCallback(JSFreeOp* fop, JSFinalizeStatus status,
 }
 
 /* static */
-void XPCJSRuntime::WeakPointerZonesCallback(JSTracer* trc, void* data) {
+void XPCJSRuntime::WeakPointerZonesCallback(JSContext* cx, void* data) {
   // Called before each sweeping slice -- after processing any final marking
   // triggered by barriers -- to clear out any references to things that are
   // about to be finalized and update any pointers to moved GC things.
@@ -938,26 +938,26 @@ void XPCJSRuntime::WeakPointerZonesCallback(JSTracer* trc, void* data) {
   AutoRestore<bool> restoreState(self->mGCIsRunning);
   self->mGCIsRunning = true;
 
-  self->mWrappedJSMap->UpdateWeakPointersAfterGC(trc);
-  self->mUAWidgetScopeMap.traceWeak(trc);
+  self->mWrappedJSMap->UpdateWeakPointersAfterGC();
+  self->mUAWidgetScopeMap.sweep();
 }
 
 /* static */
-void XPCJSRuntime::WeakPointerCompartmentCallback(JSTracer* trc,
+void XPCJSRuntime::WeakPointerCompartmentCallback(JSContext* cx,
                                                   JS::Compartment* comp,
                                                   void* data) {
   // Called immediately after the ZoneGroup weak pointer callback, but only
   // once for each compartment that is being swept.
   CompartmentPrivate* xpcComp = CompartmentPrivate::Get(comp);
   if (xpcComp) {
-    xpcComp->UpdateWeakPointersAfterGC(trc);
+    xpcComp->UpdateWeakPointersAfterGC();
   }
 }
 
-void CompartmentPrivate::UpdateWeakPointersAfterGC(JSTracer* trc) {
-  mRemoteProxies.traceWeak(trc);
-  mWrappedJSMap->UpdateWeakPointersAfterGC(trc);
-  mScope->UpdateWeakPointersAfterGC(trc);
+void CompartmentPrivate::UpdateWeakPointersAfterGC() {
+  mRemoteProxies.sweep();
+  mWrappedJSMap->UpdateWeakPointersAfterGC();
+  mScope->UpdateWeakPointersAfterGC();
 }
 
 void XPCJSRuntime::CustomOutOfMemoryCallback() {

js/xpconnect/src/XPCMaps.cpp

@@ -17,7 +17,7 @@ using namespace mozilla;
 /***************************************************************************/
 // implement JSObject2WrappedJSMap...
 
-void JSObject2WrappedJSMap::UpdateWeakPointersAfterGC(JSTracer* trc) {
+void JSObject2WrappedJSMap::UpdateWeakPointersAfterGC() {
   // Check all wrappers and update their JSObject pointer if it has been
   // moved. Release any wrappers whose weakly held JSObject has died.
 

js/xpconnect/src/XPCMaps.h

@@ -80,7 +80,7 @@ class JSObject2WrappedJSMap {
     }
   }
 
-  void UpdateWeakPointersAfterGC(JSTracer* trc);
+  void UpdateWeakPointersAfterGC();
 
   void ShutdownMarker();
 
@@ -385,7 +385,7 @@ class JSObject2JSObjectMap {
 
   inline uint32_t Count() { return mTable.count(); }
 
-  void UpdateWeakPointers(JSTracer* trc) { mTable.traceWeak(trc); }
+  void Sweep() { mTable.sweep(); }
 
  private:
   Map mTable{XPC_WRAPPER_MAP_LENGTH};

js/xpconnect/src/XPCWrappedNativeScope.cpp

@@ -267,10 +267,10 @@ void XPCWrappedNativeScope::SuspectAllWrappers(
   }
 }
 
-void XPCWrappedNativeScope::UpdateWeakPointersAfterGC(JSTracer* trc) {
+void XPCWrappedNativeScope::UpdateWeakPointersAfterGC() {
   // Sweep waivers.
   if (mWaiverWrapperMap) {
-    mWaiverWrapperMap->UpdateWeakPointers(trc);
+    mWaiverWrapperMap->Sweep();
   }
 
   if (!js::IsCompartmentZoneSweepingOrCompacting(mCompartment)) {

js/xpconnect/src/xpcprivate.h

@@ -547,8 +547,8 @@ class XPCJSRuntime final : public mozilla::CycleCollectedJSRuntime {
   static void DoCycleCollectionCallback(JSContext* cx);
   static void FinalizeCallback(JSFreeOp* fop, JSFinalizeStatus status,
                                void* data);
-  static void WeakPointerZonesCallback(JSTracer* trc, void* data);
-  static void WeakPointerCompartmentCallback(JSTracer* trc,
+  static void WeakPointerZonesCallback(JSContext* cx, void* data);
+  static void WeakPointerCompartmentCallback(JSContext* cx,
                                              JS::Compartment* comp, void* data);
 
   inline void AddVariantRoot(XPCTraceableVariant* variant);
@@ -613,10 +613,9 @@ class XPCJSRuntime final : public mozilla::CycleCollectedJSRuntime {
   };
 
   struct SweepPolicy {
-    static bool traceWeak(JSTracer* trc,
-                          RefPtr<mozilla::BasePrincipal>* /* unused */,
-                          JS::Heap<JSObject*>* value) {
-      return JS::GCPolicy<JS::Heap<JSObject*>>::traceWeak(trc, value);
+    static bool needsSweep(RefPtr<mozilla::BasePrincipal>* /* unused */,
+                           JS::Heap<JSObject*>* value) {
+      return JS::GCPolicy<JS::Heap<JSObject*>>::needsSweep(value);
     }
   };
 
@@ -851,7 +850,7 @@ class XPCWrappedNativeScope final
 
   static void SweepAllWrappedNativeTearOffs();
 
-  void UpdateWeakPointersAfterGC(JSTracer* trc);
+  void UpdateWeakPointersAfterGC();
 
   static void DebugDumpAllScopes(int16_t depth);
 
@@ -2638,16 +2637,16 @@ class CompartmentPrivate {
   bool wasShutdown;
 
   JSObject2WrappedJSMap* GetWrappedJSMap() const { return mWrappedJSMap.get(); }
-  void UpdateWeakPointersAfterGC(JSTracer* trc);
+  void UpdateWeakPointersAfterGC();
 
   void SystemIsBeingShutDown();
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf);
 
   struct SweepPolicy {
-    static bool traceWeak(JSTracer* trc, const void* /* unused */,
-                          JS::Heap<JSObject*>* value) {
-      return JS::GCPolicy<JS::Heap<JSObject*>>::traceWeak(trc, value);
+    static bool needsSweep(const void* /* unused */,
+                           JS::Heap<JSObject*>* value) {
+      return JS::GCPolicy<JS::Heap<JSObject*>>::needsSweep(value);
     }
   };