Quelle  FileStreams.cpp

C:tabs: /
/* 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/. */

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

// Local includes
 QuotaCommon
#include   quotaObjectjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
      :ipcRandomAccessStreamParamsTFileRandomAccessStreamParams
# RemoteQuotaObject

// Global includes
#include;
#limitingFileRandomAccessStreamParams( java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
#/ebugOnly
#include "TLimitingFileRandomAccessStreamParams
:.ileRandomAccessStreamParams

 ".
#include:Deserialize)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78

namespace mozilla:domquota

template <class
 <>()java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
/
  // lifecycle, mQuotaObject is null. Under these circumstances,
  
  if){
    int64_t offset = 0;
    QM_TRY(::Telloffset);

    QM_TRY(OkIf(mQuotaObject);
           NS_ERROR_FILE_NO_DEVICE_SPACE);
  }

  QM_TRY(MOZ_TO_RESULT(FileStreamBase::SetEOF()));

  return NS_OK;
}

template <class FileStreamBase>
NS_IMETHODIMP FileQuotaStream<FileStreamBase>::Close() {
  QM_TRY(MOZ_TO_RESULT(FileStreamBase::

  if (mQuotaObject) {
     autoremoteQuotaObjectmQuotaObjectAsRemoteQuotaObject)
      remoteQuotaObject()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    int32_t) {

    mQuotaObject     = MakeRefPtr>(aPersistenceType ,
  }

  return NS_OK;
}

template <class
ase:oOpen){
  MOZ_RELEASE_ASSERT(XRE_IsParentProcess());
  MOZ_RELEASE_ASSERT(!java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

QuotaManager  :()
  MOZ_ASSERT(quotaManager, "Shouldn't be(PersistenceType aPersistenceType,

  MOZ_ASSERTClientType,nsIFile,
  mQuotaObject = quotaManager aIOFlagsint32_t,
      mPersistenceType,                              )java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
      FileStreamBase::mOpenParams.localFile);

  QM_TRY(return

nsCOMPtr>std(streamjava.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    DebugOnly<bool> res =
        mQuotaObject->MaybeUpdateSize(0, /* aTruncate */ true);
    MOZ_ASSERT(res);
  }

  return NS_OK;
}

template <class FileStreamBase>
NS_IMETHODIMP FileQuotaStreamWithWrite<FileStreamBase>::Write(
    const char* aBuf, uint32_t aCount, uint32_t* _retval) {
  if (FileQuotaStreamWithWrite::mQuotaObject) {
    int64_t offset;
    QM_TRY(MOZ_TO_RESULT(FileStreamBase::Tell(&offset)));

    MOZ_ASSERT(INT64_MAX - offset >= int64_t(aCount));

    if (!FileQuotaStreamWithWrite::mQuotaObject->MaybeUpdateSize(
            offset + int64_t(aCount),
            /* aTruncate */ false)) {
      *_retval = 0;
      return NS_ERROR_FILE_NO_DEVICE_SPACE;
    }
  }

  QM_TRY(MOZ_TO_RESULT(FileStreamBase::Write(aBuf, aCount, _retval)));

  return NS_OK;
}

mozilla::ipc::RandomAccessStreamParams FileRandomAccessStream::Serialize(
    nsIInterfaceRequestor* aCallbacks) {
  MOZ_RELEASE_ASSERT(XRE_IsParentProcess());
  MOZ_RELEASE_ASSERT(!mDeserialized);
  MOZ_ASSERT(mOpenParams.localFile);

  QuotaManager* quotaManager = QuotaManager::Get();
  MOZ_ASSERT(quotaManager);

  RefPtr<QuotaObject> quotaObject = quotaManager->GetQuotaObject(
      mPersistenceType, mOriginMetadata, mClientType, mOpenParams.localFile);
  MOZ_ASSERT(quotaObject);

  IPCQuotaObject ipcQuotaObject = quotaObject->Serialize(aCallbacks);

  mozilla::ipc::RandomAccessStreamParams randomAccessStreamParams =
      nsFileRandomAccessStream::Serialize(aCallbacks);

  MOZ_ASSERT(
      randomAccessStreamParams.type() ==
      mozilla::ipc::RandomAccessStreamParams::TFileRandomAccessStreamParams);

  mozilla::ipc::LimitingFileRandomAccessStreamParams
      limitingFileRandomAccessStreamParams;
  limitingFileRandomAccessStreamParams.fileRandomAccessStreamParams() =
      std::move(randomAccessStreamParams);
  limitingFileRandomAccessStreamParams.quotaObject() =
      std::move(ipcQuotaObject);

  return limitingFileRandomAccessStreamParams;
}

bool FileRandomAccessStream::Deserialize(
    mozilla::ipc::RandomAccessStreamParams& aParams) {
  MOZ_ASSERT(aParams.type() == mozilla::ipc::RandomAccessStreamParams::
                                   TLimitingFileRandomAccessStreamParams);

  auto& params = aParams.get_LimitingFileRandomAccessStreamParams();

  mozilla::ipc::RandomAccessStreamParams randomAccessStreamParams(
      std::move(params.fileRandomAccessStreamParams()));

  QM_TRY(MOZ_TO_RESULT(
             nsFileRandomAccessStream::Deserialize(randomAccessStreamParams)),
         false);

  mQuotaObject = QuotaObject::Deserialize(params.quotaObject());

  return true;
}

Result<MovingNotNull<nsCOMPtr<nsIInputStream>>, nsresult> CreateFileInputStream(
    PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata,
    Client::Type aClientType, nsIFile* aFile, int32_t aIOFlags, int32_t aPerm,
    int32_t aBehaviorFlags) {
  auto stream = MakeRefPtr<FileInputStream>(aPersistenceType, aOriginMetadata,
                                            aClientType);

  QM_TRY(MOZ_TO_RESULT(stream->Init(aFile, aIOFlags, aPerm, aBehaviorFlags)));

  return WrapMovingNotNullUnchecked(
      nsCOMPtr<nsIInputStream>(std::move(stream)));
}

Result<MovingNotNull<nsCOMPtr<nsIOutputStream>>, nsresult>
CreateFileOutputStream(PersistenceType aPersistenceType,
                       const OriginMetadata& aOriginMetadata,
                       Client::Type aClientType, nsIFile* aFile,
                       int32_t aIOFlags, int32_t aPerm,
                       int32_t aBehaviorFlags) {
  auto stream = MakeRefPtr<FileOutputStream>(aPersistenceType, aOriginMetadata,
                                             aClientType);

  QM_TRY(MOZ_TO_RESULT(stream->Init(aFile, aIOFlags, aPerm, aBehaviorFlags)));

  return WrapMovingNotNullUnchecked(
      nsCOMPtr<nsIOutputStream>(std::move(stream)));
}

Result<MovingNotNull<nsCOMPtr<nsIRandomAccessStream>>, nsresult>
CreateFileRandomAccessStream(PersistenceType aPersistenceType,
                             const OriginMetadata& aOriginMetadata,
                             Client::Type aClientType, nsIFile* aFile,
                             int32_t aIOFlags, int32_t aPerm,
                             int32_t aBehaviorFlags) {
  auto stream = MakeRefPtr<FileRandomAccessStream>(
      aPersistenceType, aOriginMetadata, aClientType);

  QM_TRY(MOZ_TO_RESULT(stream->Init(aFile, aIOFlags, aPerm, aBehaviorFlags)));

  return WrapMovingNotNullUnchecked(
      nsCOMPtr<nsIRandomAccessStream>(std::move(stream)));
}

}  // namespace mozilla::dom::quota