Commit 183be490 authored by Cristian Tuns's avatar Cristian Tuns
Browse files

Backed out 2 changesets (bug 1825552) for causing build bustages in... 

Backed out 2 changesets (bug 1825552) for causing build bustages in FileSystemThreadSafeStreamOwner.h CLOSED TREE

Backed out changeset 17def1f78e36 (bug 1825552)
Backed out changeset a2519447d580 (bug 1825552)
parent ec6e03ed

dom/fs/api/FileSystemWritableFileStream.cpp

+37 −104
Original line number Diff line number Diff line
@@ -78,14 +78,11 @@ class WritableFileStreamUnderlyingSinkAlgorithms final 
};



// TODO: Refactor this function, see Bug 1804614

void WriteImpl(RefPtr<FileSystemWritableFileStream> aStream,

               const RefPtr<nsISerialEventTarget>& aTaskQueue,

void WriteImpl(const RefPtr<nsISerialEventTarget>& aTaskQueue,

               nsCOMPtr<nsIInputStream> aInputStream,

               RefPtr<fs::FileSystemThreadSafeStreamOwner>& aOutStreamOwner,

               const Maybe<uint64_t> aPosition,

               const RefPtr<Promise>& aPromise) {

  auto command = aStream->CreateCommand();



  InvokeAsync(

      aTaskQueue, __func__,

      [aTaskQueue, inputStream = std::move(aInputStream), aOutStreamOwner,
@@ -130,8 +127,7 @@ void WriteImpl(RefPtr<FileSystemWritableFileStream> aStream, 
      })

      ->Then(

          GetCurrentSerialEventTarget(), __func__,

          [command,

           aPromise](const Int64Promise::ResolveOrRejectValue& aValue) {

          [aPromise](const Int64Promise::ResolveOrRejectValue& aValue) {

            if (aValue.IsResolve()) {

              aPromise->MaybeResolve(aValue.ResolveValue());

              return;
@@ -151,21 +147,6 @@ void WriteImpl(RefPtr<FileSystemWritableFileStream> aStream, 


}  // namespace



class FileSystemWritableFileStream::Command {

 public:

  explicit Command(RefPtr<FileSystemWritableFileStream> aWritableFileStream)

      : mWritableFileStream(std::move(aWritableFileStream)) {

    MOZ_ASSERT(mWritableFileStream);

  }



  NS_INLINE_DECL_REFCOUNTING(FileSystemWritableFileStream::Command)



 private:

  ~Command() { mWritableFileStream->NoteFinishedCommand(); }



  RefPtr<FileSystemWritableFileStream> mWritableFileStream;

};



class FileSystemWritableFileStream::CloseHandler {

  enum struct State : uint8_t { Initial = 0, Open, Closing, Closed };
@@ -259,11 +240,10 @@ FileSystemWritableFileStream::FileSystemWritableFileStream( 
      mActor(std::move(aActor)),

      mTaskQueue(aTaskQueue),

      mStreamOwner(MakeAndAddRef<fs::FileSystemThreadSafeStreamOwner>(

          this, std::move(aStream))),

          std::move(aStream))),

      mWorkerRef(),

      mMetadata(std::move(aMetadata)),

      mCloseHandler(MakeAndAddRef<CloseHandler>()),

      mCommandActive(false) {

      mCloseHandler(MakeAndAddRef<CloseHandler>()) {

  LOG(("Created WritableFileStream %p for fd %p", this, mStreamOwner.get()));



  // Connect with the actor directly in the constructor. This way the actor
@@ -277,7 +257,6 @@ FileSystemWritableFileStream::FileSystemWritableFileStream( 
}



FileSystemWritableFileStream::~FileSystemWritableFileStream() {

  MOZ_ASSERT(!mCommandActive);

  MOZ_ASSERT(IsClosed());



  mozilla::DropJSObjects(this);
@@ -434,19 +413,6 @@ void FileSystemWritableFileStream::LastRelease() { 
  }

}



RefPtr<FileSystemWritableFileStream::Command>

FileSystemWritableFileStream::CreateCommand() {

  MOZ_ASSERT(!mCommandActive);



  mCommandActive = true;



  return MakeRefPtr<Command>(this);

}



bool FileSystemWritableFileStream::IsCommandActive() const {

  return mCommandActive;

}



void FileSystemWritableFileStream::ClearActor() {

  MOZ_ASSERT(mActor);
@@ -464,8 +430,7 @@ bool FileSystemWritableFileStream::IsClosed() const { 
RefPtr<BoolPromise> FileSystemWritableFileStream::BeginClose() {

  using ClosePromise = PFileSystemWritableFileStreamChild::ClosePromise;

  if (mCloseHandler->TestAndSetClosing()) {

    Finish()

        ->Then(mTaskQueue, __func__,

    InvokeAsync(mTaskQueue, __func__,

                [streamOwner = mStreamOwner]() mutable {

                  streamOwner->Close();
@@ -504,6 +469,8 @@ void FileSystemWritableFileStream::SetWorkerRef( 


already_AddRefed<Promise> FileSystemWritableFileStream::Write(

    JSContext* aCx, JS::Handle<JS::Value> aChunk, ErrorResult& aError) {

  MOZ_ASSERT(IsOpen());



  // https://fs.spec.whatwg.org/#create-a-new-filesystemwritablefilestream

  // Step 3. Let writeAlgorithm be an algorithm which takes a chunk argument

  // and returns the result of running the write a chunk algorithm with stream
@@ -527,11 +494,6 @@ already_AddRefed<Promise> FileSystemWritableFileStream::Write( 
    return nullptr;

  }



  if (!IsOpen()) {

    promise->MaybeRejectWithTypeError("WritableFileStream closed");

    return promise.forget();

  }



  // Step 3.3. Let command be input.type if input is a WriteParams, ...

  if (data.IsWriteParams()) {

    const WriteParams& params = data.GetAsWriteParams();
@@ -735,8 +697,6 @@ template <typename T> 
void FileSystemWritableFileStream::Write(const T& aData,

                                         const Maybe<uint64_t> aPosition,

                                         const RefPtr<Promise>& aPromise) {

  MOZ_ASSERT(IsOpen());



  auto rejectAndReturn = [&aPromise](const nsresult rv) {

    if (IsFileNotFoundError(rv)) {

      aPromise->MaybeRejectWithNotFoundError("File not found");
@@ -769,7 +729,7 @@ void FileSystemWritableFileStream::Write(const T& aData, 
                                               NS_ASSIGNMENT_COPY)),

           rejectAndReturn);



    WriteImpl(this, mTaskQueue, std::move(inputStream), mStreamOwner, aPosition,

    WriteImpl(mTaskQueue, std::move(inputStream), mStreamOwner, aPosition,

              aPromise);

    return;

  }
@@ -785,7 +745,7 @@ void FileSystemWritableFileStream::Write(const T& aData, 
           })),

           rejectAndReturn);



    WriteImpl(this, mTaskQueue, std::move(inputStream), mStreamOwner, aPosition,

    WriteImpl(mTaskQueue, std::move(inputStream), mStreamOwner, aPosition,

              aPromise);

    return;

  }
@@ -805,18 +765,13 @@ void FileSystemWritableFileStream::Write(const T& aData, 
                                                std::move(dataString))),

         rejectAndReturn);



  WriteImpl(this, mTaskQueue, std::move(inputStream), mStreamOwner, aPosition,

  WriteImpl(mTaskQueue, std::move(inputStream), mStreamOwner, aPosition,

            aPromise);

}



void FileSystemWritableFileStream::Seek(uint64_t aPosition,

                                        const RefPtr<Promise>& aPromise) {

  MOZ_ASSERT(IsOpen());



  LOG_VERBOSE(("%p: Seeking to %" PRIu64, mStreamOwner.get(), aPosition));



  auto command = CreateCommand();



  InvokeAsync(mTaskQueue, __func__,

              [aPosition, streamOwner = mStreamOwner]() mutable {

                QM_TRY(MOZ_TO_RESULT(streamOwner->Seek(aPosition)),
@@ -824,9 +779,8 @@ void FileSystemWritableFileStream::Seek(uint64_t aPosition, 


                return BoolPromise::CreateAndResolve(true, __func__);

              })

      ->Then(

          GetCurrentSerialEventTarget(), __func__,

          [command, aPromise](const BoolPromise::ResolveOrRejectValue& aValue) {

      ->Then(GetCurrentSerialEventTarget(), __func__,

             [aPromise](const BoolPromise::ResolveOrRejectValue& aValue) {

               if (aValue.IsReject()) {

                 auto rv = aValue.RejectValue();

                 if (IsFileNotFoundError(rv)) {
@@ -843,10 +797,6 @@ void FileSystemWritableFileStream::Seek(uint64_t aPosition, 


void FileSystemWritableFileStream::Truncate(uint64_t aSize,

                                            const RefPtr<Promise>& aPromise) {

  MOZ_ASSERT(IsOpen());



  auto command = CreateCommand();



  InvokeAsync(mTaskQueue, __func__,

              [aSize, streamOwner = mStreamOwner]() mutable {

                QM_TRY(MOZ_TO_RESULT(streamOwner->Truncate(aSize)),
@@ -854,9 +804,8 @@ void FileSystemWritableFileStream::Truncate(uint64_t aSize, 


                return BoolPromise::CreateAndResolve(true, __func__);

              })

      ->Then(

          GetCurrentSerialEventTarget(), __func__,

          [command, aPromise](const BoolPromise::ResolveOrRejectValue& aValue) {

      ->Then(GetCurrentSerialEventTarget(), __func__,

             [aPromise](const BoolPromise::ResolveOrRejectValue& aValue) {

               if (aValue.IsReject()) {

                 aPromise->MaybeReject(aValue.RejectValue());

                 return;
@@ -866,22 +815,6 @@ void FileSystemWritableFileStream::Truncate(uint64_t aSize, 
             });

}



void FileSystemWritableFileStream::NoteFinishedCommand() {

  MOZ_ASSERT(mCommandActive);



  mCommandActive = false;



  mFinishPromiseHolder.ResolveIfExists(true, __func__);

}



RefPtr<BoolPromise> FileSystemWritableFileStream::Finish() {

  if (!mCommandActive) {

    return BoolPromise::CreateAndResolve(true, __func__);

  }



  return mFinishPromiseHolder.Ensure(__func__);

}



NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED_0(

    WritableFileStreamUnderlyingSinkAlgorithms, UnderlyingSinkAlgorithmsBase)

NS_IMPL_CYCLE_COLLECTION_INHERITED(WritableFileStreamUnderlyingSinkAlgorithms,

dom/fs/api/FileSystemWritableFileStream.h

+0 −13
Original line number Diff line number Diff line
@@ -63,11 +63,6 @@ class FileSystemWritableFileStream final : public WritableStream { 


  void ClearActor();



  class Command;

  RefPtr<Command> CreateCommand();



  bool IsCommandActive() const;



  bool IsOpen() const;



  bool IsClosed() const;
@@ -114,10 +109,6 @@ class FileSystemWritableFileStream final : public WritableStream { 


  void Truncate(uint64_t aSize, const RefPtr<Promise>& aPromise);



  void NoteFinishedCommand();



  [[nodiscard]] RefPtr<BoolPromise> Finish();



  RefPtr<FileSystemManager> mManager;



  RefPtr<FileSystemWritableFileStreamChild> mActor;
@@ -131,10 +122,6 @@ class FileSystemWritableFileStream final : public WritableStream { 
  fs::FileSystemEntryMetadata mMetadata;



  RefPtr<CloseHandler> mCloseHandler;



  MozPromiseHolder<BoolPromise> mFinishPromiseHolder;



  bool mCommandActive;

};



}  // namespace dom

dom/fs/child/FileSystemThreadSafeStreamOwner.cpp

+2 −13
Original line number Diff line number Diff line
@@ -8,7 +8,6 @@ 


#include "mozilla/CheckedInt.h"

#include "mozilla/dom/FileSystemLog.h"

#include "mozilla/dom/FileSystemWritableFileStream.h"

#include "mozilla/dom/quota/QuotaCommon.h"

#include "mozilla/dom/quota/ResultExtensions.h"

#include "nsIOutputStream.h"
@@ -37,17 +36,11 @@ nsresult TruncFile(nsCOMPtr<nsIRandomAccessStream>& aStream, int64_t aEOF) { 
}  // namespace



FileSystemThreadSafeStreamOwner::FileSystemThreadSafeStreamOwner(

    FileSystemWritableFileStream* aWritableFileStream,

    nsCOMPtr<nsIRandomAccessStream>&& aStream)

    : mWritableFileStream(aWritableFileStream),

      mStream(std::forward<nsCOMPtr<nsIRandomAccessStream>>(aStream)),

      mClosed(false) {

  MOZ_ASSERT(mWritableFileStream);

}

    : mStream(std::forward<nsCOMPtr<nsIRandomAccessStream>>(aStream)),

      mClosed(false) {}



nsresult FileSystemThreadSafeStreamOwner::Truncate(uint64_t aSize) {

  MOZ_DIAGNOSTIC_ASSERT(mWritableFileStream->IsCommandActive());



  if (mClosed) {  // Multiple closes can end up in a queue

    return NS_ERROR_DOM_INVALID_STATE_ERR;

  }
@@ -69,8 +62,6 @@ nsresult FileSystemThreadSafeStreamOwner::Truncate(uint64_t aSize) { 
}



nsresult FileSystemThreadSafeStreamOwner::Seek(uint64_t aPosition) {

  MOZ_DIAGNOSTIC_ASSERT(mWritableFileStream->IsCommandActive());



  if (mClosed) {  // Multiple closes can end up in a queue

    return NS_ERROR_DOM_INVALID_STATE_ERR;

  }
@@ -93,8 +84,6 @@ void FileSystemThreadSafeStreamOwner::Close() { 
}



nsCOMPtr<nsIOutputStream> FileSystemThreadSafeStreamOwner::OutputStream() {

  MOZ_DIAGNOSTIC_ASSERT(mWritableFileStream->IsCommandActive());



  return mStream->OutputStream();

}

dom/fs/include/fs/FileSystemThreadSafeStreamOwner.h

+3 −10
Original line number Diff line number Diff line
@@ -12,16 +12,11 @@ 
class nsIOutputStream;

class nsIRandomAccessStream;



namespace mozilla::dom {



class FileSystemWritableFileStream;



namespace fs {

namespace mozilla::dom::fs {



class FileSystemThreadSafeStreamOwner {

 public:

  FileSystemThreadSafeStreamOwner(

      FileSystemWritableFileStream* aWritableFileStream,

  explicit FileSystemThreadSafeStreamOwner(

      nsCOMPtr<nsIRandomAccessStream>&& aStream);



  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(FileSystemThreadSafeStreamOwner)
@@ -38,13 +33,11 @@ class FileSystemThreadSafeStreamOwner { 
  virtual ~FileSystemThreadSafeStreamOwner() = default;



 private:

  FileSystemWritableFileStream* MOZ_NON_OWNING_REF mWritableFileStream;

  nsCOMPtr<nsIRandomAccessStream> mStream;



  bool mClosed;

};



}  // namespace fs

}  // namespace mozilla::dom

}  // namespace mozilla::dom::fs



#endif  // DOM_FS_FILESYSTEMTHREADSAFESTREAMOWNER_H_