From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- dom/storage/DOMStorageDBThread.h | 407 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 407 insertions(+) create mode 100644 dom/storage/DOMStorageDBThread.h (limited to 'dom/storage/DOMStorageDBThread.h') diff --git a/dom/storage/DOMStorageDBThread.h b/dom/storage/DOMStorageDBThread.h new file mode 100644 index 000000000..0efaebaa3 --- /dev/null +++ b/dom/storage/DOMStorageDBThread.h @@ -0,0 +1,407 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/. */ + +#ifndef DOMStorageDBThread_h___ +#define DOMStorageDBThread_h___ + +#include "prthread.h" +#include "prinrval.h" +#include "nsTArray.h" +#include "mozilla/Atomics.h" +#include "mozilla/Monitor.h" +#include "mozilla/BasePrincipal.h" +#include "mozilla/storage/StatementCache.h" +#include "nsAutoPtr.h" +#include "nsString.h" +#include "nsCOMPtr.h" +#include "nsClassHashtable.h" +#include "nsIFile.h" +#include "nsIThreadInternal.h" + +class mozIStorageConnection; + +namespace mozilla { +namespace dom { + +class DOMStorageCacheBridge; +class DOMStorageUsageBridge; +class DOMStorageUsage; + +typedef mozilla::storage::StatementCache StatementCache; + +// Interface used by the cache to post operations to the asynchronous +// database thread or process. +class DOMStorageDBBridge +{ +public: + DOMStorageDBBridge(); + virtual ~DOMStorageDBBridge() {} + + // Ensures the database engine is started + virtual nsresult Init() = 0; + + // Releases the database and disallows its usage + virtual nsresult Shutdown() = 0; + + // Asynchronously fills the cache with data from the database for first use. + // When |aPriority| is true, the preload operation is scheduled as the first one. + // This method is responsible to keep hard reference to the cache for the time of + // the preload or, when preload cannot be performed, call LoadDone() immediately. + virtual void AsyncPreload(DOMStorageCacheBridge* aCache, bool aPriority = false) = 0; + + // Asynchronously fill the |usage| object with actual usage of data by its scope. + // The scope is eTLD+1 tops, never deeper subdomains. + virtual void AsyncGetUsage(DOMStorageUsageBridge* aUsage) = 0; + + // Synchronously fills the cache, when |aForceSync| is false and cache already got some + // data before, the method waits for the running preload to finish + virtual void SyncPreload(DOMStorageCacheBridge* aCache, bool aForceSync = false) = 0; + + // Called when an existing key is modified in the storage, schedules update to the database + virtual nsresult AsyncAddItem(DOMStorageCacheBridge* aCache, const nsAString& aKey, const nsAString& aValue) = 0; + + // Called when an existing key is modified in the storage, schedules update to the database + virtual nsresult AsyncUpdateItem(DOMStorageCacheBridge* aCache, const nsAString& aKey, const nsAString& aValue) = 0; + + // Called when an item is removed from the storage, schedules delete of the key + virtual nsresult AsyncRemoveItem(DOMStorageCacheBridge* aCache, const nsAString& aKey) = 0; + + // Called when the whole storage is cleared by the DOM API, schedules delete of the scope + virtual nsresult AsyncClear(DOMStorageCacheBridge* aCache) = 0; + + // Called when chrome deletes e.g. cookies, schedules delete of the whole database + virtual void AsyncClearAll() = 0; + + // Called when only a domain and its subdomains is about to clear + virtual void AsyncClearMatchingOrigin(const nsACString& aOriginNoSuffix) = 0; + + // Called when data matching an origin pattern have to be cleared + virtual void AsyncClearMatchingOriginAttributes(const OriginAttributesPattern& aPattern) = 0; + + // Forces scheduled DB operations to be early flushed to the disk + virtual void AsyncFlush() = 0; + + // Check whether the scope has any data stored on disk and is thus allowed to preload + virtual bool ShouldPreloadOrigin(const nsACString& aOriginNoSuffix) = 0; + + // Get the complete list of scopes having data + virtual void GetOriginsHavingData(InfallibleTArray* aOrigins) = 0; +}; + +// The implementation of the the database engine, this directly works +// with the sqlite or any other db API we are based on +// This class is resposible for collecting and processing asynchronous +// DB operations over caches (DOMStorageCache) communicating though +// DOMStorageCacheBridge interface class +class DOMStorageDBThread final : public DOMStorageDBBridge +{ +public: + class PendingOperations; + + // Representation of a singe database task, like adding and removing keys, + // (pre)loading the whole origin data, cleaning. + class DBOperation + { + public: + typedef enum { + // Only operation that reads data from the database + opPreload, + // The same as opPreload, just executed with highest priority + opPreloadUrgent, + + // Load usage of a scope + opGetUsage, + + // Operations invoked by the DOM content API + opAddItem, + opUpdateItem, + opRemoveItem, + // Clears a specific single origin data + opClear, + + // Operations invoked by chrome + + // Clear all the data stored in the database, for all scopes, no exceptions + opClearAll, + // Clear data under a domain and all its subdomains regardless OriginAttributes value + opClearMatchingOrigin, + // Clear all data matching an OriginAttributesPattern regardless a domain + opClearMatchingOriginAttributes, + } OperationType; + + explicit DBOperation(const OperationType aType, + DOMStorageCacheBridge* aCache = nullptr, + const nsAString& aKey = EmptyString(), + const nsAString& aValue = EmptyString()); + DBOperation(const OperationType aType, + DOMStorageUsageBridge* aUsage); + DBOperation(const OperationType aType, + const nsACString& aOriginNoSuffix); + DBOperation(const OperationType aType, + const OriginAttributesPattern& aOriginNoSuffix); + ~DBOperation(); + + // Executes the operation, doesn't necessarity have to be called on the I/O thread + void PerformAndFinalize(DOMStorageDBThread* aThread); + + // Finalize the operation, i.e. do any internal cleanup and finish calls + void Finalize(nsresult aRv); + + // The operation type + OperationType Type() const { return mType; } + + // The origin in the database usage format (reversed) + const nsCString OriginNoSuffix() const; + + // The origin attributes suffix + const nsCString OriginSuffix() const; + + // |origin suffix + origin key| the operation is working with + // or a scope pattern to delete with simple SQL's "LIKE %" from the database. + const nsCString Origin() const; + + // |origin suffix + origin key + key| the operation is working with + const nsCString Target() const; + + // Pattern to delete matching data with this op + const OriginAttributesPattern& OriginPattern() const { return mOriginPattern; } + + private: + // The operation implementation body + nsresult Perform(DOMStorageDBThread* aThread); + + friend class PendingOperations; + OperationType mType; + RefPtr mCache; + RefPtr mUsage; + nsString const mKey; + nsString const mValue; + nsCString const mOrigin; + OriginAttributesPattern const mOriginPattern; + }; + + // Encapsulation of collective and coalescing logic for all pending operations + // except preloads that are handled separately as priority operations + class PendingOperations { + public: + PendingOperations(); + + // Method responsible for coalescing redundant update operations with the same + // |Target()| or clear operations with the same or matching |Origin()| + void Add(DBOperation* aOperation); + + // True when there are some scheduled operations to flush on disk + bool HasTasks() const; + + // Moves collected operations to a local flat list to allow execution of the operation + // list out of the thread lock + bool Prepare(); + + // Executes the previously |Prepared()'ed| list of operations, retuns result, but doesn't + // handle it in any way in case of a failure + nsresult Execute(DOMStorageDBThread* aThread); + + // Finalizes the pending operation list, returns false when too many operations failed + // to flush what indicates a long standing issue with the database access. + bool Finalize(nsresult aRv); + + // true when a clear that deletes the given origin attr pattern and/or origin key + // is among the pending operations; when a preload for that scope is being scheduled, + // it must be finished right away + bool IsOriginClearPending(const nsACString& aOriginSuffix, const nsACString& aOriginNoSuffix) const; + + // Checks whether there is a pending update operation for this scope. + bool IsOriginUpdatePending(const nsACString& aOriginSuffix, const nsACString& aOriginNoSuffix) const; + + private: + // Returns true iff new operation is of type newType and there is a pending + // operation of type pendingType for the same key (target). + bool CheckForCoalesceOpportunity(DBOperation* aNewOp, + DBOperation::OperationType aPendingType, + DBOperation::OperationType aNewType); + + // List of all clearing operations, executed first + nsClassHashtable mClears; + + // List of all update/insert operations, executed as second + nsClassHashtable mUpdates; + + // Collection of all tasks, valid only between Prepare() and Execute() + nsTArray > mExecList; + + // Number of failing flush attempts + uint32_t mFlushFailureCount; + }; + + class ThreadObserver final : public nsIThreadObserver + { + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSITHREADOBSERVER + + ThreadObserver() + : mHasPendingEvents(false) + , mMonitor("DOMStorageThreadMonitor") + { + } + + bool HasPendingEvents() { + mMonitor.AssertCurrentThreadOwns(); + return mHasPendingEvents; + } + void ClearPendingEvents() { + mMonitor.AssertCurrentThreadOwns(); + mHasPendingEvents = false; + } + Monitor& GetMonitor() { return mMonitor; } + + private: + virtual ~ThreadObserver() {} + bool mHasPendingEvents; + // The monitor we drive the thread with + Monitor mMonitor; + }; + +public: + DOMStorageDBThread(); + virtual ~DOMStorageDBThread() {} + + virtual nsresult Init(); + virtual nsresult Shutdown(); + + virtual void AsyncPreload(DOMStorageCacheBridge* aCache, bool aPriority = false) + { InsertDBOp(new DBOperation(aPriority ? DBOperation::opPreloadUrgent : DBOperation::opPreload, aCache)); } + + virtual void SyncPreload(DOMStorageCacheBridge* aCache, bool aForce = false); + + virtual void AsyncGetUsage(DOMStorageUsageBridge * aUsage) + { InsertDBOp(new DBOperation(DBOperation::opGetUsage, aUsage)); } + + virtual nsresult AsyncAddItem(DOMStorageCacheBridge* aCache, const nsAString& aKey, const nsAString& aValue) + { return InsertDBOp(new DBOperation(DBOperation::opAddItem, aCache, aKey, aValue)); } + + virtual nsresult AsyncUpdateItem(DOMStorageCacheBridge* aCache, const nsAString& aKey, const nsAString& aValue) + { return InsertDBOp(new DBOperation(DBOperation::opUpdateItem, aCache, aKey, aValue)); } + + virtual nsresult AsyncRemoveItem(DOMStorageCacheBridge* aCache, const nsAString& aKey) + { return InsertDBOp(new DBOperation(DBOperation::opRemoveItem, aCache, aKey)); } + + virtual nsresult AsyncClear(DOMStorageCacheBridge* aCache) + { return InsertDBOp(new DBOperation(DBOperation::opClear, aCache)); } + + virtual void AsyncClearAll() + { InsertDBOp(new DBOperation(DBOperation::opClearAll)); } + + virtual void AsyncClearMatchingOrigin(const nsACString& aOriginNoSuffix) + { InsertDBOp(new DBOperation(DBOperation::opClearMatchingOrigin, aOriginNoSuffix)); } + + virtual void AsyncClearMatchingOriginAttributes(const OriginAttributesPattern& aPattern) + { InsertDBOp(new DBOperation(DBOperation::opClearMatchingOriginAttributes, aPattern)); } + + virtual void AsyncFlush(); + + virtual bool ShouldPreloadOrigin(const nsACString& aOrigin); + virtual void GetOriginsHavingData(InfallibleTArray* aOrigins); + +private: + nsCOMPtr mDatabaseFile; + PRThread* mThread; + + // Used to observe runnables dispatched to our thread and to monitor it. + RefPtr mThreadObserver; + + // Flag to stop, protected by the monitor returned by + // mThreadObserver->GetMonitor(). + bool mStopIOThread; + + // Whether WAL is enabled + bool mWALModeEnabled; + + // Whether DB has already been open, avoid races between main thread reads + // and pending DB init in the background I/O thread + Atomic mDBReady; + + // State of the database initiation + nsresult mStatus; + + // List of origins (including origin attributes suffix) having data, for optimization purposes only + nsTHashtable mOriginsHavingData; + + // Connection used by the worker thread for all read and write ops + nsCOMPtr mWorkerConnection; + + // Connection used only on the main thread for sync read operations + nsCOMPtr mReaderConnection; + + StatementCache mWorkerStatements; + StatementCache mReaderStatements; + + // Time the first pending operation has been added to the pending operations + // list + PRIntervalTime mDirtyEpoch; + + // Flag to force immediate flush of all pending operations + bool mFlushImmediately; + + // List of preloading operations, in chronological or priority order. + // Executed prioritly over pending update operations. + nsTArray mPreloads; + + // Collector of pending update operations + PendingOperations mPendingTasks; + + // Counter of calls for thread priority rising. + int32_t mPriorityCounter; + + // Helper to direct an operation to one of the arrays above; + // also checks IsOriginClearPending for preloads + nsresult InsertDBOp(DBOperation* aOperation); + + // Opens the database, first thing we do after start of the thread. + nsresult OpenDatabaseConnection(); + nsresult OpenAndUpdateDatabase(); + nsresult InitDatabase(); + nsresult ShutdownDatabase(); + + // Tries to establish WAL mode + nsresult SetJournalMode(bool aIsWal); + nsresult TryJournalMode(); + + // Sets the threshold for auto-checkpointing the WAL. + nsresult ConfigureWALBehavior(); + + void SetHigherPriority(); + void SetDefaultPriority(); + + // Ensures we flush pending tasks in some reasonble time + void ScheduleFlush(); + + // Called when flush of pending tasks is being executed + void UnscheduleFlush(); + + // This method is used for two purposes: + // 1. as a value passed to monitor.Wait() method + // 2. as in indicator that flush has to be performed + // + // Return: + // - PR_INTERVAL_NO_TIMEOUT when no pending tasks are scheduled + // - larger then zero when tasks have been scheduled, but it is + // still not time to perform the flush ; it is actual interval + // time to wait until the flush has to happen + // - 0 when it is time to do the flush + PRIntervalTime TimeUntilFlush(); + + // Notifies to the main thread that flush has completed + void NotifyFlushCompletion(); + + // Thread loop + static void ThreadFunc(void* aArg); + void ThreadFunc(); +}; + +} // namespace dom +} // namespace mozilla + +#endif /* DOMStorageDBThread_h___ */ -- cgit v1.2.3