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 "ppapi/cpp/var.h"
6
7 #include <stddef.h>
8 #include <stdio.h>
9 #include <string.h>
10
11 #include <algorithm>
12
13 #include "ppapi/c/pp_var.h"
14 #include "ppapi/c/ppb_var.h"
15 #include "ppapi/cpp/instance.h"
16 #include "ppapi/cpp/logging.h"
17 #include "ppapi/cpp/module.h"
18 #include "ppapi/cpp/module_impl.h"
19
20 // Define equivalent to snprintf on Windows.
21 #if defined(_MSC_VER)
22 # define snprintf sprintf_s
23 #endif
24
25 namespace pp {
26
27 namespace {
28
interface_name()29 template <> const char* interface_name<PPB_Var_1_2>() {
30 return PPB_VAR_INTERFACE_1_2;
31 }
interface_name()32 template <> const char* interface_name<PPB_Var_1_1>() {
33 return PPB_VAR_INTERFACE_1_1;
34 }
interface_name()35 template <> const char* interface_name<PPB_Var_1_0>() {
36 return PPB_VAR_INTERFACE_1_0;
37 }
38
39 // Technically you can call AddRef and Release on any Var, but it may involve
40 // cross-process calls depending on the plugin. This is an optimization so we
41 // only do refcounting on the necessary objects.
NeedsRefcounting(const PP_Var & var)42 inline bool NeedsRefcounting(const PP_Var& var) {
43 return var.type > PP_VARTYPE_DOUBLE;
44 }
45
46 // This helper function uses the latest available version of VarFromUtf8. Note
47 // that version 1.0 of this method has a different API to later versions.
VarFromUtf8Helper(const char * utf8_str,uint32_t len)48 PP_Var VarFromUtf8Helper(const char* utf8_str, uint32_t len) {
49 if (has_interface<PPB_Var_1_2>()) {
50 return get_interface<PPB_Var_1_2>()->VarFromUtf8(utf8_str, len);
51 } else if (has_interface<PPB_Var_1_1>()) {
52 return get_interface<PPB_Var_1_1>()->VarFromUtf8(utf8_str, len);
53 } else if (has_interface<PPB_Var_1_0>()) {
54 return get_interface<PPB_Var_1_0>()->VarFromUtf8(Module::Get()->pp_module(),
55 utf8_str,
56 len);
57 }
58 return PP_MakeNull();
59 }
60
61 // This helper function uses the latest available version of AddRef.
62 // Returns true on success, false if no appropriate interface was available.
AddRefHelper(const PP_Var & var)63 bool AddRefHelper(const PP_Var& var) {
64 if (has_interface<PPB_Var_1_2>()) {
65 get_interface<PPB_Var_1_2>()->AddRef(var);
66 return true;
67 } else if (has_interface<PPB_Var_1_1>()) {
68 get_interface<PPB_Var_1_1>()->AddRef(var);
69 return true;
70 } else if (has_interface<PPB_Var_1_0>()) {
71 get_interface<PPB_Var_1_0>()->AddRef(var);
72 return true;
73 }
74 return false;
75 }
76
77 // This helper function uses the latest available version of Release.
78 // Returns true on success, false if no appropriate interface was available.
ReleaseHelper(const PP_Var & var)79 bool ReleaseHelper(const PP_Var& var) {
80 if (has_interface<PPB_Var_1_2>()) {
81 get_interface<PPB_Var_1_2>()->Release(var);
82 return true;
83 } else if (has_interface<PPB_Var_1_1>()) {
84 get_interface<PPB_Var_1_1>()->Release(var);
85 return true;
86 } else if (has_interface<PPB_Var_1_0>()) {
87 get_interface<PPB_Var_1_0>()->Release(var);
88 return true;
89 }
90 return false;
91 }
92
93 } // namespace
94
Var()95 Var::Var() {
96 memset(&var_, 0, sizeof(var_));
97 var_.type = PP_VARTYPE_UNDEFINED;
98 is_managed_ = true;
99 }
100
Var(Null)101 Var::Var(Null) {
102 memset(&var_, 0, sizeof(var_));
103 var_.type = PP_VARTYPE_NULL;
104 is_managed_ = true;
105 }
106
Var(bool b)107 Var::Var(bool b) {
108 var_.type = PP_VARTYPE_BOOL;
109 var_.padding = 0;
110 var_.value.as_bool = PP_FromBool(b);
111 is_managed_ = true;
112 }
113
Var(int32_t i)114 Var::Var(int32_t i) {
115 var_.type = PP_VARTYPE_INT32;
116 var_.padding = 0;
117 var_.value.as_int = i;
118 is_managed_ = true;
119 }
120
Var(double d)121 Var::Var(double d) {
122 var_.type = PP_VARTYPE_DOUBLE;
123 var_.padding = 0;
124 var_.value.as_double = d;
125 is_managed_ = true;
126 }
127
Var(const char * utf8_str)128 Var::Var(const char* utf8_str) {
129 uint32_t len = utf8_str ? static_cast<uint32_t>(strlen(utf8_str)) : 0;
130 var_ = VarFromUtf8Helper(utf8_str, len);
131 is_managed_ = true;
132 }
133
Var(const std::string & utf8_str)134 Var::Var(const std::string& utf8_str) {
135 var_ = VarFromUtf8Helper(utf8_str.c_str(),
136 static_cast<uint32_t>(utf8_str.size()));
137 is_managed_ = true;
138 }
139
Var(const pp::Resource & resource)140 Var::Var(const pp::Resource& resource) {
141 if (has_interface<PPB_Var_1_2>()) {
142 var_ = get_interface<PPB_Var_1_2>()->VarFromResource(
143 resource.pp_resource());
144 } else {
145 PP_NOTREACHED();
146 return;
147 }
148 // Set |is_managed_| to true, so |var_| will be properly released upon
149 // destruction.
150 is_managed_ = true;
151 }
152
153
Var(const PP_Var & var)154 Var::Var(const PP_Var& var) {
155 var_ = var;
156 is_managed_ = true;
157 if (NeedsRefcounting(var_)) {
158 if (!AddRefHelper(var_))
159 var_.type = PP_VARTYPE_NULL;
160 }
161 }
162
Var(const Var & other)163 Var::Var(const Var& other) {
164 var_ = other.var_;
165 is_managed_ = true;
166 if (NeedsRefcounting(var_)) {
167 if (!AddRefHelper(var_))
168 var_.type = PP_VARTYPE_NULL;
169 }
170 }
171
~Var()172 Var::~Var() {
173 if (NeedsRefcounting(var_) && is_managed_)
174 ReleaseHelper(var_);
175 }
176
operator =(const Var & other)177 Var& Var::operator=(const Var& other) {
178 // Early return for self-assignment. Note however, that two distinct vars
179 // can refer to the same object, so we still need to be careful about the
180 // refcounting below.
181 if (this == &other)
182 return *this;
183
184 // Be careful to keep the ref alive for cases where we're assigning an
185 // object to itself by addrefing the new one before releasing the old one.
186 bool old_is_managed = is_managed_;
187 is_managed_ = true;
188 if (NeedsRefcounting(other.var_)) {
189 AddRefHelper(other.var_);
190 }
191 if (NeedsRefcounting(var_) && old_is_managed)
192 ReleaseHelper(var_);
193
194 var_ = other.var_;
195 return *this;
196 }
197
operator ==(const Var & other) const198 bool Var::operator==(const Var& other) const {
199 if (var_.type != other.var_.type)
200 return false;
201 switch (var_.type) {
202 case PP_VARTYPE_UNDEFINED:
203 case PP_VARTYPE_NULL:
204 return true;
205 case PP_VARTYPE_BOOL:
206 return AsBool() == other.AsBool();
207 case PP_VARTYPE_INT32:
208 return AsInt() == other.AsInt();
209 case PP_VARTYPE_DOUBLE:
210 return AsDouble() == other.AsDouble();
211 case PP_VARTYPE_STRING:
212 if (var_.value.as_id == other.var_.value.as_id)
213 return true;
214 return AsString() == other.AsString();
215 case PP_VARTYPE_OBJECT:
216 case PP_VARTYPE_ARRAY:
217 case PP_VARTYPE_ARRAY_BUFFER:
218 case PP_VARTYPE_DICTIONARY:
219 case PP_VARTYPE_RESOURCE:
220 default: // Objects, arrays, dictionaries, resources.
221 return var_.value.as_id == other.var_.value.as_id;
222 }
223 }
224
AsBool() const225 bool Var::AsBool() const {
226 if (!is_bool()) {
227 PP_NOTREACHED();
228 return false;
229 }
230 return PP_ToBool(var_.value.as_bool);
231 }
232
AsInt() const233 int32_t Var::AsInt() const {
234 if (is_int())
235 return var_.value.as_int;
236 if (is_double())
237 return static_cast<int>(var_.value.as_double);
238 PP_NOTREACHED();
239 return 0;
240 }
241
AsDouble() const242 double Var::AsDouble() const {
243 if (is_double())
244 return var_.value.as_double;
245 if (is_int())
246 return static_cast<double>(var_.value.as_int);
247 PP_NOTREACHED();
248 return 0.0;
249 }
250
AsString() const251 std::string Var::AsString() const {
252 if (!is_string()) {
253 PP_NOTREACHED();
254 return std::string();
255 }
256
257 uint32_t len;
258 const char* str;
259 if (has_interface<PPB_Var_1_2>())
260 str = get_interface<PPB_Var_1_2>()->VarToUtf8(var_, &len);
261 else if (has_interface<PPB_Var_1_1>())
262 str = get_interface<PPB_Var_1_1>()->VarToUtf8(var_, &len);
263 else if (has_interface<PPB_Var_1_0>())
264 str = get_interface<PPB_Var_1_0>()->VarToUtf8(var_, &len);
265 else
266 return std::string();
267 return std::string(str, len);
268 }
269
AsResource() const270 pp::Resource Var::AsResource() const {
271 if (!is_resource()) {
272 PP_NOTREACHED();
273 return pp::Resource();
274 }
275
276 if (has_interface<PPB_Var_1_2>()) {
277 return pp::Resource(pp::PASS_REF,
278 get_interface<PPB_Var_1_2>()->VarToResource(var_));
279 } else {
280 return pp::Resource();
281 }
282 }
283
DebugString() const284 std::string Var::DebugString() const {
285 char buf[256];
286 if (is_undefined()) {
287 snprintf(buf, sizeof(buf), "Var(UNDEFINED)");
288 } else if (is_null()) {
289 snprintf(buf, sizeof(buf), "Var(NULL)");
290 } else if (is_bool()) {
291 snprintf(buf, sizeof(buf), AsBool() ? "Var(true)" : "Var(false)");
292 } else if (is_int()) {
293 snprintf(buf, sizeof(buf), "Var(%d)", static_cast<int>(AsInt()));
294 } else if (is_double()) {
295 snprintf(buf, sizeof(buf), "Var(%f)", AsDouble());
296 } else if (is_string()) {
297 char format[] = "Var<'%s'>";
298 size_t decoration = sizeof(format) - 2; // The %s is removed.
299 size_t available = sizeof(buf) - decoration;
300 std::string str = AsString();
301 if (str.length() > available) {
302 str.resize(available - 3); // Reserve space for ellipsis.
303 str.append("...");
304 }
305 snprintf(buf, sizeof(buf), format, str.c_str());
306 } else if (is_object()) {
307 snprintf(buf, sizeof(buf), "Var(OBJECT)");
308 } else if (is_array()) {
309 snprintf(buf, sizeof(buf), "Var(ARRAY)");
310 } else if (is_dictionary()) {
311 snprintf(buf, sizeof(buf), "Var(DICTIONARY)");
312 } else if (is_array_buffer()) {
313 snprintf(buf, sizeof(buf), "Var(ARRAY_BUFFER)");
314 } else if (is_resource()) {
315 snprintf(buf, sizeof(buf), "Var(RESOURCE)");
316 } else {
317 buf[0] = '\0';
318 }
319 return buf;
320 }
321
322 } // namespace pp
323