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 "ppapi/cpp/dev/scriptable_object_deprecated.h" 6#include "ppapi/c/dev/ppb_memory_dev.h" 7#include "ppapi/c/dev/ppp_class_deprecated.h" 8#include "ppapi/cpp/module.h" 9#include "ppapi/cpp/var.h" 10 11namespace pp { 12 13namespace deprecated { 14 15namespace { 16 17// Allows converting an output param of a Var to an output param of a PP_Var 18// for exceptions. The object is only copied if it is not void, which we 19// take to mean an exception occurred. 20class ExceptionConverter { 21 public: 22 ExceptionConverter(PP_Var* out) : out_(out) { 23 } 24 ~ExceptionConverter() { 25 if (!exception_.is_undefined()) 26 *out_ = exception_.Detach(); 27 } 28 29 Var* Get() { return &exception_; } 30 31 private: 32 PP_Var* out_; 33 Var exception_; 34}; 35 36// Used internally to convert a C-style array of PP_Var to a vector of Var. 37void ArgListToVector(uint32_t argc, PP_Var* argv, std::vector<Var>* output) { 38 output->reserve(argc); 39 for (size_t i = 0; i < argc; i++) 40 output->push_back(Var(Var::DontManage(), argv[i])); 41} 42 43bool HasProperty(void* object, PP_Var name, PP_Var* exception) { 44 ExceptionConverter e(exception); 45 return static_cast<ScriptableObject*>(object)->HasProperty( 46 Var(Var::DontManage(), name), e.Get()); 47} 48 49bool HasMethod(void* object, PP_Var name, PP_Var* exception) { 50 ExceptionConverter e(exception); 51 return static_cast<ScriptableObject*>(object)->HasMethod( 52 Var(Var::DontManage(), name), e.Get()); 53} 54 55PP_Var GetProperty(void* object, 56 PP_Var name, 57 PP_Var* exception) { 58 ExceptionConverter e(exception); 59 return static_cast<ScriptableObject*>(object)->GetProperty( 60 Var(Var::DontManage(), name), e.Get()).Detach(); 61} 62 63void GetAllPropertyNames(void* object, 64 uint32_t* property_count, 65 PP_Var** properties, 66 PP_Var* exception) { 67 ExceptionConverter e(exception); 68 std::vector<Var> props; 69 static_cast<ScriptableObject*>(object)->GetAllPropertyNames(&props, e.Get()); 70 if (props.empty()) 71 return; 72 *property_count = static_cast<uint32_t>(props.size()); 73 74 const PPB_Memory_Dev* memory_if = static_cast<const PPB_Memory_Dev*>( 75 pp::Module::Get()->GetBrowserInterface(PPB_MEMORY_DEV_INTERFACE)); 76 *properties = static_cast<PP_Var*>( 77 memory_if->MemAlloc(sizeof(PP_Var) * props.size())); 78 79 for (size_t i = 0; i < props.size(); ++i) 80 (*properties)[i] = props[i].Detach(); 81} 82 83void SetProperty(void* object, 84 PP_Var name, 85 PP_Var value, 86 PP_Var* exception) { 87 ExceptionConverter e(exception); 88 static_cast<ScriptableObject*>(object)->SetProperty( 89 Var(Var::DontManage(), name), Var(Var::DontManage(), value), e.Get()); 90} 91 92void RemoveProperty(void* object, 93 PP_Var name, 94 PP_Var* exception) { 95 ExceptionConverter e(exception); 96 static_cast<ScriptableObject*>(object)->RemoveProperty( 97 Var(Var::DontManage(), name), e.Get()); 98} 99 100PP_Var Call(void* object, 101 PP_Var method_name, 102 uint32_t argc, 103 PP_Var* argv, 104 PP_Var* exception) { 105 ExceptionConverter e(exception); 106 107 std::vector<Var> args; 108 ArgListToVector(argc, argv, &args); 109 return static_cast<ScriptableObject*>(object)->Call( 110 Var(Var::DontManage(), method_name), args, e.Get()).Detach(); 111} 112 113PP_Var Construct(void* object, 114 uint32_t argc, 115 PP_Var* argv, 116 PP_Var* exception) { 117 ExceptionConverter e(exception); 118 119 std::vector<Var> args; 120 ArgListToVector(argc, argv, &args); 121 return static_cast<ScriptableObject*>(object)->Construct( 122 args, e.Get()).Detach(); 123} 124 125void Deallocate(void* object) { 126 delete static_cast<ScriptableObject*>(object); 127} 128 129PPP_Class_Deprecated plugin_class = { 130 &HasProperty, 131 &HasMethod, 132 &GetProperty, 133 &GetAllPropertyNames, 134 &SetProperty, 135 &RemoveProperty, 136 &Call, 137 &Construct, 138 &Deallocate 139}; 140 141} // namespace 142 143bool ScriptableObject::HasProperty(const Var& /*name*/, Var* /*exception*/) { 144 return false; 145} 146 147bool ScriptableObject::HasMethod(const Var& /*name*/, Var* /*exception*/) { 148 return false; 149} 150 151Var ScriptableObject::GetProperty(const Var& /*name*/, Var* exception) { 152 *exception = Var("Property does not exist on ScriptableObject"); 153 return Var(); 154} 155 156void ScriptableObject::GetAllPropertyNames(std::vector<Var>* /*properties*/, 157 Var* /*exception*/) { 158} 159 160void ScriptableObject::SetProperty(const Var& /*name*/, 161 const Var& /*value*/, 162 Var* exception) { 163 *exception = Var("Property can not be set on ScriptableObject"); 164} 165 166void ScriptableObject::RemoveProperty(const Var& /*name*/, 167 Var* exception) { 168 *exception = Var( 169 "Property does does not exist to be removed in ScriptableObject"); 170} 171 172Var ScriptableObject::Call(const Var& /*method_name*/, 173 const std::vector<Var>& /*args*/, 174 Var* exception) { 175 *exception = Var("Method does not exist to call in ScriptableObject"); 176 return Var(); 177} 178 179Var ScriptableObject::Construct(const std::vector<Var>& /*args*/, 180 Var* exception) { 181 *exception = Var("Construct method does not exist in ScriptableObject"); 182 return Var(); 183} 184 185// static 186const PPP_Class_Deprecated* ScriptableObject::GetClass() { 187 return &plugin_class; 188} 189 190} // namespace deprecated 191 192} // namespace pp 193