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