1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
/*
* Copyright © 2008 Christian Persch
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __TOTEM_NPOBJECT_WRAPPER_H__
#define __TOTEM_NPOBJECT_WRAPPER_H__
#include <npapi.h>
#include <npruntime.h>
#include <assert.h>
class totemNPObjectWrapper {
public:
totemNPObjectWrapper () : mObject (0) { }
totemNPObjectWrapper (NPObject *aObject) : mObject (aObject) { } /* adopts */
totemNPObjectWrapper (const totemNPObjectWrapper& aOther) { Assign (aOther.mObject); }
~totemNPObjectWrapper () { Assign (0); }
bool IsNull () const { return mObject == 0; }
totemNPObjectWrapper& operator= (NPObject *aObject) { Assign (aObject); return *this; }
operator void*() const { return reinterpret_cast<void*>(mObject); }
operator NPObject*() const { return mObject; }
NPObject* operator->() const { assert (!IsNull ()); return mObject; }
class GetterRetains {
public:
explicit GetterRetains (totemNPObjectWrapper& aTarget) : mTarget (aTarget) { VOID_TO_NPVARIANT (mVariant); }
~GetterRetains () {
if (!NPVARIANT_IS_VOID (mVariant)) {
if (NPVARIANT_IS_OBJECT (mVariant)) {
mTarget = NPVARIANT_TO_OBJECT (mVariant);
}
NPN_ReleaseVariantValue (&mVariant);
}
}
operator void**() { return reinterpret_cast<void**> (mTarget.StartAssignment ()); } // FIXMEchpe this looks wrong...
operator NPObject**() { return mTarget.StartAssignment (); }
operator NPVariant*() { return &mVariant; }
/* NPN_GetValue uses void* which is broken */
operator void*() { return reinterpret_cast<void*> (mTarget.StartAssignment ()); }
private:
totemNPObjectWrapper& mTarget;
NPVariant mVariant;
};
class AlreadyRetained {
public:
explicit AlreadyRetained (NPObject *aObject) : mObject (aObject) { }
~AlreadyRetained () { }
NPObject *Get () const { return mObject; }
private:
NPObject *mObject;
};
totemNPObjectWrapper& operator= (const AlreadyRetained& aRetainer) { Adopt (aRetainer.Get()); return *this; }
protected:
totemNPObjectWrapper& operator= (const totemNPObjectWrapper&); // not implemented
void Assign (NPObject *aObject) {
if (mObject) {
NPN_ReleaseObject (mObject);
}
mObject = aObject;
if (mObject) {
NPN_RetainObject (mObject);
}
}
void Adopt (NPObject *aObject) {
if (mObject) {
NPN_ReleaseObject (mObject);
}
mObject = aObject;
}
NPObject** StartAssignment () { Assign (0); return &mObject; }
NPObject *mObject;
};
inline totemNPObjectWrapper::GetterRetains
getter_Retains (totemNPObjectWrapper &aTarget)
{
return totemNPObjectWrapper::GetterRetains (aTarget);
}
inline totemNPObjectWrapper::AlreadyRetained
do_CreateInstance (totemNPClass_base* aClass, NPP aNPP)
{
assert (aClass);
assert (aNPP);
return totemNPObjectWrapper::AlreadyRetained (aClass->CreateInstance (aNPP));
}
#endif /* __TOTEM_NPOBJECT_WRAPPER_H__ */
|
