--- a/netwerk/base/Predictor.cpp
+++ b/netwerk/base/Predictor.cpp
@@ -2015,17 +2015,17 @@ Predictor::Resetter::OnCacheStorageInfo(
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 Predictor::Resetter::OnCacheEntryInfo(nsIURI *uri, const nsACString &idEnhance,
                                       int64_t dataSize, int32_t fetchCount,
                                       uint32_t lastModifiedTime, uint32_t expirationTime,
-                                      bool aPinned)
+                                      bool aPinned, nsILoadContextInfo* aInfo)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   // The predictor will only ever touch entries with no idEnhance ("") or an
   // idEnhance of PREDICTOR_ORIGIN_EXTENSION, so we filter out any entries that
   // don't match that to avoid doing extra work.
   if (idEnhance.EqualsLiteral(PREDICTOR_ORIGIN_EXTENSION)) {
     // This is an entry we own, so we can just doom it entirely

--- a/netwerk/cache2/CacheFileIOManager.cpp
+++ b/netwerk/cache2/CacheFileIOManager.cpp
@@ -2462,17 +2462,18 @@ CacheFileIOManager::GetEntryInfo(const S
   }
   uint32_t lastModified;
   if (NS_FAILED(metadata->GetLastModified(&lastModified))) {
     lastModified = 0;
   }
 
   // Call directly on the callback.
   aCallback->OnEntryInfo(uriSpec, enhanceId, dataSize, fetchCount,
-                         lastModified, expirationTime, metadata->Pinned());
+                         lastModified, expirationTime, metadata->Pinned(),
+                         info);
 
   return NS_OK;
 }
 
 nsresult
 CacheFileIOManager::TruncateSeekSetEOFInternal(CacheFileHandle *aHandle,
                                                int64_t aTruncatePos,
                                                int64_t aEOFPos)

--- a/netwerk/cache2/CacheStorageService.cpp
+++ b/netwerk/cache2/CacheStorageService.cpp
@@ -320,28 +320,29 @@ private:
   {
     if (mCallback)
       ProxyReleaseMainThread(mCallback);
   }
 
   virtual void OnEntryInfo(const nsACString & aURISpec, const nsACString & aIdEnhance,
                            int64_t aDataSize, int32_t aFetchCount,
                            uint32_t aLastModifiedTime, uint32_t aExpirationTime,
-                           bool aPinned) override
+                           bool aPinned, nsILoadContextInfo* aInfo) override
   {
     nsresult rv;
 
     nsCOMPtr<nsIURI> uri;
     rv = NS_NewURI(getter_AddRefs(uri), aURISpec);
     if (NS_FAILED(rv)) {
       return;
     }
 
     rv = mCallback->OnCacheEntryInfo(uri, aIdEnhance, aDataSize, aFetchCount,
-                                     aLastModifiedTime, aExpirationTime, aPinned);
+                                     aLastModifiedTime, aExpirationTime,
+                                     aPinned, aInfo);
     if (NS_FAILED(rv)) {
       LOG(("  callback failed, canceling the walk"));
       mCancel = true;
     }
   }
 
 private:
   nsCString mContextKey;
@@ -398,33 +399,34 @@ private:
       nsCOMPtr<nsIURI> uri;
       rv = NS_NewURI(getter_AddRefs(uri), mURISpec);
       if (NS_FAILED(rv)) {
         return NS_OK;
       }
 
       rv = mWalker->mCallback->OnCacheEntryInfo(
         uri, mIdEnhance, mDataSize, mFetchCount,
-        mLastModifiedTime, mExpirationTime, mPinned);
+        mLastModifiedTime, mExpirationTime, mPinned, mInfo);
       if (NS_FAILED(rv)) {
         mWalker->mCancel = true;
       }
 
       return NS_OK;
     }
 
     RefPtr<WalkDiskCacheRunnable> mWalker;
 
     nsCString mURISpec;
     nsCString mIdEnhance;
     int64_t mDataSize;
     int32_t mFetchCount;
     uint32_t mLastModifiedTime;
     uint32_t mExpirationTime;
     bool mPinned;
