code.vuplus.com Git - vuplus_webkit/blob - Tools/DumpRenderTree/chromium/CppVariant.cpp

   1 /*
   2  * Copyright (C) 2010 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32 #include "CppVariant.h"
  33
  34 #include "WebBindings.h"
  35 #include <limits>
  36 #include <wtf/Assertions.h>
  37 #include <wtf/StringExtras.h>
  38
  39 using namespace WebKit;
  40 using namespace std;
  41
  42 CppVariant::CppVariant()
  43 {
  44     type = NPVariantType_Null;
  45 }
  46
  47 // Note that Set() performs a deep copy, which is necessary to safely
  48 // call FreeData() on the value in the destructor.
  49 CppVariant::CppVariant(const CppVariant& original)
  50 {
  51     type = NPVariantType_Null;
  52     set(original);
  53 }
  54
  55 // See comment for copy constructor, above.
  56 CppVariant& CppVariant::operator=(const CppVariant& original)
  57 {
  58     if (&original != this)
  59         set(original);
  60     return *this;
  61 }
  62
  63 CppVariant::~CppVariant()
  64 {
  65     freeData();
  66 }
  67
  68 void CppVariant::freeData()
  69 {
  70     WebBindings::releaseVariantValue(this);
  71 }
  72
  73 bool CppVariant::isEqual(const CppVariant& other) const
  74 {
  75     if (type != other.type)
  76         return false;
  77
  78     switch (type) {
  79     case NPVariantType_Bool:
  80         return (value.boolValue == other.value.boolValue);
  81     case NPVariantType_Int32:
  82         return (value.intValue == other.value.intValue);
  83     case NPVariantType_Double:
  84         return (value.doubleValue == other.value.doubleValue);
  85     case NPVariantType_String: {
  86         const NPString *this_value = &value.stringValue;
  87         const NPString *other_value = &other.value.stringValue;
  88         uint32_t len = this_value->UTF8Length;
  89         return len == other_value->UTF8Length
  90             && !strncmp(this_value->UTF8Characters,
  91                         other_value->UTF8Characters, len);
  92     }
  93     case NPVariantType_Null:
  94     case NPVariantType_Void:
  95         return true;
  96     case NPVariantType_Object: {
  97         NPObject* thisValue = value.objectValue;
  98         NPObject* otherValue = other.value.objectValue;
  99         return thisValue->_class == otherValue->_class
 100             && thisValue->referenceCount == otherValue->referenceCount;
 101     }
 102     }
 103     return false;
 104 }
 105
 106 void CppVariant::copyToNPVariant(NPVariant* result) const
 107 {
 108     result->type = type;
 109     switch (type) {
 110     case NPVariantType_Bool:
 111         result->value.boolValue = value.boolValue;
 112         break;
 113     case NPVariantType_Int32:
 114         result->value.intValue = value.intValue;
 115         break;
 116     case NPVariantType_Double:
 117         result->value.doubleValue = value.doubleValue;
 118         break;
 119     case NPVariantType_String:
 120         WebBindings::initializeVariantWithStringCopy(result, &value.stringValue);
 121         break;
 122     case NPVariantType_Null:
 123     case NPVariantType_Void:
 124         // Nothing to set.
 125         break;
 126     case NPVariantType_Object:
 127         result->type = NPVariantType_Object;
 128         result->value.objectValue = WebBindings::retainObject(value.objectValue);
 129         break;
 130     }
 131 }
 132
 133 void CppVariant::set(const NPVariant& newValue)
 134 {
 135     freeData();
 136     switch (newValue.type) {
 137     case NPVariantType_Bool:
 138         set(newValue.value.boolValue);
 139         break;
 140     case NPVariantType_Int32:
 141         set(newValue.value.intValue);
 142         break;
 143     case NPVariantType_Double:
 144         set(newValue.value.doubleValue);
 145         break;
 146     case NPVariantType_String:
 147         set(newValue.value.stringValue);
 148         break;
 149     case NPVariantType_Null:
 150     case NPVariantType_Void:
 151         type = newValue.type;
 152         break;
 153     case NPVariantType_Object:
 154         set(newValue.value.objectValue);
 155         break;
 156     }
 157 }
 158
 159 void CppVariant::setNull()
 160 {
 161     freeData();
 162     type = NPVariantType_Null;
 163 }
 164
 165 void CppVariant::set(bool newValue)
 166 {
 167     freeData();
 168     type = NPVariantType_Bool;
 169     value.boolValue = newValue;
 170 }
 171
 172 void CppVariant::set(int32_t newValue)
 173 {
 174     freeData();
 175     type = NPVariantType_Int32;
 176     value.intValue = newValue;
 177 }
 178
 179 void CppVariant::set(double newValue)
 180 {
 181     freeData();
 182     type = NPVariantType_Double;
 183     value.doubleValue = newValue;
 184 }
 185
 186 // The newValue must be a null-terminated string.
 187 void CppVariant::set(const char* newValue)
 188 {
 189     freeData();
 190     type = NPVariantType_String;
 191     NPString newString = {newValue,
 192                           static_cast<uint32_t>(strlen(newValue))};
 193     WebBindings::initializeVariantWithStringCopy(this, &newString);
 194 }
 195
 196 void CppVariant::set(const string& newValue)
 197 {
 198     freeData();
 199     type = NPVariantType_String;
 200     NPString newString = {newValue.data(),
 201                           static_cast<uint32_t>(newValue.size())};
 202     WebBindings::initializeVariantWithStringCopy(this, &newString);
 203 }
 204
 205 void CppVariant::set(const NPString& newValue)
 206 {
 207     freeData();
 208     type = NPVariantType_String;
 209     WebBindings::initializeVariantWithStringCopy(this, &newValue);
 210 }
 211
 212 void CppVariant::set(NPObject* newValue)
 213 {
 214     freeData();
 215     type = NPVariantType_Object;
 216     value.objectValue = WebBindings::retainObject(newValue);
 217 }
 218
 219 string CppVariant::toString() const
 220 {
 221     ASSERT(isString());
 222     return string(value.stringValue.UTF8Characters,
 223                   value.stringValue.UTF8Length);
 224 }
 225
 226 int32_t CppVariant::toInt32() const
 227 {
 228     if (isInt32())
 229         return value.intValue;
 230     if (isDouble())
 231         return static_cast<int32_t>(value.doubleValue);
 232     ASSERT_NOT_REACHED();
 233     return 0;
 234 }
 235
 236 double CppVariant::toDouble() const
 237 {
 238     if (isInt32())
 239         return static_cast<double>(value.intValue);
 240     if (isDouble())
 241         return value.doubleValue;
 242     ASSERT_NOT_REACHED();
 243     return 0;
 244 }
 245
 246 bool CppVariant::toBoolean() const
 247 {
 248     ASSERT(isBool());
 249     return value.boolValue;
 250 }
 251
 252 Vector<string> CppVariant::toStringVector() const
 253 {
 254
 255     ASSERT(isObject());
 256     Vector<string> stringVector;
 257     NPObject* npValue = value.objectValue;
 258     NPIdentifier lengthId = WebBindings::getStringIdentifier("length");
 259
 260     if (!WebBindings::hasProperty(0, npValue, lengthId))
 261         return stringVector;
 262
 263     NPVariant lengthValue;
 264     if (!WebBindings::getProperty(0, npValue, lengthId, &lengthValue))
 265         return stringVector;
 266
 267     int length = 0;
 268     // The length is a double in some cases.
 269     if (NPVARIANT_IS_DOUBLE(lengthValue))
 270         length = static_cast<int>(NPVARIANT_TO_DOUBLE(lengthValue));
 271     else if (NPVARIANT_IS_INT32(lengthValue))
 272         length = NPVARIANT_TO_INT32(lengthValue);
 273     WebBindings::releaseVariantValue(&lengthValue);
 274
 275     // For sanity, only allow 100 items.
 276     length = min(100, length);
 277     for (int i = 0; i < length; ++i) {
 278         // Get each of the items.
 279         char indexInChar[20]; // Enough size to store 32-bit integer
 280         snprintf(indexInChar, 20, "%d", i);
 281         string index(indexInChar);
 282         NPIdentifier indexId = WebBindings::getStringIdentifier(index.c_str());
 283         if (!WebBindings::hasProperty(0, npValue, indexId))
 284             continue;
 285         NPVariant indexValue;
 286         if (!WebBindings::getProperty(0, npValue, indexId, &indexValue))
 287             continue;
 288         if (NPVARIANT_IS_STRING(indexValue)) {
 289             string item(NPVARIANT_TO_STRING(indexValue).UTF8Characters,
 290                         NPVARIANT_TO_STRING(indexValue).UTF8Length);
 291             stringVector.append(item);
 292         }
 293         WebBindings::releaseVariantValue(&indexValue);
 294     }
 295     return stringVector;
 296 }
 297
 298 bool CppVariant::invoke(const string& method, const CppVariant* arguments,
 299                         uint32_t argumentCount, CppVariant& result) const
 300 {
 301     ASSERT(isObject());
 302     NPIdentifier methodName = WebBindings::getStringIdentifier(method.c_str());
 303     NPObject* npObject = value.objectValue;
 304     if (!WebBindings::hasMethod(0, npObject, methodName))
 305         return false;
 306     NPVariant r;
 307     bool status = WebBindings::invoke(0, npObject, methodName, arguments, argumentCount, &r);
 308     result.set(r);
 309     return status;
 310 }