--- a/startupcache/StartupCache.cpp
+++ b/startupcache/StartupCache.cpp
@@ -121,17 +121,17 @@ StartupCache::InitSingleton()
 }
 
 StartupCache* StartupCache::gStartupCache;
 bool StartupCache::gShutdownInitiated;
 bool StartupCache::gIgnoreDiskCache;
 enum StartupCache::TelemetrifyAge StartupCache::gPostFlushAgeAction = StartupCache::IGNORE_AGE;
 
 StartupCache::StartupCache() 
-  : mArchive(NULL), mStartupWriteInitiated(false), mWriteThread(NULL),
+  : mArchive(nullptr), mStartupWriteInitiated(false), mWriteThread(nullptr),
     mMappingMemoryReporter(nullptr), mDataMemoryReporter(nullptr) { }
 
 StartupCache::~StartupCache() 
 {
   if (mTimer) {
     mTimer->Cancel();
   }
 
@@ -249,17 +249,17 @@ StartupCache::Init()
  */
 nsresult
 StartupCache::LoadArchive(enum TelemetrifyAge flag)
 {
   if (gIgnoreDiskCache)
     return NS_ERROR_FAILURE;
 
   bool exists;
-  mArchive = NULL;
+  mArchive = nullptr;
   nsresult rv = mFile->Exists(&exists);
   if (NS_FAILED(rv) || !exists)
     return NS_ERROR_FILE_NOT_FOUND;
   
   mArchive = new nsZipArchive();
   rv = mArchive->OpenArchive(mFile);
   if (NS_FAILED(rv) || flag == IGNORE_AGE)
     return rv;
@@ -476,34 +476,34 @@ StartupCache::WriteToDisk()
   CacheWriteHolder holder;
   holder.stream = stream;
   holder.writer = zipW;
   holder.time = now;
 
   mTable.Enumerate(CacheCloseHelper, &holder);
 
   // Close the archive so Windows doesn't choke.
-  mArchive = NULL;
+  mArchive = nullptr;
   zipW->Close();
 
   // We succesfully wrote the archive to disk; mark the disk file as trusted
   gIgnoreDiskCache = false;
 
   // Our reader's view of the archive is outdated now, reload it.
   LoadArchive(gPostFlushAgeAction);
   
   return;
 }
 
 void
 StartupCache::InvalidateCache() 
 {
   WaitOnWriteThread();
   mTable.Clear();
-  mArchive = NULL;
+  mArchive = nullptr;
   nsresult rv = mFile->Remove(false);
   if (NS_FAILED(rv) && rv != NS_ERROR_FILE_TARGET_DOES_NOT_EXIST &&
       rv != NS_ERROR_FILE_NOT_FOUND) {
     gIgnoreDiskCache = true;
     mozilla::Telemetry::Accumulate(Telemetry::STARTUP_CACHE_INVALID, true);
     return;
   }
   gIgnoreDiskCache = false;
@@ -526,17 +526,17 @@ StartupCache::IgnoreDiskCache()
 void
 StartupCache::WaitOnWriteThread()
 {
   NS_ASSERTION(NS_IsMainThread(), "Startup cache should only wait for io thread on main thread");
   if (!mWriteThread || mWriteThread == PR_GetCurrentThread())
     return;
 
   PR_JoinThread(mWriteThread);
-  mWriteThread = NULL;
+  mWriteThread = nullptr;
 }
 
 void 
 StartupCache::ThreadedWrite(void *aClosure)
 {
   PR_SetCurrentThreadName("StartupCache");
   gStartupCache->WriteToDisk();
 }
@@ -546,17 +546,17 @@ StartupCache::ThreadedWrite(void *aClosu
  * can avoid a slow shutdown. After writing out the cache, the zipreader is
  * reloaded on the worker thread.
  */
 void
 StartupCache::WriteTimeout(nsITimer *aTimer, void *aClosure)
 {
   gStartupCache->mWriteThread = PR_CreateThread(PR_USER_THREAD,
                                                 StartupCache::ThreadedWrite,
-                                                NULL,
+                                                nullptr,
                                                 PR_PRIORITY_NORMAL,
                                                 PR_LOCAL_THREAD,
                                                 PR_JOINABLE_THREAD,
                                                 0);
 }
 
 // We don't want to refcount StartupCache, so we'll just
 // hold a ref to this and pass it to observerService instead.

--- a/startupcache/StartupCacheModule.cpp
+++ b/startupcache/StartupCacheModule.cpp
@@ -18,28 +18,28 @@
 using namespace mozilla::scache;
 
 // XXX Need help with guard for ENABLE_TEST
 NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(StartupCacheWrapper,
                                          StartupCacheWrapper::GetSingleton)
 NS_DEFINE_NAMED_CID(NS_STARTUPCACHE_CID);
 
 static const mozilla::Module::CIDEntry kStartupCacheCIDs[] = {
-    { &kNS_STARTUPCACHE_CID, false, NULL, StartupCacheWrapperConstructor },
-    { NULL }
+    { &kNS_STARTUPCACHE_CID, false, nullptr, StartupCacheWrapperConstructor },
+    { nullptr }
 };
 
 static const mozilla::Module::ContractIDEntry kStartupCacheContracts[] = {
     { "@mozilla.org/startupcache/cache;1", &kNS_STARTUPCACHE_CID },
-    { NULL }
+    { nullptr }
 };
 
 static const mozilla::Module kStartupCacheModule = {
     mozilla::Module::kVersion,
     kStartupCacheCIDs,
     kStartupCacheContracts,
-    NULL,
-    NULL,
-    NULL,
-    NULL
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr
 };
 
 NSMODULE_DEFN(StartupCacheModule) = &kStartupCacheModule;

--- a/startupcache/test/TestStartupCache.cpp
+++ b/startupcache/test/TestStartupCache.cpp
@@ -86,17 +86,17 @@ TestStartupWriteRead() {
     return NS_ERROR_FAILURE;
   } else {
     passed("got a pointer?");
   }
   sc->InvalidateCache();
   
   const char* buf = "Market opportunities for BeardBook";
   const char* id = "id";
-  char* outbufPtr = NULL;
+  char* outbufPtr = nullptr;
   nsAutoArrayPtr<char> outbuf;  
   uint32_t len;
   
   rv = sc->PutBuffer(id, buf, strlen(buf) + 1);
   NS_ENSURE_SUCCESS(rv, rv);
   
   rv = sc->GetBuffer(id, &outbufPtr, &len);
   NS_ENSURE_SUCCESS(rv, rv);
@@ -115,17 +115,17 @@ TestStartupWriteRead() {
   return NS_OK;
 }
 
 nsresult
 TestWriteInvalidateRead() {
   nsresult rv;
   const char* buf = "BeardBook competitive analysis";
   const char* id = "id";
-  char* outbuf = NULL;
+  char* outbuf = nullptr;
   uint32_t len;
   nsCOMPtr<nsIStartupCache> sc
     = do_GetService("@mozilla.org/startupcache/cache;1", &rv);
   sc->InvalidateCache();
 
   rv = sc->PutBuffer(id, buf, strlen(buf) + 1);
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -191,31 +191,31 @@ TestWriteObject() {
   }
   nsCOMPtr<nsISupports> objQI(do_QueryInterface(obj));
   rv = objectOutput->WriteObject(objQI, true);
   if (NS_FAILED(rv)) {
     fail("failed to write object");
     return rv;
   }
 
-  char* bufPtr = NULL;
+  char* bufPtr = nullptr;
   nsAutoArrayPtr<char> buf;
   uint32_t len;
   NewBufferFromStorageStream(storageStream, &bufPtr, &len);
   buf = bufPtr;
 
   // Since this is a post-startup write, it should be written and
   // available.
   rv = sc->PutBuffer(id, buf, len);
   if (NS_FAILED(rv)) {
     fail("failed to insert input stream");
     return rv;
   }
     
-  char* buf2Ptr = NULL;
+  char* buf2Ptr = nullptr;
   nsAutoArrayPtr<char> buf2;
   uint32_t len2;
   nsCOMPtr<nsIObjectInputStream> objectInput;
   rv = sc->GetBuffer(id, &buf2Ptr, &len2);
   if (NS_FAILED(rv)) {
     fail("failed to retrieve buffer");
     return rv;
   }
@@ -310,17 +310,17 @@ nsresult
 TestIgnoreDiskCache(nsIFile* profileDir) {
   nsresult rv;
   nsCOMPtr<nsIStartupCache> sc
     = do_GetService("@mozilla.org/startupcache/cache;1", &rv);
   sc->InvalidateCache();
   
   const char* buf = "Get a Beardbook app for your smartphone";
   const char* id = "id";
-  char* outbuf = NULL;
+  char* outbuf = nullptr;
   uint32_t len;
   
   rv = sc->PutBuffer(id, buf, strlen(buf) + 1);
   NS_ENSURE_SUCCESS(rv, rv);
   rv = sc->ResetStartupWriteTimer();
   rv = WaitForStartupTimer();
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -356,17 +356,17 @@ TestEarlyShutdown() {
   nsresult rv;
   nsCOMPtr<nsIStartupCache> sc
     = do_GetService("@mozilla.org/startupcache/cache;1", &rv);
   sc->InvalidateCache();
 
   const char* buf = "Find your soul beardmate on BeardBook";
   const char* id = "id";
   uint32_t len;
-  char* outbuf = NULL;
+  char* outbuf = nullptr;
   
   sc->ResetStartupWriteTimer();
   rv = sc->PutBuffer(id, buf, strlen(buf) + 1);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsCOMPtr<nsIObserver> obs;
   sc->GetObserver(getter_AddRefs(obs));
   obs->Observe(nullptr, "xpcom-shutdown", nullptr);
@@ -408,23 +408,23 @@ GetHistogramCounts(const char *testmsg, 
   nsresult trv = telemetry->GetHistogramById(histogram_id, cx, h.address());
   if (NS_FAILED(trv)) {
     fail("%s: couldn't get histogram %s", testmsg, ToNewCString(histogram_id));
     return false;
   }
   passed(testmsg);
 
   Rooted<Value> snapshot_val(cx);
-  JSFunction *snapshot_fn = NULL;
+  JSFunction *snapshot_fn = nullptr;
   Rooted<Value> ss(cx);
   return (JS_GetProperty(cx, JSVAL_TO_OBJECT(h), "snapshot",
                          &snapshot_val)
           && (snapshot_fn = JS_ValueToFunction(cx, snapshot_val))
           && JS::Call(cx, JSVAL_TO_OBJECT(h),
-                      snapshot_fn, 0, NULL, &ss)
+                      snapshot_fn, 0, nullptr, &ss)
           && JS_GetProperty(cx, JSVAL_TO_OBJECT(ss), "counts", counts));
 }
 
 nsresult
 CompareCountArrays(JSContext *cx, JSObject *aBefore, JSObject *aAfter)
 {
   uint32_t before_size, after_size;
   JS::RootedObject before(cx, aBefore);
@@ -517,17 +517,17 @@ int main(int argc, char** argv)
     "global", JSCLASS_NEW_RESOLVE | JSCLASS_GLOBAL_FLAGS | JSCLASS_HAS_PRIVATE,
     JS_PropertyStub,  JS_DeletePropertyStub,
     JS_PropertyStub,  JS_StrictPropertyStub,
     JS_EnumerateStub, JS_ResolveStub,
     JS_ConvertStub
   };
   JSObject *glob = nullptr;
   if (use_js)
-    glob = JS_NewGlobalObject(cx, &global_class, NULL);
+    glob = JS_NewGlobalObject(cx, &global_class, nullptr);
   if (!glob)
     use_js = false;
   mozilla::Maybe<JSAutoCompartment> ac;
   if (use_js)
     ac.construct(cx, glob);
   if (use_js && !JS_InitStandardClasses(cx, glob))
     use_js = false;