content/renderer/pepper/npapi_glue.cc

   1 // Copyright (c) 2011 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/npapi_glue.h"
   6
   7 #include "base/logging.h"
   8 #include "base/memory/ref_counted.h"
   9 #include "base/strings/string_util.h"
  10 #include "content/renderer/pepper/host_array_buffer_var.h"
  11 #include "content/renderer/pepper/host_globals.h"
  12 #include "content/renderer/pepper/host_var_tracker.h"
  13 #include "content/renderer/pepper/npobject_var.h"
  14 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
  15 #include "content/renderer/pepper/plugin_module.h"
  16 #include "content/renderer/pepper/plugin_object.h"
  17 #include "ppapi/c/pp_var.h"
  18 #include "third_party/npapi/bindings/npapi.h"
  19 #include "third_party/npapi/bindings/npruntime.h"
  20 #include "third_party/WebKit/public/web/WebBindings.h"
  21 #include "third_party/WebKit/public/web/WebDocument.h"
  22 #include "third_party/WebKit/public/web/WebElement.h"
  23 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  24 #include "third_party/WebKit/public/web/WebPluginContainer.h"
  25 #include "v8/include/v8.h"
  26
  27 using ppapi::NPObjectVar;
  28 using ppapi::PpapiGlobals;
  29 using ppapi::StringVar;
  30 using ppapi::Var;
  31 using blink::WebArrayBuffer;
  32 using blink::WebBindings;
  33 using blink::WebLocalFrame;
  34 using blink::WebPluginContainer;
  35
  36 namespace content {
  37
  38 namespace {
  39
  40 const char kInvalidPluginValue[] = "Error: Plugin returned invalid value.";
  41
  42 PP_Var NPObjectToPPVarImpl(PepperPluginInstanceImpl* instance,
  43                            NPObject* object,
  44                            v8::Local<v8::Context> context) {
  45   DCHECK(object);
  46   if (context.IsEmpty())
  47     return PP_MakeUndefined();
  48   v8::Context::Scope context_scope(context);
  49
  50   WebArrayBuffer buffer;
  51   // TODO(dmichael): Should I protect against duplicate Vars representing the
  52   // same array buffer? It's probably not worth the trouble, since it will only
  53   // affect in-process plugins.
  54   if (WebBindings::getArrayBuffer(object, &buffer)) {
  55     scoped_refptr<HostArrayBufferVar> buffer_var(
  56         new HostArrayBufferVar(buffer));
  57     return buffer_var->GetPPVar();
  58   }
  59   scoped_refptr<NPObjectVar> object_var(
  60       HostGlobals::Get()->host_var_tracker()->NPObjectVarForNPObject(
  61           instance->pp_instance(), object));
  62   if (!object_var.get()) {  // No object for this module yet, make a new one.
  63     object_var = new NPObjectVar(instance->pp_instance(), object);
  64   }
  65   return object_var->GetPPVar();
  66 }
  67
  68 }  // namespace
  69
  70 // Utilities -------------------------------------------------------------------
  71
  72 bool PPVarToNPVariant(PP_Var var, NPVariant* result) {
  73   switch (var.type) {
  74     case PP_VARTYPE_UNDEFINED:
  75       VOID_TO_NPVARIANT(*result);
  76       break;
  77     case PP_VARTYPE_NULL:
  78       NULL_TO_NPVARIANT(*result);
  79       break;
  80     case PP_VARTYPE_BOOL:
  81       BOOLEAN_TO_NPVARIANT(var.value.as_bool, *result);
  82       break;
  83     case PP_VARTYPE_INT32:
  84       INT32_TO_NPVARIANT(var.value.as_int, *result);
  85       break;
  86     case PP_VARTYPE_DOUBLE:
  87       DOUBLE_TO_NPVARIANT(var.value.as_double, *result);
  88       break;
  89     case PP_VARTYPE_STRING: {
  90       StringVar* string = StringVar::FromPPVar(var);
  91       if (!string) {
  92         VOID_TO_NPVARIANT(*result);
  93         return false;
  94       }
  95       const std::string& value = string->value();
  96       char* c_string = static_cast<char*>(malloc(value.size()));
  97       memcpy(c_string, value.data(), value.size());
  98       STRINGN_TO_NPVARIANT(c_string, value.size(), *result);
  99       break;
 100     }
 101     case PP_VARTYPE_OBJECT: {
 102       scoped_refptr<NPObjectVar> object(NPObjectVar::FromPPVar(var));
 103       if (!object.get()) {
 104         VOID_TO_NPVARIANT(*result);
 105         return false;
 106       }
 107       OBJECT_TO_NPVARIANT(WebBindings::retainObject(object->np_object()),
 108                           *result);
 109       break;
 110     }
 111     // The following types are not supported for use with PPB_Var_Deprecated,
 112     // because PPB_Var_Deprecated is only for trusted plugins, and the trusted
 113     // plugins we have don't need these types. We can add support in the future
 114     // if it becomes necessary.
 115     case PP_VARTYPE_ARRAY:
 116     case PP_VARTYPE_DICTIONARY:
 117     case PP_VARTYPE_ARRAY_BUFFER:
 118     case PP_VARTYPE_RESOURCE:
 119       VOID_TO_NPVARIANT(*result);
 120       break;
 121   }
 122   return true;
 123 }
 124
 125 PP_Var NPVariantToPPVar(PepperPluginInstanceImpl* instance,
 126                         const NPVariant* variant) {
 127   switch (variant->type) {
 128     case NPVariantType_Void:
 129       return PP_MakeUndefined();
 130     case NPVariantType_Null:
 131       return PP_MakeNull();
 132     case NPVariantType_Bool:
 133       return PP_MakeBool(PP_FromBool(NPVARIANT_TO_BOOLEAN(*variant)));
 134     case NPVariantType_Int32:
 135       return PP_MakeInt32(NPVARIANT_TO_INT32(*variant));
 136     case NPVariantType_Double:
 137       return PP_MakeDouble(NPVARIANT_TO_DOUBLE(*variant));
 138     case NPVariantType_String:
 139       return StringVar::StringToPPVar(
 140           NPVARIANT_TO_STRING(*variant).UTF8Characters,
 141           NPVARIANT_TO_STRING(*variant).UTF8Length);
 142     case NPVariantType_Object:
 143       return NPObjectToPPVar(instance, NPVARIANT_TO_OBJECT(*variant));
 144   }
 145   NOTREACHED();
 146   return PP_MakeUndefined();
 147 }
 148
 149 NPIdentifier PPVarToNPIdentifier(PP_Var var) {
 150   switch (var.type) {
 151     case PP_VARTYPE_STRING: {
 152       StringVar* string = StringVar::FromPPVar(var);
 153       if (!string)
 154         return NULL;
 155       return WebBindings::getStringIdentifier(string->value().c_str());
 156     }
 157     case PP_VARTYPE_INT32:
 158       return WebBindings::getIntIdentifier(var.value.as_int);
 159     default:
 160       return NULL;
 161   }
 162 }
 163
 164 PP_Var NPIdentifierToPPVar(NPIdentifier id) {
 165   const NPUTF8* string_value = NULL;
 166   int32_t int_value = 0;
 167   bool is_string = false;
 168   WebBindings::extractIdentifierData(id, string_value, int_value, is_string);
 169   if (is_string)
 170     return StringVar::StringToPPVar(string_value);
 171
 172   return PP_MakeInt32(int_value);
 173 }
 174
 175 PP_Var NPObjectToPPVar(PepperPluginInstanceImpl* instance, NPObject* object) {
 176   WebPluginContainer* container = instance->container();
 177   // It's possible that container() is NULL if the plugin has been removed from
 178   // the DOM (but the PluginInstance is not destroyed yet).
 179   if (!container)
 180     return PP_MakeUndefined();
 181   WebLocalFrame* frame = container->element().document().frame();
 182   if (!frame)
 183     return PP_MakeUndefined();
 184
 185   v8::HandleScope scope(instance->GetIsolate());
 186   v8::Local<v8::Context> context = frame->mainWorldScriptContext();
 187   return NPObjectToPPVarImpl(instance, object, context);
 188 }
 189
 190 PP_Var NPObjectToPPVarForTest(PepperPluginInstanceImpl* instance,
 191                               NPObject* object) {
 192   v8::Isolate* test_isolate = v8::Isolate::New();
 193   PP_Var result = PP_MakeUndefined();
 194   {
 195     v8::HandleScope scope(test_isolate);
 196     v8::Isolate::Scope isolate_scope(test_isolate);
 197     v8::Local<v8::Context> context = v8::Context::New(test_isolate);
 198     result = NPObjectToPPVarImpl(instance, object, context);
 199   }
 200   test_isolate->Dispose();
 201   return result;
 202 }
 203
 204 // PPResultAndExceptionToNPResult ----------------------------------------------
 205
 206 PPResultAndExceptionToNPResult::PPResultAndExceptionToNPResult(
 207     NPObject* object_var,
 208     NPVariant* np_result)
 209     : object_var_(object_var),
 210       np_result_(np_result),
 211       exception_(PP_MakeUndefined()),
 212       success_(false),
 213       checked_exception_(false) {}
 214
 215 PPResultAndExceptionToNPResult::~PPResultAndExceptionToNPResult() {
 216   // The user should have called SetResult or CheckExceptionForNoResult
 217   // before letting this class go out of scope, or the exception will have
 218   // been lost.
 219   DCHECK(checked_exception_);
 220
 221   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(exception_);
 222 }
 223
 224 // Call this with the return value of the PPAPI function. It will convert
 225 // the result to the NPVariant output parameter and pass any exception on to
 226 // the JS engine. It will update the success flag and return it.
 227 bool PPResultAndExceptionToNPResult::SetResult(PP_Var result) {
 228   DCHECK(!checked_exception_);  // Don't call more than once.
 229   DCHECK(np_result_);           // Should be expecting a result.
 230
 231   checked_exception_ = true;
 232
 233   if (has_exception()) {
 234     ThrowException();
 235     success_ = false;
 236   } else if (!PPVarToNPVariant(result, np_result_)) {
 237     WebBindings::setException(object_var_, kInvalidPluginValue);
 238     success_ = false;
 239   } else {
 240     success_ = true;
 241   }
 242
 243   // No matter what happened, we need to release the reference to the
 244   // value passed in. On success, a reference to this value will be in
 245   // the np_result_.
 246   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(result);
 247   return success_;
 248 }
 249
 250 // Call this after calling a PPAPI function that could have set the
 251 // exception. It will pass the exception on to the JS engine and update
 252 // the success flag.
 253 //
 254 // The success flag will be returned.
 255 bool PPResultAndExceptionToNPResult::CheckExceptionForNoResult() {
 256   DCHECK(!checked_exception_);  // Don't call more than once.
 257   DCHECK(!np_result_);          // Can't have a result when doing this.
 258
 259   checked_exception_ = true;
 260
 261   if (has_exception()) {
 262     ThrowException();
 263     success_ = false;
 264     return false;
 265   }
 266   success_ = true;
 267   return true;
 268 }
 269
 270 // Call this to ignore any exception. This prevents the DCHECK from failing
 271 // in the destructor.
 272 void PPResultAndExceptionToNPResult::IgnoreException() {
 273   checked_exception_ = true;
 274 }
 275
 276 // Throws the current exception to JS. The exception must be set.
 277 void PPResultAndExceptionToNPResult::ThrowException() {
 278   StringVar* string = StringVar::FromPPVar(exception_);
 279   if (string)
 280     WebBindings::setException(object_var_, string->value().c_str());
 281 }
 282
 283 // PPVarArrayFromNPVariantArray ------------------------------------------------
 284
 285 PPVarArrayFromNPVariantArray::PPVarArrayFromNPVariantArray(
 286     PepperPluginInstanceImpl* instance,
 287     size_t size,
 288     const NPVariant* variants)
 289     : size_(size) {
 290   if (size_ > 0) {
 291     array_.reset(new PP_Var[size_]);
 292     for (size_t i = 0; i < size_; i++)
 293       array_[i] = NPVariantToPPVar(instance, &variants[i]);
 294   }
 295 }
 296
 297 PPVarArrayFromNPVariantArray::~PPVarArrayFromNPVariantArray() {
 298   ppapi::VarTracker* var_tracker = PpapiGlobals::Get()->GetVarTracker();
 299   for (size_t i = 0; i < size_; i++)
 300     var_tracker->ReleaseVar(array_[i]);
 301 }
 302
 303 // PPVarFromNPObject -----------------------------------------------------------
 304
 305 PPVarFromNPObject::PPVarFromNPObject(PepperPluginInstanceImpl* instance,
 306                                      NPObject* object)
 307     : var_(NPObjectToPPVar(instance, object)) {}
 308
 309 PPVarFromNPObject::~PPVarFromNPObject() {
 310   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(var_);
 311 }
 312
 313 // NPObjectAccessorWithIdentifier ----------------------------------------------
 314
 315 NPObjectAccessorWithIdentifier::NPObjectAccessorWithIdentifier(
 316     NPObject* object,
 317     NPIdentifier identifier,
 318     bool allow_integer_identifier)
 319     : object_(PluginObject::FromNPObject(object)),
 320       identifier_(PP_MakeUndefined()) {
 321   if (object_) {
 322     identifier_ = NPIdentifierToPPVar(identifier);
 323     if (identifier_.type == PP_VARTYPE_INT32 && !allow_integer_identifier)
 324       identifier_.type = PP_VARTYPE_UNDEFINED;  // Mark it invalid.
 325   }
 326 }
 327
 328 NPObjectAccessorWithIdentifier::~NPObjectAccessorWithIdentifier() {
 329   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(identifier_);
 330 }
 331
 332 // TryCatch --------------------------------------------------------------------
 333
 334 TryCatch::TryCatch(PP_Var* exception)
 335     : has_exception_(exception && exception->type != PP_VARTYPE_UNDEFINED),
 336       exception_(exception) {
 337   WebBindings::pushExceptionHandler(&TryCatch::Catch, this);
 338 }
 339
 340 TryCatch::~TryCatch() { WebBindings::popExceptionHandler(); }
 341
 342 void TryCatch::SetException(const char* message) {
 343   if (!has_exception()) {
 344     has_exception_ = true;
 345     if (exception_) {
 346       if (!message)
 347         message = "Unknown exception.";
 348       *exception_ = ppapi::StringVar::StringToPPVar(message, strlen(message));
 349     }
 350   }
 351 }
 352
 353 // static
 354 void TryCatch::Catch(void* self, const char* message) {
 355   static_cast<TryCatch*>(self)->SetException(message);
 356 }
 357
 358 }  // namespace content