← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/webkit/WebCore/bridge/npruntime.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/webkit/WebCore/bridge/npruntime.cpp
27
27
 
28
28
#if ENABLE(NETSCAPE_PLUGIN_API)
29
29
 
 
30
#include "IdentifierRep.h"
30
31
#include "npruntime_internal.h"
31
32
#include "npruntime_impl.h"
32
33
#include "npruntime_priv.h"
38
39
#include <wtf/HashMap.h>
39
40
 
40
41
using namespace JSC::Bindings;
41
 
 
42
 
typedef HashMap<RefPtr<JSC::UString::Rep>, PrivateIdentifier*> StringIdentifierMap;
43
 
 
44
 
static StringIdentifierMap* getStringIdentifierMap()
45
 
{
46
 
    static StringIdentifierMap* stringIdentifierMap = 0;
47
 
    if (!stringIdentifierMap)
48
 
        stringIdentifierMap = new StringIdentifierMap;
49
 
    return stringIdentifierMap;
50
 
}
51
 
 
52
 
typedef HashMap<int, PrivateIdentifier*> IntIdentifierMap;
53
 
 
54
 
static IntIdentifierMap* getIntIdentifierMap()
55
 
{
56
 
    static IntIdentifierMap* intIdentifierMap = 0;
57
 
    if (!intIdentifierMap)
58
 
        intIdentifierMap = new IntIdentifierMap;
59
 
    return intIdentifierMap;
60
 
}
 
42
using namespace WebCore;
61
43
 
62
44
NPIdentifier _NPN_GetStringIdentifier(const NPUTF8* name)
63
45
{
64
 
    ASSERT(name);
65
 
    
66
 
    if (name) {
67
 
        PrivateIdentifier* identifier = 0;
68
 
        
69
 
        JSC::JSLock lock(false);
70
 
        
71
 
        identifier = getStringIdentifierMap()->get(identifierFromNPIdentifier(name).ustring().rep());
72
 
        if (identifier == 0) {
73
 
            identifier = (PrivateIdentifier*)malloc(sizeof(PrivateIdentifier));
74
 
            // We never release identifier names, so this dictionary will grow, as will
75
 
            // the memory for the identifier name strings.
76
 
            identifier->isString = true;
77
 
            identifier->value.string = strdup(name);
78
 
 
79
 
            getStringIdentifierMap()->set(identifierFromNPIdentifier(name).ustring().rep(), identifier);
80
 
        }
81
 
        return (NPIdentifier)identifier;
82
 
    }
83
 
    
84
 
    return 0;
 
46
    return static_cast<NPIdentifier>(IdentifierRep::get(name));
85
47
}
86
48
 
87
49
void _NPN_GetStringIdentifiers(const NPUTF8** names, int32_t nameCount, NPIdentifier* identifiers)
89
51
    ASSERT(names);
90
52
    ASSERT(identifiers);
91
53
    
92
 
    if (names && identifiers)
 
54
    if (names && identifiers) {
93
55
        for (int i = 0; i < nameCount; i++)
94
56
            identifiers[i] = _NPN_GetStringIdentifier(names[i]);
 
57
    }
95
58
}
96
59
 
97
60
NPIdentifier _NPN_GetIntIdentifier(int32_t intid)
98
61
{
99
 
    PrivateIdentifier* identifier;
100
 
 
101
 
    if (intid == 0 || intid == -1) {
102
 
        static PrivateIdentifier* negativeOneAndZeroIdentifiers[2];
103
 
 
104
 
        identifier = negativeOneAndZeroIdentifiers[intid + 1];
105
 
        if (!identifier) {
106
 
            identifier = (PrivateIdentifier*)malloc(sizeof(PrivateIdentifier));
107
 
            identifier->isString = false;
108
 
            identifier->value.number = intid;
109
 
 
110
 
            negativeOneAndZeroIdentifiers[intid + 1] = identifier;
111
 
        }
112
 
    } else {
113
 
        identifier = getIntIdentifierMap()->get(intid);
114
 
        if (!identifier) {
115
 
            identifier = (PrivateIdentifier*)malloc(sizeof(PrivateIdentifier));
116
 
            // We never release identifier names, so this dictionary will grow.
117
 
            identifier->isString = false;
118
 
            identifier->value.number = intid;
119
 
 
120
 
            getIntIdentifierMap()->set(intid, identifier);
121
 
        }
122
 
    }
123
 
    return (NPIdentifier)identifier;
 
62
    return static_cast<NPIdentifier>(IdentifierRep::get(intid));
124
63
}
125
64
 
126
65
bool _NPN_IdentifierIsString(NPIdentifier identifier)
127
66
{
128
 
    PrivateIdentifier* i = (PrivateIdentifier*)identifier;
129
 
    return i->isString;
 
67
    return static_cast<IdentifierRep*>(identifier)->isString();
130
68
}
131
69
 
132
70
NPUTF8 *_NPN_UTF8FromIdentifier(NPIdentifier identifier)
133
71
{
134
 
    PrivateIdentifier* i = (PrivateIdentifier*)identifier;
135
 
    if (!i->isString || !i->value.string)
136
 
        return NULL;
137
 
        
138
 
    return (NPUTF8 *)strdup(i->value.string);
 
72
    const char* string = static_cast<IdentifierRep*>(identifier)->string();
 
73
    if (!string)
 
74
        return 0;
 
75
    
 
76
    return strdup(string);
139
77
}
140
78
 
141
79
int32_t _NPN_IntFromIdentifier(NPIdentifier identifier)
142
80
{
143
 
    PrivateIdentifier* i = (PrivateIdentifier*)identifier;
144
 
    if (i->isString)
145
 
        return 0;
146
 
    return i->value.number;
 
81
    return static_cast<IdentifierRep*>(identifier)->number();
147
82
}
148
83
 
149
84
void NPN_InitializeVariantWithStringCopy(NPVariant* variant, const NPString* value)
151
86
    variant->type = NPVariantType_String;
152
87
    variant->value.stringValue.UTF8Length = value->UTF8Length;
153
88
    variant->value.stringValue.UTF8Characters = (NPUTF8 *)malloc(sizeof(NPUTF8) * value->UTF8Length);
 
89
    if (!variant->value.stringValue.UTF8Characters)
 
90
        CRASH();
154
91
    memcpy((void*)variant->value.stringValue.UTF8Characters, value->UTF8Characters, sizeof(NPUTF8) * value->UTF8Length);
155
92
}
156
93
 
180
117
            obj = aClass->allocate(npp, aClass);
181
118
        else
182
119
            obj = (NPObject*)malloc(sizeof(NPObject));
183
 
 
 
120
        if (!obj)
 
121
            CRASH();
184
122
        obj->_class = aClass;
185
123
        obj->referenceCount = 1;
186
124