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/shared_impl/var.h" 6 7 #include <limits> 8 9 #include "base/logging.h" 10 #include "base/strings/string_number_conversions.h" 11 #include "base/strings/string_util.h" 12 #include "base/strings/stringprintf.h" 13 #include "ppapi/c/pp_var.h" 14 #include "ppapi/shared_impl/ppapi_globals.h" 15 #include "ppapi/shared_impl/resource_var.h" 16 #include "ppapi/shared_impl/var_tracker.h" 17 18 namespace ppapi { 19 20 // Var ------------------------------------------------------------------------- 21 22 // static 23 std::string Var::PPVarToLogString(PP_Var var) { 24 switch (var.type) { 25 case PP_VARTYPE_UNDEFINED: 26 return "[Undefined]"; 27 case PP_VARTYPE_NULL: 28 return "[Null]"; 29 case PP_VARTYPE_BOOL: 30 return var.value.as_bool ? "[True]" : "[False]"; 31 case PP_VARTYPE_INT32: 32 return base::IntToString(var.value.as_int); 33 case PP_VARTYPE_DOUBLE: 34 return base::DoubleToString(var.value.as_double); 35 case PP_VARTYPE_STRING: { 36 StringVar* string(StringVar::FromPPVar(var)); 37 if (!string) 38 return "[Invalid string]"; 39 40 // Since this is for logging, escape NULLs, truncate length. 41 std::string result; 42 const size_t kTruncateAboveLength = 128; 43 if (string->value().size() > kTruncateAboveLength) 44 result = string->value().substr(0, kTruncateAboveLength) + "..."; 45 else 46 result = string->value(); 47 48 std::string null; 49 null.push_back(0); 50 ReplaceSubstringsAfterOffset(&result, 0, null, "\\0"); 51 return result; 52 } 53 case PP_VARTYPE_OBJECT: 54 return "[Object]"; 55 case PP_VARTYPE_ARRAY: 56 return "[Array]"; 57 case PP_VARTYPE_DICTIONARY: 58 return "[Dictionary]"; 59 case PP_VARTYPE_ARRAY_BUFFER: 60 return "[Array buffer]"; 61 case PP_VARTYPE_RESOURCE: { 62 ResourceVar* resource(ResourceVar::FromPPVar(var)); 63 if (!resource) 64 return "[Invalid resource]"; 65 66 if (resource->IsPending()) { 67 return base::StringPrintf("[Pending resource]"); 68 } else if (resource->GetPPResource()) { 69 return base::StringPrintf("[Resource %d]", resource->GetPPResource()); 70 } else { 71 return "[Null resource]"; 72 } 73 } 74 default: 75 return "[Invalid var]"; 76 } 77 } 78 79 StringVar* Var::AsStringVar() { 80 return NULL; 81 } 82 83 ArrayBufferVar* Var::AsArrayBufferVar() { 84 return NULL; 85 } 86 87 NPObjectVar* Var::AsNPObjectVar() { 88 return NULL; 89 } 90 91 ProxyObjectVar* Var::AsProxyObjectVar() { 92 return NULL; 93 } 94 95 ArrayVar* Var::AsArrayVar() { 96 return NULL; 97 } 98 99 DictionaryVar* Var::AsDictionaryVar() { 100 return NULL; 101 } 102 103 ResourceVar* Var::AsResourceVar() { 104 return NULL; 105 } 106 107 PP_Var Var::GetPPVar() { 108 int32 id = GetOrCreateVarID(); 109 if (!id) 110 return PP_MakeNull(); 111 112 PP_Var result; 113 result.type = GetType(); 114 result.padding = 0; 115 result.value.as_id = id; 116 return result; 117 } 118 119 int32 Var::GetExistingVarID() const { 120 return var_id_; 121 } 122 123 Var::Var() : var_id_(0) { 124 } 125 126 Var::~Var() { 127 } 128 129 int32 Var::GetOrCreateVarID() { 130 VarTracker* tracker = PpapiGlobals::Get()->GetVarTracker(); 131 if (var_id_) { 132 if (!tracker->AddRefVar(var_id_)) 133 return 0; 134 } else { 135 var_id_ = tracker->AddVar(this); 136 if (!var_id_) 137 return 0; 138 } 139 return var_id_; 140 } 141 142 void Var::AssignVarID(int32 id) { 143 DCHECK(!var_id_); // Must not have already been generated. 144 var_id_ = id; 145 } 146 147 // StringVar ------------------------------------------------------------------- 148 149 StringVar::StringVar() { 150 } 151 152 StringVar::StringVar(const std::string& str) 153 : value_(str) { 154 } 155 156 StringVar::StringVar(const char* str, uint32 len) 157 : value_(str, len) { 158 } 159 160 StringVar::~StringVar() { 161 } 162 163 StringVar* StringVar::AsStringVar() { 164 return this; 165 } 166 167 PP_VarType StringVar::GetType() const { 168 return PP_VARTYPE_STRING; 169 } 170 171 // static 172 PP_Var StringVar::StringToPPVar(const std::string& var) { 173 return StringToPPVar(var.c_str(), static_cast<uint32>(var.size())); 174 } 175 176 // static 177 PP_Var StringVar::StringToPPVar(const char* data, uint32 len) { 178 scoped_refptr<StringVar> str(new StringVar(data, len)); 179 if (!str.get() || !IsStringUTF8(str->value())) 180 return PP_MakeNull(); 181 return str->GetPPVar(); 182 } 183 184 // static 185 StringVar* StringVar::FromPPVar(PP_Var var) { 186 if (var.type != PP_VARTYPE_STRING) 187 return NULL; 188 scoped_refptr<Var> var_object( 189 PpapiGlobals::Get()->GetVarTracker()->GetVar(var)); 190 if (!var_object.get()) 191 return NULL; 192 return var_object->AsStringVar(); 193 } 194 195 // static 196 PP_Var StringVar::SwapValidatedUTF8StringIntoPPVar(std::string* src) { 197 scoped_refptr<StringVar> str(new StringVar); 198 str->value_.swap(*src); 199 return str->GetPPVar(); 200 } 201 202 // ArrayBufferVar -------------------------------------------------------------- 203 204 ArrayBufferVar::ArrayBufferVar() { 205 } 206 207 ArrayBufferVar::~ArrayBufferVar() { 208 } 209 210 ArrayBufferVar* ArrayBufferVar::AsArrayBufferVar() { 211 return this; 212 } 213 214 PP_VarType ArrayBufferVar::GetType() const { 215 return PP_VARTYPE_ARRAY_BUFFER; 216 } 217 218 // static 219 ArrayBufferVar* ArrayBufferVar::FromPPVar(PP_Var var) { 220 if (var.type != PP_VARTYPE_ARRAY_BUFFER) 221 return NULL; 222 scoped_refptr<Var> var_object( 223 PpapiGlobals::Get()->GetVarTracker()->GetVar(var)); 224 if (!var_object.get()) 225 return NULL; 226 return var_object->AsArrayBufferVar(); 227 } 228 229 } // namespace ppapi 230 231
