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() { return NULL; } 80 81 ArrayBufferVar* Var::AsArrayBufferVar() { return NULL; } 82 83 V8ObjectVar* Var::AsV8ObjectVar() { return NULL; } 84 85 ProxyObjectVar* Var::AsProxyObjectVar() { return NULL; } 86 87 ArrayVar* Var::AsArrayVar() { return NULL; } 88 89 DictionaryVar* Var::AsDictionaryVar() { return NULL; } 90 91 ResourceVar* Var::AsResourceVar() { return NULL; } 92 93 PP_Var Var::GetPPVar() { 94 int32 id = GetOrCreateVarID(); 95 if (!id) 96 return PP_MakeNull(); 97 98 PP_Var result; 99 result.type = GetType(); 100 result.padding = 0; 101 result.value.as_id = id; 102 return result; 103 } 104 105 int32 Var::GetExistingVarID() const { return var_id_; } 106 107 Var::Var() : var_id_(0) {} 108 109 Var::~Var() {} 110 111 int32 Var::GetOrCreateVarID() { 112 VarTracker* tracker = PpapiGlobals::Get()->GetVarTracker(); 113 if (var_id_) { 114 if (!tracker->AddRefVar(var_id_)) 115 return 0; 116 } else { 117 var_id_ = tracker->AddVar(this); 118 if (!var_id_) 119 return 0; 120 } 121 return var_id_; 122 } 123 124 void Var::AssignVarID(int32 id) { 125 DCHECK(!var_id_); // Must not have already been generated. 126 var_id_ = id; 127 } 128 129 // StringVar ------------------------------------------------------------------- 130 131 StringVar::StringVar() {} 132 133 StringVar::StringVar(const std::string& str) : value_(str) {} 134 135 StringVar::StringVar(const char* str, uint32 len) : value_(str, len) {} 136 137 StringVar::~StringVar() {} 138 139 StringVar* StringVar::AsStringVar() { return this; } 140 141 PP_VarType StringVar::GetType() const { return PP_VARTYPE_STRING; } 142 143 // static 144 PP_Var StringVar::StringToPPVar(const std::string& var) { 145 return StringToPPVar(var.c_str(), static_cast<uint32>(var.size())); 146 } 147 148 // static 149 PP_Var StringVar::StringToPPVar(const char* data, uint32 len) { 150 scoped_refptr<StringVar> str(new StringVar(data, len)); 151 if (!str.get() || !base::IsStringUTF8(str->value())) 152 return PP_MakeNull(); 153 return str->GetPPVar(); 154 } 155 156 // static 157 StringVar* StringVar::FromPPVar(PP_Var var) { 158 if (var.type != PP_VARTYPE_STRING) 159 return NULL; 160 scoped_refptr<Var> var_object( 161 PpapiGlobals::Get()->GetVarTracker()->GetVar(var)); 162 if (!var_object.get()) 163 return NULL; 164 return var_object->AsStringVar(); 165 } 166 167 // static 168 PP_Var StringVar::SwapValidatedUTF8StringIntoPPVar(std::string* src) { 169 scoped_refptr<StringVar> str(new StringVar); 170 str->value_.swap(*src); 171 return str->GetPPVar(); 172 } 173 174 // ArrayBufferVar -------------------------------------------------------------- 175 176 ArrayBufferVar::ArrayBufferVar() {} 177 178 ArrayBufferVar::~ArrayBufferVar() {} 179 180 ArrayBufferVar* ArrayBufferVar::AsArrayBufferVar() { return this; } 181 182 PP_VarType ArrayBufferVar::GetType() const { return PP_VARTYPE_ARRAY_BUFFER; } 183 184 // static 185 ArrayBufferVar* ArrayBufferVar::FromPPVar(PP_Var var) { 186 if (var.type != PP_VARTYPE_ARRAY_BUFFER) 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->AsArrayBufferVar(); 193 } 194 195 } // namespace ppapi 196
