1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "webkit/plugins/ppapi/npapi_glue.h"
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/string_util.h"
#include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
#include "webkit/plugins/ppapi/plugin_object.h"
#include "webkit/plugins/ppapi/var.h"
#include "third_party/npapi/bindings/npapi.h"
#include "third_party/npapi/bindings/npruntime.h"
#include "third_party/WebKit/Source/WebKit/chromium/public/WebBindings.h"
using WebKit::WebBindings;
namespace webkit {
namespace ppapi {
namespace {
const char kInvalidPluginValue[] = "Error: Plugin returned invalid value.";
} // namespace
// Utilities -------------------------------------------------------------------
bool PPVarToNPVariant(PP_Var var, NPVariant* result) {
switch (var.type) {
case PP_VARTYPE_UNDEFINED:
VOID_TO_NPVARIANT(*result);
break;
case PP_VARTYPE_NULL:
NULL_TO_NPVARIANT(*result);
break;
case PP_VARTYPE_BOOL:
BOOLEAN_TO_NPVARIANT(var.value.as_bool, *result);
break;
case PP_VARTYPE_INT32:
INT32_TO_NPVARIANT(var.value.as_int, *result);
break;
case PP_VARTYPE_DOUBLE:
DOUBLE_TO_NPVARIANT(var.value.as_double, *result);
break;
case PP_VARTYPE_STRING: {
scoped_refptr<StringVar> string(StringVar::FromPPVar(var));
if (!string) {
VOID_TO_NPVARIANT(*result);
return false;
}
const std::string& value = string->value();
STRINGN_TO_NPVARIANT(base::strdup(value.c_str()), value.size(), *result);
break;
}
case PP_VARTYPE_OBJECT: {
scoped_refptr<ObjectVar> object(ObjectVar::FromPPVar(var));
if (!object) {
VOID_TO_NPVARIANT(*result);
return false;
}
OBJECT_TO_NPVARIANT(WebBindings::retainObject(object->np_object()),
*result);
break;
}
case PP_VARTYPE_ARRAY:
case PP_VARTYPE_DICTIONARY:
VOID_TO_NPVARIANT(*result);
break;
}
return true;
}
// PPResultAndExceptionToNPResult ----------------------------------------------
PPResultAndExceptionToNPResult::PPResultAndExceptionToNPResult(
NPObject* object_var,
NPVariant* np_result)
: object_var_(object_var),
np_result_(np_result),
exception_(PP_MakeUndefined()),
success_(false),
checked_exception_(false) {
}
PPResultAndExceptionToNPResult::~PPResultAndExceptionToNPResult() {
// The user should have called SetResult or CheckExceptionForNoResult
// before letting this class go out of scope, or the exception will have
// been lost.
DCHECK(checked_exception_);
ObjectVar::PluginReleasePPVar(exception_);
}
// Call this with the return value of the PPAPI function. It will convert
// the result to the NPVariant output parameter and pass any exception on to
// the JS engine. It will update the success flag and return it.
bool PPResultAndExceptionToNPResult::SetResult(PP_Var result) {
DCHECK(!checked_exception_); // Don't call more than once.
DCHECK(np_result_); // Should be expecting a result.
checked_exception_ = true;
if (has_exception()) {
ThrowException();
success_ = false;
} else if (!PPVarToNPVariant(result, np_result_)) {
WebBindings::setException(object_var_, kInvalidPluginValue);
success_ = false;
} else {
success_ = true;
}
// No matter what happened, we need to release the reference to the
// value passed in. On success, a reference to this value will be in
// the np_result_.
Var::PluginReleasePPVar(result);
return success_;
}
// Call this after calling a PPAPI function that could have set the
// exception. It will pass the exception on to the JS engine and update
// the success flag.
//
// The success flag will be returned.
bool PPResultAndExceptionToNPResult::CheckExceptionForNoResult() {
DCHECK(!checked_exception_); // Don't call more than once.
DCHECK(!np_result_); // Can't have a result when doing this.
checked_exception_ = true;
if (has_exception()) {
ThrowException();
success_ = false;
return false;
}
success_ = true;
return true;
}
// Call this to ignore any exception. This prevents the DCHECK from failing
// in the destructor.
void PPResultAndExceptionToNPResult::IgnoreException() {
checked_exception_ = true;
}
// Throws the current exception to JS. The exception must be set.
void PPResultAndExceptionToNPResult::ThrowException() {
scoped_refptr<StringVar> string(StringVar::FromPPVar(exception_));
if (string) {
WebBindings::setException(object_var_, string->value().c_str());
}
}
// PPVarArrayFromNPVariantArray ------------------------------------------------
PPVarArrayFromNPVariantArray::PPVarArrayFromNPVariantArray(
PluginInstance* instance,
size_t size,
const NPVariant* variants)
: size_(size) {
if (size_ > 0) {
array_.reset(new PP_Var[size_]);
for (size_t i = 0; i < size_; i++)
array_[i] = Var::NPVariantToPPVar(instance, &variants[i]);
}
}
PPVarArrayFromNPVariantArray::~PPVarArrayFromNPVariantArray() {
for (size_t i = 0; i < size_; i++)
Var::PluginReleasePPVar(array_[i]);
}
// PPVarFromNPObject -----------------------------------------------------------
PPVarFromNPObject::PPVarFromNPObject(PluginInstance* instance, NPObject* object)
: var_(ObjectVar::NPObjectToPPVar(instance, object)) {
}
PPVarFromNPObject::~PPVarFromNPObject() {
Var::PluginReleasePPVar(var_);
}
// NPObjectAccessorWithIdentifier ----------------------------------------------
NPObjectAccessorWithIdentifier::NPObjectAccessorWithIdentifier(
NPObject* object,
NPIdentifier identifier,
bool allow_integer_identifier)
: object_(PluginObject::FromNPObject(object)),
identifier_(PP_MakeUndefined()) {
if (object_) {
identifier_ = Var::NPIdentifierToPPVar(object_->instance()->module(),
identifier);
if (identifier_.type == PP_VARTYPE_INT32 && !allow_integer_identifier)
identifier_.type = PP_VARTYPE_UNDEFINED; // Mark it invalid.
}
}
NPObjectAccessorWithIdentifier::~NPObjectAccessorWithIdentifier() {
Var::PluginReleasePPVar(identifier_);
}
} // namespace ppapi
} // namespace webkit
|
