Add m-esr52 at 52.6.0

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