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