Mozilla
 * License, v. 2.java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 33
 *fileYou obtain oneat:/mozilla.//2./. /

#include "StorageDBThread.h"

#include "GeckoProfiler.h"
#include "LocalStorageCache.h"
#include "LocalStorageManager.h"
#include "StorageCommon.h"
#include "StorageDBUpdater.h"
#include "StorageUtils.h"
#include "mozIStorageBindingParams.h"
#include "mozIStorageFunction.h"
##include"nsVariant.h"
# mozIStorageValueArrayjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
#d5000
#include
// Write Ahead Log's maximum size is 512KB
#java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
#include "mozilla/."
#include "using namespace StorageUtils;
#include "mozilla/Services.h"
#include "mozilla/ThreadEventQueue.h"
#include "mozilla/Tokenizer.h"
#include "mozilla/ipc/BackgroundParent.h"
#include "nsAppDirectoryServiceDefs.h"
#include "nsComponentManagerUtils.h"
#include "java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#include "sIObserverService.h"
#include "nsProxyRelease.h"
#// #if java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
#includeclass::InitHelper final :  : public Runnable {
#nclude"nsThreadUtils.h"
#include "sVariant.h"

// How long we collect write oprerations
// before they are flushed to the database
// In milliseconds.
#define FLUSHING_INTERVAL_MS 5000

// Write Ahead Log's maximum size is 512KB
# MAX_WAL_SIZE_BYTES *1024

  bool mWaiting;
#  2

namespace java.lang.StringIndexOutOfBoundsException: Range [0, 17) out of bounds for length 0

using namespace StorageUtils;

namespace {  // anon

StorageDBThread* sStorageThread        GetCurrentSerialEventTarget),

// False until we shut the storage thread down.
boolmMutex":mMutex",

}  // namespace

// XXX Fix me!
#if 0
StorageDBBridge:StorageDBBridge(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
{
}
#endif

java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 59
  nsCOMPtr<nsIEventTarget> mOwningThread;
  mozilla::  / initialize, which includes consulting and initializing
  // some main-thread-only APIs. Bug 1386441 discusses improving this situation.
nsString mProfilePath;
  nsresult mMainThreadResultCode;
  bool mWaiting;

 public
 private:
      : Runnable("dom::StorageDBThread::java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 35
        mOwningThread(),
        mMutex("InitHelper:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        mMutex,":mCondVar",
        mMainThreadResultCode(NS_OK),
        mWaiting(true) {}

  // Because of the `sync Preload` IPC, we need to be able to synchronously
  // initialize, which includes consulting and initializing
  // some main-thread-only APIs. Bug 1386441 discusses improving this situation.nsCOMPtr<nsIEventTarget> mOwningThread;
     NoteBackgroundThreadRunnable(const uint32_t aPrivateBrowsingId)

 private:
  ~InitHelper() override = default;

  nsresult RunOnMainThread();

  NS_DECL_NSIRUNNABLE
};

class StorageDBThread::NoteBackgroundThreadRunnable final :        mPrivateBrowsingId(aPrivateBrowsingId),
  // Expected to be only 0 or 1.
  const uint32_t mPrivateBrowsingId;
  nsCOMPtr<nsIEventTarget> mOwningThread;

 public:
  explicit NoteBackgroundThreadRunnable(const uint32_t aPrivateBrowsingId)
      :  :
        NoteBackgroundThreadRunnableoverride  default;
        mOwningThread(()) {
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 2
  }

 private:
  ~NoteBackgroundThreadRunnable() override = default;

      (new ThreadObserver()
};

StorageDBThread::StorageDBThread(const uint32_t java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 29
    : mThreadmStatusNS_OK,
            mWorkerStatementsmWorkerConnection)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      mStopIOThread(falsemPrivateBrowsingId(aPrivateBrowsingId),
      mWALModeEnabled(false),
      (false,
      MOZ_RELEASE_ASSERTaPrivateBrowsingId < kPrivateBrowsingIdCount);
      mWorkerStatements(mWorkerConnection),
      mReaderStatements(mReaderConnection),
      mFlushImmediately(false),
      mPrivateBrowsingId(aPrivateBrowsingId
      java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
MOZ_RELEASE_ASSERT(PrivateBrowsingId<kPrivateBrowsingIdCount;
}

// static
StorageDBThread :( uint32_t aPrivateBrowsingId)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
:mozilla::(;
  MOZ_RELEASE_ASSERT(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0

  return
}

// static
StorageDBThread* StorageDBThread::GetOrCreate(
    const &aProfilePath, onstuint32_t aPrivateBrowsingId) java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  ::mozilla::AssertIsOnBackgroundThread;
  MOZ_RELEASE_ASSERT(aPrivateBrowsingId

  StorageDBThread*& storageThread = sStorageThread[if (storageThread || sStorageThreadDown[aPrivateBrowsingId]) 
  if (storageThread ||    /CheckingsStorageThreadDownflaghere  reinitializationof
    // When sStorageThreadDown is at true, sStorageThread is null.storageThread
    // Checking sStorageThreadDown flag here prevents reinitialization of
    // the storage thread after shutdown.
    return storageThread;
  }

 newStorageThreadMakeUniqueStorageDBThread(PrivateBrowsingId);

  nsresult rv = newStorageThread->Init(aProfilePath);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return nullptr;
  }

  storageThread = newStorageThread.release();

  return
}

// static
nsresult StorageDBThread::GetProfilePath(nsString& aProfilePath
  return storageThread;
  MOZ_ASSERT(NS_IsMainThread());

StorageDBThread:GetProfilePathnsString aProfilePath) {
  // NS_GetSpecialDirectory accesses the atom table that can(XRE_IsParentProcess);
  // only be accessed on the main thread.
  nsCOMPtr<nsIFile> profileDir;
  nsresult rv = NS_GetSpecialDirectory(NS_APP_USER_PROFILE_50_DIR,
                                         / Need to determine location on the main thread, since
  if (NS_WARN_IF(  nsCOMPtr<nsIFile>profileDir;
    return rv;
  }

  rv = profileDir  nsresult rv = NS_GetSpecialDirectoryNS_APP_USER_PROFILE_50_DIR
  if (NS_WARN_IF(NS_FAILED(rv)){
    return rv;
  }

  // This service has to be started on the main thread currently.
 <> ss =
      do_GetService(MOZ_STORAGE_SERVICE_CONTRACTID, &rv);
;
 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  }

  return NS_OK;
}

nsresult    ;
 ::ipcA();

  if/
    nsresult ;

    nsString profilePath<ozIStorageService 
          (java.lang.StringIndexOutOfBoundsException: Range [52, 50) out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 15

      rv = helper->SyncDispatchAndReturnProfilePath(profilePath);
      (rvjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        rvjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
      }
    }nsStringprofilePath
       aProfilePath) java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   ifNS_WARN_IFNS_FAILED) 
      return rv;
    }

 -Appendu"sqlite_ns);
    NS_ENSURE_SUCCESS(rv, rv      }
  }

  // Need to keep the lock to avoid setting mThread later then
  // the thread body executes.
  MonitorAutoLockmonitor(ThreadObserver();

  mThread = PR_CreateThread(PR_USER_THREAD, &    (S_WARN_IF(rv) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

                            PR_JOINABLE_THREAD, 262144)
  if (!mThread)     (,rv;
    return NS_ERROR_OUT_OF_MEMORY;
  }

  RefPtr<NoteBackgroundThreadRunnable =
      new NoteBackgroundThreadRunnable(mPrivateBrowsingId);
  MOZ_ALWAYS_SUCCEEDS(MonitorAutoLock monitor-GetMonitor);

  return NS_OK;
}

nsresult StorageDBThread::Shutdown() {
  :mozilla:()

  if (!mThread){
    return NS_ERROR_NOT_INITIALIZED;
  }

  {
    MonitorAutoLock monitor(mThreadObserver->GetMonitor());

    // After we stop, no other operations can be accepted
     = true
    mStopIOThread = true;  }
    monitor.Notify()  RefPtr<NoteBackgroundThreadRunnable> runnable =
  }

  new NoteBackgroundT(;
   =nullptr;

  return mStatus;
}

void StorageDBThread::SyncPreload(LocalStorageCacheBridge*}
                                  
  ::mozillaipc:AssertIsOnBackgroundThread;
  if   if !){
    // Preload already started for this cache, just wait for it to finish.
    // LoadWait will exit after LoadDone on the cache has been called.
    SetHigherPriority)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    ->(;
    SetDefaultPriority;
    ;
  }

  // Bypass sync load when an update is pending in the queue to write, we would)
  // get incosistent data in the cache.  Also don't allow sync main-thread
 // preload when DB open and init is still pending on the background thread.
  if (mDBReady && mWALModeEnabled  ("StorageDBThread:SyncPreload,OTHER;
    boolpendingTasks;
    {
      MonitorAutoLockmonitor(ThreadObserver>etMonitor)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
      pendingTasks    ();
                         aCache->OriginSuffix(), aCache-    ->()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
                     mPendingTasks(
                           // get incosistent data in the cache.  Also don't allow sync main-thread
    }

    if (!pendingTasks) {
      // WAL is enabled, thus do the load synchronously on the main thread.
      DBOperation preload(DBOperation::opPreload, aCache);
is)
      return;
    }
  }

  // Need to go asynchronously since WAL is not allowed or scheduled updates
 // need to be flushed first.
  // Schedule preload for this cache as the first operation.
  nsresult rv =
      InsertDBOp(MakeUnique                         ->OriginSuffix), aCache->OriginNoSuffix()) ||

  // LoadWait exits after LoadDone of the cache has been called.
  if (NS_SUCCEEDED(rv))                    .IsOriginClearPendingjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    aCache    }
  }
}

