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 <stdio.h>
8 #include <string.h>
9
10 #include <algorithm>
11
12 #include "ppapi/c/pp_var.h"
13 #include "ppapi/c/ppb_var.h"
14 #include "ppapi/cpp/instance.h"
15 #include "ppapi/cpp/logging.h"
16 #include "ppapi/cpp/module.h"
17 #include "ppapi/cpp/module_impl.h"
18
19 // Define equivalent to snprintf on Windows.
20 #if defined(_MSC_VER)
21 # define snprintf sprintf_s
22 #endif
23
24 namespace pp {
25
26 namespace {
27
interface_name()28 template <> const char* interface_name<PPB_Var_1_1>() {
29 return PPB_VAR_INTERFACE_1_1;
30 }
interface_name()31 template <> const char* interface_name<PPB_Var_1_0>() {
32 return PPB_VAR_INTERFACE_1_0;
33 }
34
35 // Technically you can call AddRef and Release on any Var, but it may involve
36 // cross-process calls depending on the plugin. This is an optimization so we
37 // only do refcounting on the necessary objects.
NeedsRefcounting(const PP_Var & var)38 inline bool NeedsRefcounting(const PP_Var& var) {
39 return var.type > PP_VARTYPE_DOUBLE;
40 }
41
42 // This helper function detects whether PPB_Var version 1.1 is available. If so,
43 // it uses it to create a PP_Var for the given string. Otherwise it falls back
44 // to PPB_Var version 1.0.
VarFromUtf8Helper(const char * utf8_str,uint32_t len)45 PP_Var VarFromUtf8Helper(const char* utf8_str, uint32_t len) {
46 if (has_interface<PPB_Var_1_1>()) {
47 return get_interface<PPB_Var_1_1>()->VarFromUtf8(utf8_str, len);
48 } else if (has_interface<PPB_Var_1_0>()) {
49 return get_interface<PPB_Var_1_0>()->VarFromUtf8(Module::Get()->pp_module(),
50 utf8_str,
51 len);
52 } else {
53 return PP_MakeNull();
54 }
55 }
56
57 } // namespace
58
Var()59 Var::Var() {
60 memset(&var_, 0, sizeof(var_));
61 var_.type = PP_VARTYPE_UNDEFINED;
62 is_managed_ = true;
63 }
64
Var(Null)65 Var::Var(Null) {
66 memset(&var_, 0, sizeof(var_));
67 var_.type = PP_VARTYPE_NULL;
68 is_managed_ = true;
69 }
70
Var(bool b)71 Var::Var(bool b) {
72 var_.type = PP_VARTYPE_BOOL;
73 var_.padding = 0;
74 var_.value.as_bool = PP_FromBool(b);
75 is_managed_ = true;
76 }
77
Var(int32_t i)78 Var::Var(int32_t i) {
79 var_.type = PP_VARTYPE_INT32;
80 var_.padding = 0;
81 var_.value.as_int = i;
82 is_managed_ = true;
83 }
84
Var(double d)85 Var::Var(double d) {
86 var_.type = PP_VARTYPE_DOUBLE;
87 var_.padding = 0;
88 var_.value.as_double = d;
89 is_managed_ = true;
90 }
91
Var(const char * utf8_str)92 Var::Var(const char* utf8_str) {
93 uint32_t len = utf8_str ? static_cast<uint32_t>(strlen(utf8_str)) : 0;
94 var_ = VarFromUtf8Helper(utf8_str, len);
95 is_managed_ = true;
96 }
97
Var(const std::string & utf8_str)98 Var::Var(const std::string& utf8_str) {
99 var_ = VarFromUtf8Helper(utf8_str.c_str(),
100 static_cast<uint32_t>(utf8_str.size()));
101 is_managed_ = true;
102 }
103
104
Var(const PP_Var & var)105 Var::Var(const PP_Var& var) {
106 var_ = var;
107 is_managed_ = true;
108 if (NeedsRefcounting(var_)) {
109 if (has_interface<PPB_Var_1_0>())
110 get_interface<PPB_Var_1_0>()->AddRef(var_);
111 else
112 var_.type = PP_VARTYPE_NULL;
113 }
114 }
115
Var(const Var & other)116 Var::Var(const Var& other) {
117 var_ = other.var_;
118 is_managed_ = true;
119 if (NeedsRefcounting(var_)) {
120 if (has_interface<PPB_Var_1_0>())
121 get_interface<PPB_Var_1_0>()->AddRef(var_);
122 else
123 var_.type = PP_VARTYPE_NULL;
124 }
125 }
126
~Var()127 Var::~Var() {
128 if (NeedsRefcounting(var_) &&
129 is_managed_ &&
130 has_interface<PPB_Var_1_0>())
131 get_interface<PPB_Var_1_0>()->Release(var_);
132 }
133
operator =(const Var & other)134 Var& Var::operator=(const Var& other) {
135 // Early return for self-assignment. Note however, that two distinct vars
136 // can refer to the same object, so we still need to be careful about the
137 // refcounting below.
138 if (this == &other)
139 return *this;
140
141 // Be careful to keep the ref alive for cases where we're assigning an
142 // object to itself by addrefing the new one before releasing the old one.
143 bool old_is_managed = is_managed_;
144 is_managed_ = true;
145 if (NeedsRefcounting(other.var_)) {
146 // Assume we already has_interface<PPB_Var_1_0> for refcounted vars or else
147 // we couldn't have created them in the first place.
148 get_interface<PPB_Var_1_0>()->AddRef(other.var_);
149 }
150 if (NeedsRefcounting(var_) && old_is_managed)
151 get_interface<PPB_Var_1_0>()->Release(var_);
152
153 var_ = other.var_;
154 return *this;
155 }
156
operator ==(const Var & other) const157 bool Var::operator==(const Var& other) const {
158 if (var_.type != other.var_.type)
159 return false;
160 switch (var_.type) {
161 case PP_VARTYPE_UNDEFINED:
162 case PP_VARTYPE_NULL:
163 return true;
164 case PP_VARTYPE_BOOL:
165 return AsBool() == other.AsBool();
166 case PP_VARTYPE_INT32:
167 return AsInt() == other.AsInt();
168 case PP_VARTYPE_DOUBLE:
169 return AsDouble() == other.AsDouble();
170 case PP_VARTYPE_STRING:
171 if (var_.value.as_id == other.var_.value.as_id)
172 return true;
173 return AsString() == other.AsString();
174 case PP_VARTYPE_OBJECT:
175 case PP_VARTYPE_ARRAY:
176 case PP_VARTYPE_ARRAY_BUFFER:
177 case PP_VARTYPE_DICTIONARY:
178 default: // Objects, arrays, dictionaries.
179 return var_.value.as_id == other.var_.value.as_id;
180 }
181 }
182
AsBool() const183 bool Var::AsBool() const {
184 if (!is_bool()) {
185 PP_NOTREACHED();
186 return false;
187 }
188 return PP_ToBool(var_.value.as_bool);
189 }
190
AsInt() const191 int32_t Var::AsInt() const {
192 if (is_int())
193 return var_.value.as_int;
194 if (is_double())
195 return static_cast<int>(var_.value.as_double);
196 PP_NOTREACHED();
197 return 0;
198 }
199
AsDouble() const200 double Var::AsDouble() const {
201 if (is_double())
202 return var_.value.as_double;
203 if (is_int())
204 return static_cast<double>(var_.value.as_int);
205 PP_NOTREACHED();
206 return 0.0;
207 }
208
AsString() const209 std::string Var::AsString() const {
210 if (!is_string()) {
211 PP_NOTREACHED();
212 return std::string();
213 }
214
215 if (!has_interface<PPB_Var_1_0>())
216 return std::string();
217 uint32_t len;
218 const char* str = get_interface<PPB_Var_1_0>()->VarToUtf8(var_, &len);
219 return std::string(str, len);
220 }
221
DebugString() const222 std::string Var::DebugString() const {
223 char buf[256];
224 if (is_undefined()) {
225 snprintf(buf, sizeof(buf), "Var(UNDEFINED)");
226 } else if (is_null()) {
227 snprintf(buf, sizeof(buf), "Var(NULL)");
228 } else if (is_bool()) {
229 snprintf(buf, sizeof(buf), AsBool() ? "Var(true)" : "Var(false)");
230 } else if (is_int()) {
231 snprintf(buf, sizeof(buf), "Var(%d)", static_cast<int>(AsInt()));
232 } else if (is_double()) {
233 snprintf(buf, sizeof(buf), "Var(%f)", AsDouble());
234 } else if (is_string()) {
235 char format[] = "Var<'%s'>";
236 size_t decoration = sizeof(format) - 2; // The %s is removed.
237 size_t available = sizeof(buf) - decoration;
238 std::string str = AsString();
239 if (str.length() > available) {
240 str.resize(available - 3); // Reserve space for ellipsis.
241 str.append("...");
242 }
243 snprintf(buf, sizeof(buf), format, str.c_str());
244 } else if (is_object()) {
245 snprintf(buf, sizeof(buf), "Var(OBJECT)");
246 } else if (is_array()) {
247 snprintf(buf, sizeof(buf), "Var(ARRAY)");
248 } else if (is_dictionary()) {
249 snprintf(buf, sizeof(buf), "Var(DICTIONARY)");
250 } else if (is_array_buffer()) {
251 snprintf(buf, sizeof(buf), "Var(ARRAY_BUFFER)");
252 } else {
253 buf[0] = '\0';
254 }
255 return buf;
256 }
257
258 } // namespace pp
259