third_party/npapi/npspy/common/npn_gate.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 #include "xp.h"
  39
  40 #include "npapi.h"
  41 #include "npupp.h"
  42
  43 #include "logger.h"
  44
  45 extern Logger * logger;
  46 extern NPNetscapeFuncs NPNFuncs;
  47
  48 void NPN_Version(int* plugin_major, int* plugin_minor, int* netscape_major, int* netscape_minor)
  49 {
  50   if(logger)
  51     logger->logCall(action_npn_version, (DWORD)plugin_major, (DWORD)plugin_minor, (DWORD)netscape_major, (DWORD)netscape_minor);
  52
  53   *plugin_major   = NP_VERSION_MAJOR;
  54   *plugin_minor   = NP_VERSION_MINOR;
  55   *netscape_major = HIBYTE(NPNFuncs.version);
  56   *netscape_minor = LOBYTE(NPNFuncs.version);
  57
  58   if(logger)
  59     logger->logReturn(action_npn_version);
  60 }
  61
  62 NPError NPN_GetURLNotify(NPP instance, const char *url, const char *target, void* notifyData)
  63 {
  64         int navMinorVers = NPNFuncs.version & 0xFF;
  65
  66   NPError rv = NPERR_NO_ERROR;
  67
  68   if(logger)
  69     logger->logCall(action_npn_get_url_notify, (DWORD)instance, (DWORD)url, (DWORD)target, (DWORD)notifyData);
  70
  71   if( navMinorVers >= NPVERS_HAS_NOTIFICATION )
  72                 rv = NPNFuncs.geturlnotify(instance, url, target, notifyData);
  73         else
  74                 rv = NPERR_INCOMPATIBLE_VERSION_ERROR;
  75
  76   if(logger)
  77     logger->logReturn(action_npn_get_url_notify, rv);
  78
  79   return rv;
  80 }
  81
  82 NPError NPN_GetURL(NPP instance, const char *url, const char *target)
  83 {
  84   if(logger)
  85     logger->logCall(action_npn_get_url, (DWORD)instance, (DWORD)url, (DWORD)target);
  86
  87   NPError rv = NPNFuncs.geturl(instance, url, target);
  88
  89   if(logger)
  90     logger->logReturn(action_npn_get_url, rv);
  91
  92   return rv;
  93 }
  94
  95 NPError NPN_PostURLNotify(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file, void* notifyData)
  96 {
  97         int navMinorVers = NPNFuncs.version & 0xFF;
  98
  99   NPError rv = NPERR_NO_ERROR;
 100
 101   if(logger)
 102     logger->logCall(action_npn_post_url_notify, (DWORD)instance, (DWORD)url, (DWORD)window, (DWORD)len, (DWORD)buf, (DWORD)file, (DWORD)notifyData);
 103
 104         if( navMinorVers >= NPVERS_HAS_NOTIFICATION )
 105                 rv = NPNFuncs.posturlnotify(instance, url, window, len, buf, file, notifyData);
 106         else
 107                 rv = NPERR_INCOMPATIBLE_VERSION_ERROR;
 108
 109   if(logger)
 110     logger->logReturn(action_npn_post_url_notify, rv);
 111
 112   return rv;
 113 }
 114
 115 NPError NPN_PostURL(NPP instance, const char* url, const char* window, uint32 len, const char* buf, NPBool file)
 116 {
 117   if(logger)
 118     logger->logCall(action_npn_post_url, (DWORD)instance, (DWORD)url, (DWORD)window, (DWORD)len, (DWORD)buf, (DWORD)file);
 119
 120   NPError rv = NPNFuncs.posturl(instance, url, window, len, buf, file);
 121
 122   if(logger)
 123     logger->logReturn(action_npn_post_url, rv);
 124
 125   return rv;
 126 }
 127
 128 NPError NPN_RequestRead(NPStream* stream, NPByteRange* rangeList)
 129 {
 130   if(logger)
 131     logger->logCall(action_npn_request_read, (DWORD)stream, (DWORD)rangeList);
 132
 133   NPError rv = NPNFuncs.requestread(stream, rangeList);
 134
 135   if(logger)
 136     logger->logReturn(action_npn_request_read, rv);
 137
 138   return rv;
 139 }
 140
 141 NPError NPN_NewStream(NPP instance, NPMIMEType type, const char* target, NPStream** stream)
 142 {
 143         int navMinorVersion = NPNFuncs.version & 0xFF;
 144
 145   NPError rv = NPERR_NO_ERROR;
 146
 147   if(logger)
 148     logger->logCall(action_npn_new_stream, (DWORD)instance, (DWORD)type, (DWORD)target, (DWORD)stream);
 149
 150         if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT )
 151                 rv = NPNFuncs.newstream(instance, type, target, stream);
 152         else
 153                 rv = NPERR_INCOMPATIBLE_VERSION_ERROR;
 154
 155   if(logger)
 156     logger->logReturn(action_npn_new_stream, rv);
 157
 158   return rv;
 159 }
 160
 161 int32 NPN_Write(NPP instance, NPStream *stream, int32 len, void *buffer)
 162 {
 163         int navMinorVersion = NPNFuncs.version & 0xFF;
 164
 165   int32 rv = 0;
 166
 167   if(logger)
 168     logger->logCall(action_npn_write, (DWORD)instance, (DWORD)stream, (DWORD)len, (DWORD)buffer);
 169
 170   if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT )
 171                 rv = NPNFuncs.write(instance, stream, len, buffer);
 172         else
 173                 rv = -1;
 174
 175   if(logger)
 176     logger->logReturn(action_npn_write, rv);
 177
 178   return rv;
 179 }
 180
 181 NPError NPN_DestroyStream(NPP instance, NPStream* stream, NPError reason)
 182 {
 183         int navMinorVersion = NPNFuncs.version & 0xFF;
 184
 185   NPError rv = NPERR_NO_ERROR;
 186
 187   if(logger)
 188     logger->logCall(action_npn_destroy_stream, (DWORD)instance, (DWORD)stream, (DWORD)reason);
 189
 190   if( navMinorVersion >= NPVERS_HAS_STREAMOUTPUT )
 191                 rv = NPNFuncs.destroystream(instance, stream, reason);
 192         else
 193                 rv = NPERR_INCOMPATIBLE_VERSION_ERROR;
 194
 195   if(logger)
 196     logger->logReturn(action_npn_destroy_stream, rv);
 197
 198   return rv;
 199 }
 200
 201 void NPN_Status(NPP instance, const char *message)
 202 {
 203   if(logger)
 204     logger->logCall(action_npn_status, (DWORD)instance, (DWORD)message);
 205
 206   NPNFuncs.status(instance, message);
 207 }
 208
 209 const char* NPN_UserAgent(NPP instance)
 210 {
 211   static const char * rv = NULL;
 212
 213   if(logger)
 214     logger->logCall(action_npn_user_agent, (DWORD)instance);
 215
 216   rv = NPNFuncs.uagent(instance);
 217
 218   if(logger)
 219     logger->logReturn(action_npn_user_agent);
 220
 221   return rv;
 222 }
 223
 224 void* NPN_MemAlloc(uint32 size)
 225 {
 226   void * rv = NULL;
 227
 228   if(logger)
 229     logger->logCall(action_npn_mem_alloc, (DWORD)size);
 230
 231   rv = NPNFuncs.memalloc(size);
 232
 233   if(logger)
 234     logger->logReturn(action_npn_mem_alloc);
 235
 236   return rv;
 237 }
 238
 239 void NPN_MemFree(void* ptr)
 240 {
 241   if(logger)
 242     logger->logCall(action_npn_mem_free, (DWORD)ptr);
 243
 244   NPNFuncs.memfree(ptr);
 245 }
 246
 247 uint32 NPN_MemFlush(uint32 size)
 248 {
 249   if(logger)
 250     logger->logCall(action_npn_mem_flush, (DWORD)size);
 251
 252   uint32 rv = NPNFuncs.memflush(size);
 253
 254   if(logger)
 255     logger->logReturn(action_npn_mem_flush, rv);
 256
 257   return rv;
 258 }
 259
 260 void NPN_ReloadPlugins(NPBool reloadPages)
 261 {
 262   if(logger)
 263     logger->logCall(action_npn_reload_plugins, (DWORD)reloadPages);
 264
 265   NPNFuncs.reloadplugins(reloadPages);
 266 }
 267
 268 #ifdef OJI
 269 JRIEnv* NPN_GetJavaEnv(void)
 270 {
 271   JRIEnv * rv = NULL;
 272
 273   if(logger)
 274     logger->logCall(action_npn_get_java_env);
 275
 276         rv = NPNFuncs.getJavaEnv();
 277
 278   if(logger)
 279     logger->logReturn(action_npn_get_java_env);
 280
 281   return rv;
 282 }
 283
 284 jref NPN_GetJavaPeer(NPP instance)
 285 {
 286   jref rv;
 287
 288   if(logger)
 289     logger->logCall(action_npn_get_java_peer, (DWORD)instance);
 290
 291         rv = NPNFuncs.getJavaPeer(instance);
 292
 293   if(logger)
 294     logger->logReturn(action_npn_get_java_peer);
 295
 296   return rv;
 297 }
 298 #else
 299 void* NPN_GetJavaEnv(void)
 300 {
 301   JRIEnv * rv = NULL;
 302
 303   if(logger)
 304     logger->logCall(action_npn_get_java_env);
 305
 306         rv = NULL;
 307
 308   if(logger)
 309     logger->logReturn(action_npn_get_java_env);
 310
 311   return rv;
 312 }
 313
 314 void* NPN_GetJavaPeer(NPP instance)
 315 {
 316   jref rv;
 317
 318   if(logger)
 319     logger->logCall(action_npn_get_java_peer, (DWORD)instance);
 320
 321         rv = NULL;
 322
 323   if(logger)
 324     logger->logReturn(action_npn_get_java_peer);
 325
 326   return rv;
 327 }
 328 #endif
 329
 330 NPError NPN_GetValue(NPP instance, NPNVariable variable, void *value)
 331 {
 332   NPError rv = NPERR_NO_ERROR;
 333
 334   rv = NPNFuncs.getvalue(instance, variable, value);
 335
 336   if(logger)
 337     logger->logCall(action_npn_get_value, (DWORD)instance, (DWORD)variable, (DWORD)value);
 338
 339   if(logger)
 340     logger->logReturn(action_npn_get_value, rv);
 341
 342   return rv;
 343 }
 344
 345 NPError NPN_SetValue(NPP instance, NPPVariable variable, void *value)
 346 {
 347   NPError rv = NPERR_NO_ERROR;
 348
 349   if(logger)
 350     logger->logCall(action_npn_set_value, (DWORD)instance, (DWORD)variable, (DWORD)value);
 351
 352   rv = NPNFuncs.setvalue(instance, variable, value);
 353
 354   if(logger)
 355     logger->logReturn(action_npn_set_value, rv);
 356
 357   return rv;
 358 }
 359
 360 void NPN_InvalidateRect(NPP instance, NPRect *invalidRect)
 361 {
 362   if(logger)
 363     logger->logCall(action_npn_invalidate_rect, (DWORD)instance, (DWORD)invalidRect);
 364
 365   NPNFuncs.invalidaterect(instance, invalidRect);
 366 }
 367
 368 void NPN_InvalidateRegion(NPP instance, NPRegion invalidRegion)
 369 {
 370   if(logger)
 371     logger->logCall(action_npn_invalidate_region, (DWORD)instance, (DWORD)invalidRegion);
 372
 373   NPNFuncs.invalidateregion(instance, invalidRegion);
 374 }
 375
 376 void NPN_ForceRedraw(NPP instance)
 377 {
 378   if(logger)
 379     logger->logCall(action_npn_force_redraw, (DWORD)instance);
 380
 381   NPNFuncs.forceredraw(instance);
 382 }
 383
 384 NPIdentifier NPN_GetStringIdentifier(const NPUTF8 *name)
 385 {
 386   if(logger)
 387     logger->logCall(action_npn_get_string_identifier, (DWORD)name);
 388
 389   NPIdentifier rv = NPNFuncs.getstringidentifier(name);
 390
 391   if(logger)
 392     logger->logReturn(action_npn_get_string_identifier, (DWORD)(rv));
 393
 394   return rv;
 395 }
 396
 397 bool NPN_Enumerate(NPP id, NPObject* obj, NPIdentifier** identifier, uint32_t*val)
 398 {
 399   if(logger)
 400     logger->logCall(action_npn_enumerate);
 401
 402   bool rv = NPNFuncs.enumerate(id, obj, identifier, val);
 403
 404   if(logger)
 405     logger->logReturn(action_npn_enumerate, rv);
 406
 407   return rv;
 408 }
 409
 410 bool NPN_PopPopupsEnabledState(NPP id)
 411 {
 412   if(logger)
 413     logger->logCall(action_npn_pop_popups_enabled_state, (DWORD)id);
 414
 415   bool rv = NPNFuncs.poppopupsenabledstate(id);
 416
 417   if(logger)
 418     logger->logReturn(action_npn_pop_popups_enabled_state, rv);
 419
 420   return rv;
 421 }
 422
 423 bool NPN_PushPopupsEnabledState(NPP id, NPBool enabled)
 424 {
 425   if(logger)
 426     logger->logCall(action_npn_push_popups_enabled_state, (DWORD)id);
 427
 428   bool rv = NPNFuncs.pushpopupsenabledstate(id, enabled);
 429
 430   if(logger)
 431     logger->logReturn(action_npn_push_popups_enabled_state, rv);
 432
 433   return rv;
 434 }
 435
 436 void NPN_SetException(NPObject*obj, const NPUTF8*message)
 437 {
 438   if(logger)
 439     logger->logCall(action_npn_set_exception, (DWORD)message);
 440
 441   NPNFuncs.setexception(obj,message);
 442 }
 443
 444 void NPN_ReleaseVariantValue(NPVariant*variant)
 445 {
 446   if(logger)
 447     logger->logCall(action_npn_release_variant_value, (DWORD)variant);
 448
 449   NPNFuncs.releasevariantvalue(variant);
 450 }
 451
 452 bool NPN_HasMethod(NPP id, NPObject* object, NPIdentifier identifier)
 453 {
 454   if(logger)
 455     logger->logCall(action_npn_has_method, (DWORD)identifier);
 456
 457   bool rv = NPNFuncs.hasmethod(id, object, identifier);
 458
 459   if(logger)
 460     logger->logReturn(action_npn_has_method, rv);
 461
 462   return rv;
 463 }
 464
 465 bool NPN_HasProperty(NPP id, NPObject* object, NPIdentifier identifier)
 466 {
 467   if(logger)
 468     logger->logCall(action_npn_has_property, (DWORD)identifier);
 469
 470   bool rv = NPNFuncs.hasmethod(id, object, identifier);
 471
 472   if(logger)
 473     logger->logReturn(action_npn_has_property, rv);
 474
 475   return rv;
 476 }
 477
 478 bool NPN_RemoveProperty(NPP id, NPObject* object, NPIdentifier identifier)
 479 {
 480   if(logger)
 481     logger->logCall(action_npn_remove_property, (DWORD)identifier);
 482
 483   bool rv = NPNFuncs.hasmethod(id, object, identifier);
 484
 485   return rv;
 486 }
 487
 488 bool NPN_SetProperty(NPP id, NPObject* obj, NPIdentifier identifier, const NPVariant *variant)
 489 {
 490   if(logger)
 491     logger->logCall(action_npn_set_property, (DWORD)identifier);
 492
 493   bool rv = NPNFuncs.setproperty(id, obj, identifier, variant);
 494
 495   return rv;
 496 }
 497
 498 bool NPN_GetProperty(NPP id, NPObject* obj, NPIdentifier identifier, NPVariant *variant)
 499 {
 500   if(logger)
 501     logger->logCall(action_npn_get_property, (DWORD)identifier);
 502
 503   bool rv = NPNFuncs.getproperty(id, obj, identifier, variant);
 504
 505   return rv;
 506 }
 507
 508 bool NPN_Evaluate(NPP id, NPObject* obj, NPString* str, NPVariant* variant)
 509 {
 510   if(logger)
 511     logger->logCall(action_npn_evaluate, (DWORD)str);
 512
 513   bool rv = NPNFuncs.evaluate(id, obj, str, variant);
 514
 515   if(logger)
 516     logger->logReturn(action_npn_evaluate, rv);
 517
 518   return rv;
 519 }
 520
 521 bool NPN_InvokeDefault(NPP id, NPObject* obj, const NPVariant* args, uint32_t count, NPVariant*result)
 522 {
 523   if(logger)
 524     logger->logCall(action_npn_invoke_default, (DWORD)obj);
 525
 526   bool rv = NPNFuncs.invokeDefault(id, obj, args, count, result);
 527
 528   if(logger)
 529     logger->logReturn(action_npn_invoke_default, rv);
 530
 531   return rv;
 532 }
 533
 534 bool NPN_Invoke(NPP id, NPObject* obj, NPIdentifier identifier, const NPVariant *args, uint32_t count, NPVariant*result)
 535 {
 536   if(logger)
 537     logger->logCall(action_npn_invoke, (DWORD)obj);
 538
 539   bool rv = NPNFuncs.invoke(id, obj, identifier, args, count, result);
 540
 541   if(logger)
 542     logger->logReturn(action_npn_invoke, rv);
 543
 544   return rv;
 545 }
 546
 547 void NPN_ReleaseObject(NPObject *obj)
 548 {
 549   if(logger)
 550     logger->logCall(action_npn_release_object, (DWORD)obj);
 551
 552   NPNFuncs.releaseobject(obj);
 553 }
 554
 555 NPObject *NPN_RetainObject(NPObject* obj)
 556 {
 557   if(logger)
 558     logger->logCall(action_npn_retain_object, (DWORD)obj);
 559
 560   NPObject *rv = NPNFuncs.retainobject(obj);
 561
 562   return rv;
 563 }
 564
 565 NPObject* NPN_CreateObject(NPP id, NPClass *cl)
 566 {
 567   if(logger)
 568     logger->logCall(action_npn_create_object, (DWORD)cl);
 569
 570   NPObject *rv = NPNFuncs.createobject(id, cl);
 571
 572   if(logger)
 573     logger->logReturn(action_npn_create_object, (DWORD)rv);
 574
 575   return rv;
 576 }
 577
 578 int32_t NPN_IntFromIdentifier(NPIdentifier identifier)
 579 {
 580   if(logger)
 581     logger->logCall(action_npn_int_from_identifier, (DWORD)identifier);
 582
 583   int32_t rv = NPNFuncs.intfromidentifier(identifier);
 584
 585   if(logger)
 586     logger->logReturn(action_npn_int_from_identifier, rv);
 587
 588   return rv;
 589 }
 590
 591 NPUTF8 *NPN_UTF8FromIdentifier(NPIdentifier identifier)
 592 {
 593   if(logger)
 594     logger->logCall(action_npn_utf8_from_identifier, (DWORD)identifier);
 595
 596   NPUTF8 *rv = NPNFuncs.utf8fromidentifier(identifier);
 597
 598   if(logger)
 599     logger->logReturn(action_npn_utf8_from_identifier, 1234567890);
 600
 601   return rv;
 602 }
 603
 604 bool NPN_IdentifierIsString(NPIdentifier identifier)
 605 {
 606   if(logger)
 607     logger->logCall(action_npn_identifier_is_string, (DWORD)identifier);
 608
 609   bool rv = NPNFuncs.identifierisstring(identifier);
 610
 611   if(logger)
 612     logger->logReturn(action_npn_identifier_is_string, rv);
 613
 614   return rv;
 615 }
 616
 617 NPIdentifier NPN_GetIntIdentifier(int32_t value)
 618 {
 619   if(logger)
 620     logger->logCall(action_npn_get_int_identifer, (DWORD)value);
 621
 622   NPIdentifier rv = NPNFuncs.getintidentifier(value);
 623
 624   if(logger)
 625     logger->logReturn(action_npn_get_int_identifer, (DWORD)rv);
 626
 627   return rv;
 628 }
 629
 630 void NPN_GetStringIdentifiers(const NPUTF8 **names, int32_t count, NPIdentifier *identifiers)
 631 {
 632   if(logger)
 633     logger->logCall(action_npn_get_string_identifiers);
 634
 635   NPNFuncs.getstringidentifiers(names, count, identifiers);
 636 }