+    nsCOMPtr<nsILoadContextInfo> mInfo;
   };
 
   NS_IMETHOD Run() override
   {
     // The main loop
     nsresult rv;
 
     if (CacheStorageService::IsOnManagementThread()) {
@@ -495,29 +497,30 @@ private:
     }
 
     return NS_OK;
   }
 
   virtual void OnEntryInfo(const nsACString & aURISpec, const nsACString & aIdEnhance,
                            int64_t aDataSize, int32_t aFetchCount,
                            uint32_t aLastModifiedTime, uint32_t aExpirationTime,
-                           bool aPinned) override
+                           bool aPinned, nsILoadContextInfo* aInfo) override
   {
     // Called directly from CacheFileIOManager::GetEntryInfo.
 
     // Invoke onCacheEntryInfo on the main thread for this entry.
     RefPtr<OnCacheEntryInfoRunnable> info = new OnCacheEntryInfoRunnable(this);
     info->mURISpec = aURISpec;
     info->mIdEnhance = aIdEnhance;
     info->mDataSize = aDataSize;
     info->mFetchCount = aFetchCount;
     info->mLastModifiedTime = aLastModifiedTime;
     info->mExpirationTime = aExpirationTime;
     info->mPinned = aPinned;
+    info->mInfo = aInfo;
 
     NS_DispatchToMainThread(info);
   }
 
   RefPtr<nsILoadContextInfo> mLoadInfo;
   enum {
     // First, we collect stats for the load context.
     COLLECT_STATS,
@@ -1983,16 +1986,22 @@ CacheStorageService::GetCacheEntryInfo(n
 // static
 void
 CacheStorageService::GetCacheEntryInfo(CacheEntry* aEntry,
                                        EntryInfoCallback *aCallback)
 {
   nsCString const uriSpec = aEntry->GetURI();
   nsCString const enhanceId = aEntry->GetEnhanceID();
 
+  nsAutoCString entryKey;
+  aEntry->HashingKeyWithStorage(entryKey);
+
+  nsCOMPtr<nsILoadContextInfo> info =
+    CacheFileUtils::ParseKey(entryKey);
+
   uint32_t dataSize;
   if (NS_FAILED(aEntry->GetStorageDataSize(&dataSize))) {
     dataSize = 0;
   }
   int32_t fetchCount;
   if (NS_FAILED(aEntry->GetFetchCount(&fetchCount))) {
     fetchCount = 0;
   }
@@ -2002,17 +2011,17 @@ CacheStorageService::GetCacheEntryInfo(C
   }
   uint32_t expirationTime;
   if (NS_FAILED(aEntry->GetExpirationTime(&expirationTime))) {
     expirationTime = 0;
   }
 
   aCallback->OnEntryInfo(uriSpec, enhanceId, dataSize,
                          fetchCount, lastModified, expirationTime,
-                         aEntry->IsPinned());
+                         aEntry->IsPinned(), info);
 }
 
 // static
 uint32_t CacheStorageService::CacheQueueSize(bool highPriority)
 {
   RefPtr<CacheIOThread> thread = CacheFileIOManager::IOThread();
   MOZ_ASSERT(thread);
   return thread->QueueSize(highPriority);

--- a/netwerk/cache2/CacheStorageService.h
+++ b/netwerk/cache2/CacheStorageService.h
@@ -100,17 +100,17 @@ public:
   // Helper thread-safe interface to pass entry info, only difference from
   // nsICacheStorageVisitor is that instead of nsIURI only the uri spec is
   // passed.
   class EntryInfoCallback {
   public:
     virtual void OnEntryInfo(const nsACString & aURISpec, const nsACString & aIdEnhance,
                              int64_t aDataSize, int32_t aFetchCount,
                              uint32_t aLastModifiedTime, uint32_t aExpirationTime,
-                             bool aPinned) = 0;
+                             bool aPinned, nsILoadContextInfo* aInfo) = 0;
   };
 
   // Invokes OnEntryInfo for the given aEntry, synchronously.
   static void GetCacheEntryInfo(CacheEntry* aEntry, EntryInfoCallback *aVisitor);
 
   static uint32_t CacheQueueSize(bool highPriority);
 
   // Memory reporting

--- a/netwerk/cache2/OldWrappers.cpp
+++ b/netwerk/cache2/OldWrappers.cpp
@@ -257,17 +257,18 @@ NS_IMETHODIMP _OldVisitCallbackWrapper::
   if (NS_FAILED(entryInfo->GetExpirationTime(&expirationTime)))
     expirationTime = 0;
   uint32_t lastModified;
   if (NS_FAILED(entryInfo->GetLastModified(&lastModified)))
     lastModified = 0;
 
   // Send them to the consumer.
   rv = mCB->OnCacheEntryInfo(
-    uri, enhanceId, (int64_t)dataSize, fetchCount, lastModified, expirationTime, false);
+    uri, enhanceId, (int64_t)dataSize, fetchCount, lastModified,
+    expirationTime, false, mLoadInfo);
 
   *_retval = NS_SUCCEEDED(rv);
   return NS_OK;
 }
 
 // _OldGetDiskConsumption
 
 //static

--- a/netwerk/cache2/nsICacheStorageVisitor.idl
+++ b/netwerk/cache2/nsICacheStorageVisitor.idl
@@ -1,16 +1,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsISupports.idl"
 
 interface nsIURI;
 interface nsIFile;
+interface nsILoadContextInfo;
 
 [scriptable, uuid(6cc7c253-93b6-482b-8e9d-1e04d8e9d655)]
 interface nsICacheStorageVisitor : nsISupports
 {
   /**
    */
   void onCacheStorageInfo(in uint32_t aEntryCount,
                           in uint64_t aConsumption,
@@ -20,14 +21,15 @@ interface nsICacheStorageVisitor : nsISu
   /**
    */
   void onCacheEntryInfo(in nsIURI aURI,
                         in ACString aIdEnhance,
                         in int64_t aDataSize,
                         in long aFetchCount,
                         in uint32_t aLastModifiedTime,
                         in uint32_t aExpirationTime,
-                        in boolean aPinned);
+                        in boolean aPinned,
+                        in nsILoadContextInfo aInfo);
 
   /**
    */
   void onCacheEntryVisitCompleted();
 };

--- a/netwerk/protocol/about/nsAboutCache.cpp
+++ b/netwerk/protocol/about/nsAboutCache.cpp
@@ -391,17 +391,17 @@ nsAboutCache::Channel::OnCacheStorageInf
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAboutCache::Channel::OnCacheEntryInfo(nsIURI *aURI, const nsACString & aIdEnhance,
                                         int64_t aDataSize, int32_t aFetchCount,
                                         uint32_t aLastModified, uint32_t aExpirationTime,
-                                        bool aPinned)
+                                        bool aPinned, nsILoadContextInfo* aInfo)
 {
     // We need mStream for this
     if (!mStream || mCancel) {
         // Returning a failure from this callback stops the iteration
         return NS_ERROR_FAILURE;
     }
 
     if (!mEntriesHeaderAdded) {