netwerk/cache2/CacheStorage.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "CacheLog.h"
   6 #include "CacheStorage.h"
   7 #include "CacheStorageService.h"
   8 #include "CacheEntry.h"
   9 #include "CacheObserver.h"
  10
  11 #include "nsICacheEntryDoomCallback.h"
  12
  13 #include "nsIURI.h"
  14 #include "nsNetUtil.h"
  15
  16 namespace mozilla::net {
  17
  18 NS_IMPL_ISUPPORTS(CacheStorage, nsICacheStorage)
  19
  20 CacheStorage::CacheStorage(nsILoadContextInfo* aInfo, bool aAllowDisk,
  21                            bool aSkipSizeCheck, bool aPinning)
  22     : mLoadContextInfo(aInfo ? GetLoadContextInfo(aInfo) : nullptr),
  23       mWriteToDisk(aAllowDisk),
  24       mSkipSizeCheck(aSkipSizeCheck),
  25       mPinning(aPinning) {}
  26
  27 NS_IMETHODIMP CacheStorage::AsyncOpenURI(nsIURI* aURI,
  28                                          const nsACString& aIdExtension,
  29                                          uint32_t aFlags,
  30                                          nsICacheEntryOpenCallback* aCallback) {
  31   if (!CacheStorageService::Self()) return NS_ERROR_NOT_INITIALIZED;
  32
  33   if (MOZ_UNLIKELY(!CacheObserver::UseDiskCache()) && mWriteToDisk &&
  34       !(aFlags & OPEN_INTERCEPTED)) {
  35     aCallback->OnCacheEntryAvailable(nullptr, false, NS_ERROR_NOT_AVAILABLE);
  36     return NS_OK;
  37   }
  38
  39   if (MOZ_UNLIKELY(!CacheObserver::UseMemoryCache()) && !mWriteToDisk &&
  40       !(aFlags & OPEN_INTERCEPTED)) {
  41     aCallback->OnCacheEntryAvailable(nullptr, false, NS_ERROR_NOT_AVAILABLE);
  42     return NS_OK;
  43   }
  44
  45   NS_ENSURE_ARG(aURI);
  46   NS_ENSURE_ARG(aCallback);
  47
  48   nsresult rv;
  49
  50   nsCOMPtr<nsIURI> noRefURI;
  51   rv = NS_GetURIWithoutRef(aURI, getter_AddRefs(noRefURI));
  52   NS_ENSURE_SUCCESS(rv, rv);
  53
  54   nsAutoCString asciiSpec;
  55   rv = noRefURI->GetAsciiSpec(asciiSpec);
  56   NS_ENSURE_SUCCESS(rv, rv);
  57
  58   RefPtr<CacheEntryHandle> entry;
  59   rv = CacheStorageService::Self()->AddStorageEntry(
  60       this, asciiSpec, aIdExtension, aFlags, getter_AddRefs(entry));
  61   if (NS_FAILED(rv)) {
  62     aCallback->OnCacheEntryAvailable(nullptr, false, rv);
  63     return NS_OK;
  64   }
  65
  66   // May invoke the callback synchronously
  67   entry->Entry()->AsyncOpen(aCallback, aFlags);
  68
  69   return NS_OK;
  70 }
  71
  72 NS_IMETHODIMP CacheStorage::OpenTruncate(nsIURI* aURI,
  73                                          const nsACString& aIdExtension,
  74                                          nsICacheEntry** aCacheEntry) {
  75   if (!CacheStorageService::Self()) return NS_ERROR_NOT_INITIALIZED;
  76
  77   nsresult rv;
  78
  79   nsCOMPtr<nsIURI> noRefURI;
  80   rv = NS_GetURIWithoutRef(aURI, getter_AddRefs(noRefURI));
  81   NS_ENSURE_SUCCESS(rv, rv);
  82
  83   nsAutoCString asciiSpec;
  84   rv = noRefURI->GetAsciiSpec(asciiSpec);
  85   NS_ENSURE_SUCCESS(rv, rv);
  86
  87   RefPtr<CacheEntryHandle> handle;
  88   rv = CacheStorageService::Self()->AddStorageEntry(
  89       this, asciiSpec, aIdExtension,
  90       nsICacheStorage::OPEN_TRUNCATE,  // replace any existing one
  91       getter_AddRefs(handle));
  92   NS_ENSURE_SUCCESS(rv, rv);
  93
  94   // Just open w/o callback, similar to nsICacheEntry.recreate().
  95   handle->Entry()->AsyncOpen(nullptr, OPEN_TRUNCATE);
  96
  97   // Return a write handler, consumer is supposed to fill in the entry.
  98   RefPtr<CacheEntryHandle> writeHandle = handle->Entry()->NewWriteHandle();
  99   writeHandle.forget(aCacheEntry);
 100
 101   return NS_OK;
 102 }
 103
 104 NS_IMETHODIMP CacheStorage::Exists(nsIURI* aURI, const nsACString& aIdExtension,
 105                                    bool* aResult) {
 106   NS_ENSURE_ARG(aURI);
 107   NS_ENSURE_ARG(aResult);
 108
 109   if (!CacheStorageService::Self()) return NS_ERROR_NOT_INITIALIZED;
 110
 111   nsresult rv;
 112
 113   nsCOMPtr<nsIURI> noRefURI;
 114   rv = NS_GetURIWithoutRef(aURI, getter_AddRefs(noRefURI));
 115   NS_ENSURE_SUCCESS(rv, rv);
 116
 117   nsAutoCString asciiSpec;
 118   rv = noRefURI->GetAsciiSpec(asciiSpec);
 119   NS_ENSURE_SUCCESS(rv, rv);
 120
 121   return CacheStorageService::Self()->CheckStorageEntry(this, asciiSpec,
 122                                                         aIdExtension, aResult);
 123 }
 124
 125 NS_IMETHODIMP
 126 CacheStorage::GetCacheIndexEntryAttrs(nsIURI* aURI,
 127                                       const nsACString& aIdExtension,
 128                                       bool* aHasAltData, uint32_t* aSizeInKB) {
 129   NS_ENSURE_ARG(aURI);
 130   NS_ENSURE_ARG(aHasAltData);
 131   NS_ENSURE_ARG(aSizeInKB);
 132   if (!CacheStorageService::Self()) {
 133     return NS_ERROR_NOT_INITIALIZED;
 134   }
 135
 136   nsresult rv;
 137
 138   nsCOMPtr<nsIURI> noRefURI;
 139   rv = NS_GetURIWithoutRef(aURI, getter_AddRefs(noRefURI));
 140   NS_ENSURE_SUCCESS(rv, rv);
 141
 142   nsAutoCString asciiSpec;
 143   rv = noRefURI->GetAsciiSpec(asciiSpec);
 144   NS_ENSURE_SUCCESS(rv, rv);
 145
 146   return CacheStorageService::Self()->GetCacheIndexEntryAttrs(
 147       this, asciiSpec, aIdExtension, aHasAltData, aSizeInKB);
 148 }
 149
 150 NS_IMETHODIMP CacheStorage::AsyncDoomURI(nsIURI* aURI,
 151                                          const nsACString& aIdExtension,
 152                                          nsICacheEntryDoomCallback* aCallback) {
 153   if (!CacheStorageService::Self()) return NS_ERROR_NOT_INITIALIZED;
 154
 155   nsresult rv;
 156
 157   nsCOMPtr<nsIURI> noRefURI;
 158   rv = NS_GetURIWithoutRef(aURI, getter_AddRefs(noRefURI));
 159   NS_ENSURE_SUCCESS(rv, rv);
 160
 161   nsAutoCString asciiSpec;
 162   rv = noRefURI->GetAsciiSpec(asciiSpec);
 163   NS_ENSURE_SUCCESS(rv, rv);
 164
 165   rv = CacheStorageService::Self()->DoomStorageEntry(this, asciiSpec,
 166                                                      aIdExtension, aCallback);
 167   NS_ENSURE_SUCCESS(rv, rv);
 168
 169   return NS_OK;
 170 }
 171
 172 NS_IMETHODIMP CacheStorage::AsyncEvictStorage(
 173     nsICacheEntryDoomCallback* aCallback) {
 174   if (!CacheStorageService::Self()) return NS_ERROR_NOT_INITIALIZED;
 175
 176   nsresult rv =
 177       CacheStorageService::Self()->DoomStorageEntries(this, aCallback);
 178   NS_ENSURE_SUCCESS(rv, rv);
 179
 180   return NS_OK;
 181 }
 182
 183 NS_IMETHODIMP CacheStorage::AsyncVisitStorage(nsICacheStorageVisitor* aVisitor,
 184                                               bool aVisitEntries) {
 185   LOG(("CacheStorage::AsyncVisitStorage [this=%p, cb=%p, disk=%d]", this,
 186        aVisitor, (bool)mWriteToDisk));
 187   if (!CacheStorageService::Self()) return NS_ERROR_NOT_INITIALIZED;
 188
 189   nsresult rv = CacheStorageService::Self()->WalkStorageEntries(
 190       this, aVisitEntries, aVisitor);
 191   NS_ENSURE_SUCCESS(rv, rv);
 192
 193   return NS_OK;
 194 }
 195
 196 }  // namespace mozilla::net