The Tor Browser: dom/plugins/ipc/PluginScriptableObjectUtils-inl.h@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-

     2  * vim: sw=2 ts=2 et :

     3  * This Source Code Form is subject to the terms of the Mozilla Public

     4  * License, v. 2.0. If a copy of the MPL was not distributed with this

     5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     7 #include "PluginScriptableObjectUtils.h"

     9 namespace {

    11 template<class InstanceType>

    12 class VariantTraits;

    14 template<>

    15 class VariantTraits<mozilla::plugins::PluginInstanceParent>

    16 {

    17 public:

    18   typedef mozilla::plugins::PluginScriptableObjectParent ScriptableObjectType;

    19 };

    21 template<>

    22 class VariantTraits<mozilla::plugins::PluginInstanceChild>

    23 {

    24 public:

    25   typedef mozilla::plugins::PluginScriptableObjectChild ScriptableObjectType;

    26 };

    28 } /* anonymous namespace */

    30 inline bool

    31 mozilla::plugins::ConvertToVariant(const Variant& aRemoteVariant,

    32                                    NPVariant& aVariant,

    33                                    PluginInstanceParent* aInstance)

    34 {

    35   switch (aRemoteVariant.type()) {

    36     case Variant::Tvoid_t: {

    37       VOID_TO_NPVARIANT(aVariant);

    38       break;

    39     }

    41     case Variant::Tnull_t: {

    42       NULL_TO_NPVARIANT(aVariant);

    43       break;

    44     }

    46     case Variant::Tbool: {

    47       BOOLEAN_TO_NPVARIANT(aRemoteVariant.get_bool(), aVariant);

    48       break;

    49     }

    51     case Variant::Tint: {

    52       INT32_TO_NPVARIANT(aRemoteVariant.get_int(), aVariant);

    53       break;

    54     }

    56     case Variant::Tdouble: {

    57       DOUBLE_TO_NPVARIANT(aRemoteVariant.get_double(), aVariant);

    58       break;

    59     }

    61     case Variant::TnsCString: {

    62       const nsCString& string = aRemoteVariant.get_nsCString();

    63       NPUTF8* buffer = reinterpret_cast<NPUTF8*>(strdup(string.get()));

    64       if (!buffer) {

    65         NS_ERROR("Out of memory!");

    66         return false;

    67       }

    68       STRINGN_TO_NPVARIANT(buffer, string.Length(), aVariant);

    69       break;

    70     }

    72     case Variant::TPPluginScriptableObjectParent: {

    73       NS_ASSERTION(aInstance, "Must have an instance!");

    74       NPObject* object = NPObjectFromVariant(aRemoteVariant);

    75       if (!object) {

    76         NS_ERROR("Er, this shouldn't fail!");

    77         return false;

    78       }

    80       const NPNetscapeFuncs* npn = GetNetscapeFuncs(aInstance);

    81       if (!npn) {

    82         NS_ERROR("Null netscape funcs!");

    83         return false;

    84       }

    86       npn->retainobject(object);

    87       OBJECT_TO_NPVARIANT(object, aVariant);

    88       break;

    89     }

    91     case Variant::TPPluginScriptableObjectChild: {

    92       NS_ASSERTION(!aInstance, "No instance should be given!");

    93       NS_ASSERTION(PluginModuleChild::current(),

    94                    "Should be running on child only!");

    96       NPObject* object = NPObjectFromVariant(aRemoteVariant);

    97       NS_ASSERTION(object, "Null object?!");

    99       PluginModuleChild::sBrowserFuncs.retainobject(object);

   100       OBJECT_TO_NPVARIANT(object, aVariant);

   101       break;

   102     }

   104     default:

   105       NS_NOTREACHED("Shouldn't get here!");

   106       return false;

   107   }

   109   return true;

   110 }

   112 template <class InstanceType>

   113 bool

   114 mozilla::plugins::ConvertToRemoteVariant(const NPVariant& aVariant,

   115                                          Variant& aRemoteVariant,

   116                                          InstanceType* aInstance,

   117                                          bool aProtectActors)

   118 {

   119   if (NPVARIANT_IS_VOID(aVariant)) {

   120     aRemoteVariant = mozilla::void_t();

   121   }

   122   else if (NPVARIANT_IS_NULL(aVariant)) {

   123     aRemoteVariant = mozilla::null_t();

   124   }

   125   else if (NPVARIANT_IS_BOOLEAN(aVariant)) {

   126     aRemoteVariant = NPVARIANT_TO_BOOLEAN(aVariant);

   127   }

   128   else if (NPVARIANT_IS_INT32(aVariant)) {

   129     aRemoteVariant = NPVARIANT_TO_INT32(aVariant);

   130   }

   131   else if (NPVARIANT_IS_DOUBLE(aVariant)) {

   132     aRemoteVariant = NPVARIANT_TO_DOUBLE(aVariant);

   133   }

   134   else if (NPVARIANT_IS_STRING(aVariant)) {

   135     NPString str = NPVARIANT_TO_STRING(aVariant);

   136     nsCString string(str.UTF8Characters, str.UTF8Length);

   137     aRemoteVariant = string;

   138   }

   139   else if (NPVARIANT_IS_OBJECT(aVariant)) {

   140     NPObject* object = NPVARIANT_TO_OBJECT(aVariant);

   142     typename VariantTraits<InstanceType>::ScriptableObjectType* actor =

   143       aInstance->GetActorForNPObject(object);

   145     if (!actor) {

   146       NS_ERROR("Null actor!");

   147       return false;

   148     }

   150     if (aProtectActors) {

   151       actor->Protect();

   152     }

   154     aRemoteVariant = actor;

   155   }

   156   else {

   157     NS_NOTREACHED("Shouldn't get here!");

   158     return false;

   159   }

   161   return true;

   162 }

The Tor Browser / file revision