Bug 1237794: Extend ClearOnShutdown() to allow specifying the shutdown phase draft
authorRandell Jesup <rjesup@jesup.org>
Fri, 08 Jan 2016 11:38:49 -0500
changeset 320116 332379ccd0e8bdbd7b6d37df8b0c84632cda284b
parent 320115 b51f4e3d177c47600361150f545d82feadabd144
child 320117 60ee02426895894c55a5c9303d5caf7b647f90bd
push id9134
push userrjesup@wgate.com
push dateFri, 08 Jan 2016 16:39:51 +0000
bugs1237794
milestone46.0a1
Bug 1237794: Extend ClearOnShutdown() to allow specifying the shutdown phase
xpcom/base/ClearOnShutdown.cpp
xpcom/base/ClearOnShutdown.h
xpcom/build/XPCOMInit.cpp
--- a/xpcom/base/ClearOnShutdown.cpp
+++ b/xpcom/base/ClearOnShutdown.cpp
@@ -5,12 +5,12 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "mozilla/ClearOnShutdown.h"
 
 namespace mozilla {
 namespace ClearOnShutdown_Internal {
 
 bool sHasShutDown = false;
-StaticAutoPtr<LinkedList<ShutdownObserver>> sShutdownObservers;
+StaticAutoPtr<LinkedList<ShutdownObserver>> sShutdownObservers[mozilla::ShutdownPhase_Length];
 
 } // namespace ClearOnShutdown_Internal
 } // namespace mozilla
--- a/xpcom/base/ClearOnShutdown.h
+++ b/xpcom/base/ClearOnShutdown.h
@@ -10,20 +10,23 @@
 #include "mozilla/LinkedList.h"
 #include "mozilla/StaticPtr.h"
 #include "MainThreadUtils.h"
 
 /*
  * This header exports one public method in the mozilla namespace:
  *
  *   template<class SmartPtr>
- *   void ClearOnShutdown(SmartPtr *aPtr)
+ *   void ClearOnShutdown(SmartPtr *aPtr, aPhase=SHUTDOWN_FINAL)
  *
  * This function takes a pointer to a smart pointer and nulls the smart pointer
- * on shutdown.
+ * on shutdown (and a particular phase of shutdown as needed).  If a phase
+ * is specified, the ptr will be cleared at the start of that phase.  Also,
+ * if a phase has already occurred when ClearOnShutdown() is called, the
+ * pointer will be cleared on the next phase, or SHUTDOWN_FINAL.
  *
  * This is useful if you have a global smart pointer object which you don't
  * want to "leak" on shutdown.
  *
  * Although ClearOnShutdown will work with any smart pointer (i.e., nsCOMPtr,
  * nsRefPtr, nsAutoPtr, StaticRefPtr, and StaticAutoPtr), you probably want to
  * use it only with StaticRefPtr and StaticAutoPtr.  There is no way to undo a
  * call to ClearOnShutdown, so you can call it only on smart pointers which you
@@ -31,16 +34,28 @@
  * global variables, which should be Static{Ref,Auto}Ptr.
  *
  * ClearOnShutdown is currently main-thread only because we don't want to
  * accidentally free an object from a different thread than the one it was
  * created on.
  */
 
 namespace mozilla {
+
+// Must be contiguous starting at 0
+enum ShutdownPhase {
+  PROFILE_CHANGE = 0,
+  WILL_SHUTDOWN,
+  XPCOM_SHUTDOWN,
+  SHUTDOWN_THREADS,
+  SHUTDOWN_LOADERS,
+  SHUTDOWN_FINAL
+};
+static const int ShutdownPhase_Length = SHUTDOWN_FINAL+1;
+
 namespace ClearOnShutdown_Internal {
 
 class ShutdownObserver : public LinkedListElement<ShutdownObserver>
 {
 public:
   virtual void Shutdown() = 0;
   virtual ~ShutdownObserver()
   {
@@ -63,50 +78,58 @@ public:
     }
   }
 
 private:
   SmartPtr* mPtr;
 };
 
 extern bool sHasShutDown;
-extern StaticAutoPtr<LinkedList<ShutdownObserver>> sShutdownObservers;
+extern StaticAutoPtr<LinkedList<ShutdownObserver>> sShutdownObservers[ShutdownPhase_Length];
 
 } // namespace ClearOnShutdown_Internal
 
 template<class SmartPtr>
 inline void
-ClearOnShutdown(SmartPtr* aPtr)
+ClearOnShutdown(SmartPtr* aPtr, ShutdownPhase aPhase = ShutdownPhase::SHUTDOWN_FINAL)
 {
   using namespace ClearOnShutdown_Internal;
 
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!sHasShutDown);
 
-  if (!sShutdownObservers) {
-    sShutdownObservers = new LinkedList<ShutdownObserver>();
+  if (!(sShutdownObservers[aPhase])) {
+    sShutdownObservers[aPhase] = new LinkedList<ShutdownObserver>();
   }
-  sShutdownObservers->insertBack(new PointerClearer<SmartPtr>(aPtr));
+  sShutdownObservers[aPhase]->insertBack(new PointerClearer<SmartPtr>(aPtr));
 }
 
 // Called when XPCOM is shutting down, after all shutdown notifications have
 // been sent and after all threads' event loops have been purged.
 inline void
