home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / lib / plugin / nsplugin.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  15.8 KB  |  565 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18.  
  19. ////////////////////////////////////////////////////////////////////////////////
  20. // IMPLEMENTATION OF NETSCAPE COMMUNICATOR PLUGINS (NEW C++ API).
  21. //
  22. // This superscedes the old plugin API (npapi.h, npupp.h), and 
  23. // eliminates the need for glue files: npunix.c, npwin.cpp and npmac.cpp. 
  24. // Correspondences to the old API are shown throughout the file.
  25. ////////////////////////////////////////////////////////////////////////////////
  26.  
  27. #include "npglue.h" 
  28. #ifdef JAVA
  29. #include "jvmmgr.h" 
  30. #endif
  31. #include "xp_mem.h"
  32. #include "xpassert.h" 
  33. #ifdef XP_MAC
  34. #include "MacMemAllocator.h"
  35. #endif
  36.  
  37. ////////////////////////////////////////////////////////////////////////////////
  38. // THINGS IMPLEMENTED BY THE BROWSER...
  39. ////////////////////////////////////////////////////////////////////////////////
  40.  
  41. ////////////////////////////////////////////////////////////////////////////////
  42. // Plugin Manager Interface
  43. // This interface defines the minimum set of functionality that a plugin
  44. // manager will support if it implements plugins. Plugin implementations can
  45. // QueryInterface to determine if a plugin manager implements more specific 
  46. // APIs for the plugin to use.
  47.  
  48. nsPluginManager* thePluginManager = NULL;
  49.  
  50. nsPluginManager::nsPluginManager(nsISupports* outer)
  51.     : fJVMMgr(NULL)
  52. {
  53.     NS_INIT_AGGREGATED(outer);
  54. }
  55.  
  56. nsPluginManager::~nsPluginManager(void)
  57. {
  58.     fJVMMgr->Release();
  59.     fJVMMgr = NULL;
  60. }
  61.  
  62. NS_IMPL_AGGREGATED(nsPluginManager);
  63.  
  64. static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
  65.  
  66. NS_METHOD
  67. nsPluginManager::Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr)
  68. {
  69.     if (outer && !aIID.Equals(kISupportsIID))
  70.         return NS_NOINTERFACE;   // XXX right error?
  71.     nsPluginManager* mgr = new nsPluginManager(outer);
  72.     nsresult result = mgr->QueryInterface(aIID, aInstancePtr);
  73.     if (result != NS_OK) {
  74.         delete mgr;
  75.     }
  76.     return result;
  77. }
  78.  
  79. NS_METHOD_(void)
  80. nsPluginManager::ReloadPlugins(PRBool reloadPages)
  81. {
  82.     npn_reloadplugins(reloadPages);
  83. }
  84.  
  85. NS_METHOD_(void*)
  86. nsPluginManager::MemAlloc(PRUint32 size)
  87. {
  88.     return XP_ALLOC(size);
  89. }
  90.  
  91. NS_METHOD_(void)
  92. nsPluginManager::MemFree(void* ptr)
  93. {
  94.     (void)XP_FREE(ptr);
  95. }
  96.  
  97. NS_METHOD_(PRUint32)
  98. nsPluginManager::MemFlush(PRUint32 size)
  99. {
  100. #ifdef XP_MAC
  101.     /* Try to free some memory and return the amount we freed. */
  102.     if (CallCacheFlushers(size))
  103.         return size;
  104. #endif
  105.     return 0;
  106. }
  107.  
  108. static NS_DEFINE_IID(kPluginManagerIID, NP_IPLUGINMANAGER_IID);
  109. //static NS_DEFINE_IID(kNPIJVMPluginManagerIID, NP_IJVMPLUGINMANAGER_IID);
  110.  
  111. NS_METHOD
  112. nsPluginManager::AggregatedQueryInterface(const nsIID& aIID, void** aInstancePtr) 
  113. {
  114.     if (NULL == aInstancePtr) {                                            
  115.         return NS_ERROR_NULL_POINTER;                                        
  116.     }                                                                      
  117.     static NS_DEFINE_IID(kJRIEnvIID, NP_IJRIENV_IID); 
  118.     if (aIID.Equals(kJRIEnvIID)) {
  119.         // XXX Need to implement ISupports for JRIEnv
  120.         *aInstancePtr = (void*) ((nsISupports*)npn_getJavaEnv()); 
  121. //        AddRef();     // XXX should the plugin instance peer and the env be linked?
  122.         return NS_OK; 
  123.     } 
  124. #if 0   // later
  125.     static NS_DEFINE_IID(kJNIEnvIID, NP_IJNIENV_IID); 
  126.     if (aIID.Equals(kJNIEnvIID)) {
  127.         // XXX Need to implement ISupports for JNIEnv
  128.         *aInstancePtr = (void*) ((nsISupports*)npn_getJavaEnv());       // XXX need JNI version
  129. //        AddRef();     // XXX should the plugin instance peer and the env be linked?
  130.         return NS_OK; 
  131.     }
  132. #endif 
  133.     static NS_DEFINE_IID(kClassIID, kPluginManagerIID); 
  134.     if (aIID.Equals(kClassIID)) {
  135.         *aInstancePtr = (void*) this; 
  136.         AddRef(); 
  137.         return NS_OK; 
  138.     } 
  139.     if (aIID.Equals(kISupportsIID)) {
  140.         *aInstancePtr = (void*) ((nsISupports*)this); 
  141.         AddRef(); 
  142.         return NS_OK; 
  143.     } 
  144.     // Aggregates...
  145.     NPIJVMPluginManager* jvmMgr = GetJVMMgr(aIID);
  146.     if (jvmMgr) {
  147.         *aInstancePtr = (void*) ((nsISupports*)jvmMgr);
  148.         return NS_OK; 
  149.     }
  150.     return NS_NOINTERFACE;
  151. }
  152.  
  153. NPIJVMPluginManager*
  154. nsPluginManager::GetJVMMgr(const nsIID& aIID)
  155. {
  156.     NPIJVMPluginManager* result = NULL;
  157. #ifdef JAVA
  158.     if (fJVMMgr == NULL) {
  159.         // The plugin manager is the outer of the JVM manager
  160.         if (JVMMgr::Create(this, kISupportsIID, (void**)&fJVMMgr) != NS_OK)
  161.             return NULL;
  162.     }
  163.     if (fJVMMgr->QueryInterface(aIID, (void**)&result) != NS_OK)
  164.         return NULL;
  165. #endif
  166.     return result;
  167. }
  168.  
  169. ////////////////////////////////////////////////////////////////////////////////
  170. // Plugin Instance Peer Interface
  171.  
  172. nsPluginInstancePeer::nsPluginInstancePeer(NPP npp)
  173.     : npp(npp), userInst(NULL), fJVMInstancePeer(NULL)
  174. {
  175.     NS_INIT_AGGREGATED(NULL);
  176. }
  177.  
  178. nsPluginInstancePeer::~nsPluginInstancePeer(void)
  179. {
  180. }
  181.  
  182. NS_IMPL_AGGREGATED(nsPluginInstancePeer);
  183.  
  184. static NS_DEFINE_IID(kLiveConnectPluginInstancePeerIID, NP_ILIVECONNECTPLUGININSTANCEPEER_IID); 
  185. static NS_DEFINE_IID(kPluginInstancePeerIID, NP_IPLUGININSTANCEPEER_IID); 
  186.  
  187. NS_METHOD
  188. nsPluginInstancePeer::AggregatedQueryInterface(const nsIID& aIID, void** aInstancePtr) 
  189. {
  190.     if (NULL == aInstancePtr) {                                            
  191.         return NS_ERROR_NULL_POINTER;                                        
  192.     }                                                                      
  193.     if (aIID.Equals(kLiveConnectPluginInstancePeerIID) ||
  194.         aIID.Equals(kPluginInstancePeerIID) ||
  195.         aIID.Equals(kISupportsIID)) {
  196.         *aInstancePtr = (void*) ((nsISupports*)this); 
  197.         AddRef(); 
  198.         return NS_OK; 
  199.     } 
  200. #ifdef JAVA
  201.     // Aggregates...
  202.     if (fJVMInstancePeer == NULL) {
  203.         np_instance* instance = (np_instance*) npp->ndata;
  204.         NPEmbeddedApp* app = instance->app;
  205.         MWContext* cx = instance->cx;
  206.         np_data* ndata = (np_data*) app->np_data;
  207.         nsresult result =
  208.             JVMInstancePeer::Create((nsISupports*)this, kISupportsIID, (void**)&fJVMInstancePeer,
  209.                                     cx, (struct LO_JavaAppStruct_struct*)ndata->lo_struct); // XXX wrong kind of LO_Struct!
  210.         if (result != NS_OK) return result;
  211.     }
  212. #endif
  213.     return fJVMInstancePeer->QueryInterface(aIID, aInstancePtr);
  214. }
  215.  
  216. NS_METHOD_(NPIPlugin*)
  217. nsPluginInstancePeer::GetClass(void)
  218. {
  219.     return NULL;        // XXX
  220. }
  221.  
  222. NS_METHOD_(nsMIMEType)
  223. nsPluginInstancePeer::GetMIMEType(void)
  224. {
  225.     np_instance* instance = (np_instance*)npp->ndata;
  226.     return instance->typeString;
  227. }
  228.  
  229. NS_METHOD_(NPPluginType)
  230. nsPluginInstancePeer::GetMode(void)
  231. {
  232.     np_instance* instance = (np_instance*)npp->ndata;
  233.     return (NPPluginType)instance->type;
  234. }
  235.  
  236. NS_METHOD_(PRUint16)
  237. nsPluginInstancePeer::GetArgCount(void)
  238. {
  239.     np_instance* instance = (np_instance*)npp->ndata;
  240.     if (instance->type == NP_EMBED) {
  241.         np_data* ndata = (np_data*)instance->app->np_data;
  242.         return (PRUint16)ndata->lo_struct->attribute_cnt;
  243.     }
  244.     else {
  245.         return 1;
  246.     }
  247. }
  248.  
  249. NS_METHOD_(const char**)
  250. nsPluginInstancePeer::GetArgNames(void)
  251. {
  252.     np_instance* instance = (np_instance*)npp->ndata;
  253.     if (instance->type == NP_EMBED) {
  254.         np_data* ndata = (np_data*)instance->app->np_data;
  255.         return (const char**)ndata->lo_struct->attribute_list;
  256.     }
  257.     else {
  258.         static char name[] = "PALETTE";
  259.         static char* names[1];
  260.         names[0] = name;
  261.         return (const char**)names;
  262.     }
  263. }
  264.  
  265. NS_METHOD_(const char**)
  266. nsPluginInstancePeer::GetArgValues(void)
  267. {
  268.     np_instance* instance = (np_instance*)npp->ndata;
  269.     if (instance->type == NP_EMBED) {
  270.         np_data* ndata = (np_data*)instance->app->np_data;
  271.         return (const char**)ndata->lo_struct->value_list;
  272.     }
  273.     else {
  274.         static char value[] = "foreground";
  275.         static char* values[1];
  276.         values[0] = value;
  277.         return (const char**)values;
  278.     }
  279. }
  280.  
  281. NS_METHOD_(NPIPluginManager*)
  282. nsPluginInstancePeer::GetPluginManager(void)
  283. {
  284.     return thePluginManager;
  285. }
  286.  
  287. NS_METHOD_(NPPluginError)
  288. nsPluginInstancePeer::GetURL(const char* url, const char* target, void* notifyData,
  289.                              const char* altHost, const char* referrer,
  290.                              PRBool forceJSEnabled)
  291. {
  292.     return (NPPluginError)np_geturlinternal(npp, url, target, altHost, referrer,
  293.                                             forceJSEnabled, notifyData != NULL, notifyData);
  294. }
  295.  
  296. NS_METHOD_(NPPluginError)
  297. nsPluginInstancePeer::PostURL(const char* url, const char* target, PRUint32 bufLen, 
  298.                               const char* buf, PRBool file, void* notifyData,
  299.                               const char* altHost, const char* referrer,
  300.                               PRBool forceJSEnabled,
  301.                               PRUint32 postHeadersLength, const char* postHeaders)
  302. {
  303.     return (NPPluginError)np_posturlinternal(npp, url, target, altHost, referrer, forceJSEnabled,
  304.                                              bufLen, buf, file, notifyData != NULL, notifyData);
  305. }
  306.  
  307. NS_METHOD_(NPPluginError)
  308. nsPluginInstancePeer::NewStream(nsMIMEType type, const char* target,
  309.                                 NPIPluginManagerStream* *result)
  310. {
  311.     NPStream* pstream;
  312.     NPPluginError err = (NPPluginError)
  313.         npn_newstream(npp, (char*)type, (char*)target, &pstream);
  314.     if (err != NPPluginError_NoError)
  315.         return err;
  316.     *result = new nsPluginManagerStream(npp, pstream);
  317.     return NPPluginError_NoError;
  318. }
  319.  
  320. NS_METHOD_(void)
  321. nsPluginInstancePeer::ShowStatus(const char* message)
  322. {
  323.     npn_status(npp, message);
  324. }
  325.  
  326. NS_METHOD_(const char*)
  327. nsPluginInstancePeer::UserAgent(void)
  328. {
  329.     return npn_useragent(npp);
  330. }
  331.  
  332. NS_METHOD_(NPPluginError)
  333. nsPluginInstancePeer::GetValue(NPPluginManagerVariable variable, void *value)
  334. {
  335.     return (NPPluginError)npn_getvalue(npp, (NPNVariable)variable, value);
  336. }
  337.  
  338. NS_METHOD_(NPPluginError)
  339. nsPluginInstancePeer::SetValue(NPPluginVariable variable, void *value)
  340. {
  341.     return (NPPluginError)npn_setvalue(npp, (NPPVariable)variable, value);
  342. }
  343.  
  344. NS_METHOD_(void)
  345. nsPluginInstancePeer::InvalidateRect(nsRect *invalidRect)
  346. {
  347.     npn_invalidaterect(npp, (NPRect*)invalidRect);
  348. }
  349.  
  350. NS_METHOD_(void)
  351. nsPluginInstancePeer::InvalidateRegion(nsRegion invalidRegion)
  352. {
  353.     npn_invalidateregion(npp, invalidRegion);
  354. }
  355.  
  356. NS_METHOD_(void)
  357. nsPluginInstancePeer::ForceRedraw(void)
  358. {
  359.     npn_forceredraw(npp);
  360. }
  361.  
  362. NS_METHOD_(void)
  363. nsPluginInstancePeer::RegisterWindow(void* window)
  364. {
  365.     npn_registerwindow(npp, window);
  366. }
  367.  
  368. NS_METHOD_(void)
  369. nsPluginInstancePeer::UnregisterWindow(void* window)
  370. {
  371.     npn_unregisterwindow(npp, window);
  372. }
  373.  
  374. NS_METHOD_(jref)
  375. nsPluginInstancePeer::GetJavaPeer(void)
  376. {
  377.     return npn_getJavaPeer(npp);
  378. }
  379.  
  380. ////////////////////////////////////////////////////////////////////////////////
  381. // Plugin Manager Stream Interface
  382.  
  383. nsPluginManagerStream::nsPluginManagerStream(NPP npp, NPStream* pstr)
  384.     : npp(npp), pstream(pstr)
  385. {
  386.     NS_INIT_REFCNT();
  387.     // XXX get rid of the npp instance variable if this is true
  388.     PR_ASSERT(npp == ((np_stream*)pstr->ndata)->instance->npp);
  389. }
  390.  
  391. nsPluginManagerStream::~nsPluginManagerStream(void)
  392. {
  393. }
  394.  
  395. NS_METHOD_(PRInt32)
  396. nsPluginManagerStream::WriteReady(void)
  397. {
  398.     // XXX This call didn't exist before, but I think that it should have.
  399.     // Is this implementation right?
  400.     return NP_STREAM_MAXREADY;
  401. }
  402.  
  403. NS_METHOD_(PRInt32)
  404. nsPluginManagerStream::Write(PRInt32 len, void* buffer)
  405. {
  406.     return npn_write(npp, pstream, len, buffer);
  407. }
  408.  
  409. NS_METHOD_(const char*)
  410. nsPluginManagerStream::GetURL(void)
  411. {
  412.     return pstream->url;
  413. }
  414.  
  415. NS_METHOD_(PRUint32)
  416. nsPluginManagerStream::GetEnd(void)
  417. {
  418.     return pstream->end;
  419. }
  420.  
  421. NS_METHOD_(PRUint32)
  422. nsPluginManagerStream::GetLastModified(void)
  423. {
  424.     return pstream->lastmodified;
  425. }
  426.  
  427. NS_METHOD_(void*)
  428. nsPluginManagerStream::GetNotifyData(void)
  429. {
  430.     return pstream->notifyData;
  431. }
  432.  
  433. NS_DEFINE_IID(kPluginManagerStreamIID, NP_IPLUGINMANAGERSTREAM_IID);
  434. NS_IMPL_QUERY_INTERFACE(nsPluginManagerStream, kPluginManagerStreamIID);
  435. NS_IMPL_ADDREF(nsPluginManagerStream);
  436. NS_IMPL_RELEASE(nsPluginManagerStream);
  437.  
  438. ////////////////////////////////////////////////////////////////////////////////
  439. // Plugin Stream Peer Interface
  440.  
  441. nsPluginStreamPeer::nsPluginStreamPeer(URL_Struct *urls, np_stream *stream)
  442.     : userStream(NULL), urls(urls), stream(stream), 
  443.       reason(NPPluginReason_NoReason)
  444. {
  445.     NS_INIT_REFCNT();
  446. }
  447.  
  448. nsPluginStreamPeer::~nsPluginStreamPeer(void)
  449. {
  450. }
  451.  
  452. NS_METHOD_(NPPluginReason)
  453. nsPluginStreamPeer::GetReason(void)
  454. {
  455.     return reason;
  456. }
  457.  
  458. NS_METHOD_(nsMIMEType)
  459. nsPluginStreamPeer::GetMIMEType(void)
  460. {
  461.     return (nsMIMEType)urls->content_type;
  462. }
  463.  
  464. NS_METHOD_(PRUint32)
  465. nsPluginStreamPeer::GetContentLength(void)
  466. {
  467.     return urls->content_length;
  468. }
  469. #if 0
  470. NS_METHOD_(const char*)
  471. nsPluginStreamPeer::GetContentEncoding(void)
  472. {
  473.     return urls->content_encoding;
  474. }
  475.  
  476. NS_METHOD_(const char*)
  477. nsPluginStreamPeer::GetCharSet(void)
  478. {
  479.     return urls->charset;
  480. }
  481.  
  482. NS_METHOD_(const char*)
  483. nsPluginStreamPeer::GetBoundary(void)
  484. {
  485.     return urls->boundary;
  486. }
  487.  
  488. NS_METHOD_(const char*)
  489. nsPluginStreamPeer::GetContentName(void)
  490. {
  491.     return urls->content_name;
  492. }
  493.  
  494. NS_METHOD_(time_t)
  495. nsPluginStreamPeer::GetExpires(void)
  496. {
  497.     return urls->expires;
  498. }
  499.  
  500. NS_METHOD_(time_t)
  501. nsPluginStreamPeer::GetLastModified(void)
  502. {
  503.     return urls->last_modified;
  504. }
  505.  
  506. NS_METHOD_(time_t)
  507. nsPluginStreamPeer::GetServerDate(void)
  508. {
  509.     return urls->server_date;
  510. }
  511.  
  512. NS_METHOD_(NPServerStatus)
  513. nsPluginStreamPeer::GetServerStatus(void)
  514. {
  515.     return urls->server_status;
  516. }
  517. #endif
  518. NS_METHOD_(PRUint32)
  519. nsPluginStreamPeer::GetHeaderFieldCount(void)
  520. {
  521.     return urls->all_headers.empty_index;
  522. }
  523.  
  524. NS_METHOD_(const char*)
  525. nsPluginStreamPeer::GetHeaderFieldKey(PRUint32 index)
  526. {
  527.     return urls->all_headers.key[index];
  528. }
  529.  
  530. NS_METHOD_(const char*)
  531. nsPluginStreamPeer::GetHeaderField(PRUint32 index)
  532. {
  533.     return urls->all_headers.value[index];
  534. }
  535.  
  536. NS_METHOD_(NPPluginError)
  537. nsPluginStreamPeer::RequestRead(nsByteRange* rangeList)
  538. {
  539.     return (NPPluginError)npn_requestread(stream->pstream,
  540.                                           (NPByteRange*)rangeList);
  541. }
  542.  
  543. NS_DEFINE_IID(kSeekablePluginStreamPeerIID, NP_ISEEKABLEPLUGINSTREAMPEER_IID);
  544. NS_DEFINE_IID(kPluginStreamPeerIID, NP_IPLUGINSTREAMPEER_IID);
  545. NS_IMPL_ADDREF(nsPluginStreamPeer);
  546. NS_IMPL_RELEASE(nsPluginStreamPeer);
  547.  
  548. NS_METHOD
  549. nsPluginStreamPeer::QueryInterface(const nsIID& aIID, void** aInstancePtr)
  550. {
  551.     if (NULL == aInstancePtr) {
  552.         return NS_ERROR_NULL_POINTER; 
  553.     } 
  554.     if ((stream->seekable && aIID.Equals(kSeekablePluginStreamPeerIID)) ||
  555.         aIID.Equals(kPluginStreamPeerIID) ||
  556.         aIID.Equals(kISupportsIID)) {
  557.         *aInstancePtr = (void*) ((nsISupports*)this); 
  558.         AddRef(); 
  559.         return NS_OK; 
  560.     } 
  561.     return NS_NOINTERFACE; 
  562. } 
  563.  
  564. ////////////////////////////////////////////////////////////////////////////////
  565.