content/renderer/pepper/ppb_var_deprecated_impl.cc

   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/host_globals.h"
  10 #include "content/renderer/pepper/message_channel.h"
  11 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
  12 #include "content/renderer/pepper/pepper_try_catch.h"
  13 #include "content/renderer/pepper/plugin_module.h"
  14 #include "content/renderer/pepper/plugin_object.h"
  15 #include "content/renderer/pepper/v8object_var.h"
  16 #include "ppapi/c/dev/ppb_var_deprecated.h"
  17 #include "ppapi/c/ppb_var.h"
  18 #include "ppapi/shared_impl/ppb_var_shared.h"
  19 #include "third_party/WebKit/public/web/WebDocument.h"
  20 #include "third_party/WebKit/public/web/WebElement.h"
  21 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  22 #include "third_party/WebKit/public/web/WebPluginContainer.h"
  23 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
  24
  25 using ppapi::V8ObjectVar;
  26 using ppapi::PpapiGlobals;
  27 using ppapi::ScopedPPVar;
  28 using ppapi::ScopedPPVarArray;
  29 using ppapi::StringVar;
  30 using ppapi::Var;
  31
  32 namespace content {
  33
  34 namespace {
  35
  36 const char kInvalidIdentifierException[] = "Error: Invalid identifier.";
  37 const char kInvalidObjectException[] = "Error: Invalid object";
  38 const char kUnableToCallMethodException[] = "Error: Unable to call method";
  39
  40 class ObjectAccessor {
  41  public:
  42   ObjectAccessor(PP_Var var)
  43       : object_var_(V8ObjectVar::FromPPVar(var).get()),
  44         instance_(object_var_ ? object_var_->instance() : NULL) {
  45     if (instance_) {
  46       converter_.reset(new V8VarConverter(instance_->pp_instance(),
  47                                           V8VarConverter::kAllowObjectVars));
  48     }
  49   }
  50
  51   // Check if the object is valid. If it isn't, set an exception and return
  52   // false.
  53   bool IsValid(PP_Var* exception) {
  54     // If we already have an exception, then the call is invalid according to
  55     // the unittests.
  56     if (exception && exception->type != PP_VARTYPE_UNDEFINED)
  57       return false;
  58     if (instance_)
  59       return true;
  60     if (exception)
  61       *exception = ppapi::StringVar::StringToPPVar(kInvalidObjectException);
  62     return false;
  63   }
  64   // Lazily grab the object so that the handle is created in the current handle
  65   // scope.
  66   v8::Handle<v8::Object> GetObject() { return object_var_->GetHandle(); }
  67   PepperPluginInstanceImpl* instance() { return instance_; }
  68   V8VarConverter* converter() { return converter_.get(); }
  69
  70  private:
  71   V8ObjectVar* object_var_;
  72   PepperPluginInstanceImpl* instance_;
  73   scoped_ptr<V8VarConverter> converter_;
  74 };
  75
  76 bool IsValidIdentifer(PP_Var identifier, PP_Var* exception) {
  77   if (identifier.type == PP_VARTYPE_INT32 ||
  78       identifier.type == PP_VARTYPE_STRING) {
  79     return true;
  80   }
  81   if (exception)
  82     *exception = ppapi::StringVar::StringToPPVar(kInvalidIdentifierException);
  83   return false;
  84 }
  85
  86 bool HasPropertyDeprecated(PP_Var var, PP_Var name, PP_Var* exception) {
  87   ObjectAccessor accessor(var);
  88   if (!accessor.IsValid(exception) || !IsValidIdentifer(name, exception))
  89     return false;
  90
  91   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
  92                               exception);
  93   v8::Handle<v8::Value> v8_name = try_catch.ToV8(name);
  94   if (try_catch.HasException())
  95     return false;
  96
  97   bool result = accessor.GetObject()->Has(v8_name);
  98   if (try_catch.HasException())
  99     return false;
 100   return result;
 101 }
 102
 103 bool HasMethodDeprecated(PP_Var var, PP_Var name, PP_Var* exception) {
 104   ObjectAccessor accessor(var);
 105   if (!accessor.IsValid(exception) || !IsValidIdentifer(name, exception))
 106     return false;
 107
 108   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
 109                               exception);
 110   v8::Handle<v8::Value> v8_name = try_catch.ToV8(name);
 111   if (try_catch.HasException())
 112     return false;
 113
 114   bool result = accessor.GetObject()->Has(v8_name) &&
 115       accessor.GetObject()->Get(v8_name)->IsFunction();
 116   if (try_catch.HasException())
 117     return false;
 118   return result;
 119 }
 120
 121 PP_Var GetProperty(PP_Var var, PP_Var name, PP_Var* exception) {
 122   ObjectAccessor accessor(var);
 123   if (!accessor.IsValid(exception) || !IsValidIdentifer(name, exception))
 124     return PP_MakeUndefined();
 125
 126   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
 127                               exception);
 128   v8::Handle<v8::Value> v8_name = try_catch.ToV8(name);
 129   if (try_catch.HasException())
 130     return PP_MakeUndefined();
 131
 132   ScopedPPVar result_var = try_catch.FromV8(accessor.GetObject()->Get(v8_name));
 133   if (try_catch.HasException())
 134     return PP_MakeUndefined();
 135
 136   return result_var.Release();
 137 }
 138
 139 void EnumerateProperties(PP_Var var,
 140                          uint32_t* property_count,
 141                          PP_Var** properties,
 142                          PP_Var* exception) {
 143   ObjectAccessor accessor(var);
 144   if (!accessor.IsValid(exception))
 145     return;
 146
 147   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
 148                               exception);
 149
 150   *properties = NULL;
 151   *property_count = 0;
 152
 153   v8::Local<v8::Array> identifiers = accessor.GetObject()->GetPropertyNames();
 154   if (try_catch.HasException())
 155     return;
 156   ScopedPPVarArray identifier_vars(identifiers->Length());
 157   for (uint32_t i = 0; i < identifiers->Length(); ++i) {
 158     ScopedPPVar var = try_catch.FromV8(identifiers->Get(i));
 159     if (try_catch.HasException())
 160       return;
 161     identifier_vars.Set(i, var);
 162   }
 163
 164   size_t size = identifier_vars.size();
 165   *properties = identifier_vars.Release(
 166       ScopedPPVarArray::PassPPBMemoryAllocatedArray());
 167   *property_count = size;
 168 }
 169
 170 void SetPropertyDeprecated(PP_Var var,
 171                            PP_Var name,
 172                            PP_Var value,
 173                            PP_Var* exception) {
 174   ObjectAccessor accessor(var);
 175   if (!accessor.IsValid(exception) || !IsValidIdentifer(name, exception))
 176     return;
 177
 178   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
 179                               exception);
 180   v8::Handle<v8::Value> v8_name = try_catch.ToV8(name);
 181   v8::Handle<v8::Value> v8_value = try_catch.ToV8(value);
 182
 183   if (try_catch.HasException())
 184     return;
 185
 186   accessor.GetObject()->Set(v8_name, v8_value);
 187   try_catch.HasException();  // Ensure an exception gets set if one occured.
 188 }
 189
 190 void DeletePropertyDeprecated(PP_Var var, PP_Var name, PP_Var* exception) {
 191   ObjectAccessor accessor(var);
 192   if (!accessor.IsValid(exception) || !IsValidIdentifer(name, exception))
 193     return;
 194
 195   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
 196                               exception);
 197   v8::Handle<v8::Value> v8_name = try_catch.ToV8(name);
 198
 199   if (try_catch.HasException())
 200     return;
 201
 202   accessor.GetObject()->Delete(v8_name);
 203   try_catch.HasException();  // Ensure an exception gets set if one occured.
 204 }
 205
 206 PP_Var CallDeprecatedInternal(PP_Var var,
 207                               PP_Var method_name,
 208                               uint32_t argc,
 209                               PP_Var* argv,
 210                               PP_Var* exception) {
 211   ObjectAccessor accessor(var);
 212   if (!accessor.IsValid(exception))
 213     return PP_MakeUndefined();
 214
 215   // If the method name is undefined, set it to the empty string to trigger
 216   // calling |var| as a function.
 217   ScopedPPVar scoped_name(method_name);
 218   if (method_name.type == PP_VARTYPE_UNDEFINED) {
 219     scoped_name = ScopedPPVar(ScopedPPVar::PassRef(),
 220                                 StringVar::StringToPPVar(""));
 221   }
 222
 223   PepperTryCatchVar try_catch(accessor.instance(), accessor.converter(),
 224                               exception);
 225   v8::Handle<v8::Value> v8_method_name = try_catch.ToV8(scoped_name.get());
 226   if (try_catch.HasException())
 227     return PP_MakeUndefined();
 228
 229   if (!v8_method_name->IsString()) {
 230     try_catch.SetException(kUnableToCallMethodException);
 231     return PP_MakeUndefined();
 232   }
 233
 234   v8::Handle<v8::Object> function = accessor.GetObject();
 235   v8::Handle<v8::Object> recv =
 236       accessor.instance()->GetMainWorldContext()->Global();
 237   if (v8_method_name.As<v8::String>()->Length() != 0) {
 238     function = function->Get(v8_method_name)
 239                    ->ToObject(accessor.instance()->GetIsolate());
 240     recv = accessor.GetObject();
 241   }
 242
 243   if (try_catch.HasException())
 244     return PP_MakeUndefined();
 245
 246   if (!function->IsFunction()) {
 247     try_catch.SetException(kUnableToCallMethodException);
 248     return PP_MakeUndefined();
 249   }
 250
 251 #ifdef WEB_FRAME_USES_V8_LOCAL
 252   scoped_ptr<v8::Local<v8::Value>[]> converted_args(
 253       new v8::Local<v8::Value>[argc]);
 254 #else
 255   scoped_ptr<v8::Handle<v8::Value>[] > converted_args(
 256       new v8::Handle<v8::Value>[argc]);
 257 #endif
 258
 259   for (uint32_t i = 0; i < argc; ++i) {
 260     converted_args[i] = try_catch.ToV8(argv[i]);
 261     if (try_catch.HasException())
 262       return PP_MakeUndefined();
 263   }
 264
 265   blink::WebPluginContainer* container = accessor.instance()->container();
 266   blink::WebLocalFrame* frame = NULL;
 267   if (container)
 268     frame = container->element().document().frame();
 269
 270   if (!frame) {
 271     try_catch.SetException("No frame to execute script in.");
 272     return PP_MakeUndefined();
 273   }
 274
 275   v8::Handle<v8::Value> result = frame->callFunctionEvenIfScriptDisabled(
 276       function.As<v8::Function>(), recv, argc, converted_args.get());
 277   ScopedPPVar result_var = try_catch.FromV8(result);
 278
 279   if (try_catch.HasException())
 280     return PP_MakeUndefined();
 281
 282   return result_var.Release();
 283 }
 284
 285 PP_Var CallDeprecated(PP_Var var,
 286                       PP_Var method_name,
 287                       uint32_t argc,
 288                       PP_Var* argv,
 289                       PP_Var* exception) {
 290   ObjectAccessor accessor(var);
 291   if (accessor.instance() && accessor.instance()->IsProcessingUserGesture()) {
 292     blink::WebScopedUserGesture user_gesture(
 293         accessor.instance()->CurrentUserGestureToken());
 294     return CallDeprecatedInternal(var, method_name, argc, argv, exception);
 295   }
 296   return CallDeprecatedInternal(var, method_name, argc, argv, exception);
 297 }
 298
 299 PP_Var Construct(PP_Var var, uint32_t argc, PP_Var* argv, PP_Var* exception) {
 300   // Deprecated.
 301   NOTREACHED();
 302   return PP_MakeUndefined();
 303 }
 304
 305 bool IsInstanceOfDeprecated(PP_Var var,
 306                             const PPP_Class_Deprecated* ppp_class,
 307                             void** ppp_class_data) {
 308   scoped_refptr<V8ObjectVar> object(V8ObjectVar::FromPPVar(var));
 309   if (!object.get())
 310     return false;  // Not an object at all.
 311
 312   v8::HandleScope handle_scope(object->instance()->GetIsolate());
 313   v8::Handle<v8::Context> context = object->instance()->GetMainWorldContext();
 314   if (context.IsEmpty())
 315     return false;
 316   v8::Context::Scope context_scope(context);
 317   PluginObject* plugin_object = PluginObject::FromV8Object(
 318       object->instance()->GetIsolate(), object->GetHandle());
 319   if (plugin_object && plugin_object->ppp_class() == ppp_class) {
 320     if (ppp_class_data)
 321       *ppp_class_data = plugin_object->ppp_class_data();
 322     return true;
 323   }
 324
 325   return false;
 326 }
 327
 328 PP_Var CreateObjectDeprecated(PP_Instance pp_instance,
 329                               const PPP_Class_Deprecated* ppp_class,
 330                               void* ppp_class_data) {
 331   PepperPluginInstanceImpl* instance =
 332       HostGlobals::Get()->GetInstance(pp_instance);
 333   if (!instance) {
 334     DLOG(ERROR) << "Create object passed an invalid instance.";
 335     return PP_MakeNull();
 336   }
 337   return PluginObject::Create(instance, ppp_class, ppp_class_data);
 338 }
 339
 340 PP_Var CreateObjectWithModuleDeprecated(PP_Module pp_module,
 341                                         const PPP_Class_Deprecated* ppp_class,
 342                                         void* ppp_class_data) {
 343   PluginModule* module = HostGlobals::Get()->GetModule(pp_module);
 344   if (!module)
 345     return PP_MakeNull();
 346   return PluginObject::Create(
 347       module->GetSomeInstance(), ppp_class, ppp_class_data);
 348 }
 349
 350 }  // namespace
 351
 352 // static
 353 const PPB_Var_Deprecated* PPB_Var_Deprecated_Impl::GetVarDeprecatedInterface() {
 354   static const PPB_Var_Deprecated var_deprecated_interface = {
 355       ppapi::PPB_Var_Shared::GetVarInterface1_0()->AddRef,
 356       ppapi::PPB_Var_Shared::GetVarInterface1_0()->Release,
 357       ppapi::PPB_Var_Shared::GetVarInterface1_0()->VarFromUtf8,
 358       ppapi::PPB_Var_Shared::GetVarInterface1_0()->VarToUtf8,
 359       &HasPropertyDeprecated,
 360       &HasMethodDeprecated,
 361       &GetProperty,
 362       &EnumerateProperties,
 363       &SetPropertyDeprecated,
 364       &DeletePropertyDeprecated,
 365       &CallDeprecated,
 366       &Construct,
 367       &IsInstanceOfDeprecated,
 368       &CreateObjectDeprecated,
 369       &CreateObjectWithModuleDeprecated, };
 370
 371   return &var_deprecated_interface;
 372 }
 373
 374 }  // namespace content