| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2006-2008 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 #ifndef GPU_NP_UTILS_NP_UTILS_H_ | |
| 6 #define GPU_NP_UTILS_NP_UTILS_H_ | |
| 7 | |
| 8 #include <string> | |
| 9 | |
| 10 #include "gpu/np_utils/np_browser.h" | |
| 11 #include "gpu/np_utils/np_class.h" | |
| 12 #include "gpu/np_utils/np_object_pointer.h" | |
| 13 #include "gpu/np_utils/np_headers.h" | |
| 14 | |
| 15 namespace np_utils { | |
| 16 | |
| 17 // Convert NPVariant to C++ type. Returns whether the conversion was successful. | |
| 18 bool NPVariantToValue(bool* value, const NPVariant& variant); | |
| 19 bool NPVariantToValue(int32* value, const NPVariant& variant); | |
| 20 bool NPVariantToValue(float* value, const NPVariant& variant); | |
| 21 bool NPVariantToValue(double* value, const NPVariant& variant); | |
| 22 bool NPVariantToValue(std::string* value, const NPVariant& variant); | |
| 23 | |
| 24 template <typename T> | |
| 25 bool NPVariantToValue(NPObjectPointer<T>* value, | |
| 26 const NPVariant& variant) { | |
| 27 if (NPVARIANT_IS_NULL(variant)) { | |
| 28 *value = NPObjectPointer<T>(); | |
| 29 return true; | |
| 30 } else if (NPVARIANT_IS_OBJECT(variant)) { | |
| 31 NPObject* object = NPVARIANT_TO_OBJECT(variant); | |
| 32 if (object->_class == NPGetClass<T>()) { | |
| 33 *value = NPObjectPointer<T>(static_cast<T*>( | |
| 34 NPVARIANT_TO_OBJECT(variant))); | |
| 35 return true; | |
| 36 } | |
| 37 } | |
| 38 | |
| 39 return false; | |
| 40 } | |
| 41 | |
| 42 // Specialization for NPObject does not check for mismatched NPClass. | |
| 43 template <> | |
| 44 inline bool NPVariantToValue(NPObjectPointer<NPObject>* value, | |
| 45 const NPVariant& variant) { | |
| 46 if (NPVARIANT_IS_NULL(variant)) { | |
| 47 *value = NPObjectPointer<NPObject>(); | |
| 48 return true; | |
| 49 } else if (NPVARIANT_IS_OBJECT(variant)) { | |
| 50 *value = NPObjectPointer<NPObject>(NPVARIANT_TO_OBJECT(variant)); | |
| 51 return true; | |
| 52 } | |
| 53 | |
| 54 return false; | |
| 55 } | |
| 56 | |
| 57 // Convert C++ type to NPVariant. | |
| 58 void ValueToNPVariant(bool value, NPVariant* variant); | |
| 59 void ValueToNPVariant(int32 value, NPVariant* variant); | |
| 60 void ValueToNPVariant(float value, NPVariant* variant); | |
| 61 void ValueToNPVariant(double value, NPVariant* variant); | |
| 62 void ValueToNPVariant(const std::string& value, NPVariant* variant); | |
| 63 | |
| 64 template <typename T> | |
| 65 void ValueToNPVariant(const NPObjectPointer<T>& value, | |
| 66 NPVariant* variant) { | |
| 67 if (value.Get()) { | |
| 68 NPBrowser::get()->RetainObject(value.Get()); | |
| 69 OBJECT_TO_NPVARIANT(value.Get(), *variant); | |
| 70 } else { | |
| 71 NULL_TO_NPVARIANT(*variant); | |
| 72 } | |
| 73 } | |
| 74 | |
| 75 // NPVariant that automatically manages lifetime of string and object variants. | |
| 76 class SmartNPVariant : public NPVariant { | |
| 77 public: | |
| 78 SmartNPVariant(); | |
| 79 SmartNPVariant(const SmartNPVariant& rhs); | |
| 80 explicit SmartNPVariant(const NPVariant& rhs); | |
| 81 | |
| 82 template <typename T> | |
| 83 explicit SmartNPVariant(const T& v) { | |
| 84 ValueToNPVariant(v, this); | |
| 85 } | |
| 86 | |
| 87 ~SmartNPVariant(); | |
| 88 | |
| 89 SmartNPVariant& operator=(const SmartNPVariant& rhs); | |
| 90 SmartNPVariant& operator=(const NPVariant& rhs); | |
| 91 | |
| 92 template <typename T> | |
| 93 bool GetValue(T* v) const { | |
| 94 return NPVariantToValue(v, *this); | |
| 95 } | |
| 96 | |
| 97 bool IsVoid() const; | |
| 98 | |
| 99 template <typename T> | |
| 100 void SetValue(const T& v) { | |
| 101 Release(); | |
| 102 ValueToNPVariant(v, this); | |
| 103 } | |
| 104 | |
| 105 void CopyTo(NPVariant* target) const; | |
| 106 | |
| 107 // Sets the variant to void. | |
| 108 void Release(); | |
| 109 | |
| 110 // Called when an NPObject is invalidated to clear any references to other | |
| 111 // NPObjects. Does not release the object as it might no longer be valid. | |
| 112 void Invalidate(); | |
| 113 }; | |
| 114 | |
| 115 // These allow a method to be invoked with automatic conversion of C++ | |
| 116 // types to variants for arguments and return values. | |
| 117 | |
| 118 bool NPHasMethod(NPP npp, | |
| 119 const NPObjectPointer<NPObject>& object, | |
| 120 const NPUTF8* name); | |
| 121 | |
| 122 inline bool NPInvokeVoid(NPP npp, | |
| 123 const NPObjectPointer<NPObject>& object, | |
| 124 const NPUTF8* name) { | |
| 125 SmartNPVariant result; | |
| 126 return NPBrowser::get()->Invoke( | |
| 127 npp, | |
| 128 object.Get(), | |
| 129 NPBrowser::get()->GetStringIdentifier(name), | |
| 130 NULL, 0, | |
| 131 &result); | |
| 132 } | |
| 133 | |
| 134 template<typename R> | |
| 135 bool NPInvoke(NPP npp, | |
| 136 const NPObjectPointer<NPObject>& object, | |
| 137 const NPUTF8* name, | |
| 138 R* r) { | |
| 139 SmartNPVariant result; | |
| 140 if (NPBrowser::get()->Invoke( | |
| 141 npp, | |
| 142 object.Get(), | |
| 143 NPBrowser::get()->GetStringIdentifier(name), | |
| 144 NULL, 0, | |
| 145 &result)) { | |
| 146 return result.GetValue(r); | |
| 147 } | |
| 148 return false; | |
| 149 } | |
| 150 | |
| 151 template<typename P0> | |
| 152 bool NPInvokeVoid(NPP npp, | |
| 153 const NPObjectPointer<NPObject>& object, | |
| 154 const NPUTF8* name, | |
| 155 P0 p0) { | |
| 156 SmartNPVariant args[1]; | |
| 157 args[0].SetValue(p0); | |
| 158 SmartNPVariant result; | |
| 159 return NPBrowser::get()->Invoke( | |
| 160 npp, | |
| 161 object.Get(), | |
| 162 NPBrowser::get()->GetStringIdentifier(name), | |
| 163 &args[0], 1, | |
| 164 &result); | |
| 165 } | |
| 166 | |
| 167 template<typename R, typename P0> | |
| 168 bool NPInvoke(NPP npp, | |
| 169 const NPObjectPointer<NPObject>& object, | |
| 170 const NPUTF8* name, | |
| 171 P0 p0, | |
| 172 R* r) { | |
| 173 SmartNPVariant args[1]; | |
| 174 args[0].SetValue(p0); | |
| 175 SmartNPVariant result; | |
| 176 if (NPBrowser::get()->Invoke( | |
| 177 npp, | |
| 178 object.Get(), | |
| 179 NPBrowser::get()->GetStringIdentifier(name), | |
| 180 &args[0], 1, | |
| 181 &result)) { | |
| 182 return result.GetValue(r); | |
| 183 } | |
| 184 return false; | |
| 185 } | |
| 186 | |
| 187 template<typename P0, typename P1> | |
| 188 bool NPInvokeVoid(NPP npp, | |
| 189 const NPObjectPointer<NPObject>& object, | |
| 190 const NPUTF8* name, | |
| 191 P0 p0, P1 p1) { | |
| 192 SmartNPVariant args[2]; | |
| 193 args[0].SetValue(p0); | |
| 194 args[1].SetValue(p1); | |
| 195 SmartNPVariant result; | |
| 196 return NPBrowser::get()->Invoke( | |
| 197 npp, | |
| 198 object.Get(), | |
| 199 NPBrowser::get()->GetStringIdentifier(name), | |
| 200 &args[0], 2, | |
| 201 &result); | |
| 202 } | |
| 203 | |
| 204 template<typename R, typename P0, typename P1> | |
| 205 bool NPInvoke(NPP npp, | |
| 206 const NPObjectPointer<NPObject>& object, | |
| 207 const NPUTF8* name, | |
| 208 P0 p0, P1 p1, | |
| 209 R* r) { | |
| 210 SmartNPVariant args[2]; | |
| 211 args[0].SetValue(p0); | |
| 212 args[1].SetValue(p1); | |
| 213 SmartNPVariant result; | |
| 214 if (NPBrowser::get()->Invoke( | |
| 215 npp, | |
| 216 object.Get(), | |
| 217 NPBrowser::get()->GetStringIdentifier(name), | |
| 218 &args[0], 2, | |
| 219 &result)) { | |
| 220 return result.GetValue(r); | |
| 221 } | |
| 222 return false; | |
| 223 } | |
| 224 | |
| 225 bool NPHasProperty(NPP npp, | |
| 226 const NPObjectPointer<NPObject>& object, | |
| 227 const NPUTF8* name); | |
| 228 | |
| 229 template <typename T> | |
| 230 bool NPGetProperty(NPP npp, | |
| 231 const NPObjectPointer<NPObject>& object, | |
| 232 const NPUTF8* name, | |
| 233 T* value) { | |
| 234 SmartNPVariant result; | |
| 235 if (NPBrowser::get()->GetProperty(npp, | |
| 236 object.Get(), | |
| 237 NPBrowser::get()->GetStringIdentifier(name), | |
| 238 &result)) { | |
| 239 return result.GetValue(value); | |
| 240 } | |
| 241 return false; | |
| 242 } | |
| 243 | |
| 244 template <typename T> | |
| 245 bool NPSetProperty(NPP npp, | |
| 246 const NPObjectPointer<NPObject>& object, | |
| 247 const NPUTF8* name, | |
| 248 const T& value) { | |
| 249 SmartNPVariant variant(value); | |
| 250 return NPBrowser::get()->SetProperty( | |
| 251 npp, | |
| 252 object.Get(), | |
| 253 NPBrowser::get()->GetStringIdentifier(name), | |
| 254 &variant); | |
| 255 } | |
| 256 | |
| 257 bool NPRemoveProperty(NPP npp, | |
| 258 const NPObjectPointer<NPObject>& object, | |
| 259 const NPUTF8* name); | |
| 260 | |
| 261 template <typename NPObjectType> | |
| 262 NPObjectPointer<NPObjectType> NPCreateObject(NPP npp) { | |
| 263 const NPClass* np_class = NPGetClass<NPObjectType>(); | |
| 264 NPObjectType* object = static_cast<NPObjectType*>( | |
| 265 NPBrowser::get()->CreateObject(npp, np_class)); | |
| 266 return NPObjectPointer<NPObjectType>::FromReturned(object); | |
| 267 } | |
| 268 | |
| 269 } // namespace np_utils | |
| 270 | |
| 271 #endif // GPU_NP_UTILS_NP_UTILS_H_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
