dom/cache/StreamList.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/StreamList.h"
   8
   9 #include <algorithm>
  10 #include "mozilla/dom/cache/CacheStreamControlParent.h"
  11 #include "mozilla/dom/cache/Context.h"
  12 #include "mozilla/dom/cache/Manager.h"
  13 #include "nsIInputStream.h"
  14
  15 namespace mozilla::dom::cache {
  16
  17 namespace {
  18
  19 auto MatchById(const nsID& aId) {
  20   return [aId](const auto& entry) { return entry.mId == aId; };
  21 }
  22
  23 }  // namespace
  24
  25 StreamList::StreamList(SafeRefPtr<Manager> aManager,
  26                        SafeRefPtr<Context> aContext)
  27     : mManager(std::move(aManager)),
  28       mContext(std::move(aContext)),
  29       mCacheId(INVALID_CACHE_ID),
  30       mStreamControl(nullptr),
  31       mActivated(false) {
  32   MOZ_DIAGNOSTIC_ASSERT(mManager);
  33   mContext->AddActivity(*this);
  34 }
  35
  36 Manager& StreamList::GetManager() const {
  37   MOZ_DIAGNOSTIC_ASSERT(mManager);
  38   return *mManager;
  39 }
  40
  41 bool StreamList::ShouldOpenStreamFor(const nsID& aId) const {
  42   NS_ASSERT_OWNINGTHREAD(StreamList);
  43
  44   return std::any_of(mList.cbegin(), mList.cend(), MatchById(aId));
  45 }
  46
  47 void StreamList::SetStreamControl(CacheStreamControlParent* aStreamControl) {
  48   NS_ASSERT_OWNINGTHREAD(StreamList);
  49   MOZ_DIAGNOSTIC_ASSERT(aStreamControl);
  50
  51   // For cases where multiple streams are serialized for a single list
  52   // then the control will get passed multiple times.  This is ok, but
  53   // it should be the same control each time.
  54   if (mStreamControl) {
  55     MOZ_DIAGNOSTIC_ASSERT(aStreamControl == mStreamControl);
  56     return;
  57   }
  58
  59   mStreamControl = aStreamControl;
  60   mStreamControl->SetStreamList(SafeRefPtrFromThis());
  61 }
  62
  63 void StreamList::RemoveStreamControl(CacheStreamControlParent* aStreamControl) {
  64   NS_ASSERT_OWNINGTHREAD(StreamList);
  65   MOZ_DIAGNOSTIC_ASSERT(mStreamControl);
  66   MOZ_DIAGNOSTIC_ASSERT(mStreamControl == aStreamControl);
  67   mStreamControl = nullptr;
  68 }
  69
  70 void StreamList::Activate(CacheId aCacheId) {
  71   NS_ASSERT_OWNINGTHREAD(StreamList);
  72   MOZ_DIAGNOSTIC_ASSERT(!mActivated);
  73   MOZ_DIAGNOSTIC_ASSERT(mCacheId == INVALID_CACHE_ID);
  74   mActivated = true;
  75   mCacheId = aCacheId;
  76   mManager->AddRefCacheId(mCacheId);
  77   mManager->AddStreamList(*this);
  78
  79   for (uint32_t i = 0; i < mList.Length(); ++i) {
  80     mManager->AddRefBodyId(mList[i].mId);
  81   }
  82 }
  83
  84 void StreamList::Add(const nsID& aId, nsCOMPtr<nsIInputStream>&& aStream) {
  85   // All streams should be added on IO thread before we set the stream
  86   // control on the owning IPC thread.
  87   MOZ_DIAGNOSTIC_ASSERT(!mStreamControl);
  88   mList.EmplaceBack(aId, std::move(aStream));
  89 }
  90
  91 already_AddRefed<nsIInputStream> StreamList::Extract(const nsID& aId) {
  92   NS_ASSERT_OWNINGTHREAD(StreamList);
  93
  94   const auto it = std::find_if(mList.begin(), mList.end(), MatchById(aId));
  95
  96   return it != mList.end() ? it->mStream.forget() : nullptr;
  97 }
  98
  99 void StreamList::NoteClosed(const nsID& aId) {
 100   NS_ASSERT_OWNINGTHREAD(StreamList);
 101
 102   const auto it = std::find_if(mList.begin(), mList.end(), MatchById(aId));
 103   if (it != mList.end()) {
 104     mList.RemoveElementAt(it);
 105     mManager->ReleaseBodyId(aId);
 106   }
 107
 108   if (mList.IsEmpty() && mStreamControl) {
 109     mStreamControl->Shutdown();
 110   }
 111 }
 112
 113 void StreamList::NoteClosedAll() {
 114   NS_ASSERT_OWNINGTHREAD(StreamList);
 115   for (uint32_t i = 0; i < mList.Length(); ++i) {
 116     mManager->ReleaseBodyId(mList[i].mId);
 117   }
 118   mList.Clear();
 119
 120   if (mStreamControl) {
 121     mStreamControl->Shutdown();
 122   }
 123 }
 124
 125 void StreamList::CloseAll() {
 126   NS_ASSERT_OWNINGTHREAD(StreamList);
 127   if (mStreamControl) {
 128     auto* streamControl = std::exchange(mStreamControl, nullptr);
 129
 130     streamControl->CloseAll();
 131
 132     mStreamControl = std::exchange(streamControl, nullptr);
 133
 134     mStreamControl->Shutdown();
 135   }
 136 }
 137
 138 void StreamList::Cancel() {
 139   NS_ASSERT_OWNINGTHREAD(StreamList);
 140   CloseAll();
 141 }
 142
 143 bool StreamList::MatchesCacheId(CacheId aCacheId) const {
 144   NS_ASSERT_OWNINGTHREAD(StreamList);
 145   return aCacheId == mCacheId;
 146 }
 147
 148 StreamList::~StreamList() {
 149   NS_ASSERT_OWNINGTHREAD(StreamList);
 150   MOZ_DIAGNOSTIC_ASSERT(!mStreamControl);
 151   if (mActivated) {
 152     mManager->RemoveStreamList(*this);
 153     for (uint32_t i = 0; i < mList.Length(); ++i) {
 154       mManager->ReleaseBodyId(mList[i].mId);
 155     }
 156     mManager->ReleaseCacheId(mCacheId);
 157   }
 158   mContext->RemoveActivity(*this);
 159 }
 160
 161 }  // namespace mozilla::dom::cache