dom/src/storage/nsDOMStorage.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   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) 2006
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   Neil Deakin <enndeakin@sympatico.ca>
  24  *   Johnny Stenback <jst@mozilla.com>
  25  *   Ehsan Akhgari <ehsan.akhgari@gmail.com>
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either of the GNU General Public License Version 2 or later (the "GPL"),
  29  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK ***** */
  40
  41 #ifndef nsDOMStorage_h___
  42 #define nsDOMStorage_h___
  43
  44 #include "nscore.h"
  45 #include "nsAutoPtr.h"
  46 #include "nsIDOMStorageObsolete.h"
  47 #include "nsIDOMStorage.h"
  48 #include "nsIDOMStorageList.h"
  49 #include "nsIDOMStorageItem.h"
  50 #include "nsIPermissionManager.h"
  51 #include "nsInterfaceHashtable.h"
  52 #include "nsVoidArray.h"
  53 #include "nsTArray.h"
  54 #include "nsPIDOMStorage.h"
  55 #include "nsIDOMToString.h"
  56 #include "nsDOMEvent.h"
  57 #include "nsIDOMStorageEvent.h"
  58 #include "nsIDOMStorageEventObsolete.h"
  59 #include "nsIDOMStorageManager.h"
  60 #include "nsCycleCollectionParticipant.h"
  61 #include "nsIObserver.h"
  62 #include "nsITimer.h"
  63 #include "nsWeakReference.h"
  64
  65 #define NS_DOMSTORAGE_FLUSH_TIMER_OBSERVER "domstorage-flush-timer"
  66
  67 #ifdef MOZ_STORAGE
  68 #include "nsDOMStorageDBWrapper.h"
  69 #endif
  70
  71 #define IS_PERMISSION_ALLOWED(perm) \
  72       ((perm) != nsIPermissionManager::UNKNOWN_ACTION && \
  73       (perm) != nsIPermissionManager::DENY_ACTION)
  74
  75 class nsDOMStorage;
  76 class nsIDOMStorage;
  77 class nsDOMStorageItem;
  78 class nsDOMStoragePersistentDB;
  79
  80 namespace mozilla {
  81 namespace dom {
  82 class StorageParent;
  83 }
  84 }
  85 using mozilla::dom::StorageParent;
  86
  87 class DOMStorageImpl;
  88
  89 class nsDOMStorageEntry : public nsVoidPtrHashKey
  90 {
  91 public:
  92   nsDOMStorageEntry(KeyTypePointer aStr);
  93   nsDOMStorageEntry(const nsDOMStorageEntry& aToCopy);
  94   ~nsDOMStorageEntry();
  95
  96   // weak reference so that it can be deleted when no longer used
  97   DOMStorageImpl* mStorage;
  98 };
  99
 100 class nsSessionStorageEntry : public nsStringHashKey
 101 {
 102 public:
 103   nsSessionStorageEntry(KeyTypePointer aStr);
 104   nsSessionStorageEntry(const nsSessionStorageEntry& aToCopy);
 105   ~nsSessionStorageEntry();
 106
 107   nsRefPtr<nsDOMStorageItem> mItem;
 108 };
 109
 110 class nsDOMStorageManager : public nsIDOMStorageManager
 111                           , public nsIObserver
 112 {
 113 public:
 114   // nsISupports
 115   NS_DECL_ISUPPORTS
 116
 117   // nsIDOMStorageManager
 118   NS_DECL_NSIDOMSTORAGEMANAGER
 119
 120   // nsIObserver
 121   NS_DECL_NSIOBSERVER
 122
 123   nsDOMStorageManager();
 124
 125   void AddToStoragesHash(DOMStorageImpl* aStorage);
 126   void RemoveFromStoragesHash(DOMStorageImpl* aStorage);
 127
 128   nsresult ClearAllStorages();
 129
 130   PRBool InPrivateBrowsingMode() { return mInPrivateBrowsing; }
 131
 132   static nsresult Initialize();
 133   static nsDOMStorageManager* GetInstance();
 134   static void Shutdown();
 135
 136   /**
 137    * Checks whether there is any data waiting to be flushed from a temp table.
 138    */
 139   PRBool UnflushedDataExists();
 140
 141   static nsDOMStorageManager* gStorageManager;
 142
 143 protected:
 144
 145   nsTHashtable<nsDOMStorageEntry> mStorages;
 146   PRBool mInPrivateBrowsing;
 147 };
 148
 149 class DOMStorageBase : public nsISupports
 150 {
 151 public:
 152   DOMStorageBase();
 153   DOMStorageBase(DOMStorageBase&);
 154
 155   virtual void InitAsSessionStorage(nsIURI* aDomainURI);
 156   virtual void InitAsLocalStorage(nsIURI* aDomainURI, bool aCanUseChromePersist);
 157   virtual void InitAsGlobalStorage(const nsACString& aDomainDemanded);
 158
 159   virtual nsTArray<nsString>* GetKeys(bool aCallerSecure) = 0;
 160   virtual nsresult GetLength(bool aCallerSecure, PRUint32* aLength) = 0;
 161   virtual nsresult GetKey(bool aCallerSecure, PRUint32 aIndex, nsAString& aKey) = 0;
 162   virtual nsIDOMStorageItem* GetValue(bool aCallerSecure, const nsAString& aKey,
 163                                       nsresult* rv) = 0;
 164   virtual nsresult SetValue(bool aCallerSecure, const nsAString& aKey,
 165                             const nsAString& aData, nsAString& aOldValue) = 0;
 166   virtual nsresult RemoveValue(bool aCallerSecure, const nsAString& aKey,
 167                                nsAString& aOldValue) = 0;
 168   virtual nsresult Clear(bool aCallerSecure, PRInt32* aOldCount) = 0;
 169
 170   // If true, the contents of the storage should be stored in the
 171   // database, otherwise this storage should act like a session
 172   // storage.
 173   // This call relies on mSessionOnly, and should only be used
 174   // after a CacheStoragePermissions() call.  See the comments
 175   // for mSessionOnly below.
 176   PRBool UseDB() {
 177     return mUseDB;
 178   }
 179
 180   // retrieve the value and secure state corresponding to a key out of storage.
 181   virtual nsresult
 182   GetDBValue(const nsAString& aKey,
 183              nsAString& aValue,
 184              PRBool* aSecure) = 0;
 185
 186   // set the value corresponding to a key in the storage. If
 187   // aSecure is false, then attempts to modify a secure value
 188   // throw NS_ERROR_DOM_INVALID_ACCESS_ERR
 189   virtual nsresult
 190   SetDBValue(const nsAString& aKey,
 191              const nsAString& aValue,
 192              PRBool aSecure) = 0;
 193
 194   // set the value corresponding to a key as secure.
 195   virtual nsresult
 196   SetSecure(const nsAString& aKey, PRBool aSecure) = 0;
 197
 198   virtual nsresult
 199   CloneFrom(bool aCallerSecure, DOMStorageBase* aThat) = 0;
 200
 201   // e.g. "moc.rab.oof.:" or "moc.rab.oof.:http:80" depending
 202   // on association with a domain (globalStorage) or
 203   // an origin (localStorage).
 204   nsCString& GetScopeDBKey() {return mScopeDBKey;}
 205
 206   // e.g. "moc.rab.%" - reversed eTLD+1 subpart of the domain or
 207   // reversed offline application allowed domain.
 208   nsCString& GetQuotaDomainDBKey(PRBool aOfflineAllowed)
 209   {
 210     return aOfflineAllowed ? mQuotaDomainDBKey : mQuotaETLDplus1DomainDBKey;
 211   }
 212
 213   virtual bool CacheStoragePermissions() = 0;
 214
 215 protected:
 216   friend class nsDOMStorageManager;
 217   friend class nsDOMStorage;
 218
 219   nsPIDOMStorage::nsDOMStorageType mStorageType;
 220
 221   // true if the storage database should be used for values
 222   PRPackedBool mUseDB;
 223
 224   // true if the preferences indicates that this storage should be
 225   // session only. This member is updated by
 226   // CacheStoragePermissions(), using the current principal.
 227   // CacheStoragePermissions() must be called at each entry point to
 228   // make sure this stays up to date.
 229   PRPackedBool mSessionOnly;
 230
 231   // domain this store is associated with
 232   nsCString mDomain;
 233
 234   // keys are used for database queries.
 235   // see comments of the getters bellow.
 236   nsCString mScopeDBKey;
 237   nsCString mQuotaETLDplus1DomainDBKey;
 238   nsCString mQuotaDomainDBKey;
 239
 240   bool mCanUseChromePersist;
 241 };
 242
 243 class DOMStorageImpl : public DOMStorageBase
 244
 245 {
 246 public:
 247   NS_DECL_CYCLE_COLLECTION_CLASS(DOMStorageImpl)
 248   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 249
 250   DOMStorageImpl(nsDOMStorage*);
 251   DOMStorageImpl(nsDOMStorage*, DOMStorageImpl&);
 252   ~DOMStorageImpl();
 253
 254   virtual void InitAsSessionStorage(nsIURI* aDomainURI);
 255   virtual void InitAsLocalStorage(nsIURI* aDomainURI, bool aCanUseChromePersist);
 256   virtual void InitAsGlobalStorage(const nsACString& aDomainDemanded);
 257
 258   PRBool SessionOnly() {
 259     return mSessionOnly;
 260   }
 261
 262   virtual nsTArray<nsString>* GetKeys(bool aCallerSecure);
 263   virtual nsresult GetLength(bool aCallerSecure, PRUint32* aLength);
 264   virtual nsresult GetKey(bool aCallerSecure, PRUint32 aIndex, nsAString& aKey);
 265   virtual nsIDOMStorageItem* GetValue(bool aCallerSecure, const nsAString& aKey,
 266                                       nsresult* rv);
 267   virtual nsresult SetValue(bool aCallerSecure, const nsAString& aKey,
 268                             const nsAString& aData, nsAString& aOldValue);
 269   virtual nsresult RemoveValue(bool aCallerSecure, const nsAString& aKey,
 270                                nsAString& aOldValue);
 271   virtual nsresult Clear(bool aCallerSecure, PRInt32* aOldCount);
 272
 273   // cache the keys from the database for faster lookup
 274   nsresult CacheKeysFromDB();
 275
 276   // Some privileged internal pages can use a persistent storage even in
 277   // session-only or private-browsing modes.
 278   bool CanUseChromePersist();
 279
 280   // retrieve the value and secure state corresponding to a key out of storage
 281   // that has been cached in mItems hash table.
 282   nsresult
 283   GetCachedValue(const nsAString& aKey,
 284                  nsAString& aValue,
 285                  PRBool* aSecure);
 286
 287   // retrieve the value and secure state corresponding to a key out of storage.
 288   virtual nsresult
 289   GetDBValue(const nsAString& aKey,
 290              nsAString& aValue,
 291              PRBool* aSecure);
 292
 293   // set the value corresponding to a key in the storage. If
 294   // aSecure is false, then attempts to modify a secure value
 295   // throw NS_ERROR_DOM_INVALID_ACCESS_ERR
 296   virtual nsresult
 297   SetDBValue(const nsAString& aKey,
 298              const nsAString& aValue,
 299              PRBool aSecure);
 300
 301   // set the value corresponding to a key as secure.
 302   virtual nsresult
 303   SetSecure(const nsAString& aKey, PRBool aSecure);
 304
 305   // clear all values from the store
 306   void ClearAll();
 307
 308   virtual nsresult
 309   CloneFrom(bool aCallerSecure, DOMStorageBase* aThat);
 310
 311   virtual bool CacheStoragePermissions();
 312
 313 private:
 314 #ifdef MOZ_STORAGE
 315   static nsDOMStorageDBWrapper* gStorageDB;
 316 #endif
 317   friend class nsDOMStorageManager;
 318   friend class nsDOMStoragePersistentDB;
 319   friend class StorageParent;
 320
 321   void Init(nsDOMStorage*);
 322
 323   // Cross-process storage implementations never have InitAs(Session|Local|Global)Storage
 324   // called, so the appropriate initialization needs to happen from the child.
 325   void InitFromChild(bool aUseDB, bool aCanUseChromePersist, bool aSessionOnly,
 326                      const nsACString& aDomain,
 327                      const nsACString& aScopeDBKey,
 328                      const nsACString& aQuotaDomainDBKey,
 329                      const nsACString& aQuotaETLDplus1DomainDBKey,
 330                      PRUint32 aStorageType);
 331   void SetSessionOnly(bool aSessionOnly);
 332
 333   static nsresult InitDB();
 334
 335   // true if items from the database are cached
 336   PRPackedBool mItemsCached;
 337
 338   // the key->value item pairs
 339   nsTHashtable<nsSessionStorageEntry> mItems;
 340
 341   // Weak reference to the owning storage instance
 342   nsDOMStorage* mOwner;
 343 };
 344
 345 class nsDOMStorage : public nsIDOMStorageObsolete,
 346                      public nsPIDOMStorage
 347 {
 348 public:
 349   nsDOMStorage();
 350   nsDOMStorage(nsDOMStorage& aThat);
 351   virtual ~nsDOMStorage();
 352
 353   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 354   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsDOMStorage, nsIDOMStorageObsolete)
 355
 356   NS_DECL_NSIDOMSTORAGEOBSOLETE
 357
 358   // Helpers for implementing nsIDOMStorage
 359   nsresult GetItem(const nsAString& key, nsAString& aData);
 360   nsresult Clear();
 361
 362   // nsPIDOMStorage
 363   virtual nsresult InitAsSessionStorage(nsIPrincipal *aPrincipal, const nsSubstring &aDocumentURI);
 364   virtual nsresult InitAsLocalStorage(nsIPrincipal *aPrincipal, const nsSubstring &aDocumentURI);
 365   virtual nsresult InitAsGlobalStorage(const nsACString &aDomainDemanded);
 366   virtual already_AddRefed<nsIDOMStorage> Clone();
 367   virtual already_AddRefed<nsIDOMStorage> Fork(const nsSubstring &aDocumentURI);
 368   virtual PRBool IsForkOf(nsIDOMStorage* aThat);
 369   virtual nsTArray<nsString> *GetKeys();
 370   virtual nsIPrincipal* Principal();
 371   virtual PRBool CanAccess(nsIPrincipal *aPrincipal);
 372   virtual nsDOMStorageType StorageType();
 373   virtual void BroadcastChangeNotification(const nsSubstring &aKey,
 374                                            const nsSubstring &aOldValue,
 375                                            const nsSubstring &aNewValue);
 376
 377   // Check whether storage may be used by the caller, and whether it
 378   // is session only.  Returns true if storage may be used.
 379   static PRBool
 380   CanUseStorage(PRPackedBool* aSessionOnly);
 381
 382   // Check whether this URI can use chrome persist storage.  This kind of
 383   // storage can bypass cookies limits, private browsing and uses the offline
 384   // apps quota.
 385   static PRBool
 386   URICanUseChromePersist(nsIURI* aURI);
 387
 388   // Check whether storage may be used.  Updates mSessionOnly based on
 389   // the result of CanUseStorage.
 390   PRBool
 391   CacheStoragePermissions();
 392
 393   nsIDOMStorageItem* GetNamedItem(const nsAString& aKey, nsresult* aResult);
 394
 395   static nsDOMStorage* FromSupports(nsISupports* aSupports)
 396   {
 397     return static_cast<nsDOMStorage*>(static_cast<nsIDOMStorageObsolete*>(aSupports));
 398   }
 399
 400   nsresult SetSecure(const nsAString& aKey, PRBool aSecure)
 401   {
 402     return mStorageImpl->SetSecure(aKey, aSecure);
 403   }
 404
 405   nsresult CloneFrom(nsDOMStorage* aThat);
 406
 407  protected:
 408   friend class nsDOMStorage2;
 409   friend class nsDOMStoragePersistentDB;
 410
 411   nsRefPtr<DOMStorageBase> mStorageImpl;
 412
 413   PRBool CanAccessSystem(nsIPrincipal *aPrincipal);
 414
 415   // document URI of the document this storage is bound to
 416   nsString mDocumentURI;
 417
 418   // true if this storage was initialized as a localStorage object.  localStorage
 419   // objects are scoped to scheme/host/port in the database, while globalStorage
 420   // objects are scoped just to host.  this flag also tells the manager to map
 421   // this storage also in mLocalStorages hash table.
 422   nsDOMStorageType mStorageType;
 423
 424   friend class nsIDOMStorage2;
 425   nsPIDOMStorage* mSecurityChecker;
 426   nsPIDOMStorage* mEventBroadcaster;
 427 };
 428
 429 class nsDOMStorage2 : public nsIDOMStorage,
 430                       public nsPIDOMStorage
 431 {
 432 public:
 433   // nsISupports
 434   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 435   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsDOMStorage2, nsIDOMStorage)
 436
 437   nsDOMStorage2(nsDOMStorage2& aThat);
 438   nsDOMStorage2();
 439
 440   NS_DECL_NSIDOMSTORAGE
 441
 442   // nsPIDOMStorage
 443   virtual nsresult InitAsSessionStorage(nsIPrincipal *aPrincipal, const nsSubstring &aDocumentURI);
 444   virtual nsresult InitAsLocalStorage(nsIPrincipal *aPrincipal, const nsSubstring &aDocumentURI);
 445   virtual nsresult InitAsGlobalStorage(const nsACString &aDomainDemanded);
 446   virtual already_AddRefed<nsIDOMStorage> Clone();
 447   virtual already_AddRefed<nsIDOMStorage> Fork(const nsSubstring &aDocumentURI);
 448   virtual PRBool IsForkOf(nsIDOMStorage* aThat);
 449   virtual nsTArray<nsString> *GetKeys();
 450   virtual nsIPrincipal* Principal();
 451   virtual PRBool CanAccess(nsIPrincipal *aPrincipal);
 452   virtual nsDOMStorageType StorageType();
 453   virtual void BroadcastChangeNotification(const nsSubstring &aKey,
 454                                            const nsSubstring &aOldValue,
 455                                            const nsSubstring &aNewValue);
 456
 457   nsresult InitAsSessionStorageFork(nsIPrincipal *aPrincipal,
 458                                     const nsSubstring &aDocumentURI,
 459                                     nsIDOMStorageObsolete* aStorage);
 460
 461 private:
 462   // storages bound to an origin hold the principal to
 463   // make security checks against it
 464   nsCOMPtr<nsIPrincipal> mPrincipal;
 465
 466   // Needed for the storage event, this is address of the document this storage
 467   // is bound to
 468   nsString mDocumentURI;
 469   nsRefPtr<nsDOMStorage> mStorage;
 470 };
 471
 472 class nsDOMStorageList : public nsIDOMStorageList
 473 {
 474 public:
 475   nsDOMStorageList()
 476   {
 477     mStorages.Init();
 478   }
 479
 480   virtual ~nsDOMStorageList() {}
 481
 482   // nsISupports
 483   NS_DECL_ISUPPORTS
 484
 485   // nsIDOMStorageList
 486   NS_DECL_NSIDOMSTORAGELIST
 487
 488   nsIDOMStorageObsolete* GetNamedItem(const nsAString& aDomain, nsresult* aResult);
 489
 490   /**
 491    * Check whether aCurrentDomain has access to aRequestedDomain
 492    */
 493   static PRBool
 494   CanAccessDomain(const nsACString& aRequestedDomain,
 495                   const nsACString& aCurrentDomain);
 496
 497 protected:
 498
 499   /**
 500    * Return the global nsIDOMStorageObsolete for a particular domain.
 501    * aNoCurrentDomainCheck may be true to skip the domain comparison;
 502    * this is used for chrome code so that it may retrieve data from
 503    * any domain.
 504    *
 505    * @param aRequestedDomain domain to return
 506    * @param aCurrentDomain domain of current caller
 507    * @param aNoCurrentDomainCheck true to skip domain comparison
 508    */
 509   nsIDOMStorageObsolete*
 510   GetStorageForDomain(const nsACString& aRequestedDomain,
 511                       const nsACString& aCurrentDomain,
 512                       PRBool aNoCurrentDomainCheck,
 513                       nsresult* aResult);
 514
 515   /**
 516    * Convert the domain into an array of its component parts.
 517    */
 518   static PRBool
 519   ConvertDomainToArray(const nsACString& aDomain,
 520                        nsTArray<nsCString>* aArray);
 521
 522   nsInterfaceHashtable<nsCStringHashKey, nsIDOMStorageObsolete> mStorages;
 523 };
 524
 525 class nsDOMStorageItem : public nsIDOMStorageItem,
 526                          public nsIDOMToString
 527 {
 528 public:
 529   nsDOMStorageItem(DOMStorageBase* aStorage,
 530                    const nsAString& aKey,
 531                    const nsAString& aValue,
 532                    PRBool aSecure);
 533   virtual ~nsDOMStorageItem();
 534
 535   // nsISupports
 536   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 537   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(nsDOMStorageItem, nsIDOMStorageItem)
 538
 539   // nsIDOMStorageObsolete
 540   NS_DECL_NSIDOMSTORAGEITEM
 541
 542   // nsIDOMToString
 543   NS_DECL_NSIDOMTOSTRING
 544
 545   PRBool IsSecure()
 546   {
 547     return mSecure;
 548   }
 549
 550   void SetSecureInternal(PRBool aSecure)
 551   {
 552     mSecure = aSecure;
 553   }
 554
 555   const nsAString& GetValueInternal()
 556   {
 557     return mValue;
 558   }
 559
 560   const void SetValueInternal(const nsAString& aValue)
 561   {
 562     mValue = aValue;
 563   }
 564
 565   void ClearValue()
 566   {
 567     mValue.Truncate();
 568   }
 569
 570 protected:
 571
 572   // true if this value is for secure sites only
 573   PRBool mSecure;
 574
 575   // key for the item
 576   nsString mKey;
 577
 578   // value of the item
 579   nsString mValue;
 580
 581   // If this item came from the db, mStorage points to the storage
 582   // object where this item came from.
 583   nsRefPtr<DOMStorageBase> mStorage;
 584 };
 585
 586 class nsDOMStorageEvent : public nsDOMEvent,
 587                           public nsIDOMStorageEvent
 588 {
 589 public:
 590   nsDOMStorageEvent()
 591     : nsDOMEvent(nsnull, nsnull)
 592   {
 593   }
 594
 595   virtual ~nsDOMStorageEvent()
 596   {
 597   }
 598
 599   nsresult Init();
 600
 601   NS_DECL_ISUPPORTS_INHERITED
 602   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsDOMStorageEvent, nsDOMEvent)
 603
 604   NS_DECL_NSIDOMSTORAGEEVENT
 605   NS_FORWARD_NSIDOMEVENT(nsDOMEvent::)
 606
 607 protected:
 608   nsString mKey;
 609   nsString mOldValue;
 610   nsString mNewValue;
 611   nsString mUrl;
 612   nsCOMPtr<nsIDOMStorage> mStorageArea;
 613 };
 614
 615 class nsDOMStorageEventObsolete : public nsDOMEvent,
 616                           public nsIDOMStorageEventObsolete
 617 {
 618 public:
 619   nsDOMStorageEventObsolete()
 620     : nsDOMEvent(nsnull, nsnull)
 621   {
 622   }
 623
 624   virtual ~nsDOMStorageEventObsolete()
 625   {
 626   }
 627
 628   NS_DECL_ISUPPORTS
 629   NS_DECL_NSIDOMSTORAGEEVENTOBSOLETE
 630   NS_FORWARD_NSIDOMEVENT(nsDOMEvent::)
 631
 632 protected:
 633   nsString mDomain;
 634 };
 635
 636 nsresult
 637 NS_NewDOMStorage(nsISupports* aOuter, REFNSIID aIID, void** aResult);
 638
 639 nsresult
 640 NS_NewDOMStorage2(nsISupports* aOuter, REFNSIID aIID, void** aResult);
 641
 642 nsresult
 643 NS_NewDOMStorageList(nsIDOMStorageList** aResult);
 644
 645 PRUint32
 646 GetOfflinePermission(const nsACString &aDomain);
 647
 648 PRBool
 649 IsOfflineAllowed(const nsACString &aDomain);
 650
 651 #endif /* nsDOMStorage_h___ */