--- a/addon-sdk/source/lib/sdk/event/core.js
+++ b/addon-sdk/source/lib/sdk/event/core.js
@@ -97,17 +97,17 @@ function emitOnObject(target, type, this
   // If error event and there are no handlers (explicit or catch-all)
   // then print error message to the console.
   if (type === 'error' && !listeners.size && !allListeners.get('*').size)
     console.exception(args[0]);
 
   let count = listenerCount;
   for (let [listener, added] of listeners)
     try {
-      // Since our contract unfortuantely requires that we not dispatch to
+      // Since our contract unfortunately requires that we not dispatch to
       // this event to listeners that were either added or removed during this
       // dispatch, we need to check when each listener was added.
       if (added >= count)
         break;
       listener.apply(thisArg, args);
     }
     catch (error) {
       // If exception is not thrown by a error listener and error listener is

--- a/js/src/gc/GCRuntime.h
+++ b/js/src/gc/GCRuntime.h
@@ -503,17 +503,17 @@ class GCSchedulingTunables
  *      TOO_MUCH_MALLOC
  *      ---------------
  *      Performs a GC before size[allocated] - size[retained] gets too large
  *      for non-incremental sweeping to be fast in the case that we have
  *      significantly more malloc allocation than GC allocation. This is meant
  *      to complement MAYBEGC triggers. We track this by counting malloced
  *      bytes; the counter gets reset at every GC since we do not always have a
  *      size at the time we call free. Because of this, the malloc heuristic
- *      is, unfortunatly, not usefully able to augment our other GC heap
+ *      is, unfortunately, not usefully able to augment our other GC heap
  *      triggers and is limited to this singular heuristic.
  *
  *          Assumptions:
  *            -> EITHER size[allocated_by_malloc] ~= size[allocated_by_GC]
  *                 OR   time[sweeping] ~= size[allocated_by_malloc]
  *            -> size[retained] @ t0 ~= size[retained] @ t1
  *               i.e. That the mutator is in steady-state operation.
  *

--- a/netwerk/cache2/CacheEntry.cpp
+++ b/netwerk/cache2/CacheEntry.cpp
@@ -580,17 +580,17 @@ void CacheEntry::TransferCallbacks(Cache
 
   if (!mCallbacks.Length())
     mCallbacks.SwapElements(aFromEntry.mCallbacks);
   else
     mCallbacks.AppendElements(aFromEntry.mCallbacks);
 
   uint32_t callbacksLength = mCallbacks.Length();
   if (callbacksLength) {
-    // Carry the entry reference (unfortunatelly, needs to be done manually...)
+    // Carry the entry reference (unfortunately, needs to be done manually...)
     for (uint32_t i = 0; i < callbacksLength; ++i)
       mCallbacks[i].ExchangeEntry(this);
 
     BackgroundOp(Ops::CALLBACKS, true);
   }
 }
 
 void CacheEntry::RememberCallback(Callback & aCallback)
@@ -1929,17 +1929,17 @@ size_t CacheEntry::SizeOfExcludingThis(m
 
   n += mURI.SizeOfExcludingThisIfUnshared(mallocSizeOf);
   n += mEnhanceID.SizeOfExcludingThisIfUnshared(mallocSizeOf);
   n += mStorageID.SizeOfExcludingThisIfUnshared(mallocSizeOf);
 
   // mDoomCallback is an arbitrary class that is probably reported elsewhere.
   // mOutputStream is reported in mFile.
   // mWriter is one of many handles we create, but (intentionally) not keep
-  // any reference to, so those unfortunatelly cannot be reported.  Handles are
+  // any reference to, so those unfortunately cannot be reported.  Handles are
   // small, though.
   // mSecurityInfo doesn't impl nsISizeOf.
 
   return n;
 }
 
 size_t CacheEntry::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
 {

--- a/netwerk/cache2/CacheFileOutputStream.cpp
+++ b/netwerk/cache2/CacheFileOutputStream.cpp
@@ -102,17 +102,17 @@ CacheFileOutputStream::Write(const char 
     LOG(("CacheFileOutputStream::Write() - Entry is too big, failing and "
          "dooming the entry. [this=%p]", this));
 
     mFile->DoomLocked(nullptr);
     CloseWithStatusLocked(NS_ERROR_FILE_TOO_BIG);
     return NS_ERROR_FILE_TOO_BIG;
   }
 
-  // We use 64-bit offset when accessing the file, unfortunatelly we use 32-bit
+  // We use 64-bit offset when accessing the file, unfortunately we use 32-bit
   // metadata offset, so we cannot handle data bigger than 4GB.
   if (mPos + aCount > PR_UINT32_MAX) {
     LOG(("CacheFileOutputStream::Write() - Entry's size exceeds 4GB while it "
          "isn't too big according to CacheObserver::EntryIsTooBig(). Failing "
          "and dooming the entry. [this=%p]", this));
 
     mFile->DoomLocked(nullptr);
     CloseWithStatusLocked(NS_ERROR_FILE_TOO_BIG);

--- a/netwerk/cache2/CacheStorageService.cpp
+++ b/netwerk/cache2/CacheStorageService.cpp
@@ -586,17 +586,17 @@ private:
   nsCOMPtr<nsIFile> mCache2Profileless;
 #endif
 };
 
 // static
 bool CleaupCacheDirectoriesRunnable::Post(uint32_t aVersion, uint32_t aActive)
 {
   // CleaupCacheDirectories is called regardless what cache version is set up to use.
-  // To obtain the cache1 directory we must unfortunatelly instantiate the old cache
+  // To obtain the cache1 directory we must unfortunately instantiate the old cache
   // service despite it may not be used at all...  This also initialize nsDeleteDir.
   nsCOMPtr<nsICacheService> service = do_GetService(NS_CACHESERVICE_CONTRACTID);
   if (!service)
     return false;
 
   nsCOMPtr<nsIEventTarget> thread;
   service->GetCacheIOTarget(getter_AddRefs(thread));
   if (!thread)