The Tor Browser: dom/plugins/ipc/PluginScriptableObjectUtils.h@b8a032363ba2 (annotated)

dom/plugins/ipc/PluginScriptableObjectUtils.h@b8a032363ba2 (annotated)

dom/plugins/ipc/PluginScriptableObjectUtils.h

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- 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 / annotate

dom/plugins/ipc/PluginScriptableObjectUtils.h@b8a032363ba2 (annotated)

dom/plugins/ipc/PluginScriptableObjectUtils.h