FileStreams.h (6168B)
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 #ifndef mozilla_dom_quota_filestreams_h__ 8 #define mozilla_dom_quota_filestreams_h__ 9 10 // Local includes 11 #include "Client.h" 12 13 // Global includes 14 #include <cstdint> 15 16 #include "mozilla/RefPtr.h" 17 #include "mozilla/dom/quota/CommonMetadata.h" 18 #include "mozilla/dom/quota/PersistenceType.h" 19 #include "mozilla/dom/quota/QuotaObject.h" 20 #include "nsFileStreams.h" 21 #include "nsISupports.h" 22 #include "nscore.h" 23 24 class nsIFile; 25 26 namespace mozilla { 27 class Runnable; 28 } 29 30 namespace mozilla::dom::quota { 31 32 class QuotaObject; 33 34 template <class FileStreamBase> 35 class FileQuotaStream : public FileStreamBase { 36 public: 37 // nsFileStreamBase override 38 NS_IMETHOD 39 SetEOF() override; 40 41 NS_IMETHOD 42 Close() override; 43 44 protected: 45 FileQuotaStream(PersistenceType aPersistenceType, 46 const OriginMetadata& aOriginMetadata, 47 Client::Type aClientType) 48 : mPersistenceType(aPersistenceType), 49 mOriginMetadata(aOriginMetadata), 50 mClientType(aClientType), 51 mDeserialized(false) {} 52 53 FileQuotaStream() 54 : mPersistenceType(PERSISTENCE_TYPE_INVALID), 55 mClientType(Client::TYPE_MAX), 56 mDeserialized(true) {} 57 58 ~FileQuotaStream() { Close(); } 59 60 // nsFileStreamBase override 61 virtual nsresult DoOpen() override; 62 63 PersistenceType mPersistenceType; 64 OriginMetadata mOriginMetadata; 65 Client::Type mClientType; 66 RefPtr<QuotaObject> mQuotaObject; 67 const bool mDeserialized; 68 }; 69 70 template <class FileStreamBase> 71 class FileQuotaStreamWithWrite : public FileQuotaStream<FileStreamBase> { 72 public: 73 // nsFileStreamBase override 74 NS_IMETHOD 75 Write(const char* aBuf, uint32_t aCount, uint32_t* _retval) override; 76 77 protected: 78 FileQuotaStreamWithWrite(PersistenceType aPersistenceType, 79 const OriginMetadata& aOriginMetadata, 80 Client::Type aClientType) 81 : FileQuotaStream<FileStreamBase>(aPersistenceType, aOriginMetadata, 82 aClientType) {} 83 84 FileQuotaStreamWithWrite() = default; 85 }; 86 87 class FileInputStream : public FileQuotaStream<nsFileInputStream> { 88 public: 89 NS_INLINE_DECL_REFCOUNTING_INHERITED(FileInputStream, 90 FileQuotaStream<nsFileInputStream>) 91 92 FileInputStream(PersistenceType aPersistenceType, 93 const OriginMetadata& aOriginMetadata, 94 Client::Type aClientType) 95 : FileQuotaStream<nsFileInputStream>(aPersistenceType, aOriginMetadata, 96 aClientType) {} 97 98 private: 99 virtual ~FileInputStream() { Close(); } 100 }; 101 102 class FileOutputStream : public FileQuotaStreamWithWrite<nsFileOutputStream> { 103 public: 104 NS_INLINE_DECL_REFCOUNTING_INHERITED( 105 FileOutputStream, FileQuotaStreamWithWrite<nsFileOutputStream>); 106 107 FileOutputStream(PersistenceType aPersistenceType, 108 const OriginMetadata& aOriginMetadata, 109 Client::Type aClientType) 110 : FileQuotaStreamWithWrite<nsFileOutputStream>( 111 aPersistenceType, aOriginMetadata, aClientType) {} 112 113 private: 114 virtual ~FileOutputStream() { Close(); } 115 }; 116 117 // FileRandomAccessStream type is serializable, but only in a restricted 118 // manner. The type is only safe to serialize in the parent process and only 119 // when the type hasn't been previously deserialized. So the type can be 120 // serialized in the parent process and desrialized in a child process or it 121 // can be serialized in the parent process and deserialized in the parent 122 // process as well (non-e10s mode). The same type can never be 123 // serialized/deserialized more than once. 124 class FileRandomAccessStream 125 : public FileQuotaStreamWithWrite<nsFileRandomAccessStream> { 126 public: 127 NS_INLINE_DECL_REFCOUNTING_INHERITED( 128 FileRandomAccessStream, 129 FileQuotaStreamWithWrite<nsFileRandomAccessStream>) 130 131 FileRandomAccessStream(PersistenceType aPersistenceType, 132 const OriginMetadata& aOriginMetadata, 133 Client::Type aClientType) 134 : FileQuotaStreamWithWrite<nsFileRandomAccessStream>( 135 aPersistenceType, aOriginMetadata, aClientType) {} 136 137 FileRandomAccessStream() = default; 138 139 // nsFileRandomAccessStream override 140 141 // Serialize this FileRandomAccessStream. This method works only in the 142 // parent process and only with streams which haven't been previously 143 // deserialized. 144 mozilla::ipc::RandomAccessStreamParams Serialize( 145 nsIInterfaceRequestor* aCallbacks) override; 146 147 // Deserialize this FileRandomAccessStream. This method works in both the 148 // child and parent. 149 bool Deserialize(mozilla::ipc::RandomAccessStreamParams& aParams) override; 150 151 private: 152 virtual ~FileRandomAccessStream() { Close(); } 153 }; 154 155 Result<MovingNotNull<nsCOMPtr<nsIInputStream>>, nsresult> CreateFileInputStream( 156 PersistenceType aPersistenceType, const OriginMetadata& aOriginMetadata, 157 Client::Type aClientType, nsIFile* aFile, int32_t aIOFlags = -1, 158 int32_t aPerm = -1, int32_t aBehaviorFlags = 0); 159 160 Result<MovingNotNull<nsCOMPtr<nsIOutputStream>>, nsresult> 161 CreateFileOutputStream(PersistenceType aPersistenceType, 162 const OriginMetadata& aOriginMetadata, 163 Client::Type aClientType, nsIFile* aFile, 164 int32_t aIOFlags = -1, int32_t aPerm = -1, 165 int32_t aBehaviorFlags = 0); 166 167 Result<MovingNotNull<nsCOMPtr<nsIRandomAccessStream>>, nsresult> 168 CreateFileRandomAccessStream(PersistenceType aPersistenceType, 169 const OriginMetadata& aOriginMetadata, 170 Client::Type aClientType, nsIFile* aFile, 171 int32_t aIOFlags = -1, int32_t aPerm = -1, 172 int32_t aBehaviorFlags = 0); 173 174 } // namespace mozilla::dom::quota 175 176 #endif /* mozilla_dom_quota_filestreams_h__ */