uriloader/prefetch/nsOfflineCacheUpdate.h

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Mozilla Corporation
  19  * Portions created by the Initial Developer are Copyright (C) 2007
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Dave Camp <dcamp@mozilla.com>
  24  *
  25  * Alternatively, the contents of this file may be used under the terms of
  26  * either the GNU General Public License Version 2 or later (the "GPL"), or
  27  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  28  * in which case the provisions of the GPL or the LGPL are applicable instead
  29  * of those above. If you wish to allow use of your version of this file only
  30  * under the terms of either the GPL or the LGPL, and not to allow others to
  31  * use your version of this file under the terms of the MPL, indicate your
  32  * decision by deleting the provisions above and replace them with the notice
  33  * and other provisions required by the GPL or the LGPL. If you do not delete
  34  * the provisions above, a recipient may use your version of this file under
  35  * the terms of any one of the MPL, the GPL or the LGPL.
  36  *
  37  * ***** END LICENSE BLOCK ***** */
  38
  39 #ifndef nsOfflineCacheUpdate_h__
  40 #define nsOfflineCacheUpdate_h__
  41
  42 #include "nsIOfflineCacheUpdate.h"
  43
  44 #include "nsAutoPtr.h"
  45 #include "nsCOMArray.h"
  46 #include "nsCOMPtr.h"
  47 #include "nsICacheService.h"
  48 #include "nsIChannelEventSink.h"
  49 #include "nsIDOMDocument.h"
  50 #include "nsIDOMNode.h"
  51 #include "nsIDOMLoadStatus.h"
  52 #include "nsIInterfaceRequestor.h"
  53 #include "nsIMutableArray.h"
  54 #include "nsIObserver.h"
  55 #include "nsIObserverService.h"
  56 #include "nsIApplicationCache.h"
  57 #include "nsIRequestObserver.h"
  58 #include "nsIRunnable.h"
  59 #include "nsIStreamListener.h"
  60 #include "nsIURI.h"
  61 #include "nsIWebProgressListener.h"
  62 #include "nsClassHashtable.h"
  63 #include "nsString.h"
  64 #include "nsTArray.h"
  65 #include "nsWeakReference.h"
  66 #include "nsICryptoHash.h"
  67
  68 class nsOfflineCacheUpdate;
  69
  70 class nsICacheEntryDescriptor;
  71 class nsIUTF8StringEnumerator;
  72
  73 class nsOfflineCacheUpdateItem : public nsIDOMLoadStatus
  74                                , public nsIStreamListener
  75                                , public nsIRunnable
  76                                , public nsIInterfaceRequestor
  77                                , public nsIChannelEventSink
  78 {
  79 public:
  80     NS_DECL_ISUPPORTS
  81     NS_DECL_NSIDOMLOADSTATUS
  82     NS_DECL_NSIREQUESTOBSERVER
  83     NS_DECL_NSISTREAMLISTENER
  84     NS_DECL_NSIRUNNABLE
  85     NS_DECL_NSIINTERFACEREQUESTOR
  86     NS_DECL_NSICHANNELEVENTSINK
  87
  88     nsOfflineCacheUpdateItem(nsOfflineCacheUpdate *aUpdate,
  89                              nsIURI *aURI,
  90                              nsIURI *aReferrerURI,
  91                              nsIApplicationCache *aPreviousApplicationCache,
  92                              const nsACString &aClientID,
  93                              PRUint32 aType);
  94     virtual ~nsOfflineCacheUpdateItem();
  95
  96     nsCOMPtr<nsIURI>           mURI;
  97     nsCOMPtr<nsIURI>           mReferrerURI;
  98     nsCOMPtr<nsIApplicationCache> mPreviousApplicationCache;
  99     nsCString                  mClientID;
 100     nsCString                  mCacheKey;
 101     PRUint32                   mItemType;
 102
 103     nsresult OpenChannel();
 104     nsresult Cancel();
 105
 106 private:
 107     nsOfflineCacheUpdate*          mUpdate;
 108     nsCOMPtr<nsIChannel>           mChannel;
 109     PRUint16                       mState;
 110
 111 protected:
 112     PRInt32                        mBytesRead;
 113 };
 114
 115
 116 class nsOfflineManifestItem : public nsOfflineCacheUpdateItem
 117 {
 118 public:
 119     NS_DECL_NSISTREAMLISTENER
 120     NS_DECL_NSIREQUESTOBSERVER
 121
 122     nsOfflineManifestItem(nsOfflineCacheUpdate *aUpdate,
 123                           nsIURI *aURI,
 124                           nsIURI *aReferrerURI,
 125                           nsIApplicationCache *aPreviousApplicationCache,
 126                           const nsACString &aClientID);
 127     virtual ~nsOfflineManifestItem();
 128
 129     nsCOMArray<nsIURI> &GetExplicitURIs() { return mExplicitURIs; }
 130     nsCOMArray<nsIURI> &GetFallbackURIs() { return mFallbackURIs; }
 131
 132     nsTArray<nsCString> &GetOpportunisticNamespaces()
 133         { return mOpportunisticNamespaces; }
 134     nsIArray *GetNamespaces()
 135         { return mNamespaces.get(); }
 136
 137     PRBool ParseSucceeded()
 138         { return (mParserState != PARSE_INIT && mParserState != PARSE_ERROR); }
 139     PRBool NeedsUpdate() { return mParserState != PARSE_INIT && mNeedsUpdate; }
 140
 141     void GetManifestHash(nsCString &aManifestHash)
 142         { aManifestHash = mManifestHashValue; }
 143
 144 private:
 145     static NS_METHOD ReadManifest(nsIInputStream *aInputStream,
 146                                   void *aClosure,
 147                                   const char *aFromSegment,
 148                                   PRUint32 aOffset,
 149                                   PRUint32 aCount,
 150                                   PRUint32 *aBytesConsumed);
 151
 152     nsresult AddNamespace(PRUint32 namespaceType,
 153                           const nsCString &namespaceSpec,
 154                           const nsCString &data);
 155
 156     nsresult HandleManifestLine(const nsCString::const_iterator &aBegin,
 157                                 const nsCString::const_iterator &aEnd);
 158
 159     /**
 160      * Saves "offline-manifest-hash" meta data from the old offline cache
 161      * token to mOldManifestHashValue member to be compared on
 162      * successfull load.
 163      */
 164     nsresult GetOldManifestContentHash(nsIRequest *aRequest);
 165     /**
 166      * This method setups the mNeedsUpdate to PR_FALSE when hash value
 167      * of the just downloaded manifest file is the same as stored in cache's
 168      * "offline-manifest-hash" meta data. Otherwise stores the new value
 169      * to this meta data.
 170      */
 171     nsresult CheckNewManifestContentHash(nsIRequest *aRequest);
 172
 173     void ReadStrictFileOriginPolicyPref();
 174
 175     enum {
 176         PARSE_INIT,
 177         PARSE_CACHE_ENTRIES,
 178         PARSE_FALLBACK_ENTRIES,
 179         PARSE_BYPASS_ENTRIES,
 180         PARSE_ERROR
 181     } mParserState;
 182
 183     nsCString mReadBuf;
 184
 185     nsCOMArray<nsIURI> mExplicitURIs;
 186     nsCOMArray<nsIURI> mFallbackURIs;
 187
 188     // All opportunistic caching namespaces.  Used to decide whether
 189     // to include previously-opportunistically-cached entries.
 190     nsTArray<nsCString> mOpportunisticNamespaces;
 191
 192     // Array of nsIApplicationCacheNamespace objects specified by the
 193     // manifest.
 194     nsCOMPtr<nsIMutableArray> mNamespaces;
 195
 196     PRBool mNeedsUpdate;
 197     PRBool mStrictFileOriginPolicy;
 198
 199     // manifest hash data
 200     nsCOMPtr<nsICryptoHash> mManifestHash;
 201     PRBool mManifestHashInitialized;
 202     nsCString mManifestHashValue;
 203     nsCString mOldManifestHashValue;
 204 };
 205
 206 class nsOfflineCacheUpdate : public nsIOfflineCacheUpdate
 207 {
 208 public:
 209     NS_DECL_ISUPPORTS
 210     NS_DECL_NSIOFFLINECACHEUPDATE
 211
 212     nsOfflineCacheUpdate();
 213     ~nsOfflineCacheUpdate();
 214
 215     static nsresult GetCacheKey(nsIURI *aURI, nsACString &aKey);
 216
 217     nsresult Init();
 218
 219     nsresult Begin();
 220     nsresult Cancel();
 221
 222     void LoadCompleted();
 223     void ManifestCheckCompleted(nsresult aStatus,
 224                                 const nsCString &aManifestHash);
 225     void AddDocument(nsIDOMDocument *aDocument);
 226
 227 private:
 228     nsresult HandleManifest(PRBool *aDoUpdate);
 229     nsresult AddURI(nsIURI *aURI, PRUint32 aItemType);
 230
 231     nsresult ProcessNextURI();
 232
 233     // Adds items from the previous cache witha type matching aType.
 234     // If namespaceFilter is non-null, only items matching the
 235     // specified namespaces will be added.
 236     nsresult AddExistingItems(PRUint32 aType,
 237                               nsTArray<nsCString>* namespaceFilter = nsnull);
 238
 239     nsresult GatherObservers(nsCOMArray<nsIOfflineCacheUpdateObserver> &aObservers);
 240     nsresult NotifyError();
 241     nsresult NotifyChecking();
 242     nsresult NotifyNoUpdate();
 243     nsresult NotifyObsolete();
 244     nsresult NotifyDownloading();
 245     nsresult NotifyStarted(nsOfflineCacheUpdateItem *aItem);
 246     nsresult NotifyCompleted(nsOfflineCacheUpdateItem *aItem);
 247     nsresult AssociateDocument(nsIDOMDocument *aDocument);
 248     nsresult ScheduleImplicit();
 249     nsresult Finish();
 250
 251     enum {
 252         STATE_UNINITIALIZED,
 253         STATE_INITIALIZED,
 254         STATE_CHECKING,
 255         STATE_DOWNLOADING,
 256         STATE_CANCELLED,
 257         STATE_FINISHED
 258     } mState;
 259
 260     PRPackedBool mAddedItems;
 261     PRPackedBool mPartialUpdate;
 262     PRPackedBool mSucceeded;
 263     PRPackedBool mObsolete;
 264
 265     nsCString mUpdateDomain;
 266     nsCOMPtr<nsIURI> mManifestURI;
 267
 268     nsCOMPtr<nsIURI> mDocumentURI;
 269
 270     nsCString mClientID;
 271     nsCOMPtr<nsIApplicationCache> mApplicationCache;
 272     nsCOMPtr<nsIApplicationCache> mPreviousApplicationCache;
 273
 274     nsCOMPtr<nsIObserverService> mObserverService;
 275
 276     nsRefPtr<nsOfflineManifestItem> mManifestItem;
 277
 278     /* Items being updated */
 279     PRInt32 mCurrentItem;
 280     nsTArray<nsRefPtr<nsOfflineCacheUpdateItem> > mItems;
 281
 282     /* Clients watching this update for changes */
 283     nsCOMArray<nsIWeakReference> mWeakObservers;
 284     nsCOMArray<nsIOfflineCacheUpdateObserver> mObservers;
 285
 286     /* Documents that requested this update */
 287     nsCOMArray<nsIDOMDocument> mDocuments;
 288
 289     /* Reschedule count.  When an update is rescheduled due to
 290      * mismatched manifests, the reschedule count will be increased. */
 291     PRUint32 mRescheduleCount;
 292 };
 293
 294 class nsOfflineCacheUpdateService : public nsIOfflineCacheUpdateService
 295                                   , public nsIWebProgressListener
 296                                   , public nsIObserver
 297                                   , public nsSupportsWeakReference
 298 {
 299 public:
 300     NS_DECL_ISUPPORTS
 301     NS_DECL_NSIOFFLINECACHEUPDATESERVICE
 302     NS_DECL_NSIWEBPROGRESSLISTENER
 303     NS_DECL_NSIOBSERVER
 304
 305     nsOfflineCacheUpdateService();
 306     ~nsOfflineCacheUpdateService();
 307
 308     nsresult Init();
 309
 310     nsresult Schedule(nsOfflineCacheUpdate *aUpdate);
 311     nsresult Schedule(nsIURI *aManifestURI,
 312                       nsIURI *aDocumentURI,
 313                       nsIDOMDocument *aDocument,
 314                       nsIOfflineCacheUpdate **aUpdate);
 315
 316     nsresult UpdateFinished(nsOfflineCacheUpdate *aUpdate);
 317
 318     /**
 319      * Returns the singleton nsOfflineCacheUpdateService without an addref, or
 320      * nsnull if the service couldn't be created.
 321      */
 322     static nsOfflineCacheUpdateService *EnsureService();
 323
 324     /** Addrefs and returns the singleton nsOfflineCacheUpdateService. */
 325     static nsOfflineCacheUpdateService *GetInstance();
 326
 327 private:
 328     nsresult ProcessNextUpdate();
 329
 330     nsTArray<nsRefPtr<nsOfflineCacheUpdate> > mUpdates;
 331
 332     struct PendingUpdate {
 333         nsCOMPtr<nsIURI> mManifestURI;
 334         nsCOMPtr<nsIURI> mDocumentURI;
 335     };
 336     nsClassHashtable<nsVoidPtrHashKey, PendingUpdate> mDocUpdates;
 337
 338     PRBool mDisabled;
 339     PRBool mUpdateRunning;
 340 };
 341
 342 #endif