-KillClearOnShutdown()
+KillClearOnShutdown(ShutdownPhase aPhase)
 {
   using namespace ClearOnShutdown_Internal;
 
   MOZ_ASSERT(NS_IsMainThread());
 
-  if (sShutdownObservers) {
-    while (ShutdownObserver* observer = sShutdownObservers->popFirst()) {
-      observer->Shutdown();
-      delete observer;
+  // Out of caution, when we clear a phase, clear all "older" phases in
+  // case something gets re-added to them after we passed that phase.
+  for (int phase = ShutdownPhase::PROFILE_CHANGE; phase <= static_cast<int>(aPhase); phase++) {
+    if (sShutdownObservers[static_cast<ShutdownPhase>(phase)]) {
+      while (ShutdownObserver* observer = sShutdownObservers[static_cast<ShutdownPhase>(phase)]->popFirst()) {
+        observer->Shutdown();
+        delete observer;
+      }
     }
   }
 
-  sShutdownObservers = nullptr;
-  sHasShutDown = true;
+  if (aPhase == ShutdownPhase::SHUTDOWN_FINAL) {
+    for (int phase = ShutdownPhase::PROFILE_CHANGE; phase <= ShutdownPhase::SHUTDOWN_FINAL; phase++) {
+      sShutdownObservers[static_cast<ShutdownPhase>(phase)] = nullptr;
+    }
+    sHasShutDown = true;
+  }
 }
 
 } // namespace mozilla
 
 #endif
--- a/xpcom/build/XPCOMInit.cpp
+++ b/xpcom/build/XPCOMInit.cpp
@@ -838,35 +838,38 @@ ShutdownXPCOM(nsIServiceManager* aServMg
       return NS_ERROR_UNEXPECTED;
     }
 
     RefPtr<nsObserverService> observerService;
     CallGetService("@mozilla.org/observer-service;1",
                    (nsObserverService**)getter_AddRefs(observerService));
 
     if (observerService) {
+      mozilla::KillClearOnShutdown(WILL_SHUTDOWN);
       observerService->NotifyObservers(nullptr,
                                        NS_XPCOM_WILL_SHUTDOWN_OBSERVER_ID,
                                        nullptr);
 
       nsCOMPtr<nsIServiceManager> mgr;
       rv = NS_GetServiceManager(getter_AddRefs(mgr));
       if (NS_SUCCEEDED(rv)) {
+        mozilla::KillClearOnShutdown(XPCOM_SHUTDOWN);
         observerService->NotifyObservers(mgr, NS_XPCOM_SHUTDOWN_OBSERVER_ID,
                                          nullptr);
       }
     }
 
     // This must happen after the shutdown of media and widgets, which
     // are triggered by the NS_XPCOM_SHUTDOWN_OBSERVER_ID notification.
     NS_ProcessPendingEvents(thread);
     gfxPlatform::ShutdownLayersIPC();
 
     mozilla::scache::StartupCache::DeleteSingleton();
     if (observerService)
+      mozilla::KillClearOnShutdown(SHUTDOWN_THREADS);
       observerService->NotifyObservers(nullptr,
                                        NS_XPCOM_SHUTDOWN_THREADS_OBSERVER_ID,
                                        nullptr);
 
     gXPCOMThreadsShutDown = true;
     NS_ProcessPendingEvents(thread);
 
     // Shutdown the timer thread and all timers that might still be alive before
@@ -887,27 +890,28 @@ ShutdownXPCOM(nsIServiceManager* aServMg
     // Late-write checks needs to find the profile directory, so it has to
     // be initialized before mozilla::services::Shutdown or (because of
     // xpcshell tests replacing the service) modules being unloaded.
     mozilla::InitLateWriteChecks();
 
     // We save the "xpcom-shutdown-loaders" observers to notify after
     // the observerservice is gone.
     if (observerService) {
+      mozilla::KillClearOnShutdown(SHUTDOWN_LOADERS);
       observerService->EnumerateObservers(NS_XPCOM_SHUTDOWN_LOADERS_OBSERVER_ID,
                                           getter_AddRefs(moduleLoaders));
 
       observerService->Shutdown();
     }
   }
 
   // Free ClearOnShutdown()'ed smart pointers.  This needs to happen *after*
   // we've finished notifying observers of XPCOM shutdown, because shutdown
   // observers themselves might call ClearOnShutdown().
-  mozilla::KillClearOnShutdown();
+  mozilla::KillClearOnShutdown(SHUTDOWN_FINAL);
 
   // XPCOM is officially in shutdown mode NOW
   // Set this only after the observers have been notified as this
   // will cause servicemanager to become inaccessible.
   mozilla::services::Shutdown();
 
 #ifdef DEBUG_dougt
   fprintf(stderr, "* * * * XPCOM shutdown. Access will be denied * * * * \n");