The Tor Browser: dom/src/storage/DOMStorageIPC.cpp@6474c204b198 (annotated)

dom/src/storage/DOMStorageIPC.cpp@6474c204b198 (annotated)

dom/src/storage/DOMStorageIPC.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "DOMStorageIPC.h"
 #include "DOMStorageManager.h"
 #include "mozilla/dom/ContentChild.h"
 #include "mozilla/dom/ContentParent.h"
 #include "mozilla/unused.h"
 #include "nsIDiskSpaceWatcher.h"
 #include "nsThreadUtils.h"
 namespace mozilla {
 namespace dom {
 // ----------------------------------------------------------------------------
 // Child
 // ----------------------------------------------------------------------------
 NS_IMPL_ADDREF(DOMStorageDBChild)
 NS_IMETHODIMP_(MozExternalRefCountType) DOMStorageDBChild::Release(void)
 {
   NS_PRECONDITION(0 != mRefCnt, "dup release");
   nsrefcnt count = --mRefCnt;
   NS_LOG_RELEASE(this, count, "DOMStorageDBChild");
   if (count == 1 && mIPCOpen) {
     Send__delete__(this);
     return 0;
   }
   if (count == 0) {
     mRefCnt = 1;
     delete this;
     return 0;
   }
   return count;
 }
 void
 DOMStorageDBChild::AddIPDLReference()
 {
   NS_ABORT_IF_FALSE(!mIPCOpen, "Attempting to retain multiple IPDL references");
   mIPCOpen = true;
   AddRef();
 }
 void
 DOMStorageDBChild::ReleaseIPDLReference()
 {
   NS_ABORT_IF_FALSE(mIPCOpen, "Attempting to release non-existent IPDL reference");
   mIPCOpen = false;
   Release();
 }
 DOMStorageDBChild::DOMStorageDBChild(DOMLocalStorageManager* aManager)
   : mManager(aManager)
   , mStatus(NS_OK)
   , mIPCOpen(false)
 {
 }
 DOMStorageDBChild::~DOMStorageDBChild()
 {
 }
 nsTHashtable<nsCStringHashKey>&
 DOMStorageDBChild::ScopesHavingData()
 {
   if (!mScopesHavingData) {
     mScopesHavingData = new nsTHashtable<nsCStringHashKey>;
   }
   return *mScopesHavingData;
 }
 nsresult
 DOMStorageDBChild::Init()
 {
   ContentChild* child = ContentChild::GetSingleton();
   AddIPDLReference();
   child->SendPStorageConstructor(this);
   return NS_OK;
 }
 nsresult
 DOMStorageDBChild::Shutdown()
 {
   // There is nothing to do here, IPC will release automatically and
   // the actual thread running on the parent process will also stop
   // automatically in profile-before-change topic observer.
   return NS_OK;
 }
 void
 DOMStorageDBChild::AsyncPreload(DOMStorageCacheBridge* aCache, bool aPriority)
 {
   if (mIPCOpen) {
     // Adding ref to cache for the time of preload.  This ensures a reference to
     // to the cache and that all keys will load into this cache object.
     mLoadingCaches.PutEntry(aCache);
     SendAsyncPreload(aCache->Scope(), aPriority);
   } else {
     // No IPC, no love.  But the LoadDone call is expected.
     aCache->LoadDone(NS_ERROR_UNEXPECTED);
   }
 }
 void
 DOMStorageDBChild::AsyncGetUsage(DOMStorageUsageBridge* aUsage)
 {
   if (mIPCOpen) {
     SendAsyncGetUsage(aUsage->Scope());
   }
 }
 void
 DOMStorageDBChild::SyncPreload(DOMStorageCacheBridge* aCache, bool aForceSync)
 {
   if (NS_FAILED(mStatus)) {
     aCache->LoadDone(mStatus);
     return;
   }
   if (!mIPCOpen) {
     aCache->LoadDone(NS_ERROR_UNEXPECTED);
     return;
   }
   // There is no way to put the child process to a wait state to receive all
   // incoming async responses from the parent, hence we have to do a sync preload
   // instead.  We are smart though, we only demand keys that are left to load in
   // case the async preload has already loaded some keys.
   InfallibleTArray<nsString> keys, values;
   nsresult rv;
   SendPreload(aCache->Scope(), aCache->LoadedCount(), &keys, &values, &rv);
   for (uint32_t i = 0; i < keys.Length(); ++i) {
     aCache->LoadItem(keys[i], values[i]);
   }
   aCache->LoadDone(rv);
 }
 nsresult
 DOMStorageDBChild::AsyncAddItem(DOMStorageCacheBridge* aCache,
                                 const nsAString& aKey,
                                 const nsAString& aValue)
 {
   if (NS_FAILED(mStatus) || !mIPCOpen) {
     return mStatus;
   }
   SendAsyncAddItem(aCache->Scope(), nsString(aKey), nsString(aValue));
   ScopesHavingData().PutEntry(aCache->Scope());
   return NS_OK;
 }
 nsresult
 DOMStorageDBChild::AsyncUpdateItem(DOMStorageCacheBridge* aCache,
                                    const nsAString& aKey,
                                    const nsAString& aValue)
 {
   if (NS_FAILED(mStatus) || !mIPCOpen) {
     return mStatus;
   }
   SendAsyncUpdateItem(aCache->Scope(), nsString(aKey), nsString(aValue));
   ScopesHavingData().PutEntry(aCache->Scope());
   return NS_OK;
 }
 nsresult
 DOMStorageDBChild::AsyncRemoveItem(DOMStorageCacheBridge* aCache,
                                    const nsAString& aKey)
 {
   if (NS_FAILED(mStatus) || !mIPCOpen) {
     return mStatus;
   }
   SendAsyncRemoveItem(aCache->Scope(), nsString(aKey));
   return NS_OK;
 }
 nsresult
 DOMStorageDBChild::AsyncClear(DOMStorageCacheBridge* aCache)
 {
   if (NS_FAILED(mStatus) || !mIPCOpen) {
     return mStatus;
   }
   SendAsyncClear(aCache->Scope());
   ScopesHavingData().RemoveEntry(aCache->Scope());
   return NS_OK;
 }
 bool
 DOMStorageDBChild::ShouldPreloadScope(const nsACString& aScope)
 {
   // Return true if we didn't receive the aScope list yet.
   // I tend to rather preserve a bit of early-after-start performance
   // then a bit of memory here.
   return !mScopesHavingData || mScopesHavingData->Contains(aScope);
 }
 bool
 DOMStorageDBChild::RecvObserve(const nsCString& aTopic,
                                const nsCString& aScopePrefix)
 {
   DOMStorageObserver::Self()->Notify(aTopic.get(), aScopePrefix);
   return true;
 }
 bool
 DOMStorageDBChild::RecvScopesHavingData(const InfallibleTArray<nsCString>& aScopes)
 {
   for (uint32_t i = 0; i < aScopes.Length(); ++i) {
     ScopesHavingData().PutEntry(aScopes[i]);
   }
   return true;
 }
 bool
 DOMStorageDBChild::RecvLoadItem(const nsCString& aScope,
                                 const nsString& aKey,
                                 const nsString& aValue)
 {
   DOMStorageCache* aCache = mManager->GetCache(aScope);
   if (aCache) {
     aCache->LoadItem(aKey, aValue);
   }
   return true;
 }
 bool
 DOMStorageDBChild::RecvLoadDone(const nsCString& aScope, const nsresult& aRv)
 {
   DOMStorageCache* aCache = mManager->GetCache(aScope);
   if (aCache) {
     aCache->LoadDone(aRv);
     // Just drop reference to this cache now since the load is done.
     mLoadingCaches.RemoveEntry(static_cast<DOMStorageCacheBridge*>(aCache));
   }
   return true;
 }
 bool
 DOMStorageDBChild::RecvLoadUsage(const nsCString& aScope, const int64_t& aUsage)
 {
   nsRefPtr<DOMStorageUsageBridge> scopeUsage = mManager->GetScopeUsage(aScope);
   scopeUsage->LoadUsage(aUsage);
   return true;
 }
 bool
 DOMStorageDBChild::RecvError(const nsresult& aRv)
 {
   mStatus = aRv;
   return true;
 }
 // ----------------------------------------------------------------------------
 // Parent
 // ----------------------------------------------------------------------------
 NS_IMPL_ADDREF(DOMStorageDBParent)
 NS_IMPL_RELEASE(DOMStorageDBParent)
 void
 DOMStorageDBParent::AddIPDLReference()
 {
   NS_ABORT_IF_FALSE(!mIPCOpen, "Attempting to retain multiple IPDL references");
   mIPCOpen = true;
   AddRef();
 }
 void
 DOMStorageDBParent::ReleaseIPDLReference()
 {
   NS_ABORT_IF_FALSE(mIPCOpen, "Attempting to release non-existent IPDL reference");
   mIPCOpen = false;
   Release();
 }
 namespace { // anon
 class SendInitialChildDataRunnable : public nsRunnable
 {
 public:
   SendInitialChildDataRunnable(DOMStorageDBParent* aParent)
     : mParent(aParent)
   {}
 private:
   NS_IMETHOD Run()
   {
     if (!mParent->IPCOpen()) {
       return NS_OK;
     }
     DOMStorageDBBridge* db = DOMStorageCache::GetDatabase();
     if (db) {
       InfallibleTArray<nsCString> scopes;
       db->GetScopesHavingData(&scopes);
       mozilla::unused << mParent->SendScopesHavingData(scopes);
     }
     // We need to check if the device is in a low disk space situation, so
     // we can forbid in that case any write in localStorage.
     nsCOMPtr<nsIDiskSpaceWatcher> diskSpaceWatcher =
       do_GetService("@mozilla.org/toolkit/disk-space-watcher;1");
     if (!diskSpaceWatcher) {
       NS_WARNING("Could not get disk information from DiskSpaceWatcher");
       return NS_OK;
     }
     bool lowDiskSpace = false;
     diskSpaceWatcher->GetIsDiskFull(&lowDiskSpace);
     if (lowDiskSpace) {
       mozilla::unused << mParent->SendObserve(
         nsDependentCString("low-disk-space"), EmptyCString());
     }
     return NS_OK;
   }
   nsRefPtr<DOMStorageDBParent> mParent;
 };
 } // anon
 DOMStorageDBParent::DOMStorageDBParent()
 : mIPCOpen(false)
 {
   DOMStorageObserver* observer = DOMStorageObserver::Self();
   if (observer) {
     observer->AddSink(this);
   }
   // We are always open by IPC only
   AddIPDLReference();
   // Cannot send directly from here since the channel
   // is not completely built at this moment.
   nsRefPtr<SendInitialChildDataRunnable> r =
     new SendInitialChildDataRunnable(this);
   NS_DispatchToCurrentThread(r);
 }
 DOMStorageDBParent::~DOMStorageDBParent()
 {
   DOMStorageObserver* observer = DOMStorageObserver::Self();
   if (observer) {
     observer->RemoveSink(this);
   }
 }
 mozilla::ipc::IProtocol*
 DOMStorageDBParent::CloneProtocol(Channel* aChannel,
                                   mozilla::ipc::ProtocolCloneContext* aCtx)
 {
   ContentParent* contentParent = aCtx->GetContentParent();
   nsAutoPtr<PStorageParent> actor(contentParent->AllocPStorageParent());
   if (!actor || !contentParent->RecvPStorageConstructor(actor)) {
     return nullptr;
   }
   return actor.forget();
 }
 DOMStorageDBParent::CacheParentBridge*
 DOMStorageDBParent::NewCache(const nsACString& aScope)
 {
   return new CacheParentBridge(this, aScope);
 }
 bool
 DOMStorageDBParent::RecvAsyncPreload(const nsCString& aScope, const bool& aPriority)
 {
   DOMStorageDBBridge* db = DOMStorageCache::StartDatabase();
   if (!db) {
     return false;
   }
   db->AsyncPreload(NewCache(aScope), aPriority);
   return true;
 }
 bool
 DOMStorageDBParent::RecvAsyncGetUsage(const nsCString& aScope)
 {
   DOMStorageDBBridge* db = DOMStorageCache::StartDatabase();
   if (!db) {
     return false;
   }
   // The object releases it self in LoadUsage method
   nsRefPtr<UsageParentBridge> usage = new UsageParentBridge(this, aScope);
   db->AsyncGetUsage(usage);
   return true;
 }
 namespace { // anon
 // We need another implementation of DOMStorageCacheBridge to do
 // synchronous IPC preload.  This class just receives Load* notifications
 // and fills the returning arguments of RecvPreload with the database
 // values for us.
 class SyncLoadCacheHelper : public DOMStorageCacheBridge
 {
 public:
   SyncLoadCacheHelper(const nsCString& aScope,
                       uint32_t aAlreadyLoadedCount,
                       InfallibleTArray<nsString>* aKeys,
                       InfallibleTArray<nsString>* aValues,
                       nsresult* rv)
   : mMonitor("DOM Storage SyncLoad IPC")
   , mScope(aScope)
   , mKeys(aKeys)
   , mValues(aValues)
   , mRv(rv)
   , mLoaded(false)
   , mLoadedCount(aAlreadyLoadedCount)
   {
     // Precaution
     *mRv = NS_ERROR_UNEXPECTED;
   }
   virtual const nsCString& Scope() const { return mScope; }
   virtual bool Loaded() { return mLoaded; }
   virtual uint32_t LoadedCount() { return mLoadedCount; }
   virtual bool LoadItem(const nsAString& aKey, const nsString& aValue)
   {
     // Called on the aCache background thread
     if (mLoaded) {
       return false;
     }
     ++mLoadedCount;
     mKeys->AppendElement(aKey);
     mValues->AppendElement(aValue);
     return true;
   }
   virtual void LoadDone(nsresult aRv)
   {
     // Called on the aCache background thread
     MonitorAutoLock monitor(mMonitor);
     mLoaded = true;
     *mRv = aRv;
     monitor.Notify();
   }
   virtual void LoadWait()
   {
     // Called on the main thread, exits after LoadDone() call
     MonitorAutoLock monitor(mMonitor);
     while (!mLoaded) {
       monitor.Wait();
     }
   }
 private:
   Monitor mMonitor;
   nsCString mScope;
   InfallibleTArray<nsString>* mKeys;
   InfallibleTArray<nsString>* mValues;
   nsresult* mRv;
   bool mLoaded;
   uint32_t mLoadedCount;
 };
 } // anon
 bool
 DOMStorageDBParent::RecvPreload(const nsCString& aScope,
                                 const uint32_t& aAlreadyLoadedCount,
                                 InfallibleTArray<nsString>* aKeys,
                                 InfallibleTArray<nsString>* aValues,
                                 nsresult* aRv)
 {
   DOMStorageDBBridge* db = DOMStorageCache::StartDatabase();
   if (!db) {
     return false;
   }
   nsRefPtr<SyncLoadCacheHelper> cache(
     new SyncLoadCacheHelper(aScope, aAlreadyLoadedCount, aKeys, aValues, aRv));
   db->SyncPreload(cache, true);
   return true;
 }
 bool
 DOMStorageDBParent::RecvAsyncAddItem(const nsCString& aScope,
                                      const nsString& aKey,
                                      const nsString& aValue)
 {
   DOMStorageDBBridge* db = DOMStorageCache::StartDatabase();
   if (!db) {
     return false;
   }
   nsresult rv = db->AsyncAddItem(NewCache(aScope), aKey, aValue);
   if (NS_FAILED(rv) && mIPCOpen) {
     mozilla::unused << SendError(rv);
   }
   return true;
 }
 bool
 DOMStorageDBParent::RecvAsyncUpdateItem(const nsCString& aScope,
                                         const nsString& aKey,
                                         const nsString& aValue)
 {
   DOMStorageDBBridge* db = DOMStorageCache::StartDatabase();
   if (!db) {
     return false;
   }
   nsresult rv = db->AsyncUpdateItem(NewCache(aScope), aKey, aValue);
   if (NS_FAILED(rv) && mIPCOpen) {
     mozilla::unused << SendError(rv);
   }
   return true;
 }
 bool
 DOMStorageDBParent::RecvAsyncRemoveItem(const nsCString& aScope,
                                         const nsString& aKey)
 {
   DOMStorageDBBridge* db = DOMStorageCache::StartDatabase();
   if (!db) {
     return false;
   }
   nsresult rv = db->AsyncRemoveItem(NewCache(aScope), aKey);
   if (NS_FAILED(rv) && mIPCOpen) {
     mozilla::unused << SendError(rv);
   }
   return true;
 }
 bool
 DOMStorageDBParent::RecvAsyncClear(const nsCString& aScope)
 {
   DOMStorageDBBridge* db = DOMStorageCache::StartDatabase();
   if (!db) {
     return false;
   }
   nsresult rv = db->AsyncClear(NewCache(aScope));
   if (NS_FAILED(rv) && mIPCOpen) {
     mozilla::unused << SendError(rv);
   }
   return true;
 }
 bool
 DOMStorageDBParent::RecvAsyncFlush()
 {
   DOMStorageDBBridge* db = DOMStorageCache::GetDatabase();
   if (!db) {
     return false;
   }
   db->AsyncFlush();
   return true;
 }
 // DOMStorageObserverSink
 nsresult
 DOMStorageDBParent::Observe(const char* aTopic,
                             const nsACString& aScopePrefix)
 {
   if (mIPCOpen) {
     mozilla::unused << SendObserve(nsDependentCString(aTopic),
                                    nsCString(aScopePrefix));
   }
   return NS_OK;
 }
 namespace { // anon
 // Results must be sent back on the main thread
 class LoadRunnable : public nsRunnable
 {
 public:
   enum TaskType {
     loadItem,
     loadDone
   };
   LoadRunnable(DOMStorageDBParent* aParent,
                TaskType aType,
                const nsACString& aScope,
                const nsAString& aKey = EmptyString(),
                const nsAString& aValue = EmptyString())
   : mParent(aParent)
   , mType(aType)
   , mScope(aScope)
   , mKey(aKey)
   , mValue(aValue)
   { }
   LoadRunnable(DOMStorageDBParent* aParent,
                TaskType aType,
                const nsACString& aScope,
                nsresult aRv)
   : mParent(aParent)
   , mType(aType)
   , mScope(aScope)
   , mRv(aRv)
   { }
 private:
   nsRefPtr<DOMStorageDBParent> mParent;
   TaskType mType;
   nsCString mScope;
   nsString mKey;
   nsString mValue;
   nsresult mRv;
   NS_IMETHOD Run()
   {
     if (!mParent->IPCOpen()) {
       return NS_OK;
     }
     switch (mType)
     {
     case loadItem:
       mozilla::unused << mParent->SendLoadItem(mScope, mKey, mValue);
       break;
     case loadDone:
       mozilla::unused << mParent->SendLoadDone(mScope, mRv);
       break;
     }
     return NS_OK;
   }
 };
 } // anon
 // DOMStorageDBParent::CacheParentBridge
 bool
 DOMStorageDBParent::CacheParentBridge::LoadItem(const nsAString& aKey, const nsString& aValue)
 {
   if (mLoaded) {
     return false;
   }
   ++mLoadedCount;
   nsRefPtr<LoadRunnable> r =
     new LoadRunnable(mParent, LoadRunnable::loadItem, mScope, aKey, aValue);
   NS_DispatchToMainThread(r);
   return true;
 }
 void
 DOMStorageDBParent::CacheParentBridge::LoadDone(nsresult aRv)
 {
   // Prevent send of duplicate LoadDone.
   if (mLoaded) {
     return;
   }
   mLoaded = true;
   nsRefPtr<LoadRunnable> r =
     new LoadRunnable(mParent, LoadRunnable::loadDone, mScope, aRv);
   NS_DispatchToMainThread(r);
 }
 void
 DOMStorageDBParent::CacheParentBridge::LoadWait()
 {
   // Should never be called on this implementation
   MOZ_ASSERT(false);
 }
 // DOMStorageDBParent::UsageParentBridge
 namespace { // anon
 class UsageRunnable : public nsRunnable
 {
 public:
   UsageRunnable(DOMStorageDBParent* aParent, const nsACString& aScope, const int64_t& aUsage)
   : mParent(aParent)
   , mScope(aScope)
   , mUsage(aUsage)
   {}
 private:
   NS_IMETHOD Run()
   {
     if (!mParent->IPCOpen()) {
       return NS_OK;
     }
     mozilla::unused << mParent->SendLoadUsage(mScope, mUsage);
     return NS_OK;
   }
   nsRefPtr<DOMStorageDBParent> mParent;
   nsCString mScope;
   int64_t mUsage;
 };
 } // anon
 void
 DOMStorageDBParent::UsageParentBridge::LoadUsage(const int64_t aUsage)
 {
   nsRefPtr<UsageRunnable> r = new UsageRunnable(mParent, mScope, aUsage);
   NS_DispatchToMainThread(r);
 }
 } // ::dom
 } // ::mozilla

The Tor Browser / annotate

dom/src/storage/DOMStorageIPC.cpp@6474c204b198 (annotated)

dom/src/storage/DOMStorageIPC.cpp