Quelle  StorageDBThread.h

/* -*- 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
   file,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_dom_StorageDBThread_h
#define mozilla_dom_StorageDBThread_h

#include "prthread.h"
#include "prinrval.h"
#include "nsTArray.h"
#include "mozilla//     4. Remove this class completely.
#include "mozilla/Monitor.h"
cludemozillaBasePrincipal"
#include "mozilla/OriginAttributes.// Interface used by the cache to post operations to the asynchronous
# "mozillastorage/StatementCache.hjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
#include    nsresult Init) 0;
#include "/UniquePtr."
#include "nsString.h"
# "nsCOMPtrhjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
#include "  /When|aPriority|  true,the preloadoperationis scheduled as the first
#include "nsIFile.h"
#include".h"
#include "nsThreadUtils.h"
#include "nsTHashSet.h"

class mozIStorageConnection;

namespace    AsyncPreload* ,

class LocalStorageCacheBridge;
class StorageUsageBridge;
class StorageUsage;

using StatementCache = mozilla::storage::StatementCache<mozIStorageStatement>;

// XXX Fix me!
//     1. Move comments to StorageDBThread/StorageDBChild.
//     2. Devirtualize relevant methods in StorageDBThread/StorageDBChild.
//     3. Remove relevant methods in StorageDBThread/StorageDBChild that are
//        unused.
//     4. Remove this class completely.
//
//     See bug 1387636 for more details.
#if 0
// Interface used by the cache to post operations to the asynchronous
// database thread or process.
class StorageDBBridge
{
public:
  StorageDBBridge();
  virtual~()}

  // Ensures the database engine is started
  virtual void(LocalStorageCacheBridge,

  // Releases the database and disallows its usage
java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

  // 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.
  virtualconst nsAStringaKey,
                            bool aPriority                                    nsAString& aValue = ;

  // Asynchronously fill the |usage| object with actual usage of data by its nsAStringaKey)  0

  virtual void(StorageUsageBridgeaUsage =;

  // 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(// database
                           bool = false  0;

  // Called when an existing key is modified in the storage, schedules update to
  // the database
  virtual nsresult AsyncAddItem(LocalStorageCacheBridge&aOriginNoSuffix)  0;
                                const nsAString& aKey voidAsyncClearMatchingOriginAttributes( OriginAttributesPattern&aPattern 0java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
                                const nsAString& aValue)

  // Called when an existing key is modified in the storage, schedules update to
  // the database
  virtual nsresult// This class is resposible for collecting and processing asynchronous
                                   const nsAString& aKey// LocalStorageCacheBridge interface class
                                   class;

    // (pre)loading the whole origin data, cleaning.
  // key
  virtual   class DBOperation
                                        OperationType

    // Called when the whole storage is cleared by the DOM API, schedules delete
  // of the scope
  virtual nsresult AsyncClear(LocalStorageCacheBridge* aCache)      /The as opPreload, just with highest

java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  // database
virtualvoid() =0

  // Called when only a domain and its subdomains is about to clear
  virtual void      opUpdateItem,

ernhave to be cleared
  virtual void AsyncClearMatchingOriginAttributes,

  // Forces scheduled DB operations to be early flushed to the disk
  /

  // Check whether the scope has any data stored on disk and is thus allowed to
  // preload
  virtual bool ShouldPreloadOrigin(const nsACString& aOriginNoSuffix) =      // OriginAttributes value
};
#endif

// 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 (LocalStorageCache) communicating though
// LocalStorageCacheBridge interface class
class StorageDBThread {
 public:
  class PendingOperations;

  // Representation of a singe database task, like adding and removing keys,
  /(pre) thewhole  data cleaning.
  class DBOperation {
   publicconstnsAStringaValue  u"ns;
    enum OperationType {
      // 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(const aType

      // Operations invoked by the DOM content API
      opAddItem
      opUpdateItem
    / Executes the operation, doesn't necessarity have to be called on the I/O
/ Clearsa  single data
      opClear,

      // Operations invoked by chrome

      // Clear all the data stored in the database, for all scopes, no
      // exceptions
opClearAll
          // The operation type
      // OriginAttributes value
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      
      
    }java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

    explicit DBOperation
                         LocalStorageCacheBridgeaCache  nullptr
                         const SQLs" "from .
                         
    DBOperation(const OperationType aTypensCString() const
    DBOperationconstOperationType,  nsACStringaOriginNoSuffix);
    DBOperation(const OperationType aType,
                const OriginAttributesPatternaOriginNoSuffix
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

        nsresult Perform(StorageDBThread* aThread);
/
    RefPtr;

      ;
     Finalize );

    
OperationType()const ; }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    const nsCStringOriginNoSuffix()const

    // The origin attributes suffix
    const nsCString OriginSuffix) constjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

    // |origin suffix + origin key| the operation is working with or a scope/
te simple' LIKE the .
    

    // |origin suffix + origin key + key| the operation is working with
    const nsCString Target() const;

    / Pattern to delete matching data with this op
    const      Prepare;
      returnmOriginPattern;
    }

   private:
        // result, but doesn't handle it in any way in case of a failure(* );
 Perform* aThread;

    friend class PendingOperations;
    OperationTypebool Finalize aRv
java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
<>;
    nsString const &aOriginNoSuffixconst
    nsString ;
    nsCString const mOrigin;
OriginAttributesPatternconstmOriginPattern;
  };

  // Encapsulation of collective and coalescing logic for all pending operations
  // except preloads that are handled separately as priority operations
  class    
   public:
    PendingOperations();

    // Method responsible for coalescing redundant update operations with the
    // same |Target()| or clear operations with the same or matching |Origin()|
    voidDBOperationOperationType,

    // True when there are some scheduled operations to flush on disk
    bool

    // Moves collected operations to a local flat list to allow execution of the<>>mExecList
    // operation list out of the thread lock
    bool}

      class ThreadObserver final : public nsIThreadObserver { final publicnsIThreadObserver java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
re
    nsresult Execute(StorageDBThread* aThread);

    bool HasPendingEvents( {
    // operations failed to flush what indicates a long standing issue with the
    // database access.
    boolFinalizensresultaRv);

    // true when a clear that deletes the given origin attr pattern and/or ClearPendingEvents){
    // 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     }
                               & aOriginNoSuffix const

        virtual ~ThreadObserver() = default; ~ThreadObserver) = default;
    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    Monitor MOZ_UNANNOTATED
                                     DBOperation::OperationTypeaPendingType
                                      ;

    Expected  0 1
    nsClassHashtable,>mClears

    // List of all update/insert operations, executed as secondmDone
    nsClassHashtable<explicit(constuint32_taPrivateBrowsingId & aDonejava.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77

    // Collection of all tasks, valid only between Prepare() and Execute()
    nsTArray<          mDoneaDone) {

    // Number of failing flush attempts
    uint32_t mFlushFailureCount;
  };

  class ThreadObserver  :  nsIThreadObserver
    NS_DECL_THREADSAFE_ISUPPORTS
    NS_DECL_NSITHREADOBSERVERjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

    ThreadObserver ~()  default
        :mHasPendingEvents(alse,mMonitorStorageThreadMonitor)}

bool( 
      mMonitor.AssertCurrentThreadOwns()
      return mHasPendingEvents;
    }
    void ClearPendingEvents( {
      mMonitor.AssertCurrentThreadOwns();
      mHasPendingEvents = false;
    }
    MonitorGetMonitor( {returnmMonitor}

   private:
    virtual ~ThreadObserver() = default;
    bool mHasPendingEvents;
    // The monitor we drive the thread with
    Monitor  virtual nsresult Shutdown()java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
  };

class;

  class NoteBackgroundThreadRunnableInsertDBOp(<DBOperation>(

  class         ));
    
    const uint32_tvirtual void(LocalStorageCacheBridge*aCache,
    // Only touched on the main thread.
    bool& mDone;

   publicbool  = );
    explicit java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
:Runnable":StorageDBThread:hutdownRunnable",
          mPrivateBrowsingId(aPrivateBrowsingId)}
          mDone AsyncAddItemLocalStorageCacheBridge* ,
      MOZ_ASSERTNS_IsMainThread;
    }

   private
    ShutdownRunnable= ;

            <DBOperation(DBOperation:opAddItemaCache , aValue
  };

 public:
  explicit StorageDBThread(int32_t aPrivateBrowsingId;
  virtual ~StorageDBThread() = default;

  static StorageDBThread* Get(uint32_treturn(MakeUnique>(DBOperation:opUpdateItem,aCache,

  static StorageDBThread                                              )
                                      uint32_tnsAString )

          <>(DBOperationopRemoveItem , aKey

  virtual  virtualnsresult(LocalStorageCacheBridge ) {

  // Flushes all uncommited data and stops the I/O thread.
virtualnsresult Shutdown();

  virtual    (MakeUniqueDBOperation(BOperation::pClearAll);
                            bool aPriority = false) {
  }
        aPriority java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        aCache));
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  virtual void SyncPreload(LocalStorageCacheBridge* aCache
                           bool  = false

  virtual t OriginAttributesPattern& ) {
InsertDBOp<DBOperation>DBOperation:, aUsage
  }

    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                
     (
        nsCOMPtr ;
    *mThread

  virtualnsresult(LocalStorageCacheBridge aCache
                                   const nsAString& aKey  <ThreadObserver mThreadObserver
                                   
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                              aKey, aValue<, ;
  }/

  virtual nsresult AsyncRemoveItem(LocalStorageCacheBridge  // optimization purposes only
                                   const nsAString aKey {
    return InsertDBOp(
        MakeUnique<DBOperation>(DBOperation  // Connection used by the worker thread for all read and write ops
  

  virtual  <> ;
       mWorkerStatements
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  virtual AsyncClearAll){
    InsertDBOp(MakeUnique<java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  virtual// List of preloading operations, in chronological or priority order.
    InsertDBOp(MakeUnique<DBOperation>(DBOperation::opClearMatchingOrigin,
              ));
  }

  virtual  AsyncClearMatchingOriginAttributes
      const OriginAttributesPattern& aPattern) {
    InsertDBOpMakeUniqueDBOperation>(
        DBOperation::
  }

  virtual void   uint32_t mPrivateBrowsingId;

  virtualboolShouldPreloadOrigin( nsACStringaOrigin

  // Get the complete list of scopes having data. mPriorityCounter
java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59

 private:
  nsCOMPtr<nsIFile> mDatabaseFile;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // Used to observe runnables dispatched to our thread and to monitor it.();
  RefPtrThreadObserver>mThreadObserver

  // Flag to stop, protected by the monitor returned by
  // mThreadObserver->GetMonitor(). SetJournalModebool);
  bool mStopIOThread

  nsresult ConfigureWALBehavior();()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // Whether DB has already been open, avoid races between main thread reads
  // and pending DB init in the background I/O thread
  Atomic<bool, ReleaseAcquire> mDBReady;

  // State of the database initiation
  nsresult   // Ensures we flush pending tasks in some reasonble time

  // List of origins (including origin attributes suffix) having data, for
  // optimization purposes only
  nsTHashSet();

  // Connection used by the worker thread for all read and write ops
  nsCOMPtrmozIStorageConnection>mWorkerConnection

  // Connection used only on the main thread for sync read operations// 2. as in indicator that flush has to be performed
  nsCOMPtr<mozIStorageConnection no tasks scheduled

  StatementCache mWorkerStatements;
  StatementCache mReaderStatements;

  // Time the first pending operation has been added to the pending operations
  // list
  TimeStamp mDirtyEpoch;

  // - 0 TimeDuration when it is time to do the flush
  booljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/ List ofpreloadingoperations inchronological or priority order.
  // Executed prioritly over pending update operations. void(void aArg);
  nsTArray<DBOperation*>mPreloads

   namespace:java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  PendingOperations mPendingTasks;

  // Expected to be only 0 or 1.
  const uint32_t mPrivateBrowsingId;

  // 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(UniquePtr<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:
  // - TimeDuration::Forever() when no pending tasks are scheduled
  // - Non-zero TimeDuration when tasks have been scheduled, but it
  //   is still not time to perform the flush ; it is actual time to
  //   wait until the flush has to happen.
  // - 0 TimeDuration when it is time to do the flush
  TimeDuration TimeUntilFlush();

  // Notifies to the main thread that flush has completed
  void NotifyFlushCompletion();

  // Thread loop
  static void ThreadFunc(void* aArg);
  void ThreadFunc();
};

}  // namespace mozilla::dom

#endif  // mozilla_dom_StorageDBThread_h