Clean up ChunkedUpdateDrawingAreaProxy
[WebKit-https.git] / Tools / DumpRenderTree / TestNetscapePlugIn / PluginTest.h
1 /*
2  * Copyright (C) 2010 Apple 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
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef PluginTest_h
27 #define PluginTest_h
28
29 #include <WebKit/npfunctions.h>
30 #include <assert.h>
31 #include <map>
32 #include <string>
33
34 // Helper classes for implementing has_member
35 typedef char (&no_tag)[1];
36 typedef char (&yes_tag)[2];
37
38 #define DEFINE_HAS_MEMBER_CHECK(member, returnType, argumentTypes) \
39 template<typename T, returnType (T::*member) argumentTypes> struct pmf_##member##_helper {}; \
40 template<typename T> no_tag has_member_##member##_helper(...); \
41 template<typename T> yes_tag has_member_##member##_helper(pmf_##member##_helper<T, &T::member >*); \
42 template<typename T> struct has_member_##member { \
43 static const bool value = sizeof(has_member_##member##_helper<T>(0)) == sizeof(yes_tag); \
44 };
45
46 DEFINE_HAS_MEMBER_CHECK(hasMethod, bool, (NPIdentifier methodName));
47 DEFINE_HAS_MEMBER_CHECK(invoke, bool, (NPIdentifier methodName, const NPVariant*, uint32_t, NPVariant* result));
48 DEFINE_HAS_MEMBER_CHECK(invokeDefault, bool, (const NPVariant*, uint32_t, NPVariant* result));
49 DEFINE_HAS_MEMBER_CHECK(hasProperty, bool, (NPIdentifier propertyName));
50 DEFINE_HAS_MEMBER_CHECK(getProperty, bool, (NPIdentifier propertyName, NPVariant* result));
51
52 class PluginTest {
53 public:
54     static PluginTest* create(NPP, const std::string& identifier);
55     virtual ~PluginTest();
56
57     // NPP functions.
58     virtual NPError NPP_New(NPMIMEType pluginType, uint16_t mode, int16_t argc, char *argn[], char *argv[], NPSavedData *saved);
59     virtual NPError NPP_Destroy(NPSavedData**);
60     virtual NPError NPP_DestroyStream(NPStream* stream, NPReason reason);
61     virtual NPError NPP_GetValue(NPPVariable, void* value);
62     virtual NPError NPP_SetWindow(NPP, NPWindow*);
63
64     // NPN functions.
65     void NPN_InvalidateRect(NPRect* invalidRect);
66     NPIdentifier NPN_GetStringIdentifier(const NPUTF8* name);
67     NPIdentifier NPN_GetIntIdentifier(int32_t intid);
68     NPError NPN_GetValue(NPNVariable, void* value);
69     NPObject* NPN_CreateObject(NPClass*);
70     bool NPN_RemoveProperty(NPObject*, NPIdentifier propertyName);
71     
72     void executeScript(const char*);
73
74     template<typename TestClassTy> class Register {
75     public:
76         Register(const std::string& identifier)
77         {
78             registerCreateTestFunction(identifier, Register::create);
79         }
80     
81     private:
82         static PluginTest* create(NPP npp, const std::string& identifier) 
83         {
84             return new TestClassTy(npp, identifier);
85         }
86     };
87
88 protected:
89     PluginTest(NPP npp, const std::string& identifier);
90
91     // FIXME: A plug-in test shouldn't need to know about it's NPP. Make this private.
92     NPP m_npp;
93
94     const std::string& identifier() const { return m_identifier; }
95
96     void waitUntilDone();
97     void notifyDone();
98
99     // NPObject helper template.
100     template<typename T> struct Object : NPObject {
101     public:
102         static NPObject* create(PluginTest* pluginTest)
103         {
104             Object* object = static_cast<Object*>(pluginTest->NPN_CreateObject(npClass()));
105
106             object->m_pluginTest = pluginTest;
107             return object;
108         }
109     
110         // These should never be called.
111         bool hasMethod(NPIdentifier methodName)
112         {
113             assert(false);
114             return false;
115         }
116
117         bool invoke(NPIdentifier methodName, const NPVariant*, uint32_t, NPVariant* result)
118         {
119             assert(false);
120             return false;
121         }
122         
123         bool invokeDefault(const NPVariant*, uint32_t, NPVariant* result)
124         {
125             assert(false);
126             return false;
127         }
128
129         bool hasProperty(NPIdentifier propertyName)
130         {
131             assert(false);
132             return false;
133         }
134
135         bool getProperty(NPIdentifier propertyName, NPVariant* result)
136         {
137             assert(false);
138             return false;
139         }
140
141     protected:
142         Object()
143             : m_pluginTest(0)
144         {
145         }
146         
147         virtual ~Object() 
148         { 
149         }
150
151         PluginTest* pluginTest() const { return m_pluginTest; }
152
153     private:
154         static NPObject* NP_Allocate(NPP npp, NPClass* aClass)
155         {
156             return new T;
157         }
158
159         static void NP_Deallocate(NPObject* npObject)
160         {
161             delete static_cast<T*>(npObject);
162         }
163
164         static bool NP_HasMethod(NPObject* npObject, NPIdentifier methodName)
165         {
166             return static_cast<T*>(npObject)->hasMethod(methodName);
167         }
168
169         static bool NP_Invoke(NPObject* npObject, NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
170         {
171             return static_cast<T*>(npObject)->invoke(methodName, arguments, argumentCount, result);
172         }
173
174         static bool NP_InvokeDefault(NPObject* npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
175         {
176             return static_cast<T*>(npObject)->invokeDefault(arguments, argumentCount, result);
177         }
178
179         static bool NP_HasProperty(NPObject* npObject, NPIdentifier propertyName)
180         {
181             return static_cast<T*>(npObject)->hasProperty(propertyName);
182         }
183
184         static bool NP_GetProperty(NPObject* npObject, NPIdentifier propertyName, NPVariant* result)
185         {
186             return static_cast<T*>(npObject)->getProperty(propertyName, result);
187         }
188
189         static NPClass* npClass()
190         {
191             static NPClass npClass = {
192                 NP_CLASS_STRUCT_VERSION, 
193                 NP_Allocate,
194                 NP_Deallocate,
195                 0, // NPClass::invalidate
196                 has_member_hasMethod<T>::value ? NP_HasMethod : 0,
197                 has_member_invoke<T>::value ? NP_Invoke : 0,
198                 has_member_invokeDefault<T>::value ? NP_InvokeDefault : 0,
199                 has_member_hasProperty<T>::value ? NP_HasProperty : 0,
200                 has_member_getProperty<T>::value ? NP_GetProperty : 0,
201                 0, // NPClass::setProperty
202                 0, // NPClass::removeProperty
203                 0, // NPClass::enumerate
204                 0  // NPClass::construct
205             };
206             
207             return &npClass;
208         };
209
210         PluginTest* m_pluginTest;
211     };
212     
213 private:
214     typedef PluginTest* (*CreateTestFunction)(NPP, const std::string&);
215     
216     static void registerCreateTestFunction(const std::string&, CreateTestFunction);
217     static std::map<std::string, CreateTestFunction>& createTestFunctions();
218     
219     std::string m_identifier;
220 };
221
222 #endif // PluginTest_h