michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: #include "Blob.h"
michael@0: 
michael@0: #include "ContentChild.h"
michael@0: #include "ContentParent.h"
michael@0: #include "FileDescriptorSetChild.h"
michael@0: #include "jsapi.h"
michael@0: #include "mozilla/Assertions.h"
michael@0: #include "mozilla/DebugOnly.h"
michael@0: #include "mozilla/Monitor.h"
michael@0: #include "mozilla/unused.h"
michael@0: #include "mozilla/dom/PBlobStreamChild.h"
michael@0: #include "mozilla/dom/PBlobStreamParent.h"
michael@0: #include "mozilla/dom/PFileDescriptorSetParent.h"
michael@0: #include "mozilla/ipc/InputStreamUtils.h"
michael@0: #include "nsCOMPtr.h"
michael@0: #include "nsDOMFile.h"
michael@0: #include "nsIDOMFile.h"
michael@0: #include "nsIInputStream.h"
michael@0: #include "nsIIPCSerializableInputStream.h"
michael@0: #include "nsIMultiplexInputStream.h"
michael@0: #include "nsIRemoteBlob.h"
michael@0: #include "nsISeekableStream.h"
michael@0: #include "nsNetCID.h"
michael@0: #include "nsProxyRelease.h"
michael@0: #include "nsThreadUtils.h"
michael@0: 
michael@0: #define PRIVATE_REMOTE_INPUT_STREAM_IID \
michael@0:   {0x30c7699f, 0x51d2, 0x48c8, {0xad, 0x56, 0xc0, 0x16, 0xd7, 0x6f, 0x71, 0x27}}
michael@0: 
michael@0: using namespace mozilla;
michael@0: using namespace mozilla::dom;
michael@0: using namespace mozilla::ipc;
michael@0: 
michael@0: namespace {
michael@0: 
michael@0: enum ActorType
michael@0: {
michael@0:   ChildActor,
michael@0:   ParentActor
michael@0: };
michael@0: 
michael@0: // Ensure that a nsCOMPtr/nsRefPtr is released on the main thread.
michael@0: template <template <class> class SmartPtr, class T>
michael@0: void
michael@0: ProxyReleaseToMainThread(SmartPtr<T>& aDoomed)
michael@0: {
michael@0:   MOZ_ASSERT(!NS_IsMainThread());
michael@0: 
michael@0:   nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
michael@0:   NS_ENSURE_TRUE_VOID(mainThread);
michael@0: 
michael@0:   if (NS_FAILED(NS_ProxyRelease(mainThread, aDoomed, true))) {
michael@0:     NS_WARNING("Failed to proxy release to main thread!");
michael@0:   }
michael@0: }
michael@0: 
michael@0: class NS_NO_VTABLE IPrivateRemoteInputStream : public nsISupports
michael@0: {
michael@0: public:
michael@0:   NS_DECLARE_STATIC_IID_ACCESSOR(PRIVATE_REMOTE_INPUT_STREAM_IID)
michael@0: 
michael@0:   // This will return the underlying stream.
michael@0:   virtual nsIInputStream*
michael@0:   BlockAndGetInternalStream() = 0;
michael@0: };
michael@0: 
michael@0: NS_DEFINE_STATIC_IID_ACCESSOR(IPrivateRemoteInputStream,
michael@0:                               PRIVATE_REMOTE_INPUT_STREAM_IID)
michael@0: 
michael@0: // This class exists to keep a blob alive at least as long as its internal
michael@0: // stream.
michael@0: class BlobInputStreamTether : public nsIMultiplexInputStream,
michael@0:                               public nsISeekableStream,
michael@0:                               public nsIIPCSerializableInputStream
michael@0: {
michael@0:   nsCOMPtr<nsIInputStream> mStream;
michael@0:   nsCOMPtr<nsIDOMBlob> mSourceBlob;
michael@0: 
michael@0:   nsIMultiplexInputStream* mWeakMultiplexStream;
michael@0:   nsISeekableStream* mWeakSeekableStream;
michael@0:   nsIIPCSerializableInputStream* mWeakSerializableStream;
michael@0: 
michael@0: public:
michael@0:   NS_DECL_THREADSAFE_ISUPPORTS
michael@0:   NS_FORWARD_NSIINPUTSTREAM(mStream->)
michael@0:   NS_FORWARD_SAFE_NSIMULTIPLEXINPUTSTREAM(mWeakMultiplexStream)
michael@0:   NS_FORWARD_SAFE_NSISEEKABLESTREAM(mWeakSeekableStream)
michael@0:   NS_FORWARD_SAFE_NSIIPCSERIALIZABLEINPUTSTREAM(mWeakSerializableStream)
michael@0: 
michael@0:   BlobInputStreamTether(nsIInputStream* aStream, nsIDOMBlob* aSourceBlob)
michael@0:   : mStream(aStream), mSourceBlob(aSourceBlob), mWeakMultiplexStream(nullptr),
michael@0:     mWeakSeekableStream(nullptr), mWeakSerializableStream(nullptr)
michael@0:   {
michael@0:     MOZ_ASSERT(aStream);
michael@0:     MOZ_ASSERT(aSourceBlob);
michael@0: 
michael@0:     nsCOMPtr<nsIMultiplexInputStream> multiplexStream =
michael@0:       do_QueryInterface(aStream);
michael@0:     if (multiplexStream) {
michael@0:       MOZ_ASSERT(SameCOMIdentity(aStream, multiplexStream));
michael@0:       mWeakMultiplexStream = multiplexStream;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsISeekableStream> seekableStream = do_QueryInterface(aStream);
michael@0:     if (seekableStream) {
michael@0:       MOZ_ASSERT(SameCOMIdentity(aStream, seekableStream));
michael@0:       mWeakSeekableStream = seekableStream;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIIPCSerializableInputStream> serializableStream =
michael@0:       do_QueryInterface(aStream);
michael@0:     if (serializableStream) {
michael@0:       MOZ_ASSERT(SameCOMIdentity(aStream, serializableStream));
michael@0:       mWeakSerializableStream = serializableStream;
michael@0:     }
michael@0:   }
michael@0: 
michael@0: protected:
michael@0:   virtual ~BlobInputStreamTether()
michael@0:   {
michael@0:     MOZ_ASSERT(mStream);
michael@0:     MOZ_ASSERT(mSourceBlob);
michael@0: 
michael@0:     if (!NS_IsMainThread()) {
michael@0:       mStream = nullptr;
michael@0:       ProxyReleaseToMainThread(mSourceBlob);
michael@0:     }
michael@0:   }
michael@0: };
michael@0: 
michael@0: NS_IMPL_ADDREF(BlobInputStreamTether)
michael@0: NS_IMPL_RELEASE(BlobInputStreamTether)
michael@0: 
michael@0: NS_INTERFACE_MAP_BEGIN(BlobInputStreamTether)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsIInputStream)
michael@0:   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIMultiplexInputStream,
michael@0:                                      mWeakMultiplexStream)
michael@0:   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsISeekableStream, mWeakSeekableStream)
michael@0:   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIIPCSerializableInputStream,
michael@0:                                      mWeakSerializableStream)
michael@0:   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStream)
michael@0: NS_INTERFACE_MAP_END
michael@0: 
michael@0: class RemoteInputStream : public nsIInputStream,
michael@0:                           public nsISeekableStream,
michael@0:                           public nsIIPCSerializableInputStream,
michael@0:                           public IPrivateRemoteInputStream
michael@0: {
michael@0:   mozilla::Monitor mMonitor;
michael@0:   nsCOMPtr<nsIInputStream> mStream;
michael@0:   nsCOMPtr<nsIDOMBlob> mSourceBlob;
michael@0:   nsISeekableStream* mWeakSeekableStream;
michael@0:   ActorType mOrigin;
michael@0: 
michael@0: public:
michael@0:   NS_DECL_THREADSAFE_ISUPPORTS
michael@0: 
michael@0:   RemoteInputStream(nsIDOMBlob* aSourceBlob, ActorType aOrigin)
michael@0:   : mMonitor("RemoteInputStream.mMonitor"), mSourceBlob(aSourceBlob),
michael@0:     mWeakSeekableStream(nullptr), mOrigin(aOrigin)
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     MOZ_ASSERT(aSourceBlob);
michael@0:   }
michael@0: 
michael@0:   void
michael@0:   Serialize(InputStreamParams& aParams,
michael@0:             FileDescriptorArray& /* aFileDescriptors */)
michael@0:   {
michael@0:     nsCOMPtr<nsIRemoteBlob> remote = do_QueryInterface(mSourceBlob);
michael@0:     MOZ_ASSERT(remote);
michael@0: 
michael@0:     if (mOrigin == ParentActor) {
michael@0:       aParams = RemoteInputStreamParams(
michael@0:         static_cast<PBlobParent*>(remote->GetPBlob()), nullptr);
michael@0:     } else {
michael@0:       MOZ_ASSERT(mOrigin == ChildActor);
michael@0:       aParams = RemoteInputStreamParams(
michael@0:         nullptr, static_cast<PBlobChild*>(remote->GetPBlob()));
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   bool
michael@0:   Deserialize(const InputStreamParams& aParams,
michael@0:               const FileDescriptorArray& /* aFileDescriptors */)
michael@0:   {
michael@0:     // See InputStreamUtils.cpp to see how deserialization of a
michael@0:     // RemoteInputStream is special-cased.
michael@0:     MOZ_CRASH("RemoteInputStream should never be deserialized");
michael@0:   }
michael@0: 
michael@0:   void
michael@0:   SetStream(nsIInputStream* aStream)
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     MOZ_ASSERT(aStream);
michael@0: 
michael@0:     nsCOMPtr<nsIInputStream> stream = aStream;
michael@0:     nsCOMPtr<nsISeekableStream> seekableStream = do_QueryInterface(aStream);
michael@0: 
michael@0:     MOZ_ASSERT_IF(seekableStream, SameCOMIdentity(aStream, seekableStream));
michael@0: 
michael@0:     {
michael@0:       mozilla::MonitorAutoLock lock(mMonitor);
michael@0: 
michael@0:       MOZ_ASSERT(!mStream);
michael@0:       MOZ_ASSERT(!mWeakSeekableStream);
michael@0: 
michael@0:       mStream.swap(stream);
michael@0:       mWeakSeekableStream = seekableStream;
michael@0: 
michael@0:       mMonitor.Notify();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Close() MOZ_OVERRIDE
michael@0:   {
michael@0:     nsresult rv = BlockAndWaitForStream();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     nsCOMPtr<nsIDOMBlob> sourceBlob;
michael@0:     mSourceBlob.swap(sourceBlob);
michael@0: 
michael@0:     rv = mStream->Close();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Available(uint64_t* aAvailable) MOZ_OVERRIDE
michael@0:   {
michael@0:     // See large comment in FileInputStreamWrapper::Available.
michael@0:     if (NS_IsMainThread()) {
michael@0:       return NS_BASE_STREAM_CLOSED;
michael@0:     }
michael@0: 
michael@0:     nsresult rv = BlockAndWaitForStream();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     rv = mStream->Available(aAvailable);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Read(char* aBuffer, uint32_t aCount, uint32_t* aResult) MOZ_OVERRIDE
michael@0:   {
michael@0:     nsresult rv = BlockAndWaitForStream();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     rv = mStream->Read(aBuffer, aCount, aResult);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   ReadSegments(nsWriteSegmentFun aWriter, void* aClosure, uint32_t aCount,
michael@0:                uint32_t* aResult) MOZ_OVERRIDE
michael@0:   {
michael@0:     nsresult rv = BlockAndWaitForStream();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     rv = mStream->ReadSegments(aWriter, aClosure, aCount, aResult);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   IsNonBlocking(bool* aNonBlocking) MOZ_OVERRIDE
michael@0:   {
michael@0:     NS_ENSURE_ARG_POINTER(aNonBlocking);
michael@0: 
michael@0:     *aNonBlocking = false;
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Seek(int32_t aWhence, int64_t aOffset) MOZ_OVERRIDE
michael@0:   {
michael@0:     nsresult rv = BlockAndWaitForStream();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     if (!mWeakSeekableStream) {
michael@0:       NS_WARNING("Underlying blob stream is not seekable!");
michael@0:       return NS_ERROR_NO_INTERFACE;
michael@0:     }
michael@0: 
michael@0:     rv = mWeakSeekableStream->Seek(aWhence, aOffset);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Tell(int64_t* aResult)
michael@0:   {
michael@0:     // We can cheat here and assume that we're going to start at 0 if we don't
michael@0:     // yet have our stream. Though, really, this should abort since most input
michael@0:     // streams could block here.
michael@0:     if (NS_IsMainThread() && !mStream) {
michael@0:       *aResult = 0;
michael@0:       return NS_OK;
michael@0:     }
michael@0: 
michael@0:     nsresult rv = BlockAndWaitForStream();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     if (!mWeakSeekableStream) {
michael@0:       NS_WARNING("Underlying blob stream is not seekable!");
michael@0:       return NS_ERROR_NO_INTERFACE;
michael@0:     }
michael@0: 
michael@0:     rv = mWeakSeekableStream->Tell(aResult);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   SetEOF()
michael@0:   {
michael@0:     nsresult rv = BlockAndWaitForStream();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     if (!mWeakSeekableStream) {
michael@0:       NS_WARNING("Underlying blob stream is not seekable!");
michael@0:       return NS_ERROR_NO_INTERFACE;
michael@0:     }
michael@0: 
michael@0:     rv = mWeakSeekableStream->SetEOF();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   virtual nsIInputStream*
michael@0:   BlockAndGetInternalStream()
michael@0:   {
michael@0:     MOZ_ASSERT(!NS_IsMainThread());
michael@0: 
michael@0:     nsresult rv = BlockAndWaitForStream();
michael@0:     NS_ENSURE_SUCCESS(rv, nullptr);
michael@0: 
michael@0:     return mStream;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   virtual ~RemoteInputStream()
michael@0:   {
michael@0:     if (!NS_IsMainThread()) {
michael@0:       mStream = nullptr;
michael@0:       mWeakSeekableStream = nullptr;
michael@0:       ProxyReleaseToMainThread(mSourceBlob);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   void
michael@0:   ReallyBlockAndWaitForStream()
michael@0:   {
michael@0:     mozilla::DebugOnly<bool> waited;
michael@0: 
michael@0:     {
michael@0:       mozilla::MonitorAutoLock lock(mMonitor);
michael@0: 
michael@0:       waited = !mStream;
michael@0: 
michael@0:       while (!mStream) {
michael@0:         mMonitor.Wait();
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSERT(mStream);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:     if (waited && mWeakSeekableStream) {
michael@0:       int64_t position;
michael@0:       MOZ_ASSERT(NS_SUCCEEDED(mWeakSeekableStream->Tell(&position)),
michael@0:                  "Failed to determine initial stream position!");
michael@0:       MOZ_ASSERT(!position, "Stream not starting at 0!");
michael@0:     }
michael@0: #endif
michael@0:   }
michael@0: 
michael@0:   nsresult
michael@0:   BlockAndWaitForStream()
michael@0:   {
michael@0:     if (NS_IsMainThread()) {
michael@0:       NS_WARNING("Blocking the main thread is not supported!");
michael@0:       return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     ReallyBlockAndWaitForStream();
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   bool
michael@0:   IsSeekableStream()
michael@0:   {
michael@0:     if (NS_IsMainThread()) {
michael@0:       if (!mStream) {
michael@0:         NS_WARNING("Don't know if this stream is seekable yet!");
michael@0:         return true;
michael@0:       }
michael@0:     }
michael@0:     else {
michael@0:       ReallyBlockAndWaitForStream();
michael@0:     }
michael@0: 
michael@0:     return !!mWeakSeekableStream;
michael@0:   }
michael@0: };
michael@0: 
michael@0: NS_IMPL_ADDREF(RemoteInputStream)
michael@0: NS_IMPL_RELEASE(RemoteInputStream)
michael@0: 
michael@0: NS_INTERFACE_MAP_BEGIN(RemoteInputStream)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsIInputStream)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsIIPCSerializableInputStream)
michael@0:   NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsISeekableStream, IsSeekableStream())
michael@0:   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStream)
michael@0:   NS_INTERFACE_MAP_ENTRY(IPrivateRemoteInputStream)
michael@0: NS_INTERFACE_MAP_END
michael@0: 
michael@0: class InputStreamChild MOZ_FINAL
michael@0:   : public PBlobStreamChild
michael@0: {
michael@0:   nsRefPtr<RemoteInputStream> mRemoteStream;
michael@0: 
michael@0: public:
michael@0:   InputStreamChild(RemoteInputStream* aRemoteStream)
michael@0:   : mRemoteStream(aRemoteStream)
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     MOZ_ASSERT(aRemoteStream);
michael@0:   }
michael@0: 
michael@0:   InputStreamChild()
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   // This method is only called by the IPDL message machinery.
michael@0:   virtual bool
michael@0:   Recv__delete__(const InputStreamParams& aParams,
michael@0:                  const OptionalFileDescriptorSet& aFDs) MOZ_OVERRIDE;
michael@0: };
michael@0: 
michael@0: class InputStreamParent MOZ_FINAL
michael@0:   : public PBlobStreamParent
michael@0: {
michael@0:   nsRefPtr<RemoteInputStream> mRemoteStream;
michael@0: 
michael@0: public:
michael@0:   InputStreamParent(RemoteInputStream* aRemoteStream)
michael@0:   : mRemoteStream(aRemoteStream)
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     MOZ_ASSERT(aRemoteStream);
michael@0:   }
michael@0: 
michael@0:   InputStreamParent()
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   // This method is only called by the IPDL message machinery.
michael@0:   virtual bool
michael@0:   Recv__delete__(const InputStreamParams& aParams,
michael@0:                  const OptionalFileDescriptorSet& aFDs) MOZ_OVERRIDE;
michael@0: };
michael@0: 
michael@0: nsDOMFileBase*
michael@0: ToConcreteBlob(nsIDOMBlob* aBlob)
michael@0: {
michael@0:   // XXX This is only safe so long as all blob implementations in our tree
michael@0:   //     inherit nsDOMFileBase. If that ever changes then this will need to grow
michael@0:   //     a real interface or something.
michael@0:   return static_cast<nsDOMFileBase*>(aBlob);
michael@0: }
michael@0: 
michael@0: } // anonymous namespace
michael@0: 
michael@0: // Each instance of this class will be dispatched to the network stream thread
michael@0: // pool to run the first time where it will open the file input stream. It will
michael@0: // then dispatch itself back to the main thread to send the child process its
michael@0: // response (assuming that the child has not crashed). The runnable will then
michael@0: // dispatch itself to the thread pool again in order to close the file input
michael@0: // stream.
michael@0: class BlobParent::OpenStreamRunnable MOZ_FINAL
michael@0:   : public nsRunnable
michael@0: {
michael@0:   friend class nsRevocableEventPtr<OpenStreamRunnable>;
michael@0: 
michael@0:   // Only safe to access these pointers if mRevoked is false!
michael@0:   BlobParent* mBlobActor;
michael@0:   PBlobStreamParent* mStreamActor;
michael@0: 
michael@0:   nsCOMPtr<nsIInputStream> mStream;
michael@0:   nsCOMPtr<nsIIPCSerializableInputStream> mSerializable;
michael@0:   nsCOMPtr<nsIEventTarget> mTarget;
michael@0: 
michael@0:   bool mRevoked;
michael@0:   bool mClosing;
michael@0: 
michael@0: public:
michael@0:   OpenStreamRunnable(BlobParent* aBlobActor,
michael@0:                      PBlobStreamParent* aStreamActor,
michael@0:                      nsIInputStream* aStream,
michael@0:                      nsIIPCSerializableInputStream* aSerializable,
michael@0:                      nsIEventTarget* aTarget)
michael@0:   : mBlobActor(aBlobActor), mStreamActor(aStreamActor), mStream(aStream),
michael@0:     mSerializable(aSerializable), mTarget(aTarget), mRevoked(false),
michael@0:     mClosing(false)
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     MOZ_ASSERT(aBlobActor);
michael@0:     MOZ_ASSERT(aStreamActor);
michael@0:     MOZ_ASSERT(aStream);
michael@0:     // aSerializable may be null.
michael@0:     MOZ_ASSERT(aTarget);
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Run()
michael@0:   {
michael@0:     if (NS_IsMainThread()) {
michael@0:       return SendResponse();
michael@0:     }
michael@0: 
michael@0:     if (!mClosing) {
michael@0:       return OpenStream();
michael@0:     }
michael@0: 
michael@0:     return CloseStream();
michael@0:   }
michael@0: 
michael@0:   nsresult
michael@0:   Dispatch()
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     MOZ_ASSERT(mTarget);
michael@0: 
michael@0:     nsresult rv = mTarget->Dispatch(this, NS_DISPATCH_NORMAL);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   void
michael@0:   Revoke()
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0: #ifdef DEBUG
michael@0:     mBlobActor = nullptr;
michael@0:     mStreamActor = nullptr;
michael@0: #endif
michael@0:     mRevoked = true;
michael@0:   }
michael@0: 
michael@0:   nsresult
michael@0:   OpenStream()
michael@0:   {
michael@0:     MOZ_ASSERT(!NS_IsMainThread());
michael@0:     MOZ_ASSERT(mStream);
michael@0: 
michael@0:     if (!mSerializable) {
michael@0:       nsCOMPtr<IPrivateRemoteInputStream> remoteStream =
michael@0:         do_QueryInterface(mStream);
michael@0:       MOZ_ASSERT(remoteStream, "Must QI to IPrivateRemoteInputStream here!");
michael@0: 
michael@0:       nsCOMPtr<nsIInputStream> realStream =
michael@0:         remoteStream->BlockAndGetInternalStream();
michael@0:       NS_ENSURE_TRUE(realStream, NS_ERROR_FAILURE);
michael@0: 
michael@0:       mSerializable = do_QueryInterface(realStream);
michael@0:       if (!mSerializable) {
michael@0:         MOZ_ASSERT(false, "Must be serializable!");
michael@0:         return NS_ERROR_FAILURE;
michael@0:       }
michael@0: 
michael@0:       mStream.swap(realStream);
michael@0:     }
michael@0: 
michael@0:     // To force the stream open we call Available(). We don't actually care
michael@0:     // how much data is available.
michael@0:     uint64_t available;
michael@0:     if (NS_FAILED(mStream->Available(&available))) {
michael@0:       NS_WARNING("Available failed on this stream!");
michael@0:     }
michael@0: 
michael@0:     nsresult rv = NS_DispatchToMainThread(this, NS_DISPATCH_NORMAL);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsresult
michael@0:   CloseStream()
michael@0:   {
michael@0:     MOZ_ASSERT(!NS_IsMainThread());
michael@0:     MOZ_ASSERT(mStream);
michael@0: 
michael@0:     // Going to always release here.
michael@0:     nsCOMPtr<nsIInputStream> stream;
michael@0:     mStream.swap(stream);
michael@0: 
michael@0:     nsresult rv = stream->Close();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsresult
michael@0:   SendResponse()
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0: 
michael@0:     MOZ_ASSERT(mStream);
michael@0:     MOZ_ASSERT(mSerializable);
michael@0:     MOZ_ASSERT(mTarget);
michael@0:     MOZ_ASSERT(!mClosing);
michael@0: 
michael@0:     nsCOMPtr<nsIIPCSerializableInputStream> serializable;
michael@0:     mSerializable.swap(serializable);
michael@0: 
michael@0:     if (mRevoked) {
michael@0:       MOZ_ASSERT(!mBlobActor);
michael@0:       MOZ_ASSERT(!mStreamActor);
michael@0:     }
michael@0:     else {
michael@0:       MOZ_ASSERT(mBlobActor);
michael@0:       MOZ_ASSERT(mStreamActor);
michael@0: 
michael@0:       InputStreamParams params;
michael@0:       nsAutoTArray<FileDescriptor, 10> fds;
michael@0:       serializable->Serialize(params, fds);
michael@0: 
michael@0:       MOZ_ASSERT(params.type() != InputStreamParams::T__None);
michael@0: 
michael@0:       PFileDescriptorSetParent* fdSet = nullptr;
michael@0: 
michael@0:       if (!fds.IsEmpty()) {
michael@0:         auto* manager = static_cast<ContentParent*>(mBlobActor->Manager());
michael@0:         MOZ_ASSERT(manager);
michael@0: 
michael@0:         fdSet = manager->SendPFileDescriptorSetConstructor(fds[0]);
michael@0:         if (fdSet) {
michael@0:           for (uint32_t index = 1; index < fds.Length(); index++) {
michael@0:             unused << fdSet->SendAddFileDescriptor(fds[index]);
michael@0:           }
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       OptionalFileDescriptorSet optionalFDs;
michael@0:       if (fdSet) {
michael@0:         optionalFDs = fdSet;
michael@0:       } else {
michael@0:         optionalFDs = mozilla::void_t();
michael@0:       }
michael@0: 
michael@0:       unused <<
michael@0:         PBlobStreamParent::Send__delete__(mStreamActor, params, optionalFDs);
michael@0: 
michael@0:       mBlobActor->NoteRunnableCompleted(this);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:       mBlobActor = nullptr;
michael@0:       mStreamActor = nullptr;
michael@0: #endif
michael@0:     }
michael@0: 
michael@0:     mClosing = true;
michael@0: 
michael@0:     nsCOMPtr<nsIEventTarget> target;
michael@0:     mTarget.swap(target);
michael@0: 
michael@0:     nsresult rv = target->Dispatch(this, NS_DISPATCH_NORMAL);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: };
michael@0: 
michael@0: /*******************************************************************************
michael@0:  * BlobChild::RemoteBlob Declaration
michael@0:  ******************************************************************************/
michael@0: 
michael@0: class BlobChild::RemoteBlob MOZ_FINAL
michael@0:   : public nsDOMFile
michael@0:   , public nsIRemoteBlob
michael@0: {
michael@0:   class StreamHelper;
michael@0:   class SliceHelper;
michael@0: 
michael@0:   BlobChild* mActor;
michael@0: 
michael@0: public:
michael@0:   RemoteBlob(const nsAString& aName,
michael@0:              const nsAString& aContentType,
michael@0:              uint64_t aLength,
michael@0:              uint64_t aModDate)
michael@0:     : nsDOMFile(aName, aContentType, aLength, aModDate)
michael@0:     , mActor(nullptr)
michael@0:   {
michael@0:     mImmutable = true;
michael@0:   }
michael@0: 
michael@0:   RemoteBlob(const nsAString& aContentType, uint64_t aLength)
michael@0:     : nsDOMFile(aContentType, aLength)
michael@0:     , mActor(nullptr)
michael@0:   {
michael@0:     mImmutable = true;
michael@0:   }
michael@0: 
michael@0:   RemoteBlob()
michael@0:     : nsDOMFile(EmptyString(), EmptyString(), UINT64_MAX, UINT64_MAX)
michael@0:     , mActor(nullptr)
michael@0:   {
michael@0:     mImmutable = true;
michael@0:   }
michael@0: 
michael@0:   void
michael@0:   SetActor(BlobChild* aActor)
michael@0:   {
michael@0:     MOZ_ASSERT(!aActor || !mActor);
michael@0:     mActor = aActor;
michael@0:   }
michael@0: 
michael@0:   NS_DECL_ISUPPORTS_INHERITED
michael@0: 
michael@0:   virtual already_AddRefed<nsIDOMBlob>
michael@0:   CreateSlice(uint64_t aStart, uint64_t aLength, const nsAString& aContentType)
michael@0:               MOZ_OVERRIDE;
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   GetInternalStream(nsIInputStream** aStream) MOZ_OVERRIDE;
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   GetLastModifiedDate(JSContext* cx,
michael@0:                       JS::MutableHandle<JS::Value> aLastModifiedDate)
michael@0:                       MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void*
michael@0:   GetPBlob() MOZ_OVERRIDE;
michael@0: 
michael@0: private:
michael@0:   ~RemoteBlob()
michael@0:   {
michael@0:     if (mActor) {
michael@0:       mActor->NoteDyingRemoteBlob();
michael@0:     }
michael@0:   }
michael@0: };
michael@0: 
michael@0: class BlobChild::RemoteBlob::StreamHelper MOZ_FINAL
michael@0:   : public nsRunnable
michael@0: {
michael@0:   mozilla::Monitor mMonitor;
michael@0:   BlobChild* mActor;
michael@0:   nsCOMPtr<nsIDOMBlob> mSourceBlob;
michael@0:   nsRefPtr<RemoteInputStream> mInputStream;
michael@0:   bool mDone;
michael@0: 
michael@0: public:
michael@0:   StreamHelper(BlobChild* aActor, nsIDOMBlob* aSourceBlob)
michael@0:     : mMonitor("BlobChild::RemoteBlob::StreamHelper::mMonitor")
michael@0:     , mActor(aActor)
michael@0:     , mSourceBlob(aSourceBlob)
michael@0:     , mDone(false)
michael@0:   {
michael@0:     // This may be created on any thread.
michael@0:     MOZ_ASSERT(aActor);
michael@0:     MOZ_ASSERT(aSourceBlob);
michael@0:   }
michael@0: 
michael@0:   nsresult
michael@0:   GetStream(nsIInputStream** aInputStream)
michael@0:   {
michael@0:     // This may be called on any thread.
michael@0:     MOZ_ASSERT(aInputStream);
michael@0:     MOZ_ASSERT(mActor);
michael@0:     MOZ_ASSERT(!mInputStream);
michael@0:     MOZ_ASSERT(!mDone);
michael@0: 
michael@0:     if (NS_IsMainThread()) {
michael@0:       RunInternal(false);
michael@0:     }
michael@0:     else {
michael@0:       nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
michael@0:       NS_ENSURE_TRUE(mainThread, NS_ERROR_FAILURE);
michael@0: 
michael@0:       nsresult rv = mainThread->Dispatch(this, NS_DISPATCH_NORMAL);
michael@0:       NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:       {
michael@0:         MonitorAutoLock lock(mMonitor);
michael@0:         while (!mDone) {
michael@0:           lock.Wait();
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSERT(!mActor);
michael@0:     MOZ_ASSERT(mDone);
michael@0: 
michael@0:     if (!mInputStream) {
michael@0:       return NS_ERROR_UNEXPECTED;
michael@0:     }
michael@0: 
michael@0:     mInputStream.forget(aInputStream);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Run()
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     RunInternal(true);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   void
michael@0:   RunInternal(bool aNotify)
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     MOZ_ASSERT(mActor);
michael@0:     MOZ_ASSERT(!mInputStream);
michael@0:     MOZ_ASSERT(!mDone);
michael@0: 
michael@0:     nsRefPtr<RemoteInputStream> stream =
michael@0:       new RemoteInputStream(mSourceBlob, ChildActor);
michael@0: 
michael@0:     InputStreamChild* streamActor = new InputStreamChild(stream);
michael@0:     if (mActor->SendPBlobStreamConstructor(streamActor)) {
michael@0:       stream.swap(mInputStream);
michael@0:     }
michael@0: 
michael@0:     mActor = nullptr;
michael@0: 
michael@0:     if (aNotify) {
michael@0:       MonitorAutoLock lock(mMonitor);
michael@0:       mDone = true;
michael@0:       lock.Notify();
michael@0:     }
michael@0:     else {
michael@0:       mDone = true;
michael@0:     }
michael@0:   }
michael@0: };
michael@0: 
michael@0: class BlobChild::RemoteBlob::SliceHelper MOZ_FINAL
michael@0:   : public nsRunnable
michael@0: {
michael@0:   mozilla::Monitor mMonitor;
michael@0:   BlobChild* mActor;
michael@0:   nsCOMPtr<nsIDOMBlob> mSlice;
michael@0:   uint64_t mStart;
michael@0:   uint64_t mLength;
michael@0:   nsString mContentType;
michael@0:   bool mDone;
michael@0: 
michael@0: public:
michael@0:   SliceHelper(BlobChild* aActor)
michael@0:     : mMonitor("BlobChild::RemoteBlob::SliceHelper::mMonitor")
michael@0:     , mActor(aActor)
michael@0:     , mStart(0)
michael@0:     , mLength(0)
michael@0:     , mDone(false)
michael@0:   {
michael@0:     // This may be created on any thread.
michael@0:     MOZ_ASSERT(aActor);
michael@0:   }
michael@0: 
michael@0:   nsresult
michael@0:   GetSlice(uint64_t aStart,
michael@0:            uint64_t aLength,
michael@0:            const nsAString& aContentType,
michael@0:            nsIDOMBlob** aSlice)
michael@0:   {
michael@0:     // This may be called on any thread.
michael@0:     MOZ_ASSERT(aSlice);
michael@0:     MOZ_ASSERT(mActor);
michael@0:     MOZ_ASSERT(!mSlice);
michael@0:     MOZ_ASSERT(!mDone);
michael@0: 
michael@0:     mStart = aStart;
michael@0:     mLength = aLength;
michael@0:     mContentType = aContentType;
michael@0: 
michael@0:     if (NS_IsMainThread()) {
michael@0:       RunInternal(false);
michael@0:     }
michael@0:     else {
michael@0:       nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
michael@0:       NS_ENSURE_TRUE(mainThread, NS_ERROR_FAILURE);
michael@0: 
michael@0:       nsresult rv = mainThread->Dispatch(this, NS_DISPATCH_NORMAL);
michael@0:       NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:       {
michael@0:         MonitorAutoLock lock(mMonitor);
michael@0:         while (!mDone) {
michael@0:           lock.Wait();
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSERT(!mActor);
michael@0:     MOZ_ASSERT(mDone);
michael@0: 
michael@0:     if (!mSlice) {
michael@0:       return NS_ERROR_UNEXPECTED;
michael@0:     }
michael@0: 
michael@0:     mSlice.forget(aSlice);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Run()
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     RunInternal(true);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   void
michael@0:   RunInternal(bool aNotify)
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     MOZ_ASSERT(mActor);
michael@0:     MOZ_ASSERT(!mSlice);
michael@0:     MOZ_ASSERT(!mDone);
michael@0: 
michael@0:     NS_ENSURE_TRUE_VOID(mActor->Manager());
michael@0: 
michael@0:     NormalBlobConstructorParams normalParams;
michael@0:     normalParams.contentType() = mContentType;
michael@0:     normalParams.length() = mLength;
michael@0: 
michael@0:     auto* manager = static_cast<ContentChild*>(mActor->Manager());
michael@0:     MOZ_ASSERT(manager);
michael@0: 
michael@0:     BlobChild* newActor = BlobChild::Create(manager, normalParams);
michael@0:     MOZ_ASSERT(newActor);
michael@0: 
michael@0:     SlicedBlobConstructorParams slicedParams;
michael@0:     slicedParams.contentType() = mContentType;
michael@0:     slicedParams.begin() = mStart;
michael@0:     slicedParams.end() = mStart + mLength;
michael@0:     slicedParams.sourceChild() = mActor;
michael@0: 
michael@0:     ParentBlobConstructorParams otherSideParams;
michael@0:     otherSideParams.blobParams() = slicedParams;
michael@0:     otherSideParams.optionalInputStreamParams() = mozilla::void_t();
michael@0: 
michael@0:     if (mActor->Manager()->SendPBlobConstructor(newActor, otherSideParams)) {
michael@0:       mSlice = newActor->GetBlob();
michael@0:     }
michael@0: 
michael@0:     mActor = nullptr;
michael@0: 
michael@0:     if (aNotify) {
michael@0:       MonitorAutoLock lock(mMonitor);
michael@0:       mDone = true;
michael@0:       lock.Notify();
michael@0:     }
michael@0:     else {
michael@0:       mDone = true;
michael@0:     }
michael@0:   }
michael@0: };
michael@0: 
michael@0: /*******************************************************************************
michael@0:  * BlobChild::RemoteBlob Implementation
michael@0:  ******************************************************************************/
michael@0: 
michael@0: NS_IMPL_ISUPPORTS_INHERITED(BlobChild::RemoteBlob, nsDOMFile, nsIRemoteBlob)
michael@0: 
michael@0: already_AddRefed<nsIDOMBlob>
michael@0: BlobChild::
michael@0: RemoteBlob::CreateSlice(uint64_t aStart,
michael@0:                         uint64_t aLength,
michael@0:                         const nsAString& aContentType)
michael@0: {
michael@0:   if (!mActor) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<SliceHelper> helper = new SliceHelper(mActor);
michael@0: 
michael@0:   nsCOMPtr<nsIDOMBlob> slice;
michael@0:   nsresult rv =
michael@0:     helper->GetSlice(aStart, aLength, aContentType, getter_AddRefs(slice));
michael@0:   NS_ENSURE_SUCCESS(rv, nullptr);
michael@0: 
michael@0:   return slice.forget();
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: BlobChild::
michael@0: RemoteBlob::GetInternalStream(nsIInputStream** aStream)
michael@0: {
michael@0:   if (!mActor) {
michael@0:     return NS_ERROR_UNEXPECTED;
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<StreamHelper> helper = new StreamHelper(mActor, this);
michael@0:   return helper->GetStream(aStream);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: BlobChild::
michael@0: RemoteBlob::GetLastModifiedDate(JSContext* cx,
michael@0:                                 JS::MutableHandle<JS::Value> aLastModifiedDate)
michael@0: {
michael@0:   if (IsDateUnknown()) {
michael@0:     aLastModifiedDate.setNull();
michael@0:   } else {
michael@0:     JSObject* date = JS_NewDateObjectMsec(cx, mLastModificationDate);
michael@0:     if (!date) {
michael@0:       return NS_ERROR_OUT_OF_MEMORY;
michael@0:     }
michael@0:     aLastModifiedDate.setObject(*date);
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void*
michael@0: BlobChild::
michael@0: RemoteBlob::GetPBlob()
michael@0: {
michael@0:   return static_cast<PBlobChild*>(mActor);
michael@0: }
michael@0: 
michael@0: /*******************************************************************************
michael@0:  * BlobChild
michael@0:  ******************************************************************************/
michael@0: 
michael@0: BlobChild::BlobChild(ContentChild* aManager, nsIDOMBlob* aBlob)
michael@0:   : mBlob(aBlob)
michael@0:   , mRemoteBlob(nullptr)
michael@0:   , mStrongManager(aManager)
michael@0:   , mOwnsBlob(true)
michael@0:   , mBlobIsFile(false)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(aManager);
michael@0:   MOZ_ASSERT(aBlob);
michael@0: 
michael@0:   aBlob->AddRef();
michael@0: 
michael@0:   nsCOMPtr<nsIDOMFile> file = do_QueryInterface(aBlob);
michael@0:   mBlobIsFile = !!file;
michael@0: }
michael@0: 
michael@0: BlobChild::BlobChild(ContentChild* aManager,
michael@0:                      const ChildBlobConstructorParams& aParams)
michael@0:   : mBlob(nullptr)
michael@0:   , mRemoteBlob(nullptr)
michael@0:   , mStrongManager(aManager)
michael@0:   , mOwnsBlob(false)
michael@0:   , mBlobIsFile(false)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(aManager);
michael@0: 
michael@0:   ChildBlobConstructorParams::Type paramsType = aParams.type();
michael@0: 
michael@0:   mBlobIsFile =
michael@0:     paramsType == ChildBlobConstructorParams::TFileBlobConstructorParams ||
michael@0:     paramsType == ChildBlobConstructorParams::TMysteryBlobConstructorParams;
michael@0: 
michael@0:   nsRefPtr<RemoteBlob> remoteBlob = CreateRemoteBlob(aParams);
michael@0:   MOZ_ASSERT(remoteBlob);
michael@0: 
michael@0:   remoteBlob->SetActor(this);
michael@0:   remoteBlob.forget(&mRemoteBlob);
michael@0: 
michael@0:   mBlob = mRemoteBlob;
michael@0:   mOwnsBlob = true;
michael@0: }
michael@0: 
michael@0: BlobChild::~BlobChild()
michael@0: {
michael@0: }
michael@0: 
michael@0: BlobChild*
michael@0: BlobChild::Create(ContentChild* aManager,
michael@0:                   const ChildBlobConstructorParams& aParams)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(aManager);
michael@0: 
michael@0:   switch (aParams.type()) {
michael@0:     case ChildBlobConstructorParams::TNormalBlobConstructorParams:
michael@0:     case ChildBlobConstructorParams::TFileBlobConstructorParams:
michael@0:     case ChildBlobConstructorParams::TMysteryBlobConstructorParams:
michael@0:       return new BlobChild(aManager, aParams);
michael@0: 
michael@0:     case ChildBlobConstructorParams::TSlicedBlobConstructorParams: {
michael@0:       const SlicedBlobConstructorParams& params =
michael@0:         aParams.get_SlicedBlobConstructorParams();
michael@0: 
michael@0:       auto* actor =
michael@0:         const_cast<BlobChild*>(
michael@0:           static_cast<const BlobChild*>(params.sourceChild()));
michael@0:       MOZ_ASSERT(actor);
michael@0: 
michael@0:       nsCOMPtr<nsIDOMBlob> source = actor->GetBlob();
michael@0:       MOZ_ASSERT(source);
michael@0: 
michael@0:       nsCOMPtr<nsIDOMBlob> slice;
michael@0:       nsresult rv =
michael@0:         source->Slice(params.begin(), params.end(), params.contentType(), 3,
michael@0:                       getter_AddRefs(slice));
michael@0:       NS_ENSURE_SUCCESS(rv, nullptr);
michael@0: 
michael@0:       return new BlobChild(aManager, slice);
michael@0:     }
michael@0: 
michael@0:     default:
michael@0:       MOZ_CRASH("Unknown params!");
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: already_AddRefed<nsIDOMBlob>
michael@0: BlobChild::GetBlob()
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(mBlob);
michael@0: 
michael@0:   nsCOMPtr<nsIDOMBlob> blob;
michael@0: 
michael@0:   // Remote blobs are held alive until the first call to GetBlob. Thereafter we
michael@0:   // only hold a weak reference. Normal blobs are held alive until the actor is
michael@0:   // destroyed.
michael@0:   if (mRemoteBlob && mOwnsBlob) {
michael@0:     blob = dont_AddRef(mBlob);
michael@0:     mOwnsBlob = false;
michael@0:   }
michael@0:   else {
michael@0:     blob = mBlob;
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(blob);
michael@0: 
michael@0:   return blob.forget();
michael@0: }
michael@0: 
michael@0: bool
michael@0: BlobChild::SetMysteryBlobInfo(const nsString& aName,
michael@0:                               const nsString& aContentType,
michael@0:                               uint64_t aLength,
michael@0:                               uint64_t aLastModifiedDate)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(mBlob);
michael@0:   MOZ_ASSERT(mRemoteBlob);
michael@0:   MOZ_ASSERT(aLastModifiedDate != UINT64_MAX);
michael@0: 
michael@0:   ToConcreteBlob(mBlob)->SetLazyData(aName, aContentType, aLength,
michael@0:                                      aLastModifiedDate);
michael@0: 
michael@0:   FileBlobConstructorParams params(aName, aContentType, aLength,
michael@0:                                    aLastModifiedDate);
michael@0:   return SendResolveMystery(params);
michael@0: }
michael@0: 
michael@0: bool
michael@0: BlobChild::SetMysteryBlobInfo(const nsString& aContentType, uint64_t aLength)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(mBlob);
michael@0:   MOZ_ASSERT(mRemoteBlob);
michael@0: 
michael@0:   nsString voidString;
michael@0:   voidString.SetIsVoid(true);
michael@0: 
michael@0:   ToConcreteBlob(mBlob)->SetLazyData(voidString, aContentType, aLength,
michael@0:                                      UINT64_MAX);
michael@0: 
michael@0:   NormalBlobConstructorParams params(aContentType, aLength);
michael@0:   return SendResolveMystery(params);
michael@0: }
michael@0: 
michael@0: already_AddRefed<BlobChild::RemoteBlob>
michael@0: BlobChild::CreateRemoteBlob(const ChildBlobConstructorParams& aParams)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0: 
michael@0:   nsRefPtr<RemoteBlob> remoteBlob;
michael@0: 
michael@0:   switch (aParams.type()) {
michael@0:     case ChildBlobConstructorParams::TNormalBlobConstructorParams: {
michael@0:       const NormalBlobConstructorParams& params =
michael@0:         aParams.get_NormalBlobConstructorParams();
michael@0:       remoteBlob = new RemoteBlob(params.contentType(), params.length());
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     case ChildBlobConstructorParams::TFileBlobConstructorParams: {
michael@0:       const FileBlobConstructorParams& params =
michael@0:         aParams.get_FileBlobConstructorParams();
michael@0:       remoteBlob =
michael@0:         new RemoteBlob(params.name(), params.contentType(), params.length(),
michael@0:                        params.modDate());
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     case ChildBlobConstructorParams::TMysteryBlobConstructorParams: {
michael@0:       remoteBlob = new RemoteBlob();
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     default:
michael@0:       MOZ_CRASH("Unknown params!");
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(remoteBlob);
michael@0: 
michael@0:   if (NS_FAILED(remoteBlob->SetMutable(false))) {
michael@0:     MOZ_CRASH("Failed to make remote blob immutable!");
michael@0:   }
michael@0: 
michael@0:   return remoteBlob.forget();
michael@0: }
michael@0: 
michael@0: void
michael@0: BlobChild::NoteDyingRemoteBlob()
michael@0: {
michael@0:   MOZ_ASSERT(mBlob);
michael@0:   MOZ_ASSERT(mRemoteBlob);
michael@0:   MOZ_ASSERT(!mOwnsBlob);
michael@0: 
michael@0:   // This may be called on any thread due to the fact that RemoteBlob is
michael@0:   // designed to be passed between threads. We must start the shutdown process
michael@0:   // on the main thread, so we proxy here if necessary.
michael@0:   if (!NS_IsMainThread()) {
michael@0:     nsCOMPtr<nsIRunnable> runnable =
michael@0:       NS_NewNonOwningRunnableMethod(this, &BlobChild::NoteDyingRemoteBlob);
michael@0:     if (NS_FAILED(NS_DispatchToMainThread(runnable))) {
michael@0:       MOZ_ASSERT(false, "Should never fail!");
michael@0:     }
michael@0: 
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   // Must do this before calling Send__delete__ or we'll crash there trying to
michael@0:   // access a dangling pointer.
michael@0:   mBlob = nullptr;
michael@0:   mRemoteBlob = nullptr;
michael@0: 
michael@0:   PBlobChild::Send__delete__(this);
michael@0: }
michael@0: 
michael@0: void
michael@0: BlobChild::ActorDestroy(ActorDestroyReason aWhy)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0: 
michael@0:   if (mRemoteBlob) {
michael@0:     mRemoteBlob->SetActor(nullptr);
michael@0:   }
michael@0: 
michael@0:   if (mBlob && mOwnsBlob) {
michael@0:     mBlob->Release();
michael@0:   }
michael@0: 
michael@0:   mStrongManager = nullptr;
michael@0: }
michael@0: 
michael@0: PBlobStreamChild*
michael@0: BlobChild::AllocPBlobStreamChild()
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0: 
michael@0:   return new InputStreamChild();
michael@0: }
michael@0: 
michael@0: bool
michael@0: BlobChild::RecvPBlobStreamConstructor(PBlobStreamChild* aActor)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(aActor);
michael@0:   MOZ_ASSERT(mBlob);
michael@0:   MOZ_ASSERT(!mRemoteBlob);
michael@0: 
michael@0:   nsCOMPtr<nsIInputStream> stream;
michael@0:   nsresult rv = mBlob->GetInternalStream(getter_AddRefs(stream));
michael@0:   NS_ENSURE_SUCCESS(rv, false);
michael@0: 
michael@0:   nsCOMPtr<nsIIPCSerializableInputStream> serializable =
michael@0:     do_QueryInterface(stream);
michael@0:   if (!serializable) {
michael@0:     MOZ_ASSERT(false, "Must be serializable!");
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   InputStreamParams params;
michael@0:   nsTArray<FileDescriptor> fds;
michael@0:   serializable->Serialize(params, fds);
michael@0: 
michael@0:   MOZ_ASSERT(params.type() != InputStreamParams::T__None);
michael@0:   MOZ_ASSERT(fds.IsEmpty());
michael@0: 
michael@0:   return aActor->Send__delete__(aActor, params, mozilla::void_t());
michael@0: }
michael@0: 
michael@0: bool
michael@0: BlobChild::DeallocPBlobStreamChild(PBlobStreamChild* aActor)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0: 
michael@0:   delete static_cast<InputStreamChild*>(aActor);
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: bool
michael@0: BlobChild::RecvResolveMystery(const ResolveMysteryParams& aParams)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(mBlob);
michael@0:   MOZ_ASSERT(!mRemoteBlob);
michael@0:   MOZ_ASSERT(mOwnsBlob);
michael@0: 
michael@0:   if (!mBlobIsFile) {
michael@0:     MOZ_ASSERT(false, "Must always be a file!");
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   nsDOMFileBase* blob = ToConcreteBlob(mBlob);
michael@0: 
michael@0:   switch (aParams.type()) {
michael@0:     case ResolveMysteryParams::TNormalBlobConstructorParams: {
michael@0:       const NormalBlobConstructorParams& params =
michael@0:         aParams.get_NormalBlobConstructorParams();
michael@0:       nsString voidString;
michael@0:       voidString.SetIsVoid(true);
michael@0:       blob->SetLazyData(voidString, params.contentType(), params.length(),
michael@0:                         UINT64_MAX);
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     case ResolveMysteryParams::TFileBlobConstructorParams: {
michael@0:       const FileBlobConstructorParams& params =
michael@0:         aParams.get_FileBlobConstructorParams();
michael@0:       blob->SetLazyData(params.name(), params.contentType(), params.length(),
michael@0:                         params.modDate());
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     default:
michael@0:       MOZ_CRASH("Unknown params!");
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: /*******************************************************************************
michael@0:  * BlobParent::RemoteBlob Declaration
michael@0:  ******************************************************************************/
michael@0: 
michael@0: class BlobParent::RemoteBlob MOZ_FINAL
michael@0:   : public nsDOMFile
michael@0:   , public nsIRemoteBlob
michael@0: {
michael@0:   class StreamHelper;
michael@0:   class SliceHelper;
michael@0: 
michael@0:   BlobParent* mActor;
michael@0:   InputStreamParams mInputStreamParams;
michael@0: 
michael@0: public:
michael@0:   RemoteBlob(const nsAString& aName,
michael@0:              const nsAString& aContentType,
michael@0:              uint64_t aLength,
michael@0:              uint64_t aModDate)
michael@0:     : nsDOMFile(aName, aContentType, aLength, aModDate)
michael@0:     , mActor(nullptr)
michael@0:   {
michael@0:     mImmutable = true;
michael@0:   }
michael@0: 
michael@0:   RemoteBlob(const nsAString& aContentType, uint64_t aLength)
michael@0:     : nsDOMFile(aContentType, aLength)
michael@0:     , mActor(nullptr)
michael@0:   {
michael@0:     mImmutable = true;
michael@0:   }
michael@0: 
michael@0:   RemoteBlob()
michael@0:     : nsDOMFile(EmptyString(), EmptyString(), UINT64_MAX, UINT64_MAX)
michael@0:     , mActor(nullptr)
michael@0:   {
michael@0:     mImmutable = true;
michael@0:   }
michael@0: 
michael@0:   void
michael@0:   SetActor(BlobParent* aActor)
michael@0:   {
michael@0:     MOZ_ASSERT(!aActor || !mActor);
michael@0:     mActor = aActor;
michael@0:   }
michael@0: 
michael@0:   void
michael@0:   MaybeSetInputStream(const ParentBlobConstructorParams& aParams)
michael@0:   {
michael@0:     if (aParams.optionalInputStreamParams().type() ==
michael@0:         OptionalInputStreamParams::TInputStreamParams) {
michael@0:       mInputStreamParams =
michael@0:         aParams.optionalInputStreamParams().get_InputStreamParams();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   NS_DECL_ISUPPORTS_INHERITED
michael@0: 
michael@0:   virtual already_AddRefed<nsIDOMBlob>
michael@0:   CreateSlice(uint64_t aStart, uint64_t aLength, const nsAString& aContentType)
michael@0:               MOZ_OVERRIDE;
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   GetInternalStream(nsIInputStream** aStream) MOZ_OVERRIDE;
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   GetLastModifiedDate(JSContext* cx,
michael@0:                       JS::MutableHandle<JS::Value> aLastModifiedDate)
michael@0:                       MOZ_OVERRIDE;
michael@0: 
michael@0:   virtual void*
michael@0:   GetPBlob() MOZ_OVERRIDE;
michael@0: 
michael@0: private:
michael@0:   ~RemoteBlob()
michael@0:   {
michael@0:     if (mActor) {
michael@0:       mActor->NoteDyingRemoteBlob();
michael@0:     }
michael@0:   }
michael@0: };
michael@0: 
michael@0: class BlobParent::RemoteBlob::StreamHelper MOZ_FINAL
michael@0:   : public nsRunnable
michael@0: {
michael@0:   mozilla::Monitor mMonitor;
michael@0:   BlobParent* mActor;
michael@0:   nsCOMPtr<nsIDOMBlob> mSourceBlob;
michael@0:   nsRefPtr<RemoteInputStream> mInputStream;
michael@0:   bool mDone;
michael@0: 
michael@0: public:
michael@0:   StreamHelper(BlobParent* aActor, nsIDOMBlob* aSourceBlob)
michael@0:     : mMonitor("BlobParent::RemoteBlob::StreamHelper::mMonitor")
michael@0:     , mActor(aActor)
michael@0:     , mSourceBlob(aSourceBlob)
michael@0:     , mDone(false)
michael@0:   {
michael@0:     // This may be created on any thread.
michael@0:     MOZ_ASSERT(aActor);
michael@0:     MOZ_ASSERT(aSourceBlob);
michael@0:   }
michael@0: 
michael@0:   nsresult
michael@0:   GetStream(nsIInputStream** aInputStream)
michael@0:   {
michael@0:     // This may be called on any thread.
michael@0:     MOZ_ASSERT(aInputStream);
michael@0:     MOZ_ASSERT(mActor);
michael@0:     MOZ_ASSERT(!mInputStream);
michael@0:     MOZ_ASSERT(!mDone);
michael@0: 
michael@0:     if (NS_IsMainThread()) {
michael@0:       RunInternal(false);
michael@0:     }
michael@0:     else {
michael@0:       nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
michael@0:       NS_ENSURE_TRUE(mainThread, NS_ERROR_FAILURE);
michael@0: 
michael@0:       nsresult rv = mainThread->Dispatch(this, NS_DISPATCH_NORMAL);
michael@0:       NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:       {
michael@0:         MonitorAutoLock lock(mMonitor);
michael@0:         while (!mDone) {
michael@0:           lock.Wait();
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSERT(!mActor);
michael@0:     MOZ_ASSERT(mDone);
michael@0: 
michael@0:     if (!mInputStream) {
michael@0:       return NS_ERROR_UNEXPECTED;
michael@0:     }
michael@0: 
michael@0:     mInputStream.forget(aInputStream);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Run()
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     RunInternal(true);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   void
michael@0:   RunInternal(bool aNotify)
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     MOZ_ASSERT(mActor);
michael@0:     MOZ_ASSERT(!mInputStream);
michael@0:     MOZ_ASSERT(!mDone);
michael@0: 
michael@0:     nsRefPtr<RemoteInputStream> stream =
michael@0:       new RemoteInputStream(mSourceBlob, ParentActor);
michael@0: 
michael@0:     InputStreamParent* streamActor = new InputStreamParent(stream);
michael@0:     if (mActor->SendPBlobStreamConstructor(streamActor)) {
michael@0:       stream.swap(mInputStream);
michael@0:     }
michael@0: 
michael@0:     mActor = nullptr;
michael@0: 
michael@0:     if (aNotify) {
michael@0:       MonitorAutoLock lock(mMonitor);
michael@0:       mDone = true;
michael@0:       lock.Notify();
michael@0:     }
michael@0:     else {
michael@0:       mDone = true;
michael@0:     }
michael@0:   }
michael@0: };
michael@0: 
michael@0: class BlobParent::RemoteBlob::SliceHelper MOZ_FINAL
michael@0:   : public nsRunnable
michael@0: {
michael@0:   mozilla::Monitor mMonitor;
michael@0:   BlobParent* mActor;
michael@0:   nsCOMPtr<nsIDOMBlob> mSlice;
michael@0:   uint64_t mStart;
michael@0:   uint64_t mLength;
michael@0:   nsString mContentType;
michael@0:   bool mDone;
michael@0: 
michael@0: public:
michael@0:   SliceHelper(BlobParent* aActor)
michael@0:     : mMonitor("BlobParent::RemoteBlob::SliceHelper::mMonitor")
michael@0:     , mActor(aActor)
michael@0:     , mStart(0)
michael@0:     , mLength(0)
michael@0:     , mDone(false)
michael@0:   {
michael@0:     // This may be created on any thread.
michael@0:     MOZ_ASSERT(aActor);
michael@0:   }
michael@0: 
michael@0:   nsresult
michael@0:   GetSlice(uint64_t aStart,
michael@0:            uint64_t aLength,
michael@0:            const nsAString& aContentType,
michael@0:            nsIDOMBlob** aSlice)
michael@0:   {
michael@0:     // This may be called on any thread.
michael@0:     MOZ_ASSERT(aSlice);
michael@0:     MOZ_ASSERT(mActor);
michael@0:     MOZ_ASSERT(!mSlice);
michael@0:     MOZ_ASSERT(!mDone);
michael@0: 
michael@0:     mStart = aStart;
michael@0:     mLength = aLength;
michael@0:     mContentType = aContentType;
michael@0: 
michael@0:     if (NS_IsMainThread()) {
michael@0:       RunInternal(false);
michael@0:     }
michael@0:     else {
michael@0:       nsCOMPtr<nsIThread> mainThread = do_GetMainThread();
michael@0:       NS_ENSURE_TRUE(mainThread, NS_ERROR_FAILURE);
michael@0: 
michael@0:       nsresult rv = mainThread->Dispatch(this, NS_DISPATCH_NORMAL);
michael@0:       NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:       {
michael@0:         MonitorAutoLock lock(mMonitor);
michael@0:         while (!mDone) {
michael@0:           lock.Wait();
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     MOZ_ASSERT(!mActor);
michael@0:     MOZ_ASSERT(mDone);
michael@0: 
michael@0:     if (!mSlice) {
michael@0:       return NS_ERROR_UNEXPECTED;
michael@0:     }
michael@0: 
michael@0:     mSlice.forget(aSlice);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD
michael@0:   Run()
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     RunInternal(true);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   void
michael@0:   RunInternal(bool aNotify)
michael@0:   {
michael@0:     MOZ_ASSERT(NS_IsMainThread());
michael@0:     MOZ_ASSERT(mActor);
michael@0:     MOZ_ASSERT(!mSlice);
michael@0:     MOZ_ASSERT(!mDone);
michael@0: 
michael@0:     NS_ENSURE_TRUE_VOID(mActor->Manager());
michael@0: 
michael@0:     NormalBlobConstructorParams normalParams;
michael@0:     normalParams.contentType() = mContentType;
michael@0:     normalParams.length() = mLength;
michael@0: 
michael@0:     ParentBlobConstructorParams params;
michael@0:     params.blobParams() = normalParams;
michael@0:     params.optionalInputStreamParams() = void_t();
michael@0: 
michael@0:     auto* manager = static_cast<ContentParent*>(mActor->Manager());
michael@0:     MOZ_ASSERT(manager);
michael@0: 
michael@0:     BlobParent* newActor = BlobParent::Create(manager, params);
michael@0:     MOZ_ASSERT(newActor);
michael@0: 
michael@0:     SlicedBlobConstructorParams slicedParams;
michael@0:     slicedParams.contentType() = mContentType;
michael@0:     slicedParams.begin() = mStart;
michael@0:     slicedParams.end() = mStart + mLength;
michael@0:     slicedParams.sourceParent() = mActor;
michael@0: 
michael@0:     ChildBlobConstructorParams otherSideParams = slicedParams;
michael@0: 
michael@0:     if (mActor->Manager()->SendPBlobConstructor(newActor, otherSideParams)) {
michael@0:       mSlice = newActor->GetBlob();
michael@0:     }
michael@0: 
michael@0:     mActor = nullptr;
michael@0: 
michael@0:     if (aNotify) {
michael@0:       MonitorAutoLock lock(mMonitor);
michael@0:       mDone = true;
michael@0:       lock.Notify();
michael@0:     }
michael@0:     else {
michael@0:       mDone = true;
michael@0:     }
michael@0:   }
michael@0: };
michael@0: 
michael@0: /*******************************************************************************
michael@0:  * BlobChild::RemoteBlob Implementation
michael@0:  ******************************************************************************/
michael@0: 
michael@0: NS_IMPL_ISUPPORTS_INHERITED(BlobParent::RemoteBlob, nsDOMFile, nsIRemoteBlob)
michael@0: 
michael@0: already_AddRefed<nsIDOMBlob>
michael@0: BlobParent::
michael@0: RemoteBlob::CreateSlice(uint64_t aStart,
michael@0:                         uint64_t aLength,
michael@0:                         const nsAString& aContentType)
michael@0: {
michael@0:   if (!mActor) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<SliceHelper> helper = new SliceHelper(mActor);
michael@0: 
michael@0:   nsCOMPtr<nsIDOMBlob> slice;
michael@0:   nsresult rv =
michael@0:     helper->GetSlice(aStart, aLength, aContentType, getter_AddRefs(slice));
michael@0:   NS_ENSURE_SUCCESS(rv, nullptr);
michael@0: 
michael@0:   return slice.forget();
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: BlobParent::
michael@0: RemoteBlob::GetInternalStream(nsIInputStream** aStream)
michael@0: {
michael@0:   if (mInputStreamParams.type() != InputStreamParams::T__None) {
michael@0:     nsTArray<FileDescriptor> fds;
michael@0:     nsCOMPtr<nsIInputStream> realStream =
michael@0:       DeserializeInputStream(mInputStreamParams, fds);
michael@0:     if (!realStream) {
michael@0:       NS_WARNING("Failed to deserialize stream!");
michael@0:       return NS_ERROR_UNEXPECTED;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIInputStream> stream =
michael@0:       new BlobInputStreamTether(realStream, this);
michael@0:     stream.forget(aStream);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (!mActor) {
michael@0:     return NS_ERROR_UNEXPECTED;
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<StreamHelper> helper = new StreamHelper(mActor, this);
michael@0:   return helper->GetStream(aStream);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: BlobParent::
michael@0: RemoteBlob::GetLastModifiedDate(JSContext* cx,
michael@0:                                 JS::MutableHandle<JS::Value> aLastModifiedDate)
michael@0: {
michael@0:   if (IsDateUnknown()) {
michael@0:     aLastModifiedDate.setNull();
michael@0:   } else {
michael@0:     JSObject* date = JS_NewDateObjectMsec(cx, mLastModificationDate);
michael@0:     if (!date) {
michael@0:       return NS_ERROR_OUT_OF_MEMORY;
michael@0:     }
michael@0:     aLastModifiedDate.setObject(*date);
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void*
michael@0: BlobParent::
michael@0: RemoteBlob::GetPBlob()
michael@0: {
michael@0:   return static_cast<PBlobParent*>(mActor);
michael@0: }
michael@0: 
michael@0: /*******************************************************************************
michael@0:  * BlobParent
michael@0:  ******************************************************************************/
michael@0: 
michael@0: BlobParent::BlobParent(ContentParent* aManager, nsIDOMBlob* aBlob)
michael@0:   : mBlob(aBlob)
michael@0:   , mRemoteBlob(nullptr)
michael@0:   , mStrongManager(aManager)
michael@0:   , mOwnsBlob(true)
michael@0:   , mBlobIsFile(false)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(aManager);
michael@0:   MOZ_ASSERT(aBlob);
michael@0: 
michael@0:   aBlob->AddRef();
michael@0: 
michael@0:   nsCOMPtr<nsIDOMFile> file = do_QueryInterface(aBlob);
michael@0:   mBlobIsFile = !!file;
michael@0: }
michael@0: 
michael@0: BlobParent::BlobParent(ContentParent* aManager,
michael@0:                        const ParentBlobConstructorParams& aParams)
michael@0:   : mBlob(nullptr)
michael@0:   , mRemoteBlob(nullptr)
michael@0:   , mStrongManager(aManager)
michael@0:   , mOwnsBlob(false)
michael@0:   , mBlobIsFile(false)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(aManager);
michael@0: 
michael@0:   ChildBlobConstructorParams::Type paramsType = aParams.blobParams().type();
michael@0: 
michael@0:   mBlobIsFile =
michael@0:     paramsType == ChildBlobConstructorParams::TFileBlobConstructorParams ||
michael@0:     paramsType == ChildBlobConstructorParams::TMysteryBlobConstructorParams;
michael@0: 
michael@0:   nsRefPtr<RemoteBlob> remoteBlob = CreateRemoteBlob(aParams);
michael@0:   MOZ_ASSERT(remoteBlob);
michael@0: 
michael@0:   remoteBlob->SetActor(this);
michael@0:   remoteBlob->MaybeSetInputStream(aParams);
michael@0:   remoteBlob.forget(&mRemoteBlob);
michael@0: 
michael@0:   mBlob = mRemoteBlob;
michael@0:   mOwnsBlob = true;
michael@0: }
michael@0: 
michael@0: BlobParent::~BlobParent()
michael@0: {
michael@0: }
michael@0: 
michael@0: BlobParent*
michael@0: BlobParent::Create(ContentParent* aManager,
michael@0:                    const ParentBlobConstructorParams& aParams)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(aManager);
michael@0: 
michael@0:   const ChildBlobConstructorParams& blobParams = aParams.blobParams();
michael@0: 
michael@0:   switch (blobParams.type()) {
michael@0:     case ChildBlobConstructorParams::TNormalBlobConstructorParams:
michael@0:     case ChildBlobConstructorParams::TFileBlobConstructorParams:
michael@0:     case ChildBlobConstructorParams::TMysteryBlobConstructorParams:
michael@0:       return new BlobParent(aManager, aParams);
michael@0: 
michael@0:     case ChildBlobConstructorParams::TSlicedBlobConstructorParams: {
michael@0:       const SlicedBlobConstructorParams& params =
michael@0:         blobParams.get_SlicedBlobConstructorParams();
michael@0: 
michael@0:       auto* actor =
michael@0:         const_cast<BlobParent*>(
michael@0:           static_cast<const BlobParent*>(params.sourceParent()));
michael@0:       MOZ_ASSERT(actor);
michael@0: 
michael@0:       nsCOMPtr<nsIDOMBlob> source = actor->GetBlob();
michael@0:       MOZ_ASSERT(source);
michael@0: 
michael@0:       nsCOMPtr<nsIDOMBlob> slice;
michael@0:       nsresult rv =
michael@0:         source->Slice(params.begin(), params.end(), params.contentType(), 3,
michael@0:                       getter_AddRefs(slice));
michael@0:       NS_ENSURE_SUCCESS(rv, nullptr);
michael@0: 
michael@0:       return new BlobParent(aManager, slice);
michael@0:     }
michael@0: 
michael@0:     default:
michael@0:       MOZ_CRASH("Unknown params!");
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: already_AddRefed<nsIDOMBlob>
michael@0: BlobParent::GetBlob()
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(mBlob);
michael@0: 
michael@0:   nsCOMPtr<nsIDOMBlob> blob;
michael@0: 
michael@0:   // Remote blobs are held alive until the first call to GetBlob. Thereafter we
michael@0:   // only hold a weak reference. Normal blobs are held alive until the actor is
michael@0:   // destroyed.
michael@0:   if (mRemoteBlob && mOwnsBlob) {
michael@0:     blob = dont_AddRef(mBlob);
michael@0:     mOwnsBlob = false;
michael@0:   }
michael@0:   else {
michael@0:     blob = mBlob;
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(blob);
michael@0: 
michael@0:   return blob.forget();
michael@0: }
michael@0: 
michael@0: bool
michael@0: BlobParent::SetMysteryBlobInfo(const nsString& aName,
michael@0:                                const nsString& aContentType,
michael@0:                                uint64_t aLength,
michael@0:                                uint64_t aLastModifiedDate)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(mBlob);
michael@0:   MOZ_ASSERT(mRemoteBlob);
michael@0:   MOZ_ASSERT(aLastModifiedDate != UINT64_MAX);
michael@0: 
michael@0:   ToConcreteBlob(mBlob)->SetLazyData(aName, aContentType, aLength,
michael@0:                                      aLastModifiedDate);
michael@0: 
michael@0:   FileBlobConstructorParams params(aName, aContentType, aLength,
michael@0:                                    aLastModifiedDate);
michael@0:   return SendResolveMystery(params);
michael@0: }
michael@0: 
michael@0: bool
michael@0: BlobParent::SetMysteryBlobInfo(const nsString& aContentType, uint64_t aLength)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(mBlob);
michael@0:   MOZ_ASSERT(mRemoteBlob);
michael@0: 
michael@0:   nsString voidString;
michael@0:   voidString.SetIsVoid(true);
michael@0: 
michael@0:   ToConcreteBlob(mBlob)->SetLazyData(voidString, aContentType, aLength,
michael@0:                                      UINT64_MAX);
michael@0: 
michael@0:   NormalBlobConstructorParams params(aContentType, aLength);
michael@0:   return SendResolveMystery(params);
michael@0: }
michael@0: 
michael@0: already_AddRefed<BlobParent::RemoteBlob>
michael@0: BlobParent::CreateRemoteBlob(const ParentBlobConstructorParams& aParams)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0: 
michael@0:   const ChildBlobConstructorParams& blobParams = aParams.blobParams();
michael@0: 
michael@0:   nsRefPtr<RemoteBlob> remoteBlob;
michael@0: 
michael@0:   switch (blobParams.type()) {
michael@0:     case ChildBlobConstructorParams::TNormalBlobConstructorParams: {
michael@0:       const NormalBlobConstructorParams& params =
michael@0:         blobParams.get_NormalBlobConstructorParams();
michael@0:       remoteBlob = new RemoteBlob(params.contentType(), params.length());
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     case ChildBlobConstructorParams::TFileBlobConstructorParams: {
michael@0:       const FileBlobConstructorParams& params =
michael@0:         blobParams.get_FileBlobConstructorParams();
michael@0:       remoteBlob =
michael@0:         new RemoteBlob(params.name(), params.contentType(), params.length(),
michael@0:                        params.modDate());
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     case ChildBlobConstructorParams::TMysteryBlobConstructorParams: {
michael@0:       remoteBlob = new RemoteBlob();
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     default:
michael@0:       MOZ_CRASH("Unknown params!");
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(remoteBlob);
michael@0: 
michael@0:   if (NS_FAILED(remoteBlob->SetMutable(false))) {
michael@0:     MOZ_CRASH("Failed to make remote blob immutable!");
michael@0:   }
michael@0: 
michael@0:   return remoteBlob.forget();
michael@0: }
michael@0: 
michael@0: void
michael@0: BlobParent::NoteDyingRemoteBlob()
michael@0: {
michael@0:   MOZ_ASSERT(mBlob);
michael@0:   MOZ_ASSERT(mRemoteBlob);
michael@0:   MOZ_ASSERT(!mOwnsBlob);
michael@0: 
michael@0:   // This may be called on any thread due to the fact that RemoteBlob is
michael@0:   // designed to be passed between threads. We must start the shutdown process
michael@0:   // on the main thread, so we proxy here if necessary.
michael@0:   if (!NS_IsMainThread()) {
michael@0:     nsCOMPtr<nsIRunnable> runnable =
michael@0:       NS_NewNonOwningRunnableMethod(this, &BlobParent::NoteDyingRemoteBlob);
michael@0:     if (NS_FAILED(NS_DispatchToMainThread(runnable))) {
michael@0:       MOZ_ASSERT(false, "Should never fail!");
michael@0:     }
michael@0: 
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   // Must do this before calling Send__delete__ or we'll crash there trying to
michael@0:   // access a dangling pointer.
michael@0:   mBlob = nullptr;
michael@0:   mRemoteBlob = nullptr;
michael@0: 
michael@0:   mozilla::unused << PBlobParent::Send__delete__(this);
michael@0: }
michael@0: 
michael@0: void
michael@0: BlobParent::NoteRunnableCompleted(OpenStreamRunnable* aRunnable)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0: 
michael@0:   for (uint32_t index = 0; index < mOpenStreamRunnables.Length(); index++) {
michael@0:     nsRevocableEventPtr<OpenStreamRunnable>& runnable =
michael@0:       mOpenStreamRunnables[index];
michael@0: 
michael@0:     if (runnable.get() == aRunnable) {
michael@0:       runnable.Forget();
michael@0:       mOpenStreamRunnables.RemoveElementAt(index);
michael@0:       return;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   MOZ_CRASH("Runnable not in our array!");
michael@0: }
michael@0: 
michael@0: void
michael@0: BlobParent::ActorDestroy(ActorDestroyReason aWhy)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0: 
michael@0:   if (mRemoteBlob) {
michael@0:     mRemoteBlob->SetActor(nullptr);
michael@0:   }
michael@0: 
michael@0:   if (mBlob && mOwnsBlob) {
michael@0:     mBlob->Release();
michael@0:   }
michael@0: 
michael@0:   mStrongManager = nullptr;
michael@0: }
michael@0: 
michael@0: PBlobStreamParent*
michael@0: BlobParent::AllocPBlobStreamParent()
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0: 
michael@0:   return new InputStreamParent();
michael@0: }
michael@0: 
michael@0: bool
michael@0: BlobParent::RecvPBlobStreamConstructor(PBlobStreamParent* aActor)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(aActor);
michael@0:   MOZ_ASSERT(mBlob);
michael@0:   MOZ_ASSERT(!mRemoteBlob);
michael@0: 
michael@0:   nsCOMPtr<nsIInputStream> stream;
michael@0:   nsresult rv = mBlob->GetInternalStream(getter_AddRefs(stream));
michael@0:   NS_ENSURE_SUCCESS(rv, false);
michael@0: 
michael@0:   nsCOMPtr<nsIRemoteBlob> remoteBlob = do_QueryInterface(mBlob);
michael@0: 
michael@0:   nsCOMPtr<IPrivateRemoteInputStream> remoteStream;
michael@0:   if (remoteBlob) {
michael@0:     remoteStream = do_QueryInterface(stream);
michael@0:   }
michael@0: 
michael@0:   // There are three cases in which we can use the stream obtained from the blob
michael@0:   // directly as our serialized stream:
michael@0:   //
michael@0:   //   1. The blob is not a remote blob.
michael@0:   //   2. The blob is a remote blob that represents this actor.
michael@0:   //   3. The blob is a remote blob representing a different actor but we
michael@0:   //      already have a non-remote, i.e. serialized, serialized stream.
michael@0:   //
michael@0:   // In all other cases we need to be on a background thread before we can get
michael@0:   // to the real stream.
michael@0:   nsCOMPtr<nsIIPCSerializableInputStream> serializableStream;
michael@0:   if (!remoteBlob ||
michael@0:       static_cast<PBlobParent*>(remoteBlob->GetPBlob()) == this ||
michael@0:       !remoteStream) {
michael@0:     serializableStream = do_QueryInterface(stream);
michael@0:     if (!serializableStream) {
michael@0:       MOZ_ASSERT(false, "Must be serializable!");
michael@0:       return false;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIEventTarget> target =
michael@0:     do_GetService(NS_STREAMTRANSPORTSERVICE_CONTRACTID);
michael@0:   NS_ENSURE_TRUE(target, false);
michael@0: 
michael@0:   nsRefPtr<OpenStreamRunnable> runnable =
michael@0:     new OpenStreamRunnable(this, aActor, stream, serializableStream, target);
michael@0: 
michael@0:   rv = runnable->Dispatch();
michael@0:   NS_ENSURE_SUCCESS(rv, false);
michael@0: 
michael@0:   // nsRevocableEventPtr lacks some of the operators needed for anything nicer.
michael@0:   *mOpenStreamRunnables.AppendElement() = runnable;
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: bool
michael@0: BlobParent::DeallocPBlobStreamParent(PBlobStreamParent* aActor)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0: 
michael@0:   delete static_cast<InputStreamParent*>(aActor);
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: bool
michael@0: BlobParent::RecvResolveMystery(const ResolveMysteryParams& aParams)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(mBlob);
michael@0:   MOZ_ASSERT(!mRemoteBlob);
michael@0:   MOZ_ASSERT(mOwnsBlob);
michael@0: 
michael@0:   if (!mBlobIsFile) {
michael@0:     MOZ_ASSERT(false, "Must always be a file!");
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   nsDOMFileBase* blob = ToConcreteBlob(mBlob);
michael@0: 
michael@0:   switch (aParams.type()) {
michael@0:     case ResolveMysteryParams::TNormalBlobConstructorParams: {
michael@0:       const NormalBlobConstructorParams& params =
michael@0:         aParams.get_NormalBlobConstructorParams();
michael@0:       nsString voidString;
michael@0:       voidString.SetIsVoid(true);
michael@0:       blob->SetLazyData(voidString, params.contentType(),
michael@0:                         params.length(), UINT64_MAX);
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     case ResolveMysteryParams::TFileBlobConstructorParams: {
michael@0:       const FileBlobConstructorParams& params =
michael@0:         aParams.get_FileBlobConstructorParams();
michael@0:       blob->SetLazyData(params.name(), params.contentType(),
michael@0:                         params.length(), params.modDate());
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     default:
michael@0:       MOZ_CRASH("Unknown params!");
michael@0:   }
michael@0: 
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: bool
michael@0: InputStreamChild::Recv__delete__(const InputStreamParams& aParams,
michael@0:                                  const OptionalFileDescriptorSet& aFDs)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(mRemoteStream);
michael@0: 
michael@0:   nsTArray<FileDescriptor> fds;
michael@0:   if (aFDs.type() == OptionalFileDescriptorSet::TPFileDescriptorSetChild) {
michael@0:     FileDescriptorSetChild* fdSetActor =
michael@0:       static_cast<FileDescriptorSetChild*>(aFDs.get_PFileDescriptorSetChild());
michael@0:     MOZ_ASSERT(fdSetActor);
michael@0: 
michael@0:     fdSetActor->ForgetFileDescriptors(fds);
michael@0:     MOZ_ASSERT(!fds.IsEmpty());
michael@0: 
michael@0:     fdSetActor->Send__delete__(fdSetActor);
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIInputStream> stream = DeserializeInputStream(aParams, fds);
michael@0:   if (!stream) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   mRemoteStream->SetStream(stream);
michael@0:   return true;
michael@0: }
michael@0: 
michael@0: bool
michael@0: InputStreamParent::Recv__delete__(const InputStreamParams& aParams,
michael@0:                                   const OptionalFileDescriptorSet& aFDs)
michael@0: {
michael@0:   MOZ_ASSERT(NS_IsMainThread());
michael@0:   MOZ_ASSERT(mRemoteStream);
michael@0: 
michael@0:   if (aFDs.type() != OptionalFileDescriptorSet::Tvoid_t) {
michael@0:     NS_WARNING("Child cannot send FileDescriptors to the parent!");
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   nsTArray<FileDescriptor> fds;
michael@0:   nsCOMPtr<nsIInputStream> stream = DeserializeInputStream(aParams, fds);
michael@0:   if (!stream) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   MOZ_ASSERT(fds.IsEmpty());
michael@0: 
michael@0:   mRemoteStream->SetStream(stream);
michael@0:   return true;
michael@0: }