1 // Stuff to link the old imp to the new api - will go away!
2 
3 #ifndef OLDWRAPPERS__H__
4 #define OLDWRAPPERS__H__
5 
6 #include "nsICacheEntry.h"
7 #include "nsICacheListener.h"
8 #include "nsICacheStorage.h"
9 
10 #include "nsCOMPtr.h"
11 #include "nsICacheEntryOpenCallback.h"
12 #include "nsICacheEntryDescriptor.h"
13 #include "nsICacheStorageVisitor.h"
14 #include "nsThreadUtils.h"
15 #include "mozilla/TimeStamp.h"
16 
17 class nsIURI;
18 class nsICacheEntryOpenCallback;
19 class nsICacheStorageConsumptionObserver;
20 class nsIApplicationCache;
21 class nsILoadContextInfo;
22 
23 namespace mozilla { namespace net {
24 
25 class CacheStorage;
26 
27 class _OldCacheEntryWrapper : public nsICacheEntry
28 {
29 public:
30   NS_DECL_THREADSAFE_ISUPPORTS
31 
32   // nsICacheEntryDescriptor
SetExpirationTime(uint32_t expirationTime)33   NS_IMETHOD SetExpirationTime(uint32_t expirationTime) override
34   {
35     return !mOldDesc ? NS_ERROR_NULL_POINTER :
36                        mOldDesc->SetExpirationTime(expirationTime);
37   }
OpenInputStream(uint32_t offset,nsIInputStream ** _retval)38   nsresult OpenInputStream(uint32_t offset, nsIInputStream * *_retval)
39   {
40     return !mOldDesc ? NS_ERROR_NULL_POINTER :
41                        mOldDesc->OpenInputStream(offset, _retval);
42   }
OpenOutputStream(uint32_t offset,nsIOutputStream ** _retval)43   nsresult OpenOutputStream(uint32_t offset, nsIOutputStream * *_retval)
44   {
45     return !mOldDesc ? NS_ERROR_NULL_POINTER :
46                        mOldDesc->OpenOutputStream(offset, _retval);
47   }
OpenAlternativeOutputStream(const nsACString & type,nsIOutputStream ** _retval)48   NS_IMETHOD OpenAlternativeOutputStream(const nsACString & type, nsIOutputStream * *_retval) override
49   {
50     return NS_ERROR_NOT_IMPLEMENTED;
51   }
OpenAlternativeInputStream(const nsACString & type,nsIInputStream ** _retval)52   NS_IMETHOD OpenAlternativeInputStream(const nsACString & type, nsIInputStream * *_retval) override
53   {
54     return NS_ERROR_NOT_IMPLEMENTED;
55   }
56 
GetPredictedDataSize(int64_t * aPredictedDataSize)57   NS_IMETHOD GetPredictedDataSize(int64_t *aPredictedDataSize) override
58   {
59     return !mOldDesc ? NS_ERROR_NULL_POINTER :
60                        mOldDesc->GetPredictedDataSize(aPredictedDataSize);
61   }
SetPredictedDataSize(int64_t aPredictedDataSize)62   NS_IMETHOD SetPredictedDataSize(int64_t aPredictedDataSize) override
63   {
64     return !mOldDesc ? NS_ERROR_NULL_POINTER :
65                        mOldDesc->SetPredictedDataSize(aPredictedDataSize);
66   }
GetSecurityInfo(nsISupports ** aSecurityInfo)67   NS_IMETHOD GetSecurityInfo(nsISupports * *aSecurityInfo) override
68   {
69     return !mOldDesc ? NS_ERROR_NULL_POINTER :
70                        mOldDesc->GetSecurityInfo(aSecurityInfo);
71   }
SetSecurityInfo(nsISupports * aSecurityInfo)72   NS_IMETHOD SetSecurityInfo(nsISupports *aSecurityInfo) override
73   {
74     return !mOldDesc ? NS_ERROR_NULL_POINTER :
75                        mOldDesc->SetSecurityInfo(aSecurityInfo);
76   }
GetStorageDataSize(uint32_t * aStorageDataSize)77   NS_IMETHOD GetStorageDataSize(uint32_t *aStorageDataSize) override
78   {
79     return !mOldDesc ? NS_ERROR_NULL_POINTER :
80                        mOldDesc->GetStorageDataSize(aStorageDataSize);
81   }
AsyncDoom(nsICacheListener * listener)82   nsresult AsyncDoom(nsICacheListener *listener)
83   {
84     return !mOldDesc ? NS_ERROR_NULL_POINTER :
85                        mOldDesc->AsyncDoom(listener);
86   }
MarkValid(void)87   NS_IMETHOD MarkValid(void) override
88   {
89     return !mOldDesc ? NS_ERROR_NULL_POINTER :
90                        mOldDesc->MarkValid();
91   }
Close(void)92   NS_IMETHOD Close(void) override
93   {
94     return !mOldDesc ? NS_ERROR_NULL_POINTER :
95                        mOldDesc->Close();
96   }
GetMetaDataElement(const char * key,char ** _retval)97   NS_IMETHOD GetMetaDataElement(const char * key, char * *_retval) override
98   {
99     return !mOldDesc ? NS_ERROR_NULL_POINTER :
100                        mOldDesc->GetMetaDataElement(key, _retval);
101   }
SetMetaDataElement(const char * key,const char * value)102   NS_IMETHOD SetMetaDataElement(const char * key, const char * value) override
103   {
104     return !mOldDesc ? NS_ERROR_NULL_POINTER :
105                        mOldDesc->SetMetaDataElement(key, value);
106   }
107 
GetDiskStorageSizeInKB(uint32_t * aDiskStorageSize)108   NS_IMETHOD GetDiskStorageSizeInKB(uint32_t *aDiskStorageSize) override
109   {
110     return NS_ERROR_NOT_IMPLEMENTED;
111   }
112 
113   // nsICacheEntryInfo
GetKey(nsACString & aKey)114   NS_IMETHOD GetKey(nsACString & aKey) override
115   {
116     return mOldInfo->GetKey(aKey);
117   }
GetFetchCount(int32_t * aFetchCount)118   NS_IMETHOD GetFetchCount(int32_t *aFetchCount) override
119   {
120     return mOldInfo->GetFetchCount(aFetchCount);
121   }
GetLastFetched(uint32_t * aLastFetched)122   NS_IMETHOD GetLastFetched(uint32_t *aLastFetched) override
123   {
124     return mOldInfo->GetLastFetched(aLastFetched);
125   }
GetLastModified(uint32_t * aLastModified)126   NS_IMETHOD GetLastModified(uint32_t *aLastModified) override
127   {
128     return mOldInfo->GetLastModified(aLastModified);
129   }
GetExpirationTime(uint32_t * aExpirationTime)130   NS_IMETHOD GetExpirationTime(uint32_t *aExpirationTime) override
131   {
132     return mOldInfo->GetExpirationTime(aExpirationTime);
133   }
GetDataSize(uint32_t * aDataSize)134   nsresult GetDataSize(uint32_t *aDataSize)
135   {
136     return mOldInfo->GetDataSize(aDataSize);
137   }
138 
139   NS_IMETHOD AsyncDoom(nsICacheEntryDoomCallback* listener) override;
140   NS_IMETHOD GetPersistent(bool *aPersistToDisk) override;
141   NS_IMETHOD GetIsForcedValid(bool *aIsForcedValid) override;
142   NS_IMETHOD ForceValidFor(uint32_t aSecondsToTheFuture) override;
SetValid()143   NS_IMETHOD SetValid() override { return NS_OK; }
MetaDataReady()144   NS_IMETHOD MetaDataReady() override { return NS_OK; }
145   NS_IMETHOD Recreate(bool, nsICacheEntry**) override;
146   NS_IMETHOD GetDataSize(int64_t *size) override;
147   NS_IMETHOD GetAltDataSize(int64_t *size) override;
148   NS_IMETHOD OpenInputStream(int64_t offset, nsIInputStream * *_retval) override;
149   NS_IMETHOD OpenOutputStream(int64_t offset, nsIOutputStream * *_retval) override;
150   NS_IMETHOD MaybeMarkValid() override;
151   NS_IMETHOD HasWriteAccess(bool aWriteOnly, bool *aWriteAccess) override;
152   NS_IMETHOD VisitMetaData(nsICacheEntryMetaDataVisitor*) override;
153 
154   explicit _OldCacheEntryWrapper(nsICacheEntryDescriptor* desc);
155   explicit _OldCacheEntryWrapper(nsICacheEntryInfo* info);
156 
157 private:
158   virtual ~_OldCacheEntryWrapper();
159 
160   _OldCacheEntryWrapper() = delete;
161   nsICacheEntryDescriptor* mOldDesc; // ref holded in mOldInfo
162   nsCOMPtr<nsICacheEntryInfo> mOldInfo;
163 };
164 
165 
166 class _OldCacheLoad : public Runnable
167                     , public nsICacheListener
168 {
169 public:
170   NS_DECL_ISUPPORTS_INHERITED
171   NS_DECL_NSIRUNNABLE
172   NS_DECL_NSICACHELISTENER
173 
174   _OldCacheLoad(nsCSubstring const& aScheme,
175                 nsCSubstring const& aCacheKey,
176                 nsICacheEntryOpenCallback* aCallback,
177                 nsIApplicationCache* aAppCache,
178                 nsILoadContextInfo* aLoadInfo,
179                 bool aWriteToDisk,
180                 uint32_t aFlags);
181 
182   nsresult Start();
183 
184 protected:
185   virtual ~_OldCacheLoad();
186 
187 private:
188   void Check();
189 
190   nsCOMPtr<nsIEventTarget> mCacheThread;
191 
192   nsCString const mScheme;
193   nsCString const mCacheKey;
194   nsCOMPtr<nsICacheEntryOpenCallback> mCallback;
195   nsCOMPtr<nsILoadContextInfo> mLoadInfo;
196   uint32_t const mFlags;
197 
198   bool const mWriteToDisk : 1;
199   bool mNew : 1;
200   bool mOpening : 1;
201   bool mSync : 1;
202 
203   nsCOMPtr<nsICacheEntry> mCacheEntry;
204   nsresult mStatus;
205   uint32_t mRunCount;
206   nsCOMPtr<nsIApplicationCache> mAppCache;
207 
208   mozilla::TimeStamp mLoadStart;
209 };
210 
211 
212 class _OldStorage : public nsICacheStorage
213 {
214   NS_DECL_THREADSAFE_ISUPPORTS
215   NS_DECL_NSICACHESTORAGE
216 
217 public:
218   _OldStorage(nsILoadContextInfo* aInfo,
219               bool aAllowDisk,
220               bool aLookupAppCache,
221               bool aOfflineStorage,
222               nsIApplicationCache* aAppCache);
223 
224 private:
225   virtual ~_OldStorage();
226   nsresult AssembleCacheKey(nsIURI *aURI, nsACString const & aIdExtension,
227                             nsACString & aCacheKey, nsACString & aScheme);
228   nsresult ChooseApplicationCache(nsCSubstring const &cacheKey, nsIApplicationCache** aCache);
229 
230   nsCOMPtr<nsILoadContextInfo> mLoadInfo;
231   nsCOMPtr<nsIApplicationCache> mAppCache;
232   bool const mWriteToDisk : 1;
233   bool const mLookupAppCache : 1;
234   bool const mOfflineStorage : 1;
235 };
236 
237 class _OldVisitCallbackWrapper : public nsICacheVisitor
238 {
239   NS_DECL_THREADSAFE_ISUPPORTS
240   NS_DECL_NSICACHEVISITOR
241 
_OldVisitCallbackWrapper(char const * deviceID,nsICacheStorageVisitor * cb,bool visitEntries,nsILoadContextInfo * aInfo)242   _OldVisitCallbackWrapper(char const * deviceID,
243                            nsICacheStorageVisitor * cb,
244                            bool visitEntries,
245                            nsILoadContextInfo * aInfo)
246   : mCB(cb)
247   , mVisitEntries(visitEntries)
248   , mDeviceID(deviceID)
249   , mLoadInfo(aInfo)
250   , mHit(false)
251   {
252     MOZ_COUNT_CTOR(_OldVisitCallbackWrapper);
253   }
254 
255 private:
256   virtual ~_OldVisitCallbackWrapper();
257   nsCOMPtr<nsICacheStorageVisitor> mCB;
258   bool mVisitEntries;
259   char const * mDeviceID;
260   nsCOMPtr<nsILoadContextInfo> mLoadInfo;
261   bool mHit; // set to true when the device was found
262 };
263 
264 class _OldGetDiskConsumption : public Runnable,
265                                public nsICacheVisitor
266 {
267 public:
268   static nsresult Get(nsICacheStorageConsumptionObserver* aCallback);
269 
270 private:
271   explicit _OldGetDiskConsumption(nsICacheStorageConsumptionObserver* aCallback);
~_OldGetDiskConsumption()272   virtual ~_OldGetDiskConsumption() {}
273   NS_DECL_ISUPPORTS_INHERITED
274   NS_DECL_NSICACHEVISITOR
275   NS_DECL_NSIRUNNABLE
276 
277   nsCOMPtr<nsICacheStorageConsumptionObserver> mCallback;
278   int64_t mSize;
279 };
280 
281 } // namespace net
282 } // namespace mozilla
283 
284 #endif
285