diff -r 000000000000 -r 6474c204b198 dom/plugins/ipc/PluginScriptableObjectChild.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dom/plugins/ipc/PluginScriptableObjectChild.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,238 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * vim: sw=2 ts=2 et :
+ * 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 dom_plugins_PluginScriptableObjectChild_h
+#define dom_plugins_PluginScriptableObjectChild_h 1
+
+#include "mozilla/plugins/PPluginScriptableObjectChild.h"
+#include "mozilla/plugins/PluginMessageUtils.h"
+
+#include "npruntime.h"
+
+namespace mozilla {
+namespace plugins {
+
+class PluginInstanceChild;
+class PluginScriptableObjectChild;
+class PPluginIdentifierChild;
+
+struct ChildNPObject : NPObject
+{
+  ChildNPObject()
+    : NPObject(), parent(nullptr), invalidated(false)
+  {
+    MOZ_COUNT_CTOR(ChildNPObject);
+  }
+
+  ~ChildNPObject()
+  {
+    MOZ_COUNT_DTOR(ChildNPObject);
+  }
+
+  // |parent| is always valid as long as the actor is alive. Once the actor is
+  // destroyed this will be set to null.
+  PluginScriptableObjectChild* parent;
+  bool invalidated;
+};
+
+class PluginScriptableObjectChild : public PPluginScriptableObjectChild
+{
+  friend class PluginInstanceChild;
+
+public:
+  PluginScriptableObjectChild(ScriptableObjectType aType);
+  virtual ~PluginScriptableObjectChild();
+
+  void
+  InitializeProxy();
+
+  void
+  InitializeLocal(NPObject* aObject);
+
+
+  virtual bool
+  AnswerInvalidate() MOZ_OVERRIDE;
+
+  virtual bool
+  AnswerHasMethod(PPluginIdentifierChild* aId,
+                  bool* aHasMethod) MOZ_OVERRIDE;
+
+  virtual bool
+  AnswerInvoke(PPluginIdentifierChild* aId,
+               const InfallibleTArray<Variant>& aArgs,
+               Variant* aResult,
+               bool* aSuccess) MOZ_OVERRIDE;
+
+  virtual bool
+  AnswerInvokeDefault(const InfallibleTArray<Variant>& aArgs,
+                      Variant* aResult,
+                      bool* aSuccess) MOZ_OVERRIDE;
+
+  virtual bool
+  AnswerHasProperty(PPluginIdentifierChild* aId,
+                    bool* aHasProperty) MOZ_OVERRIDE;
+
+  virtual bool
+  AnswerGetChildProperty(PPluginIdentifierChild* aId,
+                         bool* aHasProperty,
+                         bool* aHasMethod,
+                         Variant* aResult,
+                         bool* aSuccess) MOZ_OVERRIDE;
+
+  virtual bool
+  AnswerSetProperty(PPluginIdentifierChild* aId,
+                    const Variant& aValue,
+                    bool* aSuccess) MOZ_OVERRIDE;
+
+  virtual bool
+  AnswerRemoveProperty(PPluginIdentifierChild* aId,
+                       bool* aSuccess) MOZ_OVERRIDE;
+
+  virtual bool
+  AnswerEnumerate(InfallibleTArray<PPluginIdentifierChild*>* aProperties,
+                  bool* aSuccess) MOZ_OVERRIDE;
+
+  virtual bool
+  AnswerConstruct(const InfallibleTArray<Variant>& aArgs,
+                  Variant* aResult,
+                  bool* aSuccess) MOZ_OVERRIDE;
+
+  virtual bool
+  RecvProtect() MOZ_OVERRIDE;
+
+  virtual bool
+  RecvUnprotect() MOZ_OVERRIDE;
+
+  NPObject*
+  GetObject(bool aCanResurrect);
+
+  static const NPClass*
+  GetClass()
+  {
+    return &sNPClass;
+  }
+
+  PluginInstanceChild*
+  GetInstance() const
+  {
+    return mInstance;
+  }
+
+  // Protect only affects LocalObject actors. It is called by the
+  // ProtectedVariant/Actor helper classes before the actor is used as an
+  // argument to an IPC call and when the parent process resurrects a
+  // proxy object to the NPObject associated with this actor.
+  void Protect();
+
+  // Unprotect only affects LocalObject actors. It is called by the
+  // ProtectedVariant/Actor helper classes after the actor is used as an
+  // argument to an IPC call and when the parent process is no longer using
+  // this actor.
+  void Unprotect();
+
+  // DropNPObject is only used for Proxy actors and is called when the child
+  // process is no longer using the NPObject associated with this actor. The
+  // parent process may subsequently use this actor again in which case a new
+  // NPObject will be created and associated with this actor (see
+  // ResurrectProxyObject).
+  void DropNPObject();
+
+  /**
+   * After NPP_Destroy, all NPObjects associated with an instance are
+   * destroyed. We are informed of this destruction. This should only be called
+   * on Local actors.
+   */
+  void NPObjectDestroyed();
+
+  bool
+  Evaluate(NPString* aScript,
+           NPVariant* aResult);
+
+  ScriptableObjectType
+  Type() const {
+    return mType;
+  }
+
+private:
+  static NPObject*
+  ScriptableAllocate(NPP aInstance,
+                     NPClass* aClass);
+
+  static void
+  ScriptableInvalidate(NPObject* aObject);
+
+  static void
+  ScriptableDeallocate(NPObject* aObject);
+
+  static bool
+  ScriptableHasMethod(NPObject* aObject,
+                      NPIdentifier aName);
+
+  static bool
+  ScriptableInvoke(NPObject* aObject,
+                   NPIdentifier aName,
+                   const NPVariant* aArgs,
+                   uint32_t aArgCount,
+                   NPVariant* aResult);
+
+  static bool
+  ScriptableInvokeDefault(NPObject* aObject,
+                          const NPVariant* aArgs,
+                          uint32_t aArgCount,
+                          NPVariant* aResult);
+
+  static bool
+  ScriptableHasProperty(NPObject* aObject,
+                        NPIdentifier aName);
+
+  static bool
+  ScriptableGetProperty(NPObject* aObject,
+                        NPIdentifier aName,
+                        NPVariant* aResult);
+
+  static bool
+  ScriptableSetProperty(NPObject* aObject,
+                        NPIdentifier aName,
+                        const NPVariant* aValue);
+
+  static bool
+  ScriptableRemoveProperty(NPObject* aObject,
+                           NPIdentifier aName);
+
+  static bool
+  ScriptableEnumerate(NPObject* aObject,
+                      NPIdentifier** aIdentifiers,
+                      uint32_t* aCount);
+
+  static bool
+  ScriptableConstruct(NPObject* aObject,
+                      const NPVariant* aArgs,
+                      uint32_t aArgCount,
+                      NPVariant* aResult);
+
+  NPObject*
+  CreateProxyObject();
+
+  // ResurrectProxyObject is only used with Proxy actors. It is called when the
+  // parent process uses an actor whose NPObject was deleted by the child
+  // process.
+  bool ResurrectProxyObject();
+
+private:
+  PluginInstanceChild* mInstance;
+  NPObject* mObject;
+  bool mInvalidated;
+  int mProtectCount;
+
+  ScriptableObjectType mType;
+
+  static const NPClass sNPClass;
+};
+
+} /* namespace plugins */
+} /* namespace mozilla */
+
+#endif /* dom_plugins_PluginScriptableObjectChild_h */