summaryrefslogtreecommitdiffstats
path: root/dom/ipc/BlobParent.h
diff options
context:
space:
mode:
Diffstat (limited to 'dom/ipc/BlobParent.h')
-rw-r--r--dom/ipc/BlobParent.h260
1 files changed, 260 insertions, 0 deletions
diff --git a/dom/ipc/BlobParent.h b/dom/ipc/BlobParent.h
new file mode 100644
index 000000000..98cfe6d28
--- /dev/null
+++ b/dom/ipc/BlobParent.h
@@ -0,0 +1,260 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_ipc_BlobParent_h
+#define mozilla_dom_ipc_BlobParent_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/dom/PBlobParent.h"
+#include "nsCOMPtr.h"
+#include "nsTArray.h"
+
+template <class, class> class nsDataHashtable;
+class nsIDHashKey;
+class nsIEventTarget;
+class nsIRemoteBlob;
+template <class> class nsRevocableEventPtr;
+class nsString;
+
+namespace mozilla {
+
+class Mutex;
+
+namespace ipc {
+
+class PBackgroundParent;
+
+} // namespace ipc
+
+namespace dom {
+
+class ContentParent;
+class BlobImpl;
+class nsIContentParent;
+class PBlobStreamParent;
+
+class BlobParent final
+ : public PBlobParent
+{
+ typedef mozilla::ipc::PBackgroundParent PBackgroundParent;
+
+ class IDTableEntry;
+ typedef nsDataHashtable<nsIDHashKey, IDTableEntry*> IDTable;
+
+ class OpenStreamRunnable;
+ friend class OpenStreamRunnable;
+
+ class RemoteBlobImpl;
+
+ struct CreateBlobImplMetadata;
+
+ static StaticAutoPtr<IDTable> sIDTable;
+ static StaticAutoPtr<Mutex> sIDTableMutex;
+
+ BlobImpl* mBlobImpl;
+ RemoteBlobImpl* mRemoteBlobImpl;
+
+ // One of these will be null and the other non-null.
+ PBackgroundParent* mBackgroundManager;
+ nsCOMPtr<nsIContentParent> mContentManager;
+
+ nsCOMPtr<nsIEventTarget> mEventTarget;
+
+ // nsIInputStreams backed by files must ensure that the files are actually
+ // opened and closed on a background thread before we can send their file
+ // handles across to the child. The child process could crash during this
+ // process so we need to make sure we cancel the intended response in such a
+ // case. We do that by holding an array of nsRevocableEventPtr. If the child
+ // crashes then this actor will be destroyed and the nsRevocableEventPtr
+ // destructor will cancel any stream events that are currently in flight.
+ nsTArray<nsRevocableEventPtr<OpenStreamRunnable>> mOpenStreamRunnables;
+
+ RefPtr<IDTableEntry> mIDTableEntry;
+
+ bool mOwnsBlobImpl;
+
+public:
+ class FriendKey;
+
+ static void
+ Startup(const FriendKey& aKey);
+
+ // These create functions are called on the sending side.
+ static BlobParent*
+ GetOrCreate(nsIContentParent* aManager, BlobImpl* aBlobImpl);
+
+ static BlobParent*
+ GetOrCreate(PBackgroundParent* aManager, BlobImpl* aBlobImpl);
+
+ // These create functions are called on the receiving side.
+ static BlobParent*
+ Create(nsIContentParent* aManager,
+ const ParentBlobConstructorParams& aParams);
+
+ static BlobParent*
+ Create(PBackgroundParent* aManager,
+ const ParentBlobConstructorParams& aParams);
+
+ static void
+ Destroy(PBlobParent* aActor)
+ {
+ delete static_cast<BlobParent*>(aActor);
+ }
+
+ static already_AddRefed<BlobImpl>
+ GetBlobImplForID(const nsID& aID);
+
+ bool
+ HasManager() const
+ {
+ return mBackgroundManager || mContentManager;
+ }
+
+ PBackgroundParent*
+ GetBackgroundManager() const
+ {
+ return mBackgroundManager;
+ }
+
+ nsIContentParent*
+ GetContentManager() const
+ {
+ return mContentManager;
+ }
+
+ // Get the BlobImpl associated with this actor.
+ already_AddRefed<BlobImpl>
+ GetBlobImpl();
+
+ void
+ AssertIsOnOwningThread() const
+#ifdef DEBUG
+ ;
+#else
+ { }
+#endif
+
+private:
+ // These constructors are called on the sending side.
+ BlobParent(nsIContentParent* aManager, IDTableEntry* aIDTableEntry);
+
+ BlobParent(PBackgroundParent* aManager, IDTableEntry* aIDTableEntry);
+
+ // These constructors are called on the receiving side.
+ BlobParent(nsIContentParent* aManager,
+ BlobImpl* aBlobImpl,
+ IDTableEntry* aIDTableEntry);
+
+ BlobParent(PBackgroundParent* aManager,
+ BlobImpl* aBlobImpl,
+ IDTableEntry* aIDTableEntry);
+
+ // Only destroyed by BackgroundParentImpl and ContentParent.
+ ~BlobParent();
+
+ void
+ CommonInit(IDTableEntry* aIDTableEntry);
+
+ void
+ CommonInit(BlobImpl* aBlobImpl, IDTableEntry* aIDTableEntry);
+
+ template <class ParentManagerType>
+ static BlobParent*
+ GetOrCreateFromImpl(ParentManagerType* aManager,
+ BlobImpl* aBlobImpl);
+
+ template <class ParentManagerType>
+ static BlobParent*
+ CreateFromParams(ParentManagerType* aManager,
+ const ParentBlobConstructorParams& aParams);
+
+ template <class ParentManagerType>
+ static BlobParent*
+ SendSliceConstructor(ParentManagerType* aManager,
+ const ParentBlobConstructorParams& aParams,
+ const ChildBlobConstructorParams& aOtherSideParams);
+
+ static BlobParent*
+ MaybeGetActorFromRemoteBlob(nsIRemoteBlob* aRemoteBlob,
+ nsIContentParent* aManager);
+
+ static BlobParent*
+ MaybeGetActorFromRemoteBlob(nsIRemoteBlob* aRemoteBlob,
+ PBackgroundParent* aManager);
+
+ void
+ NoteDyingRemoteBlobImpl();
+
+ void
+ NoteRunnableCompleted(OpenStreamRunnable* aRunnable);
+
+ nsIEventTarget*
+ EventTarget() const
+ {
+ return mEventTarget;
+ }
+
+ bool
+ IsOnOwningThread() const;
+
+ // These methods are only called by the IPDL message machinery.
+ virtual void
+ ActorDestroy(ActorDestroyReason aWhy) override;
+
+ virtual PBlobStreamParent*
+ AllocPBlobStreamParent(const uint64_t& aStart,
+ const uint64_t& aLength) override;
+
+ virtual bool
+ RecvPBlobStreamConstructor(PBlobStreamParent* aActor,
+ const uint64_t& aStart,
+ const uint64_t& aLength) override;
+
+ virtual bool
+ DeallocPBlobStreamParent(PBlobStreamParent* aActor) override;
+
+ virtual bool
+ RecvResolveMystery(const ResolveMysteryParams& aParams) override;
+
+ virtual bool
+ RecvBlobStreamSync(const uint64_t& aStart,
+ const uint64_t& aLength,
+ InputStreamParams* aParams,
+ OptionalFileDescriptorSet* aFDs) override;
+
+ virtual bool
+ RecvWaitForSliceCreation() override;
+
+ virtual bool
+ RecvGetFileId(int64_t* aFileId) override;
+
+ virtual bool
+ RecvGetFilePath(nsString* aFilePath) override;
+};
+
+// Only let ContentParent call BlobParent::Startup() and ensure that
+// ContentParent can't access any other BlobParent internals.
+class BlobParent::FriendKey final
+{
+ friend class ContentParent;
+
+private:
+ FriendKey()
+ { }
+
+ FriendKey(const FriendKey& /* aOther */)
+ { }
+
+public:
+ ~FriendKey()
+ { }
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_ipc_BlobParent_h