The Tor Browser: comparison dom/plugins/ipc/PluginScriptableObjectUtils.h

--1:000000000000
+:9b3855c311c8
+/* -*- 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_PluginScriptableObjectUtils_h
+#define dom_plugins_PluginScriptableObjectUtils_h
+#include "PluginModuleParent.h"
+#include "PluginModuleChild.h"
+#include "PluginInstanceParent.h"
+#include "PluginInstanceChild.h"
+#include "PluginScriptableObjectParent.h"
+#include "PluginScriptableObjectChild.h"
+#include "npapi.h"
+#include "npfunctions.h"
+#include "npruntime.h"
+#include "nsDebug.h"
+namespace mozilla {
+namespace plugins {
+inline PluginInstanceParent*
+GetInstance(NPObject* aObject)
+{
+NS_ASSERTION(aObject->_class == PluginScriptableObjectParent::GetClass(),
+"Bad class!");
+ParentNPObject* object = reinterpret_cast<ParentNPObject*>(aObject);
+if (object->invalidated) {
+NS_WARNING("Calling method on an invalidated object!");
+return nullptr;
+}
+if (!object->parent) {
+return nullptr;
+}
+return object->parent->GetInstance();
+}
+inline NPObject*
+NPObjectFromVariant(const Variant& aRemoteVariant)
+{
+switch (aRemoteVariant.type()) {
+case Variant::TPPluginScriptableObjectParent: {
+PluginScriptableObjectParent* actor =
+const_cast<PluginScriptableObjectParent*>(
+reinterpret_cast<const PluginScriptableObjectParent*>(
+aRemoteVariant.get_PPluginScriptableObjectParent()));
+return actor->GetObject(true);
+}
+case Variant::TPPluginScriptableObjectChild: {
+PluginScriptableObjectChild* actor =
+const_cast<PluginScriptableObjectChild*>(
+reinterpret_cast<const PluginScriptableObjectChild*>(
+aRemoteVariant.get_PPluginScriptableObjectChild()));
+return actor->GetObject(true);
+}
+default:
+NS_NOTREACHED("Shouldn't get here!");
+return nullptr;
+}
+}
+inline NPObject*
+NPObjectFromVariant(const NPVariant& aVariant)
+{
+NS_ASSERTION(NPVARIANT_IS_OBJECT(aVariant), "Wrong variant type!");
+return NPVARIANT_TO_OBJECT(aVariant);
+}
+inline const NPNetscapeFuncs*
+GetNetscapeFuncs(PluginInstanceParent* aInstance)
+{
+PluginModuleParent* module = aInstance->Module();
+if (!module) {
+NS_WARNING("Null module?!");
+return nullptr;
+}
+return module->GetNetscapeFuncs();
+}
+inline const NPNetscapeFuncs*
+GetNetscapeFuncs(NPObject* aObject)
+{
+NS_ASSERTION(aObject->_class == PluginScriptableObjectParent::GetClass(),
+"Bad class!");
+PluginInstanceParent* instance = GetInstance(aObject);
+if (!instance) {
+return nullptr;
+}
+return GetNetscapeFuncs(instance);
+}
+inline void
+ReleaseRemoteVariant(Variant& aVariant)
+{
+switch (aVariant.type()) {
+case Variant::TPPluginScriptableObjectParent: {
+PluginScriptableObjectParent* actor =
+const_cast<PluginScriptableObjectParent*>(
+reinterpret_cast<const PluginScriptableObjectParent*>(
+aVariant.get_PPluginScriptableObjectParent()));
+actor->Unprotect();
+break;
+}
+case Variant::TPPluginScriptableObjectChild: {
+NS_ASSERTION(PluginModuleChild::current(),
+"Should only be running in the child!");
+PluginScriptableObjectChild* actor =
+const_cast<PluginScriptableObjectChild*>(
+reinterpret_cast<const PluginScriptableObjectChild*>(
+aVariant.get_PPluginScriptableObjectChild()));
+actor->Unprotect();
+break;
+}
+default:
+break; // Intentional fall-through for other variant types.
+}
+aVariant = mozilla::void_t();
+}
+bool
+ConvertToVariant(const Variant& aRemoteVariant,
+NPVariant& aVariant,
+PluginInstanceParent* aInstance = nullptr);
+template <class InstanceType>
+bool
+ConvertToRemoteVariant(const NPVariant& aVariant,
+Variant& aRemoteVariant,
+InstanceType* aInstance,
+bool aProtectActors = false);
+class ProtectedVariant
+{
+public:
+ProtectedVariant(const NPVariant& aVariant,
+PluginInstanceParent* aInstance)
+{
+mOk = ConvertToRemoteVariant(aVariant, mVariant, aInstance, true);
+}
+ProtectedVariant(const NPVariant& aVariant,
+PluginInstanceChild* aInstance)
+{
+mOk = ConvertToRemoteVariant(aVariant, mVariant, aInstance, true);
+}
+~ProtectedVariant() {
+ReleaseRemoteVariant(mVariant);
+}
+bool IsOk() {
+return mOk;
+}
+operator const Variant&() {
+return mVariant;
+}
+private:
+Variant mVariant;
+bool mOk;
+};
+class ProtectedVariantArray
+{
+public:
+ProtectedVariantArray(const NPVariant* aArgs,
+uint32_t aCount,
+PluginInstanceParent* aInstance)
+: mUsingShadowArray(false)
+{
+for (uint32_t index = 0; index < aCount; index++) {
+Variant* remoteVariant = mArray.AppendElement();
+if (!(remoteVariant &&
+ConvertToRemoteVariant(aArgs[index], *remoteVariant, aInstance,
+true))) {
+mOk = false;
+return;
+}
+}
+mOk = true;
+}
+ProtectedVariantArray(const NPVariant* aArgs,
+uint32_t aCount,
+PluginInstanceChild* aInstance)
+: mUsingShadowArray(false)
+{
+for (uint32_t index = 0; index < aCount; index++) {
+Variant* remoteVariant = mArray.AppendElement();
+if (!(remoteVariant &&
+ConvertToRemoteVariant(aArgs[index], *remoteVariant, aInstance,
+true))) {
+mOk = false;
+return;
+}
+}
+mOk = true;
+}
+~ProtectedVariantArray()
+{
+InfallibleTArray<Variant>& vars = EnsureAndGetShadowArray();
+uint32_t count = vars.Length();
+for (uint32_t index = 0; index < count; index++) {
+ReleaseRemoteVariant(vars[index]);
+}
+}
+operator const InfallibleTArray<Variant>&()
+{
+return EnsureAndGetShadowArray();
+}
+bool IsOk()
+{
+return mOk;
+}
+private:
+InfallibleTArray<Variant>&
+EnsureAndGetShadowArray()
+{
+if (!mUsingShadowArray) {
+mShadowArray.SwapElements(mArray);
+mUsingShadowArray = true;
+}
+return mShadowArray;
+}
+// We convert the variants fallibly, but pass them to Call*()
+// methods as an infallible array
+nsTArray<Variant> mArray;
+InfallibleTArray<Variant> mShadowArray;
+bool mOk;
+bool mUsingShadowArray;
+};
+template<class ActorType>
+struct ProtectedActorTraits
+{
+static bool Nullable();
+};
+template<class ActorType, class Traits=ProtectedActorTraits<ActorType> >
+class ProtectedActor
+{
+public:
+ProtectedActor(ActorType* aActor) : mActor(aActor)
+{
+if (!Traits::Nullable()) {
+NS_ASSERTION(mActor, "This should never be null!");
+}
+}
+~ProtectedActor()
+{
+if (Traits::Nullable() && !mActor)
+return;
+mActor->Unprotect();
+}
+ActorType* operator->()
+{
+return mActor;
+}
+operator bool()
+{
+return !!mActor;
+}
+private:
+ActorType* mActor;
+};
+template<>
+struct ProtectedActorTraits<PluginScriptableObjectParent>
+{
+static bool Nullable() { return true; }
+};
+template<>
+struct ProtectedActorTraits<PluginScriptableObjectChild>
+{
+static bool Nullable() { return false; }
+};
+} /* namespace plugins */
+} /* namespace mozilla */
+#include "PluginScriptableObjectUtils-inl.h"
+#endif /* dom_plugins_PluginScriptableObjectUtils_h */

The Tor Browser / file comparison

comparison: dom/plugins/ipc/PluginScriptableObjectUtils.h

dom/plugins/ipc/PluginScriptableObjectUtils.h