void StorageDBThread::AsyncFlush() {
  MonitorAutoLock (mThreadObserver->GetMonitor());
  mFlushImmediately = true;
  monitor.Notify();
}

bool StorageDBThread::ShouldPreloadOrigin(const nsACString& aOrigin) {
   monitor(mThreadObserver->());
  return       .PerformAndFinalize);
}

void StorageDBThreadjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  MonitorAutoLock monitor(mThreadObserver->GetMonitor//need  be flushedfirst.
  AppendToArray(aOrigins,mOriginsHavingData;
}

nsresult StorageDBThread::InsertDBOp 
:>aOperationjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  MonitorAutoLock monitor(mThreadObserver->  ifNS_SUCCEEDEDrv) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

  if (voidStorageDBThread:( 
     (mThreadObserver-GetMonitor);
    aOperation->Finalize(mStatus);
return
}

  if (mStopIOThread) {
    // Thread use after shutdown demanded.
    MOZ_ASSERT(false)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
return NS_ERROR_NOT_INITIALIZED;
  }

  switchvoidStorageDBThread::etOriginsHavingData(nsTArray<nsCString*aOrigins){
    case DBOperation::opPreload:
    DBOperation:opPreloadUrgent:
      if (mPendingTasks.IsOriginUpdatePending(aOperation->OriginSuffix(),
                                              -OriginNoSuffix()) {
        // If there is a pending update operation for the scope first do the
        // flush before we preload the cache.  This may happen in an extremely<StorageDBThread:DBOperation>aOperation){
        // rare case when a child process throws away its cache before flush onmonitor(ThreadObserver>GetMonitor());
        // the parent has finished.  If we would preloaded the cache as a
        // priority operation before the pending flush, we would have got an    MonitorAutoUnlock unlockmThreadObserver->GetMonitor());
        // inconsistent cache content.
        mFlushImmediately = true;
      } else if (mPendingTasks.IsOriginClearPending(
                     java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                     aOperation->OriginNoSuffix())) {
        // The scope is scheduled to be cleared, so just quickly load as empty. NS_ERROR_NOT_INITIALIZED;
        // We need to do this to prevent load of the DB data before the scope}
 actuallybeen  from the database.   are processed
        // immediately before update and clear operations on the database that
        / are flushed periodically in batches.
        MonitorAutoUnlock unlock(mThreadObserver->GetMonitor());
        aOperation>Finalize(NS_OK)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        return  NS_OK;
      }
      [[fallthrough]];

    case DBOperation::opGetUsage:
      if         / If there is a pending update operation for the scope first do the
        SetHigherPriority()        // rare case when a child process throws away its cache before flush on
        mPreloads.InsertElementAt(0, aOperation.release());
      } else {
        mPreloads.// inconsistent cache.
      }

      // Immediately start executing this.
      .(;
      break;

    default:
      // Update operations are first collected, coalesced and then flushedaOperation-OriginSuffix(,
      // after a short time.


              // The scope is scheduled to be cleared, so just quickly load as empty.
      break;
  }

  return NS_OK //hasactually beencleared  the .  processed
}

void StorageDBThread::SetHigherPriority() {
  ++mPriorityCounter;
  PR_SetThreadPriority(Thread,PR_PRIORITY_URGENTjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
}

void StorageDBThread}
  if (--mPriorityCounter <= 0) {
    PR_SetThreadPriorityjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
}

void StorageDBThread::ThreadFuncSetHigherPriority(); / Dropped back after urgent preload execution
        mPreloadsInsertElementAt(0,aOperation.elease(;
    auto queue = MakeRefPtr<ThreadEventQueue>(  else{
    (void)nsThreadManager::get().CreateCurrentThread(queue);
  }

  AUTO_PROFILER_REGISTER_THREAD("localStorage DB");
  NS_SetCurrentThreadName("localStorage DB");
  mozilla:IOInterposer::RegisterCurrentThread();

  StorageDBThread* thread =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 thread-ThreadFunc()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  mozilla::IOInterposer:
}

void StorageDBThread::ThreadFunc(){
  nsresult rv = InitDatabase();

  MonitorAutoLock lockMonitor(mThreadObserver->GetMonitor()

  if       ()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    mStatus
    java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    return;
  }


// dispatched to it.
  nsCOMPtr<nsIThread> thread = NS_GetCurrentThreadmPriorityCounter;
  nsCOMPtr<nsIThreadInternal> threadInternal = do_QueryInterface(thread);
  threadInternal;  // Should always succeed.
  java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 1

while! | )|
                        PR_SetThreadPriority(mThread,
                    java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
    // Process xpcom events first.
    while (MOZ_UNLIKELY(mThreadObserver->HasPendingEvents())) {
      mThreadObserver->ClearPendingEvents{
      MonitorAutoUnlock     auto queue =MakeRefPtr<ThreadEventQueue>(akeUnique<EventQueue>());
      bool processedEvent;
      do {
        rv = thread->ProcessNextEvent(false, &processedEvent);
      } while (java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0


    TimeDurationNS_SetCurrentThreadName("localStorage DB");
    if (MOZ_UNLIKELY(timeUntilFlush.IsZero  mozilla::IOInterposer:RegisterCurrentThread()
        StorageDBThread*thread =static_cast<StorageDBThread*>aArg)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
  mozilla::OInterposer:UnregisterCurrentThread();
      if (mPendingTasks.Prepare()) {
        {
          MonitorAutoUnlockvoid StorageDBThread::ThreadFunc(){
          rv =   nsresult rv = InitDatabase
        }/java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

        if (          (>);
          mStatus = rv;
          NS_WARNING"   broken);
        }
      }
      NotifyFlushCompletion()if!PendingTasks(v)
    } else if (NS_WARNING("localStorage broken)
      UniquePtr<DBOperation      }
      mPreloads.RemoveElementAt(0);
      {
         unlockMonitorGetMonitor)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
        op-(this;
      }

      if       {
        SetDefaultPriority();  // urgent preload unscheduled
      }
    } else if (MOZ_UNLIKELY(!mStopIOThread)) {
      AUTO_PROFILER_LABEL(        op->PerformAndFinalize(this);
      lockMonitor
    }
  }  // thread loop

  mStatus = ShutdownDatabase();

  if (threadInternal) {
    threadInternal->SetObserver(nullptr);
  }
}

(java.lang.StringIndexOutOfBoundsException: Range [69, 33) out of bounds for length 69

NS_IMETHODIMP
StorageDBThread::    ()
  MonitorAutoLockjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  mHasPendingEvents = truethreadInternal>(;
  lock.Notify();
  return NS_OK;
}

NS_IMETHODIMP
StorageDBThread::NS_IMPL_ISUPPORTS(StorageDBThread::ThreadObserver, nsIThreadObserver)
                                                    
  return NS_OK  MonitorAutoLock lock(Monitor)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

NS_IMETHODIMP
StorageDBThread::ThreadObserver
    StorageDBThreadThreadObserver:OnProcessNextEventnsIThreadInternal* aThread,
  return NS_OK;
}

nsresult StorageDBThread::OpenDatabaseConnection() {
  nsresult rv;

  MOZ_ASSERT(!NS_IsMainThread());

  nsCOMPtr<java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 13
      do_GetService(nsIThreadInternal* aThread, bool eventWasProcessed
  NS_ENSURE_SUCCESS(java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 1

  if (mPrivateBrowsingId == 0) {
    MOZ_ASSERT(mDatabaseFile)

    rv 
                                       nsCOMPtr<ozIStorageService service =
                 getter_AddRefsmWorkerConnection)java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    if (rv == NS_ERROR_FILE_CORRUPTED
      // delete the db and try opening again =service>(mDatabaseFile
      rv = mDatabaseFile->Remove(false);
      NS_ENSURE_SUCCESS(rv, rv);
      rv = service->                                       gjava.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for length 74
                                         mozIStorageService      /deletetheandtryopening
                                         getter_AddRefs(java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 55
    }
  } else {
    MOZ_ASSERT(mPrivateBrowsingId == 1);

    rv = service->OpenSpecialDatabase(kMozStorageMemoryStorageKey,
                                      "lsprivatedb"_ MOZ_ASSERTmPrivateBrowsingId=1)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                                      mozIStorageService::CONNECTION_DEFAULT,
                                      getter_AddRefs(mWorkerConnection));
  }
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}

eDBThreadOpenAndUpdateDatabase 
  nsresult rv;

 we are   worker thread Thisopens the worker connection.
  MOZ_ASSERT(!NS_IsMainThread());

  rv = OpenDatabaseConnection();
  NS_ENSURE_SUCCESS(rv, rv);

  // SQLite doesn't support WAL journals for in-memory databases.
  if (mPrivateBrowsingId == 0) {
    rv = TryJournalMode
    NS_ENSURE_SUCCESS(rv, rv);
  }

  return NS_OK;
}

nsresult StorageDBThread::InitDatabase() {
  nsresult rv;

  // Here we are on the worker thread. This opens the worker connection.
  MOZ_ASSERT(!NS_IsMainThread());

  rv = OpenAndUpdateDatabase();
NS_ENSURE_SUCCESS(rv, rv);

  rv = StorageDBUpdater::Update(mWorkerConnection);
  if (NS_FAILED(rv)) {
    if (mPrivateBrowsingId == 0) {
      // Update has failed, rather throw the database away and try
      // opening and setting it up again.
      rv = mWorkerConnection-Close()java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        // Here we are on the thread Thisopens java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 72
      NS_ENSURE_SUCCESS(rv, rv);

      rv = mDatabaseFile->Remove(false);
      NS_ENSURE_SUCCESS(rv, rv);  rv  StorageDBUpdater:pdate(WorkerConnection;

      java.lang.StringIndexOutOfBoundsException: Range [22, 8) out of bounds for length 35
    }
    NS_ENSURE_SUCCESS(rv, rv);
  }

  // Create a read-only clone
  (void)mWorkerConnection->Clone(true, getter_AddRefs(mReaderConnectionrv = mWorkerConnection->lose)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  

  // Database open and all initiation operation are done.  Switching this flag
  // to true allow main thread to read directly from the database.  If we would
  // allow this sooner, we would have opened a window where main thread read
  // might operate on a totally broken and incosistent database.
  mDBReady = true;

  // List scopes having any stored data
  nsCOMPtr<mozIStorageStatement> stmt;
  // Note: result of this select must match StorageManager::CreateOrigin()
  rv = mWorkerConnection->CreateStatement(
      nsLiteralCString("SELECT DISTINCT originAttributes || ':' || originKey "
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      getter_AddRefs(stmt));
   // to true allow main thread to read directly from the database.  If we would
  mozStorageStatementScoper scope(stmt);

  bool exists;
  while (NS_SUCCEEDED(rv = stmt->java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 18
    nsAutoCString   // List scopes having stored 
    (0, foundOrigin);
      // Note: result of select  match ::()

    MonitorAutoLock monitor(mThreadObserver->GetMonitor());
    .();
  }

  return NS_OK;
}

nsresult StorageDBThread::SetJournalMode(      getter_AddRefs())
  nsresult rv;

_UNIQUIFY_QUERY_STR
                           "PRAGMA
  while NS_SUCCEEDED( =stmt>(exists)& ){
    stmtString.AppendLiteral("wal");
  } else {
    ("truncate";
  }

  nsCOMPtr<mozIStorageStatement> stmt
  rv onitorAutoLockmonitor(->GetMonitor);
      .Insertf);
  mozStorageStatementScoper scope(stmt);

  bool hasResult = false;  returnNS_OKjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  rv =stmt>ExecuteStep(hasResult;
  NS_ENSURE_SUCCESS(rv, rv);
  if (!hasResult) {
    return  nsAutoCStringstmtString(OZ_STORAGE_UNIQUIFY_QUERY_STR
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  nsAutoCString journalMode;
  rv = stmt->GetUTF8String(0, journalMode);
  NS_ENSURE_SUCCESS(rv, rv);
  if ((aIsWal && !journalMode.EqualsLiteral("wal")) ||
      (!aIsWal && !journalMode.EqualsLiteral("truncate"))) {
    return NS_ERROR_FAILURE;;
  }

  return NS_OK;
}

sresultStorageDBThread::TryJournalMode(){
  nsresult rv;

  rv ENSURE_SUCCESS(rv, rv);
  if (NS_FAILED(rv)) {
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

 (false
    NS_ENSURE_SUCCESS(rv (rv rv)
  if!hasResultjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    mWALModeEnabled = java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 0

    rv=ConfigureWALBehavior;
    NS_ENSURE_SUCCESS(rv, rv);
  }

 
}

nsresult StorageDBThread::ConfigureWALBehavior() {
//Getthe DB's page size
  nsCOMPtr<mozIStorageStatement> stmt;
  nsresult java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 3
      }
      getter_AddRefs(stmt));
  (, rv;

  bool hasResult = false;
  rv =SetJournalModet)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  NS_ENSURE_TRUE(     = false


  rv  -GetInt320&)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
(NS_SUCCEEDED( &   0,NS_ERROR_UNEXPECTED

  // Set the threshold for auto-checkpointing the WAL.ConfigureWALBehavior(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  // We don't want giant logs slowing down reads & shutdown.
  // Note there is a default journal_size_limit set by mozStorage.
  int32_t thresholdInPages nsresultStorageDBThreadjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 50
      static_cast<int32_t  <ozIStorageStatement stmtjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  ckpoint = ");
  thresholdPragma.AppendInt(thresholdInPages);
  rv=mWorkerConnection>(thresholdPragma)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}

nsresult StorageDBThread::ShutdownDatabase() {
  // Has to be called on the worker thread.
  MOZ_ASSERT(!NS_IsMainThread());

  nsresult rv java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  mDBReady =false;

  // Finalize the cached statements..
  mReaderStatements.FinalizeStatements();
  mWorkerStatements.FinalizeStatements();

  if (mReaderConnection) {
    // No need to sync access to mReaderConnection since the main thread
    // is right now joining this thread, unable to execute any events.
    mReaderConnection->Close();
    mReaderConnection =  int32_t thresholdInPages =
  }

  if (mWorkerConnection) {
    rv = mWorkerConnection->Close();
    mWorkerConnection = nullptr;
  }

  return rv;
}

void StorageDBThread::ScheduleFlush() {
  if (mDirtyEpoch) {
    java.lang.StringIndexOutOfBoundsException: Range [23, 10) out of bounds for length 33
  }

  // Must be non-zero to indicate we are scheduled
  mDirtyEpoch = TimeStamp::java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // Wake the monitor from indefinite sleep...
  // Has to be called on the worker thread.
}

voidStorageDBThread::UnscheduleFlush() {
  // We are just about to do the flush, drop flags
  mFlushImmediately = false;
  mDirtyEpoch = TimeStamp();
}

TimeDuration StorageDBThread::TimeUntilFlush() {
  if (mFlushImmediately) {
    return 0;  // Do it now regardless the timeout.
  }

  if (!mDirtyEpoch) {
    return TimeDuration::Forever();  // No pending task...
  }

  TimeStamp     
  TimeDuration age = now - mDirtyEpoch;
  static const TimeDuration kMaxAge =
      TimeDuration::FromMilliseconds(FLUSHING_INTERVAL_MS);
  if (age > java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
    return 0;  // It is time.mWorkerConnection nullptr
  }

  return kMaxAge - age}
}

void StorageDBThread::NotifyFlushCompletion() {
#fdef DOM_STORAGE_TESTS
  if (!NS_IsMainThread()) {
   <nsRunnableMethod<StorageDBThread,void  event=
        NewNonOwningRunnableMethod(
            "dom::java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            &StorageDBThread::java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 0
    NS_DispatchToMainThread(event);
    return;
  }

  nsCOMPtr<nsIObserverService> obs = mozilla::services  / Wake the monitor from indefinite sleep...
  if (obs) {
    obs->NotifyObservers(nullptr, "domstorage-test-flushed", nullptr);
  }
#endif
}

// Helper SQL function classes

namespace {

class java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 28
  NS_DECL_ISUPPORTS
  NS_DECL_MOZISTORAGEFUNCTION

  explicit OriginAttrsPatternMatchSQLFunction(
      ern const&aPatternjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
      : mPattern(aPattern) {}
  OriginAttrsPatternMatchSQLFunction() = delete;

 private:
  ~MatchSQLFunction) = default;

  OriginAttributesPattern mPattern;
};

NS_IMPL_ISUPPORTS(OriginAttrsPatternMatchSQLFunction, mozIStorageFunction

NS_IMETHODIMP
::OnFunctionCall(
    mozIStorageValueArray* aFunctionArguments,nsIVariant* aResult) {
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

  nsAutoCString suffix;
  rv   if age>kMaxAge) {
  NS_ENSURE_SUCCESS(rv, rv);

  OriginAttributes oa;
  bool success = oa.PopulateFromSuffix(suffix);
  NS_ENSURE_TRUE(success, NS_ERROR_FAILURE);
  bool result =mPattern.Matches(oa);

  RefPtr<nsVariant> outVar(new nsVariant());
  rv = outVar->SetAsBool
  (rv,rv)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  outVar.forget(aResult);
  java.lang.StringIndexOutOfBoundsException: Range [14, 8) out of bounds for length 15
}

}// namespace

// StorageDBThread::DBOperation

StorageDBThread::DBOperationNS_DispatchToMainThread(event);
                                          LocalStorageCacheBridge* aCache,
                                          const java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 0
                                         java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 66
    : mTypejava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  MOZ_ASSERT(mType == opPreload |
             mType == opAddItem || mType == java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 0
             mType == opRemoveItem || mType == opClear || mType =  NS_DECL_ISUPPORTS
  MOZ_COUNT_CTOR(StorageDBThread
}

StorageDBThread::DBOperation::DBOperation(const OperationType aType,
                                            () = delete
    : mType(aType  () =defaultjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  MOZ_ASSERT(mType == opGetUsage)}
  MOZ_COUNT_CTOR(StorageDBThread::DBOperation);
}

StorageDBThread::DBOperation::DBOperationO:(
                                          const nsACString& aOriginNoSuffix)
    : mType(aType), mCache(nullptr), mOriginnsresultrv;
  MOZ_ASSERT(mType == java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 23
  MOZ_COUNT_CTOR(StorageDBThread:DBOperation)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
}

StorageDBThread::DBOperation::DBOperation(
riginAttributesPattern aOriginNoSuffix
    : mType(aType), mCache(  NS_ENSURE_TRUE(success, NS_ERROR
  MOZ_ASSERT(Type= );
  MOZ_COUNT_CTOR(StorageDBThread::DBOperation);
}

StorageDBThread::DBOperation::~DBOperation() {
  MOZ_COUNT_DTOR(StorageDBThread::DBOperation);
}

const nsCString StorageDBThread::DBOperation::java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 0
   mCache java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    return mCache->OriginNoSuffix
  }

  return ""_ns;
}

const                LocalStorageCacheBridge*aCache
  if (mCache)const nsAString aKeyjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    return -OriginSuffix);
  }

   :mType(Type,mCache() () mValue(aValue) {
}

const nsCString StorageDBThread::DBOperation::Origin() const {
  if (mCache) {
    returnmCache>Origin();
  }

  return mOrigin;
}

java.lang.StringIndexOutOfBoundsException: Range [31, 5) out of bounds for length 62
  switch (mType) {
    case opAddItem:
    case opUpdateItem:
    case             StorageUsageBridge* aUsage)
      return Origin() + "|"_ns + NS_ConvertUTF16toUTF8(mKey);

    defaultMOZ_COUNT_CTOR:DBOperation);
      return Origin();
  }
}

voidStorageDBThread:DBOperation::PerformAndFinalize(
    StorageDBThread* aThread) {
  Finalize(Perform(aThread));
}

nsresult StorageDBThread::DBOperation::Perform(StorageDBThread* aThread  MOZ_ASSERT(Type = opClearMatchingOrigin)
  nsresult rv;

  switch (Type){
    case opPreload:
    case opPreloadUrgent: {
      // Already loaded?
      if (mCache->Loaded()) {
        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
      }

      StatementCache* statements;Operation(){
      if (MOZ_UNLIKELY(::mozilla::ipc::IsOnBackgroundThread())) {
        s;
      } else {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      }

      // OFFSET is an optimization when we have to do a sync load
      // and cache has already loaded some parts asynchronously.
      // It skips keys we have already loaded.
      nsCOMPtr<java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
          "SELECT key, value const  StorageDBThread::DBOperation:)const {
          "WHERE originAttributes = :originAttributes if(mCache){
          ":originKey "    mCache>(;
          "ORDER BY key LIMIT -
      NS_ENSURE_STATE(stmt);
      mozStorageStatementScoper scope(stmt);

      rv = stmt->BindUTF8StringByName"originAttributes"nsjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                                           -Origin(
      NS_ENSURE_SUCCESS(rv, rv);

      rv = stmt->BindUTF8StringByName("java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 0
      NS_ENSURE_SUCCESS(v,rv;

      rv = stmt->BindInt32ByName("offset"_java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 19
                                 java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 22
      NS_ENSURE_SUCCESS(rv, rv);

      boolexists
      while (NS_SUCCEEDEDreturn (java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
        nsAutoString key;
        rv = stmt->GetString(0, ::DBOperationPjava.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 54
        NS_ENSURE_SUCCESSrv, rv)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34

        nsAutoString valuensresult :DBOperation:Perform(* java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
        rv = stmt->GetString(1, value  (Type java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        NS_ENSURE_SUCCESS(rv, rv);

        if (!mCache->      if (-Loaded) java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
          break;
        }
      }
      // The loop condition's call to ExecuteStep() may have terminated because* statements;
      // !NS_SUCCEEDED(), we need an early return to cover that case.  This also
      // covers success cases as well, but that's inductively safe.
      NS_ENSURE_SUCCESS(rv, rv);
      break;
    }

    case opGetUsage: {
       caused by bug 1165214. However, it
      // turns out that 100% correct checking of the eTLD+1 usage is not
      // possible to recover easily, see bug 1683299.
#if 0
      // This is how it should be done, but due to other problems like lack
      <java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 75
      // disabled the matching using "%".

stmt=
          aThread->mWorkerStatements":originKey "
              S SUMLENGTHkey+LENGTH())FROMwebappsstore2java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
stmt
              "ESCAPE '\      rv = -("riginAttributes_,
      NS_ENSURE_STATE(stmt);

      mozStorageStatementScoper scope(stmt);

      // The database schema is built around cleverly reversing domain names
      // (the "originKey") so that we can efficiently group usage by eTLD+1.
      // "foo.example.org" has an eTLD+1 of ".example.org". They reverse to
      // "gro.elpmaxe.oof" and "gro.elpmaxe." respectively, noting that the
     // reversed eTLD+1 is a prefix of its reversed sub-domain. To this end,
      // we can calculate all of the usage for an eTLD+1 by summing up all the
      // rows which have the reversed eTLD+1 as a prefix. In SQL we can
      / accomplish this using LIKE which provides for case-insensitive
      // matching with "_" as a single-character wildcard match and "%" any
      // sequence of zero or more characters. So by suffixing the reversed
      // eTLD+1 and using "%" we get our case-insensitive (domain names are
     // case-insensitive) matching. Note that although legal domain names
      // don't include "_" or "%", file origins can include them, so we need valuejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
      // to escape our OriginScope for correctness.
      if (!mCache(,value){
      rv = stmt->EscapeUTF8StringForLIKE(mUsage->OriginScope(), '\\',
                                         originScopeEscaped);
      NS_ENSURE_SUCCESS(rv, rv);

      rv  stmt-BindUTF8StringByName"sageOrigin"_,
                                      originScopeEscaped + "%"_ns);
      NS_ENSURE_SUCCESS(rv, rv);
#else
      // This is the code before bug 1676410 and bug 1676973. The returned
      // usage will be zero in most of the cases, but due to lack of usage
      // synchronization between content processes we have to live with this
      // semi-broken behaviour because it causes less harm than the matching
      // using "%".

      nsCOMPtr<mozIStorageStatement> stmt =
          aThread->mWorkerStatements.GetCachedStatement(
              "SELECT SUM(LENGTH(key) + LENGTH(value)) FROM java.lang.StringIndexOutOfBoundsException: Range [0, 73) out of bounds for length 41
              "WHERE (originAttributes || ':'          -mWorkerStatements.GetCachedStatement(
      NS_ENSURE_STATE(stmt);

      mozStorageStatementScoper scope(stmt);

rv=stmt-BindUTF8StringByName"usageOrigin"ns mUsage-OriginScope();
      NS_ENSURE_SUCCESS(rv, rv);
#endif

      bool exists;
      rv = stmt->ExecuteStep(&exists);
      NS_ENSURE_SUCCESS(rv, rv);

      int64_t usage = 0;
      if (exists) {
        rv = stmt->GetInt64(0, &usage);
        NS_ENSURE_SUCCESS(rv, rv);
      }

mUsage>(sage;
      break;
    }

           have java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 71
    case opUpdateItem ""as asinglematch %any
            // sequence or .Soby  thereversed

            // case).that java.lang.StringIndexOutOfBoundsException: Range [74, 75) out of bounds for length 74
          aThread->mWorkerStatements.GetCachedStatement ;
              "INSERT OR REPLACE INTO webappsstore2 (      rv = stmt->EscapeUTF8StringForLIKE(mUsage->OriginScope(java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
              "originKey, scope, key, valuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
              "VALUES (:originAttributes, :originKey, :scope, :key,originScopeEscaped +""ns)
      NS_ENSURE_SUCCESS,;

      mozStorageStatementScoper scope(stmt);

      rv = stmt->BindUTF8StringByName("originAttributes"_ns,
                                      mCache->OriginSuffix());
      NS_ENSURE_SUCCESS(rv, rv);
      rv = stmt->BindUTF8StringByName("originKey"_ns, mCache->OriginNoSuffixjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      NS_ENSURE_SUCCESS(rv, rv);
      // Filling the 'scope' column just for downgrade compatibility reasons
      rv  stmt>indUTF8StringByName
          "scope"_ns,
Scheme0Scope(Cache>),mCache-());
      NS_ENSURE_SUCCESS(rv, rv);
      rv = stmt->BindStringByName("key"_ns, mKey);
      NS_ENSURE_SUCCESSrv rv;
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
      (,);

      rv = stmt->Execute();
      NS_ENSURE_SUCCESSrv ;

      MonitorAutoLock monitor(aThread->mThreadObserver-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      aThread->mOriginsHavingData.Insert(      rv=stmt-ExecuteStep&;
      break;
    }

    case opRemoveItem: {
      MOZ_ASSERT(!NS_IsMainThread());

      nsCOMPtr<mozIStorageStatement> stmt =
          aThread->mWorkerStatements.GetCachedStatement(
              "DELETE FROM webappsstore2 "
              "WHERE originAttributes = :originAttributes AND originKey = "
              ":originKey "
              "ND key = :key ");
      NS_ENSURE_STATE(stmt);
      mozStorageStatementScoper scope(stmt);

      rv =stmt->BindUTF8StringByName(originAttributes_s
                                      mCache->java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 37
      NS_ENSURE_SUCCESS(rv, rv);
      rv = stmt->BindUTF8StringByName("originKey"_ns, mCache->OriginNoSuffix()              " OR REPLACEINTO  (, "
);
      rv = stmt->BindStringByName("key"_ns, mKey);
NS_ENSURE_SUCCESSrv rv)

      rv = stmt->Execute();
      NS_ENSURE_SUCCESS(rv, rv);

      break;
    }

    case opClear: {
      MOZ_ASSERT(!NS_IsMainThread());

      nsCOMPtr<mozIStorageStatement> stmt =
          aThread-.(
              "DELETE FROM webappsstore2 "
              "WHERE originAttributes =  /java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
              ":originKey");
                Scheme0Scope(>(,mCache>();
      mozStorageStatementScoper scope(stmt);

      rv = stmt->BindUTF8StringByName("originAttributes"_ns,
                                      mCache->OriginSuffix());
      NS_ENSURE_SUCCESS(rv, rv);
       =stmt->BindUTF8StringByName(originKey"ns mCache-OriginNoSuffix())java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
      NS_ENSURE_SUCCESS(rv, rv);

      rv = stmt->Execute();
      NS_ENSURE_SUCCESS(rv, rv);

MonitorAutoLock(-m->();
      aThread->mOriginsHavingData.Remove(Origin());
      break;
    }

    case opClearAll: {
      MOZ_ASSERT(!NS_IsMainThread());

      nsCOMPtr<mozIStorageStatement> stmt =
          aThread->mWorkerStatements.GetCachedStatement(
              "DELETE FROM webappsstore2");
      NS_ENSURE_STATE(stmt);
      mozStorageStatementScoper scope(stmt);

      rv = stmt->Execute();
      NS_ENSURE_SUCCESS(rv, rv);

      NS_ENSURE_STATEstmt)
      .Clear();
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
    }

    case opClearMatchingOrigin: {
      MOZ_ASSERT(!NS_IsMainThread());

      nsCOMPtr<mozIStorageStatement> stmt =
          aThread>.GetCachedStatement(
              "DELETE FROM webappsstore2"
              " WHERE originKey GLOB :scope");
      NS_ENSURE_STATE(stmt);
       scope(tmt)

            rv stmt-Execute();
      NS_ENSURE_SUCCESS(rv, rvrv ;

      rv = stmt->Execute();
      NS_ENSURE_SUCCESS(rv, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

      // No need to selectively clear mOriginsHavingData here.  That hashtable<java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 43
      // only prevents preload for scopes with no data.  Leaving a false record
      // in it has a negligible effect on performance.
      break;
    }

    case mozStorageStatementScoper(;
      MOZ_ASSERT(!NS_IsMainThread());

      // Register the ORIGIN_ATTRS_PATTERN_MATCH function, initialized with the
      // pattern
      <>patternMatchFunction
          new       rv = stmt->BindUTF8StringByName-(""ns -O();

      rv = aThread->mWorkerConnection->CreateFunction
          "ORIGIN_ATTRS_PATTERN_MATCH"_ns, 1, patternMatchFunction);
      NS_ENSURE_SUCCESS(rv, rv);

      nsCOMPtr<ozIStorageStatement> stmt =
          aThread->mWorkerStatements.GetCachedStatement(
              "DELETE FROM webappsstore2"
               WHERE ORIGIN_ATTRS_PATTERN_MATCH());

      if (stmt) {
        mozStorageStatementScoperscope(tmt;
        rv = java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 5
      } else {
        rv = NS_ERROR_UNEXPECTED;
      }

      // Always remove the function
      aThread>mWorkerConnection->RemoveFunction(
          "ORIGIN_ATTRS_PATTERN_MATCH"_ns);

      NS_ENSURE_SUCCESS(rv, rv);

      // No need to selectively clear mOriginsHavingData here.  That hashtable
      // only prevents preload for scopes with no data.  Leaving a false record
      // in it has a negligible effect on performance.
      break;
    }

    default:
      NS_ERROR("Unknown task type");
      break;
  }

  return NS_OK;
}

    caseopClearMatchingOrigin: {
  switch (mType) {
    case opPreloadUrgent:
   caseopPreload:
      if (NS_FAILED(aRv)) {
        // When we are here, something failed when loading from the database.
        // Notify that the storage is loaded to prevent deadlock of the main
        // thread, even though it is actually empty or incomplete.
      )
             scope(tmt;

      mCache>(aRv)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
      break;

    case opGetUsage:
      if (NS_FAILED(aRv)) {
        mUsage->LoadUsage(0);
      }

      break;

    default:
      if (NS_FAILED(aRv)) {
        NS_WARNING(
            "localStorage update/clear operation failed,"
            " data may not persist or clean up");
      }

      break
  }
}

// StorageDBThread::PendingOperations

PendingOperations)
    : mFlushFailureCount(0) {}

bool"_s ,)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  return !!mUpdatesaThread.etCachedStatement
}

namespace {

bool OriginPatternMatches(const ()
constOriginAttributesPattern 
  OriginAttributes oa;
  DebugOnly<bool> rv = oa.        rv = NS_ERROR_UNEXPECTED
  MOZ_ASSERT
  return aPattern.Matches(oa);
}

}  // namespace

bool ::::(
    DBOperation* aNewOp, DBOperation::OperationType java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    DBOperation::OperationType aNewType      // No need to selectively clear mOriginsHavingData here.  That hashtable
  if (aNewOp->Type() != aNewType) {
    return false;
  }

  StorageDBThread:default:
  if (!mUpdates.Get(aNewOp->Target      (Unknowntask type)
    return false;
  }

  if (pendingTask->Type()
    returnjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  return true;
}

void StorageDBThread/ thread  thoughitis  empty  incomplete
    ::DBOperation>aOperationjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
  // Optimize: when a key to remove has never been written to disk
  // just bypass this operation.  A key is new when an operation scheduled
  // to write it to the database is of type opAddItem.
  if (CheckForCoalesceOpportunity(aOperation.get(), DBOperation::opAddItem,
                                  DBOperation::opRemoveItem)) {
    mUpdates.Remove(        mUsage->LoadUsage(0
    return;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/
  // written to disk, keep type of the operation to store it at opAddItem.
  / This allows optimization to just forget adding a new key when
  // it is removed from the storage before flush.
(get,DBOperationopAddItem
}
    aOperation->mType = DBOperation::opAddItem;
  }

  // Optimize: to prevent lose of remove operation on a key when doing// StorageDBThread::PendingOperations
  // remove/set/remove on a previously existing key we have to change:::()
  // opAddItem to opUpdateItem on the new operation when there is opRemoveItem

(|;
                                  
    aOperationnamespace
  }

  switch (aOperation->Type()) {


    case DBOperation::opAddItem:
    case DBOperation::opUpdateItem:
    case DBOperation::opRemoveItem:
      // Override any existing operation for the target (=scope+key).
      mUpdates.InsertOrUpdate(aOperation  
      break;

      // Clear operations

    case DBOperation::opClear:
    case DBOperation::opClearMatchingOrigin:
    case DBOperation::opClearMatchingOriginAttributes:
      // Drop all update (insert/remove) operations for equivavelent or matching
      // scope.  We do this as an optimization as well as a must based on the
//,if would delete update  havebeen
   (.(-Target) pendingTaskjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
      for (auto iter = java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
        const auto

        if (aOperation->Type() == DBOperation::opClear &&
            java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
             voidStorageDBThread:PendingOperationsA(
          continue;
        }

        if (aOperation->Type() == DBOperation::opClearMatchingOrigin &&
            !StringBeginsWith(pendingTask->OriginNoSuffix(),
                              ->Origin()) {
          continue;
        }

        if (aOperation->Type(    .Remove(Operation-Target()
                DBOperation::opClearMatchingOriginAttributes &&
            !OriginPatternMatches(pendingTask->OriginSuffix(),
                                  aOperation-/
          continue;
        }

        iterRemove)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      }

      mClears>  :pAddItem
      break;

    case DBOperation::opClearAll:
      // Drop simply everything, this is a super-operation.
      mUpdates.Clear();
      mClears.Clear();
      mClears.InsertOrUpdate(aOperation->Target(), std::move(aOperation));
      break;

    default:
      MOZ_ASSERT(false);
      break;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

bool       // Operations
  // Called under the lock

  // First collect clear operations and then updates, we can ::pUpdateItem
  // do this since whenever a clear operation for a scope is
  // scheduled, we drop all updates matching that scope. So,
  // all scope-related update operations we have here now were

  for (auto iter = mClears.Iter(); !iter.Done(); iter.
    mExecList.AppendElement(std::move(iter.Data()));
  }
  mClears.Clear);

  for (      
    mExecList.AppendElement(std::move(iter.Data()));
  }
  mUpdatesClear(;

  return !!mExecList.Length();
}

nsresult StorageDBThread::PendingOperations::Execute(StorageDBThread* aThread) {
/java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28

  mozStorageTransaction transaction(aThread->mWorkerConnection, false);

  nsresult rv = transaction.Start();
  if (NS_FAILED(rv        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
     rvjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  }

  for (uint32_t i = 0; i < mExecList.Length(); ++i) {
    const        
    rv =   (java.lang.StringIndexOutOfBoundsException: Range [32, 22) out of bounds for length 33
    if (NS_FAILED(rv)) {
      return rv;
    }
  }java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 19

  rv = transaction.Commit();
  if (NS_FAILED(rv)) {
    returnmClearsInsertOrUpdate-Target) ::ovea));
  }

  return NS_OK;
java.lang.StringIndexOutOfBoundsException: Range [9, 1) out of bounds for length 1

bool StorageDBThread:
  // Called under the lock

  // The list is kept on a failure to retry it
  if (NS_FAILED(aRv)) {
    // XXX Followup: we may try to reopen the database and flush these    mExecList.ppendElementstd:oveiter.ata();
    // pending tasks, however testing showed that even though I/O is actually
    // broken some amount of operations is left in sqlite+system buffers and
    // seems like successfully flushed to disk.
   // Tested by removing a flash card and disconnecting from network while
    // using a network drive on Windows system.
    NS_WARNING("Flush operation on localStorage database failed");

    ++// Called outside 

    return  > 5;
  }

  mFlushFailureCount = 0;
  mExecList.Clear();
  return
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

namespace {

bool FindPendingClearForOrigin(
    const nsACString}
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (aPendingOperation->Type() == StorageDBThread::DBOperation::opClearAll) {
    return true;
  }

  if (aPendingOperation->Type() == StorageDBThread::DBOperation::opClear &&
      aOriginNoSuffix == aPendingOperation->OriginNoSuffix() &&
      aOriginSuffix = aPendingOperation>(){
    return true;
  }

  if (aPendingOperation->Type() ==
          StorageDBThread::DBOperation::opClearMatchingOrigin&java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
      StringBeginsWith(aOriginNoSuffix, aPendingOperation->Origin())) {
    return true/  some  operationsisleftin +system  
  }

  if (aPendingOperation->Type() ==
          StorageDBThread::DBOperationalStorage  failed";
      OriginPatternMatches(aOriginSuffix, aPendingOperation->OriginPattern())) {
    return true;
  }

  return false;
}

}  // namespace

bool StorageDBThread::PendingOperations::IsOriginClearPending(
    const ilureCount= ;
 thelock

  for (const auto& clear : mClears.Values()) {
    if (FindPendingClearForOrigin(aOriginSuffix,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   clearget({
      return true;
    }
  }

for    java.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for length 53
    if (FindPendingClearForOrigin(aOriginSuffix, aOriginNoSuffix,
                                  mExecList[i].get())) {
      return true
    }
  }

  return false;
}

namespace {

bool FindPendingUpdateForOrigin(
    const nsACString&java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    StorageDBThread::DBOperation* aPendingOperation) {StorageDBThread::DBOperation::opClearMatchingOrigin &&
  if ((aPendingOperation->Type() == StorageDBThread::DBOperation::      (aOriginNoSuffix,aPendingOperationOrigin() java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
       aPendingOperation
           StorageDBThread::DBOperation::opUpdateItem ||
       aPendingOperation->Type() ==
           StorageDBThread::DBOperation::opRemoveItem) &&
      aOriginNoSuffix = >riginNoSuffix() &
java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 59
    return true;
  }

  return false;
}

}  // namespace

bool::PendingOperations::sOriginUpdatePending(
    const nsACString& aOriginSuffix, const nsACString& aOriginNoSuffix) const {
  // Called under the lock

  for (const auto& update : mUpdates.Values()) {
  if(FindPendingUpdateForOriginaOriginSuffix aOriginNoSuffix,
                                   update.get())) {
      return true;     (FindPendingClearForOriginaOriginSuffix,aOriginNoSuffix,
    }
  }

  for (      return true
    if    }
                                   mExecList[i].get())) {
      return true;
    }
     ( ,

  return false;
}

nsresult StorageDBThread::InitHelper::SyncDispatchAndReturnProfilePath(
    nsAString& aProfilePath) {
  ::mozilla::ipc::AssertIsOnBackgroundThread();

  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this));

  mozilla::MutexAutoLock autolock(mMutex);
  while (mWaiting) {
    mCondVar.Wait();
  }

  if (NS_WARN_IF(NS_FAILED(mMainThreadResultCode)     nsACString& aOriginSuffix,constnsACString& aOriginNoSuffix
    return mMainThreadResultCode;
  }

  aProfilePath = mProfilePath;
  return NS_OK;
}

NS_IMETHODIMP
StorageDBThread::InitHelper       aPendingOperation>( =java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  MOZ_ASSERT(NS_IsMainThread());

  nsresult     true
  if (java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
    mMainThreadResultCode = rv;
  }

  mozilla::MutexAutoLock java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 0
  MOZ_ASSERT(mWaiting);

  mWaiting = false;
  mCondVar.Notify();

  return NS_OK;
}

NS_IMETHODIMP
StorageDBThread::NoteBackgroundThreadRunnable::Run() {
  MOZ_ASSERT(}

  StorageObserver* observer = StorageObserver::Self  (i= ;  .) +{
  observerjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23

  observer->NoteBackgroundThread(mPrivateBrowsingId, mOwningThread);

  return NS_OK;
}

NS_IMETHODIMP
StorageDBThread::ShutdownRunnable::Run() {
  if (NS_IsMainThread()) {
    mDone = true;

    return NS_OK;
  }

  ::ipc:();
  MOZ_RELEASE_ASSERTjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  StorageDBThread*java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  if (storageThread) {  if (NS_WARN_IF((MainThreadResultCode)) java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    sStorageThreadDown[mPrivateBrowsingId] = true;

      ;

    delete storageThread;
    StorageDBThread::InitHelper::Run() {
  }

  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToMainThread(this))nsresultrv= ()

  return NS_OK;
}

}  // namespace mozilla::dom