| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2006-2008 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 "gpu/np_utils/np_utils.h" | |
| 6 | |
| 7 namespace np_utils { | |
| 8 | |
| 9 bool NPVariantToValue(bool* value, const NPVariant& variant) { | |
| 10 if (NPVARIANT_IS_BOOLEAN(variant)) { | |
| 11 *value = NPVARIANT_TO_BOOLEAN(variant); | |
| 12 return true; | |
| 13 } | |
| 14 | |
| 15 return false; | |
| 16 } | |
| 17 | |
| 18 bool NPVariantToValue(int32* value, const NPVariant& variant) { | |
| 19 if (NPVARIANT_IS_INT32(variant)) { | |
| 20 *value = NPVARIANT_TO_INT32(variant); | |
| 21 return true; | |
| 22 } | |
| 23 | |
| 24 return false; | |
| 25 } | |
| 26 | |
| 27 bool NPVariantToValue(float* value, const NPVariant& variant) { | |
| 28 if (NPVARIANT_IS_DOUBLE(variant)) { | |
| 29 *value = static_cast<float>(NPVARIANT_TO_DOUBLE(variant)); | |
| 30 return true; | |
| 31 } else if (NPVARIANT_IS_INT32(variant)) { | |
| 32 *value = static_cast<float>(NPVARIANT_TO_INT32(variant)); | |
| 33 return true; | |
| 34 } | |
| 35 | |
| 36 return false; | |
| 37 } | |
| 38 | |
| 39 bool NPVariantToValue(double* value, const NPVariant& variant) { | |
| 40 if (NPVARIANT_IS_DOUBLE(variant)) { | |
| 41 *value = NPVARIANT_TO_DOUBLE(variant); | |
| 42 return true; | |
| 43 } else if (NPVARIANT_IS_INT32(variant)) { | |
| 44 *value = NPVARIANT_TO_INT32(variant); | |
| 45 return true; | |
| 46 } | |
| 47 | |
| 48 return false; | |
| 49 } | |
| 50 | |
| 51 bool NPVariantToValue(std::string* value, const NPVariant& variant) { | |
| 52 if (NPVARIANT_IS_STRING(variant)) { | |
| 53 const NPString& str = NPVARIANT_TO_STRING(variant); | |
| 54 *value = std::string(str.UTF8Characters, str.UTF8Length); | |
| 55 return true; | |
| 56 } | |
| 57 | |
| 58 return false; | |
| 59 } | |
| 60 | |
| 61 void ValueToNPVariant(bool value, NPVariant* variant) { | |
| 62 BOOLEAN_TO_NPVARIANT(value, *variant); | |
| 63 } | |
| 64 | |
| 65 void ValueToNPVariant(int32 value, NPVariant* variant) { | |
| 66 INT32_TO_NPVARIANT(value, *variant); | |
| 67 } | |
| 68 | |
| 69 void ValueToNPVariant(float value, NPVariant* variant) { | |
| 70 DOUBLE_TO_NPVARIANT(value, *variant); | |
| 71 } | |
| 72 | |
| 73 void ValueToNPVariant(double value, NPVariant* variant) { | |
| 74 DOUBLE_TO_NPVARIANT(value, *variant); | |
| 75 } | |
| 76 | |
| 77 void ValueToNPVariant(const std::string& value, NPVariant* variant) { | |
| 78 NPUTF8* p = static_cast<NPUTF8*>(NPBrowser::get()->MemAlloc(value.length())); | |
| 79 memcpy(p, value.c_str(), value.length()); | |
| 80 STRINGN_TO_NPVARIANT(p, value.length(), *variant); | |
| 81 } | |
| 82 | |
| 83 SmartNPVariant::SmartNPVariant() { | |
| 84 VOID_TO_NPVARIANT(*this); | |
| 85 } | |
| 86 | |
| 87 SmartNPVariant::SmartNPVariant(const SmartNPVariant& rhs) { | |
| 88 rhs.CopyTo(this); | |
| 89 } | |
| 90 | |
| 91 SmartNPVariant::SmartNPVariant(const NPVariant& rhs) { | |
| 92 static_cast<const SmartNPVariant&>(rhs).CopyTo(this); | |
| 93 } | |
| 94 | |
| 95 SmartNPVariant::~SmartNPVariant() { | |
| 96 Release(); | |
| 97 } | |
| 98 | |
| 99 SmartNPVariant& SmartNPVariant::operator=(const SmartNPVariant& rhs) { | |
| 100 Release(); | |
| 101 rhs.CopyTo(this); | |
| 102 return *this; | |
| 103 } | |
| 104 | |
| 105 SmartNPVariant& SmartNPVariant::operator=(const NPVariant& rhs) { | |
| 106 Release(); | |
| 107 static_cast<const SmartNPVariant&>(rhs).CopyTo(this); | |
| 108 return *this; | |
| 109 } | |
| 110 | |
| 111 bool SmartNPVariant::IsVoid() const { | |
| 112 return NPVARIANT_IS_VOID(*this); | |
| 113 } | |
| 114 | |
| 115 void SmartNPVariant::Release() { | |
| 116 NPBrowser::get()->ReleaseVariantValue(this); | |
| 117 VOID_TO_NPVARIANT(*this); | |
| 118 } | |
| 119 | |
| 120 void SmartNPVariant::Invalidate() { | |
| 121 if (NPVARIANT_IS_OBJECT(*this)) { | |
| 122 NULL_TO_NPVARIANT(*this); | |
| 123 } | |
| 124 } | |
| 125 | |
| 126 void SmartNPVariant::CopyTo(NPVariant* rhs) const { | |
| 127 if (NPVARIANT_IS_OBJECT(*this)) { | |
| 128 NPObject* object = NPVARIANT_TO_OBJECT(*this); | |
| 129 OBJECT_TO_NPVARIANT(object, *rhs); | |
| 130 NPBrowser::get()->RetainObject(object); | |
| 131 } else if (NPVARIANT_IS_STRING(*this)) { | |
| 132 NPUTF8* copy = static_cast<NPUTF8*>(NPBrowser::get()->MemAlloc( | |
| 133 value.stringValue.UTF8Length)); | |
| 134 memcpy(copy, | |
| 135 value.stringValue.UTF8Characters, | |
| 136 value.stringValue.UTF8Length); | |
| 137 STRINGN_TO_NPVARIANT(copy, value.stringValue.UTF8Length, *rhs); | |
| 138 } else { | |
| 139 memcpy(rhs, this, sizeof(*rhs)); | |
| 140 } | |
| 141 } | |
| 142 | |
| 143 bool NPHasMethod(NPP npp, | |
| 144 const NPObjectPointer<NPObject>& object, | |
| 145 const NPUTF8* name) { | |
| 146 return NPBrowser::get()->HasMethod( | |
| 147 npp, | |
| 148 object.Get(), | |
| 149 NPBrowser::get()->GetStringIdentifier(name)); | |
| 150 } | |
| 151 | |
| 152 bool NPHasProperty(NPP npp, | |
| 153 const NPObjectPointer<NPObject>& object, | |
| 154 const NPUTF8* name) { | |
| 155 return NPBrowser::get()->HasProperty( | |
| 156 npp, | |
| 157 object.Get(), | |
| 158 NPBrowser::get()->GetStringIdentifier(name)); | |
| 159 } | |
| 160 | |
| 161 bool NPRemoveProperty(NPP npp, | |
| 162 const NPObjectPointer<NPObject>& object, | |
| 163 const NPUTF8* name) { | |
| 164 return NPBrowser::get()->RemoveProperty( | |
| 165 npp, | |
| 166 object.Get(), | |
| 167 NPBrowser::get()->GetStringIdentifier(name)); | |
| 168 } | |
| 169 | |
| 170 } // namespace np_utils | |
| OLD | NEW |
|---|
Chromium Code Reviews
