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
NPObjectToPPVarImpl(PepperPluginInstanceImpl * instance,NPObject * object,v8::Local<v8::Context> context)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
PPVarToNPVariant(PP_Var var,NPVariant * result)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
NPVariantToPPVar(PepperPluginInstanceImpl * instance,const NPVariant * variant)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
PPVarToNPIdentifier(PP_Var var)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
NPIdentifierToPPVar(NPIdentifier id)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
NPObjectToPPVar(PepperPluginInstanceImpl * instance,NPObject * object)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
NPObjectToPPVarForTest(PepperPluginInstanceImpl * instance,NPObject * object)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
PPResultAndExceptionToNPResult(NPObject * object_var,NPVariant * np_result)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
~PPResultAndExceptionToNPResult()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.
SetResult(PP_Var result)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.
CheckExceptionForNoResult()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.
IgnoreException()272 void PPResultAndExceptionToNPResult::IgnoreException() {
273 checked_exception_ = true;
274 }
275
276 // Throws the current exception to JS. The exception must be set.
ThrowException()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
PPVarArrayFromNPVariantArray(PepperPluginInstanceImpl * instance,size_t size,const NPVariant * variants)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
~PPVarArrayFromNPVariantArray()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
PPVarFromNPObject(PepperPluginInstanceImpl * instance,NPObject * object)305 PPVarFromNPObject::PPVarFromNPObject(PepperPluginInstanceImpl* instance,
306 NPObject* object)
307 : var_(NPObjectToPPVar(instance, object)) {}
308
~PPVarFromNPObject()309 PPVarFromNPObject::~PPVarFromNPObject() {
310 PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(var_);
311 }
312
313 // NPObjectAccessorWithIdentifier ----------------------------------------------
314
NPObjectAccessorWithIdentifier(NPObject * object,NPIdentifier identifier,bool allow_integer_identifier)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
~NPObjectAccessorWithIdentifier()328 NPObjectAccessorWithIdentifier::~NPObjectAccessorWithIdentifier() {
329 PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(identifier_);
330 }
331
332 // TryCatch --------------------------------------------------------------------
333
TryCatch(PP_Var * exception)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
~TryCatch()340 TryCatch::~TryCatch() { WebBindings::popExceptionHandler(); }
341
SetException(const char * message)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
Catch(void * self,const char * message)354 void TryCatch::Catch(void* self, const char* message) {
355 static_cast<TryCatch*>(self)->SetException(message);
356 }
357
358 } // namespace content
359