dom/fs/child/FileSystemManagerChild.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "FileSystemManagerChild.h"
   8
   9 #include "FileSystemAccessHandleChild.h"
  10 #include "FileSystemBackgroundRequestHandler.h"
  11 #include "FileSystemWritableFileStreamChild.h"
  12 #include "mozilla/dom/FileSystemSyncAccessHandle.h"
  13 #include "mozilla/dom/FileSystemWritableFileStream.h"
  14
  15 namespace mozilla::dom {
  16
  17 void FileSystemManagerChild::SetBackgroundRequestHandler(
  18     FileSystemBackgroundRequestHandler* aBackgroundRequestHandler) {
  19   MOZ_ASSERT(aBackgroundRequestHandler);
  20   MOZ_ASSERT(!mBackgroundRequestHandler);
  21
  22   mBackgroundRequestHandler = aBackgroundRequestHandler;
  23 }
  24
  25 void FileSystemManagerChild::CloseAllWritables(
  26     std::function<void()>&& aCallback) {
  27   nsTArray<RefPtr<BoolPromise>> promises;
  28   CloseAllWritablesImpl(promises);
  29
  30   BoolPromise::AllSettled(GetCurrentSerialEventTarget(), promises)
  31       ->Then(GetCurrentSerialEventTarget(), __func__,
  32              [callback = std::move(aCallback)](
  33                  const BoolPromise::AllSettledPromiseType::ResolveOrRejectValue&
  34                  /* aValues */) { callback(); });
  35 }
  36
  37 #ifdef DEBUG
  38 bool FileSystemManagerChild::AllSyncAccessHandlesClosed() const {
  39   for (const auto& item : ManagedPFileSystemAccessHandleChild()) {
  40     auto* child = static_cast<FileSystemAccessHandleChild*>(item);
  41     auto* handle = child->MutableAccessHandlePtr();
  42
  43     if (!handle->IsClosed()) {
  44       return false;
  45     }
  46   }
  47
  48   return true;
  49 }
  50
  51 bool FileSystemManagerChild::AllWritableFileStreamsClosed() const {
  52   for (const auto& item : ManagedPFileSystemWritableFileStreamChild()) {
  53     auto* const child = static_cast<FileSystemWritableFileStreamChild*>(item);
  54     auto* const handle = child->MutableWritableFileStreamPtr();
  55     if (!handle) {
  56       continue;
  57     }
  58
  59     if (!handle->IsDone()) {
  60       return false;
  61     }
  62   }
  63
  64   return true;
  65 }
  66
  67 #endif
  68
  69 void FileSystemManagerChild::Shutdown() {
  70   if (!CanSend()) {
  71     return;
  72   }
  73
  74   Close();
  75 }
  76
  77 already_AddRefed<PFileSystemWritableFileStreamChild>
  78 FileSystemManagerChild::AllocPFileSystemWritableFileStreamChild() {
  79   return MakeAndAddRef<FileSystemWritableFileStreamChild>();
  80 }
  81
  82 ::mozilla::ipc::IPCResult FileSystemManagerChild::RecvCloseAll(
  83     CloseAllResolver&& aResolver) {
  84   nsTArray<RefPtr<BoolPromise>> promises;
  85
  86   // NOTE: getFile() creates blobs that read the data from the child;
  87   // we'll need to abort any reads and resolve this call only when all
  88   // blobs are closed.
  89
  90   for (const auto& item : ManagedPFileSystemAccessHandleChild()) {
  91     auto* child = static_cast<FileSystemAccessHandleChild*>(item);
  92     auto* handle = child->MutableAccessHandlePtr();
  93
  94     if (handle->IsOpen()) {
  95       promises.AppendElement(handle->BeginClose());
  96     } else if (handle->IsClosing()) {
  97       promises.AppendElement(handle->OnClose());
  98     }
  99   }
 100
 101   CloseAllWritablesImpl(promises);
 102
 103   BoolPromise::AllSettled(GetCurrentSerialEventTarget(), promises)
 104       ->Then(GetCurrentSerialEventTarget(), __func__,
 105              [resolver = std::move(aResolver)](
 106                  const BoolPromise::AllSettledPromiseType::ResolveOrRejectValue&
 107                  /* aValues */) { resolver(NS_OK); });
 108
 109   return IPC_OK();
 110 }
 111
 112 void FileSystemManagerChild::ActorDestroy(ActorDestroyReason aWhy) {
 113   if (mBackgroundRequestHandler) {
 114     mBackgroundRequestHandler->ClearActor();
 115     mBackgroundRequestHandler = nullptr;
 116   }
 117 }
 118
 119 template <class T>
 120 void FileSystemManagerChild::CloseAllWritablesImpl(T& aPromises) {
 121   for (const auto& item : ManagedPFileSystemWritableFileStreamChild()) {
 122     auto* const child = static_cast<FileSystemWritableFileStreamChild*>(item);
 123     auto* const handle = child->MutableWritableFileStreamPtr();
 124
 125     if (handle) {
 126       if (handle->IsOpen()) {
 127         aPromises.AppendElement(handle->BeginAbort());
 128       } else if (handle->IsFinishing()) {
 129         aPromises.AppendElement(handle->OnDone());
 130       }
 131     }
 132   }
 133 }
 134
 135 }  // namespace mozilla::dom