Line data    Source code

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