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 // This file contains definitions for CppVariant. 6 7 #include <limits> 8 #include "base/logging.h" 9 #include "base/strings/string_util.h" 10 #include "base/strings/stringprintf.h" 11 #include "base/strings/utf_string_conversions.h" 12 #include "third_party/WebKit/public/web/WebBindings.h" 13 #include "webkit/renderer/cpp_variant.h" 14 15 using blink::WebBindings; 16 17 namespace webkit_glue { 18 19 CppVariant::CppVariant() { 20 type = NPVariantType_Null; 21 } 22 23 // Note that Set() performs a deep copy, which is necessary to safely 24 // call FreeData() on the value in the destructor. 25 CppVariant::CppVariant(const CppVariant& original) { 26 type = NPVariantType_Null; 27 Set(original); 28 } 29 30 // See comment for copy constructor, above. 31 CppVariant& CppVariant::operator=(const CppVariant& original) { 32 if (&original != this) 33 Set(original); 34 return *this; 35 } 36 37 CppVariant::~CppVariant() { 38 FreeData(); 39 } 40 41 void CppVariant::FreeData() { 42 WebBindings::releaseVariantValue(this); 43 } 44 45 bool CppVariant::isEqual(const CppVariant& other) const { 46 if (type != other.type) 47 return false; 48 49 switch (type) { 50 case NPVariantType_Bool: { 51 return (value.boolValue == other.value.boolValue); 52 } 53 case NPVariantType_Int32: { 54 return (value.intValue == other.value.intValue); 55 } 56 case NPVariantType_Double: { 57 return (value.doubleValue == other.value.doubleValue); 58 } 59 case NPVariantType_String: { 60 const NPString *this_value = &value.stringValue; 61 const NPString *other_value = &other.value.stringValue; 62 uint32_t len = this_value->UTF8Length; 63 return (len == other_value->UTF8Length && 64 !strncmp(this_value->UTF8Characters, other_value->UTF8Characters, 65 len)); 66 } 67 case NPVariantType_Null: 68 case NPVariantType_Void: { 69 return true; 70 } 71 case NPVariantType_Object: { 72 NPObject *this_value = value.objectValue; 73 NPObject *other_value = other.value.objectValue; 74 return (this_value->_class == other_value->_class && 75 this_value->referenceCount == other_value->referenceCount); 76 } 77 } 78 return false; 79 } 80 81 void CppVariant::CopyToNPVariant(NPVariant* result) const { 82 result->type = type; 83 switch (type) { 84 case NPVariantType_Bool: 85 result->value.boolValue = value.boolValue; 86 break; 87 case NPVariantType_Int32: 88 result->value.intValue = value.intValue; 89 break; 90 case NPVariantType_Double: 91 result->value.doubleValue = value.doubleValue; 92 break; 93 case NPVariantType_String: 94 WebBindings::initializeVariantWithStringCopy(result, &value.stringValue); 95 break; 96 case NPVariantType_Null: 97 case NPVariantType_Void: 98 // Nothing to set. 99 break; 100 case NPVariantType_Object: 101 result->type = NPVariantType_Object; 102 result->value.objectValue = WebBindings::retainObject(value.objectValue); 103 break; 104 } 105 } 106 107 void CppVariant::Set(const NPVariant& new_value) { 108 FreeData(); 109 switch (new_value.type) { 110 case NPVariantType_Bool: 111 Set(new_value.value.boolValue); 112 break; 113 case NPVariantType_Int32: 114 Set(new_value.value.intValue); 115 break; 116 case NPVariantType_Double: 117 Set(new_value.value.doubleValue); 118 break; 119 case NPVariantType_String: 120 Set(new_value.value.stringValue); 121 break; 122 case NPVariantType_Null: 123 case NPVariantType_Void: 124 type = new_value.type; 125 break; 126 case NPVariantType_Object: 127 Set(new_value.value.objectValue); 128 break; 129 } 130 } 131 132 void CppVariant::SetNull() { 133 FreeData(); 134 type = NPVariantType_Null; 135 } 136 137 void CppVariant::Set(bool new_value) { 138 FreeData(); 139 type = NPVariantType_Bool; 140 value.boolValue = new_value; 141 } 142 143 void CppVariant::Set(int32_t new_value) { 144 FreeData(); 145 type = NPVariantType_Int32; 146 value.intValue = new_value; 147 } 148 149 void CppVariant::Set(double new_value) { 150 FreeData(); 151 type = NPVariantType_Double; 152 value.doubleValue = new_value; 153 } 154 155 // The new_value must be a null-terminated string. 156 void CppVariant::Set(const char* new_value) { 157 FreeData(); 158 type = NPVariantType_String; 159 NPString new_string = {new_value, 160 static_cast<uint32_t>(strlen(new_value))}; 161 WebBindings::initializeVariantWithStringCopy(this, &new_string); 162 } 163 164 void CppVariant::Set(const std::string& new_value) { 165 FreeData(); 166 type = NPVariantType_String; 167 NPString new_string = {new_value.data(), 168 static_cast<uint32_t>(new_value.size())}; 169 WebBindings::initializeVariantWithStringCopy(this, &new_string); 170 } 171 void CppVariant::Set(const NPString& new_value) { 172 FreeData(); 173 type = NPVariantType_String; 174 WebBindings::initializeVariantWithStringCopy(this, &new_value); 175 } 176 177 void CppVariant::Set(NPObject* new_value) { 178 FreeData(); 179 type = NPVariantType_Object; 180 value.objectValue = WebBindings::retainObject(new_value); 181 } 182 183 std::string CppVariant::ToString() const { 184 DCHECK(isString()); 185 return std::string(value.stringValue.UTF8Characters, 186 value.stringValue.UTF8Length); 187 } 188 189 int32_t CppVariant::ToInt32() const { 190 if (isInt32()) { 191 return value.intValue; 192 } else if (isDouble()) { 193 return static_cast<int32_t>(value.doubleValue); 194 } else { 195 NOTREACHED(); 196 return 0; 197 } 198 } 199 200 double CppVariant::ToDouble() const { 201 if (isInt32()) { 202 return static_cast<double>(value.intValue); 203 } else if (isDouble()) { 204 return value.doubleValue; 205 } else { 206 NOTREACHED(); 207 return 0.0; 208 } 209 } 210 211 bool CppVariant::ToBoolean() const { 212 DCHECK(isBool()); 213 return value.boolValue; 214 } 215 216 std::vector<CppVariant> CppVariant::ToVector() const { 217 DCHECK(isObject()); 218 std::vector<CppVariant> vector; 219 NPObject* np_value = value.objectValue; 220 NPIdentifier length_id = WebBindings::getStringIdentifier("length"); 221 222 if (WebBindings::hasProperty(NULL, np_value, length_id)) { 223 CppVariant length_value; 224 if (WebBindings::getProperty(NULL, np_value, length_id, &length_value)) { 225 int length = 0; 226 // The length is a double in some cases. 227 if (NPVARIANT_IS_DOUBLE(length_value)) 228 length = static_cast<int>(NPVARIANT_TO_DOUBLE(length_value)); 229 else if (NPVARIANT_IS_INT32(length_value)) 230 length = NPVARIANT_TO_INT32(length_value); 231 else 232 NOTREACHED(); 233 234 // For sanity, only allow 60000 items. 235 length = std::min(60000, length); 236 for (int i = 0; i < length; ++i) { 237 // Get each of the items. 238 NPIdentifier index = WebBindings::getIntIdentifier(i); 239 if (WebBindings::hasProperty(NULL, np_value, index)) { 240 CppVariant index_value; 241 if (WebBindings::getProperty(NULL, np_value, index, &index_value)) 242 vector.push_back(index_value); 243 } 244 } 245 } 246 } else { 247 NOTREACHED(); 248 } 249 return vector; 250 } 251 252 bool CppVariant::Invoke(const std::string& method, const CppVariant* args, 253 uint32 arg_count, CppVariant& result) const { 254 DCHECK(isObject()); 255 NPIdentifier method_name = WebBindings::getStringIdentifier(method.c_str()); 256 NPObject* np_object = value.objectValue; 257 if (WebBindings::hasMethod(NULL, np_object, method_name)) { 258 NPVariant r; 259 bool status = 260 WebBindings::invoke(NULL, np_object, method_name, args, arg_count, &r); 261 result.Set(r); 262 return status; 263 } else { 264 return false; 265 } 266 } 267 268 } // namespace webkit_glue 269
