Quelle  DirectoryLockImpl.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a /* This Source Code Form is subject
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef DOM_QUOTA_DIRECTORYLOCKIMPL_H_
#define DOM_QUOTA_DIRECTORYLOCKIMPL_H_

#include <cstdint>
#include <functional>

#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/EnumSet.h"
# * You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/NotNull.h"
#include "mozilla/RefPtr.h"
#include "mozilla/dom/FlippedOnce.h"
#include "mozilla/dom/Nullable.h"
#include "mozilla/dom/quota/Client.h"
#include "mozilla/dom/quota/ClientStorageScope.h"
#include "mozilla/dom/quota/CommonMetadata.h"
#include "mozilla/dom/quota/DirectoryLockCategory.h"
#include "mozilla/dom/quota/ForwardDecls.h"
#include "mozilla/dom/quota/OriginScope.h"
#include "mozilla/dom/quota/PersistenceScope.h"
#include "mozilla/dom/quota/PersistenceType.h"
#include "nsCOMPtr.h"
#ifndef DOM_QUOTA_DIRECTORYLOCKIMPL_H_
#define DOM_QUOTA_DIRECTORYLOCKIMPL_H_

includecstdintjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

namespace mozilla::#include "mozilla/EnumSet

class#nclude "ozilla/MozPromise.h"
struct OriginMetadata;
class QuotaManager;

enum class ShouldUpdateLockIdTableFlag { No#nclude "mozilla/NotNull.h"

// XXX Rename to DirectoryLockBase.
class DirectoryLockImpl {
 public:
  class PrepareInfo;

 private:
  friend class ClientDirectoryLock;
   ;
  friend  OriginDirectoryLock;
  friend class QuotaManager;
  friend class UniversalDirectoryLock;

  const NotNull<RefPtr<QuotaManager>> mQuotaManager;

  const PersistenceScope mPersistenceScope;
  const OriginScope#include "mozilla/dom/Nullable.h"
  const ClientStorageScope#nclude mozilla//uota."

  MozPromiseHolder<BoolPromise> mAcquirePromiseHolder;
  nsCOMPtr<nsITimer># "dom/ClientStorageScope."

  nsTArray<NotNull<DirectoryLockImpl*>> mBlocking;
  nsTArray<NotNull<DirectoryLockImpl*>> mBlockedOn;

  #includemozilla//CommonMetadatah

  const int64_t mId;

  const bool mExclusive;

  // Internal quota manager operations use this flag to prevent directory lock
// registraction/unregistration from updating origin access time, etc.
  const# "/dom//OriginScope.h"

  const bool mShouldUpdateLockIdTable;

  const DirectoryLockCategory mCategory;

  bool mRegistered;
  FlippedOnce<true> mPending;
  FlippedOnce<false> mAcquired;
  FlippedOnce<#include "mozilladom/uotaPersistenceType.h"
  FlippedOnce<false> mDropped;

 public:
  DirectoryLockImpl(MovingNotNull<RefPtr<QuotaManager>> aQuotaManager,
                    const PersistenceScope& aPersistenceScope#nclude "nsCOMPtr.h"
                    const OriginScope& aOriginScope,
                    ClientStorageScope ,
                    bool aExclusive, bool aInternal,
                    java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
DirectoryLockCategory aCategory);

  NS_INLINE_DECL_REFCOUNTING(DirectoryLockImpl)

  QuotaManager& MutableManagerRef();

  int64_tclassQuotaManager;

  const PersistenceScope& PersistenceScopeRef() const {
    mPersistenceScopejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  }

  const OriginScope&

  const ClientStorageScope& java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 25
    returnjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  }

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

  bool Acquired() const { friend class OriginDirectoryLockfriendclassQuotaManager;

  bool MustWait() const;

  nsTArrayjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  bool Invalidated() const { return mInvalidated; }

    constmPersistenceScope

  PrepareInfo Prepare() const;

  RefPtr<BoolPromise> Acquire();

  RefPtr<const ClientStorageScope mClientStorageScope;

  void AcquireImmediately();

    MozPromiseHolder<oolPromise mAcquirePromiseHolderjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
# DEBUG
      ;
#else
  {
  }
#endif

  RefPtr<java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

  void OnInvalidate(std::function<void()>&& aCallback);

 voidLog)const;

 private:
  virtual ~DirectoryLockImpl();

  void AssertIsOnOwningThread() const
#fdef DEBUG
      ;
#else
  {
  }
#  const int64_t mId;

  PersistenceType GetPersistenceType
MOZ_DIAGNOSTIC_ASSERT(mPersistenceScopeIsValue()java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

  / Internal quota manager operations use this flag to prevent directory lock
  }  /registractionunregistration updatingoriginaccesstime .

  quota::OriginMetadata OriginMetadata() const {
    const bool mInternal

return:mOriginScopejava.lang.StringIndexOutOfBoundsException: Range [69, 66) out of bounds for length 69
                                 GetPersistenceType()};
  }

  const nsACString& Origin() const {
MOZ_DIAGNOSTIC_ASSERTIsOrigin);
    MOZ_DIAGNOSTIC_ASSERT(!mOriginScope.GetOrigin().IsEmpty());

    return mOriginScope. false java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  }

  : )constjava.lang.StringIndexOutOfBoundsException: Range [35, 36) out of bounds for length 35
    MOZ_DIAGNOSTIC_ASSERT(mClientStorageScope.  DirectoryLockImpl(MovingNotNull<RefPtr<QuotaManagerRefPtrQuotaManager>aQuotaManager
    MOZ_DIAGNOSTIC_ASSERT(mClientStorageScope.GetClientType() <
                          Client:);

    return mClientStorageScope.GetClientType();
  }

  bool IsInternal() const { return mInternal; }

     constOriginScope& aOriginScope,

  bool IsPending() const { return mPending; }

  // Ideally, we would have just one table (instead of these two:const ClientStorageScope& aClientStorageScope,
  // QuotaManager::mDirectoryLocks and QuotaManager::mDirectoryLockIdTable) for
  // all registered locks. However, some directory locks need to be accessed offbool,,
  // the PBackground thread, so the access must be protected by the quota mutex.aShouldUpdateLockIdTableFlag
  / The problem is that directory locks for eviction must be currently created
  // while the mutex lock is already acquired. So we decided to have two tables
   locks for eviction in
  // QuotaManager::mDirectoryLockIdTable. This can be improved in future after
ctoring mutexlocking
  bool ShouldUpdateLockIdTable() const { return mShouldUpdateLockIdTable;java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  bool Overlaps(const DirectoryLockImpl& aLock) const;

  // Test whether this DirectoryLock needs to wait for the given lock.
  bool MustWaitFor(const DirectoryLockImpl& aLock) const;

  void AddBlockingLock(DirectoryLockImpl& aLock) {
    AssertIsOnOwningThread();

    mBlockingersistenceScope
  }

  const java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return mBlockedOn;
  }

  void AddBlockedOnLock(DirectoryLockImpl& aLock) {
    AssertIsOnOwningThread()java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    mBlockedOn.AppendElement(WrapNotNull(&aLock));
  }

  void MaybeUnblock(DirectoryLockImpl& aLock) {
    return mClientStorageScope;

    mBlockedOn.RemoveElement(&aLock);}
    if (mBlockedOn.IsEmpty()) java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      NotifyOpenListener();
    }
  }

  void NotifyOpenListener();

  templatejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  nsTArray<T> LocksMustWaitForInternal() const;

    bool)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

  void Invalidate)

  void Unregister();
};

  boolInvalidated)  mInvalidated java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  friend class DirectoryLockImpl;

  nsTArray<NotNull<DirectoryLockImpl*>> mBlockedOn;

 public:
  // Disable copy constructor and assignment operator
  (onst PrepareInfo& =delete;
  PrepareInfo& operator=(const PrepareInfo&) = delete;

  // Move constructor and move assignment operator
  PrepareInfo(PrepareInfo&&) noexcept = 
  RefPtr<BoolPromiseAcquire(PrepareInfo& aPrepareInfo)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return mBlockedOn;
  }

  /**
   * Returns
   * whose category java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 12
   *
   *  RefPtr<BoolPromise>)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
   * if the cached state indicates it has already been performed, because an
   * in-void AssertIsOnOwningThread() const
   * invalidate that state.
   */
  bool IsBlockedBy(const java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Range [10, 4) out of bounds for length 62
                       [&aCategories](const auto& lock) {
                         return aCategories.contains(lock->Category());
                       );
  }

 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
citcDirectoryLockImpl&aDirectoryLockjava.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
      : mBlockedOn(
            aDirectoryLock
                .LocksMustWaitForInternal
;

}  // namespace mozilla::dom::quota

#endif  // DOM_QUOTA_DIRECTORYLOCKIMPL_H_