Home | History | Annotate | Download | only in pepper 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/renderer/pepper/ppb_var_deprecated_impl.h"
      6 
      7 #include <limits>
      8 
      9 #include "content/renderer/pepper/common.h"
     10 #include "content/renderer/pepper/host_globals.h"
     11 #include "content/renderer/pepper/npapi_glue.h"
     12 #include "content/renderer/pepper/npobject_var.h"
     13 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
     14 #include "content/renderer/pepper/plugin_module.h"
     15 #include "content/renderer/pepper/plugin_object.h"
     16 #include "ppapi/c/dev/ppb_var_deprecated.h"
     17 #include "ppapi/c/ppb_var.h"
     18 #include "ppapi/c/pp_var.h"
     19 #include "ppapi/shared_impl/ppb_var_shared.h"
     20 #include "third_party/WebKit/public/web/WebBindings.h"
     21 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
     22 
     23 using ppapi::NPObjectVar;
     24 using ppapi::PpapiGlobals;
     25 using ppapi::StringVar;
     26 using ppapi::Var;
     27 using blink::WebBindings;
     28 
     29 namespace content {
     30 
     31 namespace {
     32 
     33 const char kInvalidObjectException[] = "Error: Invalid object";
     34 const char kInvalidPropertyException[] = "Error: Invalid property";
     35 const char kInvalidValueException[] = "Error: Invalid value";
     36 const char kUnableToGetPropertyException[] = "Error: Unable to get property";
     37 const char kUnableToSetPropertyException[] = "Error: Unable to set property";
     38 const char kUnableToRemovePropertyException[] =
     39     "Error: Unable to remove property";
     40 const char kUnableToGetAllPropertiesException[] =
     41     "Error: Unable to get all properties";
     42 const char kUnableToCallMethodException[] = "Error: Unable to call method";
     43 const char kUnableToConstructException[] = "Error: Unable to construct";
     44 
     45 // ---------------------------------------------------------------------------
     46 // Utilities
     47 
     48 // Converts the given PP_Var to an NPVariant, returning true on success.
     49 // False means that the given variant is invalid. In this case, the result
     50 // NPVariant will be set to a void one.
     51 //
     52 // The contents of the PP_Var will NOT be copied, so you need to ensure that
     53 // the PP_Var remains valid while the resultant NPVariant is in use.
     54 bool PPVarToNPVariantNoCopy(PP_Var var, NPVariant* result) {
     55   switch (var.type) {
     56     case PP_VARTYPE_UNDEFINED:
     57       VOID_TO_NPVARIANT(*result);
     58       break;
     59     case PP_VARTYPE_NULL:
     60       NULL_TO_NPVARIANT(*result);
     61       break;
     62     case PP_VARTYPE_BOOL:
     63       BOOLEAN_TO_NPVARIANT(var.value.as_bool, *result);
     64       break;
     65     case PP_VARTYPE_INT32:
     66       INT32_TO_NPVARIANT(var.value.as_int, *result);
     67       break;
     68     case PP_VARTYPE_DOUBLE:
     69       DOUBLE_TO_NPVARIANT(var.value.as_double, *result);
     70       break;
     71     case PP_VARTYPE_STRING: {
     72       StringVar* string = StringVar::FromPPVar(var);
     73       if (!string) {
     74         VOID_TO_NPVARIANT(*result);
     75         return false;
     76       }
     77       const std::string& value = string->value();
     78       STRINGN_TO_NPVARIANT(value.c_str(), value.size(), *result);
     79       break;
     80     }
     81     case PP_VARTYPE_OBJECT: {
     82       scoped_refptr<NPObjectVar> object(NPObjectVar::FromPPVar(var));
     83       if (!object.get()) {
     84         VOID_TO_NPVARIANT(*result);
     85         return false;
     86       }
     87       OBJECT_TO_NPVARIANT(object->np_object(), *result);
     88       break;
     89     }
     90     default:
     91       VOID_TO_NPVARIANT(*result);
     92       return false;
     93   }
     94   return true;
     95 }
     96 
     97 // ObjectAccessorTryCatch ------------------------------------------------------
     98 
     99 // Automatically sets up a TryCatch for accessing the object identified by the
    100 // given PP_Var. The module from the object will be used for the exception
    101 // strings generated by the TryCatch.
    102 //
    103 // This will automatically retrieve the ObjectVar from the object and throw
    104 // an exception if it's invalid. At the end of construction, if there is no
    105 // exception, you know that there is no previously set exception, that the
    106 // object passed in is valid and ready to use (via the object() getter), and
    107 // that the TryCatch's pp_module() getter is also set up properly and ready to
    108 // use.
    109 class ObjectAccessorTryCatch : public TryCatch {
    110  public:
    111   ObjectAccessorTryCatch(PP_Var object, PP_Var* exception)
    112       : TryCatch(exception), object_(NPObjectVar::FromPPVar(object)) {
    113     if (!object_.get()) {
    114       SetException(kInvalidObjectException);
    115     }
    116   }
    117 
    118   NPObjectVar* object() { return object_.get(); }
    119 
    120   PepperPluginInstanceImpl* GetPluginInstance() {
    121     return HostGlobals::Get()->GetInstance(object()->pp_instance());
    122   }
    123 
    124  protected:
    125   scoped_refptr<NPObjectVar> object_;
    126 
    127   DISALLOW_COPY_AND_ASSIGN(ObjectAccessorTryCatch);
    128 };
    129 
    130 // ObjectAccessiorWithIdentifierTryCatch ---------------------------------------
    131 
    132 // Automatically sets up a TryCatch for accessing the identifier on the given
    133 // object. This just extends ObjectAccessorTryCatch to additionally convert
    134 // the given identifier to an NPIdentifier and validate it, throwing an
    135 // exception if it's invalid.
    136 //
    137 // At the end of construction, if there is no exception, you know that there is
    138 // no previously set exception, that the object passed in is valid and ready to
    139 // use (via the object() getter), that the identifier is valid and ready to
    140 // use (via the identifier() getter), and that the TryCatch's pp_module() getter
    141 // is also set up properly and ready to use.
    142 class ObjectAccessorWithIdentifierTryCatch : public ObjectAccessorTryCatch {
    143  public:
    144   ObjectAccessorWithIdentifierTryCatch(PP_Var object,
    145                                        PP_Var identifier,
    146                                        PP_Var* exception)
    147       : ObjectAccessorTryCatch(object, exception), identifier_(0) {
    148     if (!has_exception()) {
    149       identifier_ = PPVarToNPIdentifier(identifier);
    150       if (!identifier_)
    151         SetException(kInvalidPropertyException);
    152     }
    153   }
    154 
    155   NPIdentifier identifier() const { return identifier_; }
    156 
    157  private:
    158   NPIdentifier identifier_;
    159 
    160   DISALLOW_COPY_AND_ASSIGN(ObjectAccessorWithIdentifierTryCatch);
    161 };
    162 
    163 PP_Bool HasProperty(PP_Var var, PP_Var name, PP_Var* exception) {
    164   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
    165   if (accessor.has_exception())
    166     return PP_FALSE;
    167   return BoolToPPBool(WebBindings::hasProperty(
    168       NULL, accessor.object()->np_object(), accessor.identifier()));
    169 }
    170 
    171 bool HasPropertyDeprecated(PP_Var var, PP_Var name, PP_Var* exception) {
    172   return PPBoolToBool(HasProperty(var, name, exception));
    173 }
    174 
    175 bool HasMethodDeprecated(PP_Var var, PP_Var name, PP_Var* exception) {
    176   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
    177   if (accessor.has_exception())
    178     return false;
    179   return WebBindings::hasMethod(
    180       NULL, accessor.object()->np_object(), accessor.identifier());
    181 }
    182 
    183 PP_Var GetProperty(PP_Var var, PP_Var name, PP_Var* exception) {
    184   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
    185   if (accessor.has_exception())
    186     return PP_MakeUndefined();
    187 
    188   NPVariant result;
    189   if (!WebBindings::getProperty(NULL,
    190                                 accessor.object()->np_object(),
    191                                 accessor.identifier(),
    192                                 &result)) {
    193     // An exception may have been raised.
    194     accessor.SetException(kUnableToGetPropertyException);
    195     return PP_MakeUndefined();
    196   }
    197 
    198   PP_Var ret = NPVariantToPPVar(accessor.GetPluginInstance(), &result);
    199   WebBindings::releaseVariantValue(&result);
    200   return ret;
    201 }
    202 
    203 void EnumerateProperties(PP_Var var,
    204                          uint32_t* property_count,
    205                          PP_Var** properties,
    206                          PP_Var* exception) {
    207   *properties = NULL;
    208   *property_count = 0;
    209 
    210   ObjectAccessorTryCatch accessor(var, exception);
    211   if (accessor.has_exception())
    212     return;
    213 
    214   NPIdentifier* identifiers = NULL;
    215   uint32_t count = 0;
    216   if (!WebBindings::enumerate(
    217           NULL, accessor.object()->np_object(), &identifiers, &count)) {
    218     accessor.SetException(kUnableToGetAllPropertiesException);
    219     return;
    220   }
    221 
    222   if (count == 0)
    223     return;
    224 
    225   *property_count = count;
    226   *properties = static_cast<PP_Var*>(malloc(sizeof(PP_Var) * count));
    227   for (uint32_t i = 0; i < count; ++i) {
    228     (*properties)[i] = NPIdentifierToPPVar(identifiers[i]);
    229   }
    230   free(identifiers);
    231 }
    232 
    233 void SetPropertyDeprecated(PP_Var var,
    234                            PP_Var name,
    235                            PP_Var value,
    236                            PP_Var* exception) {
    237   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
    238   if (accessor.has_exception())
    239     return;
    240 
    241   NPVariant variant;
    242   if (!PPVarToNPVariantNoCopy(value, &variant)) {
    243     accessor.SetException(kInvalidValueException);
    244     return;
    245   }
    246   if (!WebBindings::setProperty(NULL,
    247                                 accessor.object()->np_object(),
    248                                 accessor.identifier(),
    249                                 &variant))
    250     accessor.SetException(kUnableToSetPropertyException);
    251 }
    252 
    253 void DeletePropertyDeprecated(PP_Var var, PP_Var name, PP_Var* exception) {
    254   ObjectAccessorWithIdentifierTryCatch accessor(var, name, exception);
    255   if (accessor.has_exception())
    256     return;
    257 
    258   if (!WebBindings::removeProperty(
    259           NULL, accessor.object()->np_object(), accessor.identifier()))
    260     accessor.SetException(kUnableToRemovePropertyException);
    261 }
    262 
    263 PP_Var InternalCallDeprecated(ObjectAccessorTryCatch* accessor,
    264                               PP_Var method_name,
    265                               uint32_t argc,
    266                               PP_Var* argv,
    267                               PP_Var* exception) {
    268   NPIdentifier identifier;
    269   if (method_name.type == PP_VARTYPE_UNDEFINED) {
    270     identifier = NULL;
    271   } else if (method_name.type == PP_VARTYPE_STRING) {
    272     // Specifically allow only string functions to be called.
    273     identifier = PPVarToNPIdentifier(method_name);
    274     if (!identifier) {
    275       accessor->SetException(kInvalidPropertyException);
    276       return PP_MakeUndefined();
    277     }
    278   } else {
    279     accessor->SetException(kInvalidPropertyException);
    280     return PP_MakeUndefined();
    281   }
    282 
    283   scoped_ptr<NPVariant[]> args;
    284   if (argc) {
    285     args.reset(new NPVariant[argc]);
    286     for (uint32_t i = 0; i < argc; ++i) {
    287       if (!PPVarToNPVariantNoCopy(argv[i], &args[i])) {
    288         // This argument was invalid, throw an exception & give up.
    289         accessor->SetException(kInvalidValueException);
    290         return PP_MakeUndefined();
    291       }
    292     }
    293   }
    294 
    295   bool ok;
    296 
    297   NPVariant result;
    298   if (identifier) {
    299     ok = WebBindings::invoke(NULL,
    300                              accessor->object()->np_object(),
    301                              identifier,
    302                              args.get(),
    303                              argc,
    304                              &result);
    305   } else {
    306     ok = WebBindings::invokeDefault(
    307         NULL, accessor->object()->np_object(), args.get(), argc, &result);
    308   }
    309 
    310   if (!ok) {
    311     // An exception may have been raised.
    312     accessor->SetException(kUnableToCallMethodException);
    313     return PP_MakeUndefined();
    314   }
    315 
    316   PP_Var ret = NPVariantToPPVar(accessor->GetPluginInstance(), &result);
    317   WebBindings::releaseVariantValue(&result);
    318   return ret;
    319 }
    320 
    321 PP_Var CallDeprecated(PP_Var var,
    322                       PP_Var method_name,
    323                       uint32_t argc,
    324                       PP_Var* argv,
    325                       PP_Var* exception) {
    326   ObjectAccessorTryCatch accessor(var, exception);
    327   if (accessor.has_exception())
    328     return PP_MakeUndefined();
    329   PepperPluginInstanceImpl* plugin = accessor.GetPluginInstance();
    330   if (plugin && plugin->IsProcessingUserGesture()) {
    331     blink::WebScopedUserGesture user_gesture(plugin->CurrentUserGestureToken());
    332     return InternalCallDeprecated(
    333         &accessor, method_name, argc, argv, exception);
    334   }
    335   return InternalCallDeprecated(&accessor, method_name, argc, argv, exception);
    336 }
    337 
    338 PP_Var Construct(PP_Var var, uint32_t argc, PP_Var* argv, PP_Var* exception) {
    339   ObjectAccessorTryCatch accessor(var, exception);
    340   if (accessor.has_exception())
    341     return PP_MakeUndefined();
    342 
    343   scoped_ptr<NPVariant[]> args;
    344   if (argc) {
    345     args.reset(new NPVariant[argc]);
    346     for (uint32_t i = 0; i < argc; ++i) {
    347       if (!PPVarToNPVariantNoCopy(argv[i], &args[i])) {
    348         // This argument was invalid, throw an exception & give up.
    349         accessor.SetException(kInvalidValueException);
    350         return PP_MakeUndefined();
    351       }
    352     }
    353   }
    354 
    355   NPVariant result;
    356   if (!WebBindings::construct(
    357           NULL, accessor.object()->np_object(), args.get(), argc, &result)) {
    358     // An exception may have been raised.
    359     accessor.SetException(kUnableToConstructException);
    360     return PP_MakeUndefined();
    361   }
    362 
    363   PP_Var ret = NPVariantToPPVar(accessor.GetPluginInstance(), &result);
    364   WebBindings::releaseVariantValue(&result);
    365   return ret;
    366 }
    367 
    368 bool IsInstanceOfDeprecated(PP_Var var,
    369                             const PPP_Class_Deprecated* ppp_class,
    370                             void** ppp_class_data) {
    371   scoped_refptr<NPObjectVar> object(NPObjectVar::FromPPVar(var));
    372   if (!object.get())
    373     return false;  // Not an object at all.
    374 
    375   return PluginObject::IsInstanceOf(
    376       object->np_object(), ppp_class, ppp_class_data);
    377 }
    378 
    379 PP_Var CreateObjectDeprecated(PP_Instance pp_instance,
    380                               const PPP_Class_Deprecated* ppp_class,
    381                               void* ppp_class_data) {
    382   PepperPluginInstanceImpl* instance =
    383       HostGlobals::Get()->GetInstance(pp_instance);
    384   if (!instance) {
    385     DLOG(ERROR) << "Create object passed an invalid instance.";
    386     return PP_MakeNull();
    387   }
    388   return PluginObject::Create(instance, ppp_class, ppp_class_data);
    389 }
    390 
    391 PP_Var CreateObjectWithModuleDeprecated(PP_Module pp_module,
    392                                         const PPP_Class_Deprecated* ppp_class,
    393                                         void* ppp_class_data) {
    394   PluginModule* module = HostGlobals::Get()->GetModule(pp_module);
    395   if (!module)
    396     return PP_MakeNull();
    397   return PluginObject::Create(
    398       module->GetSomeInstance(), ppp_class, ppp_class_data);
    399 }
    400 
    401 }  // namespace
    402 
    403 // static
    404 const PPB_Var_Deprecated* PPB_Var_Deprecated_Impl::GetVarDeprecatedInterface() {
    405   static const PPB_Var_Deprecated var_deprecated_interface = {
    406       ppapi::PPB_Var_Shared::GetVarInterface1_0()->AddRef,
    407       ppapi::PPB_Var_Shared::GetVarInterface1_0()->Release,
    408       ppapi::PPB_Var_Shared::GetVarInterface1_0()->VarFromUtf8,
    409       ppapi::PPB_Var_Shared::GetVarInterface1_0()->VarToUtf8,
    410       &HasPropertyDeprecated,
    411       &HasMethodDeprecated,
    412       &GetProperty,
    413       &EnumerateProperties,
    414       &SetPropertyDeprecated,
    415       &DeletePropertyDeprecated,
    416       &CallDeprecated,
    417       &Construct,
    418       &IsInstanceOfDeprecated,
    419       &CreateObjectDeprecated,
    420       &CreateObjectWithModuleDeprecated, };
    421 
    422   return &var_deprecated_interface;
    423 }
    424 
    425 }  // namespace content
    426