code.vuplus.com Git - vuplus_webkit/blob - 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 DEFINE_HAS_MEMBER_CHECK(removeProperty, bool, (NPIdentifier propertyName));
  52
  53 class PluginTest {
  54 public:
  55     static PluginTest* create(NPP, const std::string& identifier);
  56     virtual ~PluginTest();
  57
  58     static void NP_Shutdown();
  59
  60     // NPP functions.
  61     virtual NPError NPP_New(NPMIMEType pluginType, uint16_t mode, int16_t argc, char *argn[], char *argv[], NPSavedData *saved);
  62     virtual NPError NPP_Destroy(NPSavedData**);
  63     virtual NPError NPP_SetWindow(NPP, NPWindow*);
  64     virtual NPError NPP_NewStream(NPMIMEType, NPStream*, NPBool seekable, uint16_t* stype);
  65     virtual NPError NPP_DestroyStream(NPStream*, NPReason);
  66     virtual int32_t NPP_WriteReady(NPStream*);
  67     virtual int32_t NPP_Write(NPStream*, int32_t offset, int32_t len, void* buffer);
  68
  69     virtual int16_t NPP_HandleEvent(void* event);
  70     virtual bool NPP_URLNotify(const char* url, NPReason, void* notifyData);
  71     virtual NPError NPP_GetValue(NPPVariable, void* value);
  72     virtual NPError NPP_SetValue(NPNVariable, void *value);
  73
  74     // NPN functions.
  75     NPError NPN_GetURL(const char* url, const char* target);
  76     NPError NPN_GetURLNotify(const char* url, const char* target, void* notifyData);
  77     NPError NPN_GetValue(NPNVariable, void* value);
  78     void NPN_InvalidateRect(NPRect* invalidRect);
  79
  80     // NPRuntime NPN functions.
  81     NPIdentifier NPN_GetStringIdentifier(const NPUTF8* name);
  82     NPIdentifier NPN_GetIntIdentifier(int32_t intid);
  83     bool NPN_IdentifierIsString(NPIdentifier);
  84     NPUTF8* NPN_UTF8FromIdentifier(NPIdentifier);
  85     int32_t NPN_IntFromIdentifier(NPIdentifier);
  86
  87     NPObject* NPN_CreateObject(NPClass*);
  88     NPObject* NPN_RetainObject(NPObject*);
  89     void NPN_ReleaseObject(NPObject*);
  90     bool NPN_RemoveProperty(NPObject*, NPIdentifier propertyName);
  91
  92 #ifdef XP_MACOSX
  93     bool NPN_ConvertPoint(double sourceX, double sourceY, NPCoordinateSpace sourceSpace, double *destX, double *destY, NPCoordinateSpace destSpace);
  94 #endif
  95
  96     void executeScript(const char*);
  97     void log(const char* format, ...);
  98
  99     void registerNPShutdownFunction(void (*)());
 100
 101     static void indicateTestFailure();
 102
 103     template<typename TestClassTy> class Register {
 104     public:
 105         Register(const std::string& identifier)
 106         {
 107             registerCreateTestFunction(identifier, Register::create);
 108         }
 109
 110     private:
 111         static PluginTest* create(NPP npp, const std::string& identifier)
 112         {
 113             return new TestClassTy(npp, identifier);
 114         }
 115     };
 116
 117 protected:
 118     PluginTest(NPP npp, const std::string& identifier);
 119
 120     // FIXME: A plug-in test shouldn't need to know about it's NPP. Make this private.
 121     NPP m_npp;
 122
 123     const std::string& identifier() const { return m_identifier; }
 124
 125     void waitUntilDone();
 126     void notifyDone();
 127
 128     // NPObject helper template.
 129     template<typename T> struct Object : NPObject {
 130     public:
 131         static NPObject* create(PluginTest* pluginTest)
 132         {
 133             Object* object = static_cast<Object*>(pluginTest->NPN_CreateObject(npClass()));
 134
 135             object->m_pluginTest = pluginTest;
 136             return object;
 137         }
 138
 139         // These should never be called.
 140         bool hasMethod(NPIdentifier methodName)
 141         {
 142             assert(false);
 143             return false;
 144         }
 145
 146         bool invoke(NPIdentifier methodName, const NPVariant*, uint32_t, NPVariant* result)
 147         {
 148             assert(false);
 149             return false;
 150         }
 151
 152         bool invokeDefault(const NPVariant*, uint32_t, NPVariant* result)
 153         {
 154             assert(false);
 155             return false;
 156         }
 157
 158         bool hasProperty(NPIdentifier propertyName)
 159         {
 160             assert(false);
 161             return false;
 162         }
 163
 164         bool getProperty(NPIdentifier propertyName, NPVariant* result)
 165         {
 166             assert(false);
 167             return false;
 168         }
 169
 170         bool removeProperty(NPIdentifier propertyName)
 171         {
 172             assert(false);
 173             return false;
 174         }
 175
 176         // Helper functions.
 177         bool identifierIs(NPIdentifier identifier, const char* value)
 178         {
 179             return pluginTest()->NPN_GetStringIdentifier(value) == identifier;
 180         }
 181
 182     protected:
 183         Object()
 184             : m_pluginTest(0)
 185         {
 186         }
 187
 188         virtual ~Object()
 189         {
 190         }
 191
 192         PluginTest* pluginTest() const { return m_pluginTest; }
 193
 194     private:
 195         static NPObject* NP_Allocate(NPP npp, NPClass* aClass)
 196         {
 197             return new T;
 198         }
 199
 200         static void NP_Deallocate(NPObject* npObject)
 201         {
 202             delete static_cast<T*>(npObject);
 203         }
 204
 205         static bool NP_HasMethod(NPObject* npObject, NPIdentifier methodName)
 206         {
 207             return static_cast<T*>(npObject)->hasMethod(methodName);
 208         }
 209
 210         static bool NP_Invoke(NPObject* npObject, NPIdentifier methodName, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
 211         {
 212             return static_cast<T*>(npObject)->invoke(methodName, arguments, argumentCount, result);
 213         }
 214
 215         static bool NP_InvokeDefault(NPObject* npObject, const NPVariant* arguments, uint32_t argumentCount, NPVariant* result)
 216         {
 217             return static_cast<T*>(npObject)->invokeDefault(arguments, argumentCount, result);
 218         }
 219
 220         static bool NP_HasProperty(NPObject* npObject, NPIdentifier propertyName)
 221         {
 222             return static_cast<T*>(npObject)->hasProperty(propertyName);
 223         }
 224
 225         static bool NP_GetProperty(NPObject* npObject, NPIdentifier propertyName, NPVariant* result)
 226         {
 227             return static_cast<T*>(npObject)->getProperty(propertyName, result);
 228         }
 229
 230         static bool NP_RemoveProperty(NPObject* npObject, NPIdentifier propertyName)
 231         {
 232             return static_cast<T*>(npObject)->removeProperty(propertyName);
 233         }
 234
 235         static NPClass* npClass()
 236         {
 237             static NPClass npClass = {
 238                 NP_CLASS_STRUCT_VERSION,
 239                 NP_Allocate,
 240                 NP_Deallocate,
 241                 0, // NPClass::invalidate
 242                 has_member_hasMethod<T>::value ? NP_HasMethod : 0,
 243                 has_member_invoke<T>::value ? NP_Invoke : 0,
 244                 has_member_invokeDefault<T>::value ? NP_InvokeDefault : 0,
 245                 has_member_hasProperty<T>::value ? NP_HasProperty : 0,
 246                 has_member_getProperty<T>::value ? NP_GetProperty : 0,
 247                 0, // NPClass::setProperty
 248                 has_member_removeProperty<T>::value ? NP_RemoveProperty : 0,
 249                 0, // NPClass::enumerate
 250                 0  // NPClass::construct
 251             };
 252
 253             return &npClass;
 254         };
 255
 256         PluginTest* m_pluginTest;
 257     };
 258
 259 private:
 260     typedef PluginTest* (*CreateTestFunction)(NPP, const std::string&);
 261
 262     static void registerCreateTestFunction(const std::string&, CreateTestFunction);
 263     static std::map<std::string, CreateTestFunction>& createTestFunctions();
 264
 265     std::string m_identifier;
 266 };
 267
 268 #endif // PluginTest_h