dom/cache/CacheStreamControlParent.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 "mozilla/dom/cache/CacheStreamControlParent.h"
   8
   9 #include "mozilla/UniquePtr.h"
  10 #include "mozilla/Unused.h"
  11 #include "mozilla/dom/cache/CacheTypes.h"
  12 #include "mozilla/dom/cache/ReadStream.h"
  13 #include "mozilla/dom/cache/StreamList.h"
  14 #include "mozilla/ipc/IPCStreamUtils.h"
  15 #include "mozilla/ipc/PBackgroundParent.h"
  16 #include "nsISupportsImpl.h"
  17 #include "nsTArray.h"
  18
  19 namespace mozilla::dom::cache {
  20
  21 using mozilla::ipc::FileDescriptor;
  22
  23 // declared in ActorUtils.h
  24 void DeallocPCacheStreamControlParent(PCacheStreamControlParent* aActor) {
  25   delete aActor;
  26 }
  27
  28 CacheStreamControlParent::CacheStreamControlParent() {
  29   MOZ_COUNT_CTOR(cache::CacheStreamControlParent);
  30 }
  31
  32 CacheStreamControlParent::~CacheStreamControlParent() {
  33   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
  34   MOZ_DIAGNOSTIC_ASSERT(!mStreamList);
  35   MOZ_COUNT_DTOR(cache::CacheStreamControlParent);
  36 }
  37
  38 void CacheStreamControlParent::SerializeControl(
  39     CacheReadStream* aReadStreamOut) {
  40   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
  41   MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
  42   aReadStreamOut->control() = this;
  43 }
  44
  45 void CacheStreamControlParent::SerializeStream(CacheReadStream* aReadStreamOut,
  46                                                nsIInputStream* aStream) {
  47   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
  48   MOZ_DIAGNOSTIC_ASSERT(aReadStreamOut);
  49
  50   DebugOnly<bool> ok = mozilla::ipc::SerializeIPCStream(
  51       do_AddRef(aStream), aReadStreamOut->stream(), /* aAllowLazy */ false);
  52   MOZ_ASSERT(ok);
  53 }
  54
  55 void CacheStreamControlParent::OpenStream(const nsID& aId,
  56                                           InputStreamResolver&& aResolver) {
  57   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
  58   MOZ_DIAGNOSTIC_ASSERT(aResolver);
  59
  60   if (!mStreamList || !mStreamList->ShouldOpenStreamFor(aId)) {
  61     aResolver(nullptr);
  62     return;
  63   }
  64
  65   // Make sure to add ourself as a Listener even thought we are using
  66   // a separate resolver function to signal the completion of the
  67   // operation.  The Manager uses the existence of the Listener to ensure
  68   // that its safe to complete the operation.
  69   mStreamList->GetManager().ExecuteOpenStream(this, std::move(aResolver), aId);
  70 }
  71
  72 void CacheStreamControlParent::NoteClosedAfterForget(const nsID& aId) {
  73   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
  74   RecvNoteClosed(aId);
  75 }
  76
  77 #ifdef DEBUG
  78 void CacheStreamControlParent::AssertOwningThread() {
  79   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
  80 }
  81 #endif
  82
  83 void CacheStreamControlParent::LostIPCCleanup(
  84     SafeRefPtr<StreamList> aStreamList) {
  85   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
  86   CloseAllReadStreamsWithoutReporting();
  87   // If the initial SendPStreamControlConstructor() fails we will
  88   // be called before mStreamList is set.
  89   if (!aStreamList) {
  90     return;
  91   }
  92   aStreamList->GetManager().RemoveListener(this);
  93 #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
  94   aStreamList->GetManager().RecordHaveDeletedCSCP(Id());
  95 #endif
  96   aStreamList->RemoveStreamControl(this);
  97   aStreamList->NoteClosedAll();
  98   mStreamList = nullptr;
  99 }
 100
 101 void CacheStreamControlParent::ActorDestroy(ActorDestroyReason aReason) {
 102   LostIPCCleanup(std::move(mStreamList));
 103 }
 104
 105 void CacheStreamControlParent::AssertWillDelete() {
 106 #ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
 107   // If we cannot send, Send__delete__ will not do any cleanup.
 108   // But if we are still unfreed, that might be wrong.
 109   if (mStreamList && !CanSend()) {
 110     MOZ_ASSERT(false, "Attempt to delete blocking CSCP that cannot send.");
 111     mStreamList->GetManager().RecordMayNotDeleteCSCP(Id());
 112   }
 113 #endif
 114 }
 115
 116 mozilla::ipc::IPCResult CacheStreamControlParent::RecvOpenStream(
 117     const nsID& aStreamId, OpenStreamResolver&& aResolver) {
 118   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
 119
 120   OpenStream(aStreamId, [aResolver, self = RefPtr{this}](
 121                             nsCOMPtr<nsIInputStream>&& aStream) {
 122     Maybe<IPCStream> stream;
 123     if (self->CanSend() &&
 124         mozilla::ipc::SerializeIPCStream(aStream.forget(), stream,
 125                                          /* aAllowLazy */ false)) {
 126       aResolver(stream);
 127     } else {
 128       aResolver(Nothing());
 129     }
 130   });
 131
 132   return IPC_OK();
 133 }
 134
 135 mozilla::ipc::IPCResult CacheStreamControlParent::RecvNoteClosed(
 136     const nsID& aId) {
 137   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
 138   MOZ_DIAGNOSTIC_ASSERT(mStreamList);
 139   mStreamList->NoteClosed(aId);
 140   return IPC_OK();
 141 }
 142
 143 void CacheStreamControlParent::SetStreamList(
 144     SafeRefPtr<StreamList> aStreamList) {
 145   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
 146   MOZ_DIAGNOSTIC_ASSERT(!mStreamList);
 147   mStreamList = std::move(aStreamList);
 148 }
 149
 150 void CacheStreamControlParent::CloseAll() {
 151   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
 152   NotifyCloseAll();
 153
 154   QM_WARNONLY_TRY(OkIf(SendCloseAll()));
 155 }
 156
 157 void CacheStreamControlParent::Shutdown() {
 158   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
 159
 160   AssertWillDelete();
 161   // If child process is gone, warn and allow actor to clean up normally
 162   QM_WARNONLY_TRY(OkIf(Send__delete__(this)));
 163 }
 164
 165 void CacheStreamControlParent::NotifyCloseAll() {
 166   NS_ASSERT_OWNINGTHREAD(CacheStreamControlParent);
 167   CloseAllReadStreams();
 168 }
 169
 170 }  // namespace mozilla::dom::cache