LCOV - app.info - uriloader/prefetch/nsOfflineCacheUpdate.h

LCOV - code coverage report
| Current view: | directory - uriloader/prefetch - nsOfflineCacheUpdate.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 12 | 12 | 100.0 %
| Date: | 2012-06-02 | Functions: | 8 | 8 | 100.0 %

           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                 :     nsresult GetRequestSucceeded(bool * succeeded);
         106                 :
         107                 : private:
         108                 :     nsOfflineCacheUpdate*          mUpdate;
         109                 :     nsCOMPtr<nsIChannel>           mChannel;
         110                 :     PRUint16                       mState;
         111                 :
         112                 : protected:
         113                 :     PRInt32                        mBytesRead;
         114                 : };
         115                 :
         116                 :
         117                 : class nsOfflineManifestItem : public nsOfflineCacheUpdateItem
         118                 : {
         119                 : public:
         120                 :     NS_DECL_NSISTREAMLISTENER
         121                 :     NS_DECL_NSIREQUESTOBSERVER
         122                 :
         123                 :     nsOfflineManifestItem(nsOfflineCacheUpdate *aUpdate,
         124                 :                           nsIURI *aURI,
         125                 :                           nsIURI *aReferrerURI,
         126                 :                           nsIApplicationCache *aPreviousApplicationCache,
         127                 :                           const nsACString &aClientID);
         128                 :     virtual ~nsOfflineManifestItem();
         129                 :
         130               8 :     nsCOMArray<nsIURI> &GetExplicitURIs() { return mExplicitURIs; }
         131               8 :     nsCOMArray<nsIURI> &GetFallbackURIs() { return mFallbackURIs; }
         132                 :
         133               8 :     nsTArray<nsCString> &GetOpportunisticNamespaces()
         134               8 :         { return mOpportunisticNamespaces; }
         135               8 :     nsIArray *GetNamespaces()
         136               8 :         { return mNamespaces.get(); }
         137                 :
         138              16 :     bool ParseSucceeded()
         139              16 :         { return (mParserState != PARSE_INIT && mParserState != PARSE_ERROR); }
         140               8 :     bool NeedsUpdate() { return mParserState != PARSE_INIT && mNeedsUpdate; }
         141                 :
         142               8 :     void GetManifestHash(nsCString &aManifestHash)
         143               8 :         { aManifestHash = mManifestHashValue; }
         144                 :
         145                 : private:
         146                 :     static NS_METHOD ReadManifest(nsIInputStream *aInputStream,
         147                 :                                   void *aClosure,
         148                 :                                   const char *aFromSegment,
         149                 :                                   PRUint32 aOffset,
         150                 :                                   PRUint32 aCount,
         151                 :                                   PRUint32 *aBytesConsumed);
         152                 :
         153                 :     nsresult AddNamespace(PRUint32 namespaceType,
         154                 :                           const nsCString &namespaceSpec,
         155                 :                           const nsCString &data);
         156                 :
         157                 :     nsresult HandleManifestLine(const nsCString::const_iterator &aBegin,
         158                 :                                 const nsCString::const_iterator &aEnd);
         159                 :
         160                 :     /**
         161                 :      * Saves "offline-manifest-hash" meta data from the old offline cache
         162                 :      * token to mOldManifestHashValue member to be compared on
         163                 :      * successfull load.
         164                 :      */
         165                 :     nsresult GetOldManifestContentHash(nsIRequest *aRequest);
         166                 :     /**
         167                 :      * This method setups the mNeedsUpdate to false when hash value
         168                 :      * of the just downloaded manifest file is the same as stored in cache's
         169                 :      * "offline-manifest-hash" meta data. Otherwise stores the new value
         170                 :      * to this meta data.
         171                 :      */
         172                 :     nsresult CheckNewManifestContentHash(nsIRequest *aRequest);
         173                 :
         174                 :     void ReadStrictFileOriginPolicyPref();
         175                 :
         176                 :     enum {
         177                 :         PARSE_INIT,
         178                 :         PARSE_CACHE_ENTRIES,
         179                 :         PARSE_FALLBACK_ENTRIES,
         180                 :         PARSE_BYPASS_ENTRIES,
         181                 :         PARSE_ERROR
         182                 :     } mParserState;
         183                 :
         184                 :     nsCString mReadBuf;
         185                 :
         186                 :     nsCOMArray<nsIURI> mExplicitURIs;
         187                 :     nsCOMArray<nsIURI> mFallbackURIs;
         188                 :
         189                 :     // All opportunistic caching namespaces.  Used to decide whether
         190                 :     // to include previously-opportunistically-cached entries.
         191                 :     nsTArray<nsCString> mOpportunisticNamespaces;
         192                 :
         193                 :     // Array of nsIApplicationCacheNamespace objects specified by the
         194                 :     // manifest.
         195                 :     nsCOMPtr<nsIMutableArray> mNamespaces;
         196                 :
         197                 :     bool mNeedsUpdate;
         198                 :     bool mStrictFileOriginPolicy;
         199                 :
         200                 :     // manifest hash data
         201                 :     nsCOMPtr<nsICryptoHash> mManifestHash;
         202                 :     bool mManifestHashInitialized;
         203                 :     nsCString mManifestHashValue;
         204                 :     nsCString mOldManifestHashValue;
         205                 : };
         206                 :
         207                 : class nsOfflineCacheUpdateOwner
         208              16 : {
         209                 : public:
         210                 :     virtual nsresult UpdateFinished(nsOfflineCacheUpdate *aUpdate) = 0;
         211                 : };
         212                 :
         213                 : class nsOfflineCacheUpdate : public nsIOfflineCacheUpdate
         214                 :                            , public nsIOfflineCacheUpdateObserver
         215                 :                            , public nsOfflineCacheUpdateOwner
         216                 : {
         217                 : public:
         218                 :     NS_DECL_ISUPPORTS
         219                 :     NS_DECL_NSIOFFLINECACHEUPDATE
         220                 :     NS_DECL_NSIOFFLINECACHEUPDATEOBSERVER
         221                 :
         222                 :     nsOfflineCacheUpdate();
         223                 :     ~nsOfflineCacheUpdate();
         224                 :
         225                 :     static nsresult GetCacheKey(nsIURI *aURI, nsACString &aKey);
         226                 :
         227                 :     nsresult Init();
         228                 :
         229                 :     nsresult Begin();
         230                 :     nsresult Cancel();
         231                 :
         232                 :     void LoadCompleted();
         233                 :     void ManifestCheckCompleted(nsresult aStatus,
         234                 :                                 const nsCString &aManifestHash);
         235                 :     void StickDocument(nsIURI *aDocumentURI);
         236                 :
         237                 :     void SetOwner(nsOfflineCacheUpdateOwner *aOwner);
         238                 :
         239                 :     virtual nsresult UpdateFinished(nsOfflineCacheUpdate *aUpdate);
         240                 :
         241                 : private:
         242                 :     nsresult HandleManifest(bool *aDoUpdate);
         243                 :     nsresult AddURI(nsIURI *aURI, PRUint32 aItemType);
         244                 :
         245                 :     nsresult ProcessNextURI();
         246                 :
         247                 :     // Adds items from the previous cache witha type matching aType.
         248                 :     // If namespaceFilter is non-null, only items matching the
         249                 :     // specified namespaces will be added.
         250                 :     nsresult AddExistingItems(PRUint32 aType,
         251                 :                               nsTArray<nsCString>* namespaceFilter = nsnull);
         252                 :     nsresult ScheduleImplicit();
         253                 :     nsresult AssociateDocuments(nsIApplicationCache* cache);
         254                 :
         255                 :     nsresult GatherObservers(nsCOMArray<nsIOfflineCacheUpdateObserver> &aObservers);
         256                 :     nsresult NotifyState(PRUint32 state);
         257                 :     nsresult Finish();
         258                 :     nsresult FinishNoNotify();
         259                 :
         260                 :     enum {
         261                 :         STATE_UNINITIALIZED,
         262                 :         STATE_INITIALIZED,
         263                 :         STATE_CHECKING,
         264                 :         STATE_DOWNLOADING,
         265                 :         STATE_CANCELLED,
         266                 :         STATE_FINISHED
         267                 :     } mState;
         268                 :
         269                 :     nsOfflineCacheUpdateOwner *mOwner;
         270                 :
         271                 :     bool mAddedItems;
         272                 :     bool mPartialUpdate;
         273                 :     bool mSucceeded;
         274                 :     bool mObsolete;
         275                 :
         276                 :     nsCString mUpdateDomain;
         277                 :     nsCOMPtr<nsIURI> mManifestURI;
         278                 :     nsCOMPtr<nsIURI> mDocumentURI;
         279                 :
         280                 :     nsCString mClientID;
         281                 :     nsCOMPtr<nsIApplicationCache> mApplicationCache;
         282                 :     nsCOMPtr<nsIApplicationCache> mPreviousApplicationCache;
         283                 :
         284                 :     nsCOMPtr<nsIObserverService> mObserverService;
         285                 :
         286                 :     nsRefPtr<nsOfflineManifestItem> mManifestItem;
         287                 :
         288                 :     /* Items being updated */
         289                 :     PRInt32 mCurrentItem;
         290                 :     nsTArray<nsRefPtr<nsOfflineCacheUpdateItem> > mItems;
         291                 :
         292                 :     /* Clients watching this update for changes */
         293                 :     nsCOMArray<nsIWeakReference> mWeakObservers;
         294                 :     nsCOMArray<nsIOfflineCacheUpdateObserver> mObservers;
         295                 :
         296                 :     /* Documents that requested this update */
         297                 :     nsCOMArray<nsIURI> mDocumentURIs;
         298                 :
         299                 :     /* Reschedule count.  When an update is rescheduled due to
         300                 :      * mismatched manifests, the reschedule count will be increased. */
         301                 :     PRUint32 mRescheduleCount;
         302                 :
         303                 :     nsRefPtr<nsOfflineCacheUpdate> mImplicitUpdate;
         304                 : };
         305                 :
         306                 : class nsOfflineCacheUpdateService : public nsIOfflineCacheUpdateService
         307                 :                                   , public nsIObserver
         308                 :                                   , public nsOfflineCacheUpdateOwner
         309                 :                                   , public nsSupportsWeakReference
         310                 : {
         311                 : public:
         312                 :     NS_DECL_ISUPPORTS
         313                 :     NS_DECL_NSIOFFLINECACHEUPDATESERVICE
         314                 :     NS_DECL_NSIOBSERVER
         315                 :
         316                 :     nsOfflineCacheUpdateService();
         317                 :     ~nsOfflineCacheUpdateService();
         318                 :
         319                 :     nsresult Init();
         320                 :
         321                 :     nsresult ScheduleUpdate(nsOfflineCacheUpdate *aUpdate);
         322                 :     nsresult FindUpdate(nsIURI *aManifestURI,
         323                 :                         nsIURI *aDocumentURI,
         324                 :                         nsOfflineCacheUpdate **aUpdate);
         325                 :
         326                 :     nsresult Schedule(nsIURI *aManifestURI,
         327                 :                       nsIURI *aDocumentURI,
         328                 :                       nsIDOMDocument *aDocument,
         329                 :                       nsIDOMWindow* aWindow,
         330                 :                       nsIOfflineCacheUpdate **aUpdate);
         331                 :
         332                 :     virtual nsresult UpdateFinished(nsOfflineCacheUpdate *aUpdate);
         333                 :
         334                 :     /**
         335                 :      * Returns the singleton nsOfflineCacheUpdateService without an addref, or
         336                 :      * nsnull if the service couldn't be created.
         337                 :      */
         338                 :     static nsOfflineCacheUpdateService *EnsureService();
         339                 :
         340                 :     /** Addrefs and returns the singleton nsOfflineCacheUpdateService. */
         341                 :     static nsOfflineCacheUpdateService *GetInstance();
         342                 :
         343                 : private:
         344                 :     nsresult ProcessNextUpdate();
         345                 :
         346                 :     nsTArray<nsRefPtr<nsOfflineCacheUpdate> > mUpdates;
         347                 :
         348                 :     bool mDisabled;
         349                 :     bool mUpdateRunning;
         350                 : };
         351                 :
         352                 : #endif

Generated by: LCOV version 1.7