modules/plugin/base/src/nsJSNPRuntime.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   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 "nsJSNPRuntime.h"
  39 #include "nsNPAPIPlugin.h"
  40 #include "nsNPAPIPluginInstance.h"
  41 #include "nsIPluginInstancePeer2.h"
  42 #include "nsPIPluginInstancePeer.h"
  43 #include "nsIScriptGlobalObject.h"
  44 #include "nsIScriptContext.h"
  45 #include "nsDOMJSUtils.h"
  46 #include "nsIDocument.h"
  47 #include "nsIJSRuntimeService.h"
  48 #include "nsIJSContextStack.h"
  49 #include "nsIXPConnect.h"
  50 #include "nsIDOMElement.h"
  51 #include "prmem.h"
  52 #include "nsIContent.h"
  53
  54 // FIXME(bug 332648): Give me a real API please!
  55 #include "jscntxt.h"
  56
  57 // Hash of JSObject wrappers that wraps JSObjects as NPObjects. There
  58 // will be one wrapper per JSObject per plugin instance, i.e. if two
  59 // plugins access the JSObject x, two wrappers for x will be
  60 // created. This is needed to be able to properly drop the wrappers
  61 // when a plugin is torn down in case there's a leak in the plugin (we
  62 // don't want to leak the world just because a plugin leaks an
  63 // NPObject).
  64 static PLDHashTable sJSObjWrappers;
  65
  66 // Hash of NPObject wrappers that wrap NPObjects as JSObjects.
  67 static PLDHashTable sNPObjWrappers;
  68
  69 // Global wrapper count. This includes JSObject wrappers *and*
  70 // NPObject wrappers. When this count goes to zero, there are no more
  71 // wrappers and we can kill off hash tables etc.
  72 static PRInt32 sWrapperCount;
  73
  74 // The JSRuntime. Used to unroot JSObjects when no JSContext is
  75 // reachable.
  76 static JSRuntime *sJSRuntime;
  77
  78 // The JS context stack, we use this to push a plugin's JSContext onto
  79 // while executing JS on the context.
  80 static nsIJSContextStack *sContextStack;
  81
  82
  83 // Helper class that reports any JS exceptions that were thrown while
  84 // the plugin executed JS.
  85
  86 class AutoJSExceptionReporter
  87 {
  88 public:
  89   AutoJSExceptionReporter(JSContext *cx)
  90     : mCx(cx)
  91   {
  92   }
  93
  94   ~AutoJSExceptionReporter()
  95   {
  96     JS_ReportPendingException(mCx);
  97   }
  98
  99 protected:
 100   JSContext *mCx;
 101 };
 102
 103
 104 NPClass nsJSObjWrapper::sJSObjWrapperNPClass =
 105   {
 106     NP_CLASS_STRUCT_VERSION,
 107     nsJSObjWrapper::NP_Allocate,
 108     nsJSObjWrapper::NP_Deallocate,
 109     nsJSObjWrapper::NP_Invalidate,
 110     nsJSObjWrapper::NP_HasMethod,
 111     nsJSObjWrapper::NP_Invoke,
 112     nsJSObjWrapper::NP_InvokeDefault,
 113     nsJSObjWrapper::NP_HasProperty,
 114     nsJSObjWrapper::NP_GetProperty,
 115     nsJSObjWrapper::NP_SetProperty,
 116     nsJSObjWrapper::NP_RemoveProperty,
 117     nsJSObjWrapper::NP_Enumerate,
 118     nsJSObjWrapper::NP_Construct
 119   };
 120
 121 static JSBool
 122 NPObjWrapper_AddProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
 123
 124 static JSBool
 125 NPObjWrapper_DelProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
 126
 127 static JSBool
 128 NPObjWrapper_SetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
 129
 130 static JSBool
 131 NPObjWrapper_GetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp);
 132
 133 static JSBool
 134 NPObjWrapper_newEnumerate(JSContext *cx, JSObject *obj, JSIterateOp enum_op,
 135                           jsval *statep, jsid *idp);
 136
 137 static JSBool
 138 NPObjWrapper_NewResolve(JSContext *cx, JSObject *obj, jsval id, uintN flags,
 139                         JSObject **objp);
 140
 141 static JSBool
 142 NPObjWrapper_Convert(JSContext *cx, JSObject *obj, JSType type, jsval *vp);
 143
 144 static void
 145 NPObjWrapper_Finalize(JSContext *cx, JSObject *obj);
 146
 147 static JSBool
 148 NPObjWrapper_Call(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
 149                   jsval *rval);
 150
 151 static JSBool
 152 NPObjWrapper_Construct(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
 153                        jsval *rval);
 154
 155 static bool
 156 CreateNPObjectMember(NPP npp, JSContext *cx, JSObject *obj,
 157                      NPObject *npobj, jsval id, jsval *vp);
 158
 159 static JSClass sNPObjectJSWrapperClass =
 160   {
 161     NPRUNTIME_JSCLASS_NAME,
 162     JSCLASS_HAS_PRIVATE | JSCLASS_NEW_RESOLVE | JSCLASS_NEW_ENUMERATE,
 163     NPObjWrapper_AddProperty, NPObjWrapper_DelProperty,
 164     NPObjWrapper_GetProperty, NPObjWrapper_SetProperty,
 165     (JSEnumerateOp)NPObjWrapper_newEnumerate,
 166     (JSResolveOp)NPObjWrapper_NewResolve, NPObjWrapper_Convert,
 167     NPObjWrapper_Finalize, nsnull, nsnull, NPObjWrapper_Call,
 168     NPObjWrapper_Construct, nsnull, nsnull
 169   };
 170
 171 typedef struct NPObjectMemberPrivate {
 172     JSObject *npobjWrapper;
 173     jsval fieldValue;
 174     jsval methodName;
 175     NPP   npp;
 176 } NPObjectMemberPrivate;
 177
 178 static JSBool
 179 NPObjectMember_Convert(JSContext *cx, JSObject *obj, JSType type, jsval *vp);
 180
 181 static void
 182 NPObjectMember_Finalize(JSContext *cx, JSObject *obj);
 183
 184 static JSBool
 185 NPObjectMember_Call(JSContext *cx, JSObject *obj, uintN argc,
 186                     jsval *argv, jsval *rval);
 187
 188 static uint32
 189 NPObjectMember_Mark(JSContext *cx, JSObject *obj, void *arg);
 190
 191 static JSClass sNPObjectMemberClass =
 192   {
 193     "NPObject Ambiguous Member class", JSCLASS_HAS_PRIVATE,
 194     JS_PropertyStub, JS_PropertyStub,
 195     JS_PropertyStub, JS_PropertyStub, JS_EnumerateStub,
 196     JS_ResolveStub, NPObjectMember_Convert,
 197     NPObjectMember_Finalize, nsnull, nsnull, NPObjectMember_Call,
 198     nsnull, nsnull, nsnull, NPObjectMember_Mark, nsnull
 199   };
 200
 201 static void
 202 OnWrapperCreated()
 203 {
 204   if (sWrapperCount++ == 0) {
 205     static const char rtsvc_id[] = "@mozilla.org/js/xpc/RuntimeService;1";
 206     nsCOMPtr<nsIJSRuntimeService> rtsvc(do_GetService(rtsvc_id));
 207     if (!rtsvc)
 208       return;
 209
 210     rtsvc->GetRuntime(&sJSRuntime);
 211     NS_ASSERTION(sJSRuntime != nsnull, "no JSRuntime?!");
 212
 213     CallGetService("@mozilla.org/js/xpc/ContextStack;1", &sContextStack);
 214   }
 215 }
 216
 217 static void
 218 OnWrapperDestroyed()
 219 {
 220   NS_ASSERTION(sWrapperCount, "Whaaa, unbalanced created/destroyed calls!");
 221
 222   if (--sWrapperCount == 0) {
 223     if (sJSObjWrappers.ops) {
 224       NS_ASSERTION(sJSObjWrappers.entryCount == 0, "Uh, hash not empty?");
 225
 226       // No more wrappers, and our hash was initialized. Finish the
 227       // hash to prevent leaking it.
 228       PL_DHashTableFinish(&sJSObjWrappers);
 229
 230       sJSObjWrappers.ops = nsnull;
 231     }
 232
 233     if (sNPObjWrappers.ops) {
 234       NS_ASSERTION(sNPObjWrappers.entryCount == 0, "Uh, hash not empty?");
 235
 236       // No more wrappers, and our hash was initialized. Finish the
 237       // hash to prevent leaking it.
 238       PL_DHashTableFinish(&sNPObjWrappers);
 239
 240       sNPObjWrappers.ops = nsnull;
 241     }
 242
 243     // No more need for this.
 244     sJSRuntime = nsnull;
 245
 246     NS_IF_RELEASE(sContextStack);
 247   }
 248 }
 249
 250 struct AutoCXPusher
 251 {
 252   AutoCXPusher(JSContext *cx)
 253   {
 254     // Precondition explaining why we don't need to worry about errors
 255     // in OnWrapperCreated.
 256     NS_PRECONDITION(sWrapperCount > 0,
 257                     "must have live wrappers when using AutoCXPusher");
 258
 259     // Call OnWrapperCreated and OnWrapperDestroyed to ensure that the
 260     // last OnWrapperDestroyed doesn't happen while we're on the stack
 261     // and null out sContextStack.
 262     OnWrapperCreated();
 263
 264     sContextStack->Push(cx);
 265   }
 266
 267   ~AutoCXPusher()
 268   {
 269     JSContext *cx = nsnull;
 270     sContextStack->Pop(&cx);
 271
 272     JSContext *currentCx = nsnull;
 273     sContextStack->Peek(&currentCx);
 274
 275     if (!currentCx) {
 276       // No JS is running, tell the context we're done executing
 277       // script.
 278
 279       nsIScriptContext *scx = GetScriptContextFromJSContext(cx);
 280
 281       if (scx) {
 282         scx->ScriptEvaluated(PR_TRUE);
 283       }
 284     }
 285
 286     OnWrapperDestroyed();
 287   }
 288 };
 289
 290 static JSContext *
 291 GetJSContext(NPP npp)
 292 {
 293   NS_ENSURE_TRUE(npp, nsnull);
 294
 295   nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)npp->ndata;
 296   NS_ENSURE_TRUE(inst, nsnull);
 297
 298   nsCOMPtr<nsPIPluginInstancePeer> pp(do_QueryInterface(inst->Peer()));
 299   NS_ENSURE_TRUE(pp, nsnull);
 300
 301   nsCOMPtr<nsIPluginInstanceOwner> owner;
 302   pp->GetOwner(getter_AddRefs(owner));
 303   NS_ENSURE_TRUE(owner, nsnull);
 304
 305   nsCOMPtr<nsIDocument> doc;
 306   owner->GetDocument(getter_AddRefs(doc));
 307   NS_ENSURE_TRUE(doc, nsnull);
 308
 309   nsCOMPtr<nsISupports> documentContainer = doc->GetContainer();
 310   nsCOMPtr<nsIScriptGlobalObject> sgo(do_GetInterface(documentContainer));
 311   NS_ENSURE_TRUE(sgo, nsnull);
 312
 313   nsIScriptContext *scx = sgo->GetContext();
 314   NS_ENSURE_TRUE(scx, nsnull);
 315
 316   return (JSContext *)scx->GetNativeContext();
 317 }
 318
 319
 320 static NPP
 321 LookupNPP(NPObject *npobj);
 322
 323
 324 static jsval
 325 NPVariantToJSVal(NPP npp, JSContext *cx, const NPVariant *variant)
 326 {
 327   switch (variant->type) {
 328   case NPVariantType_Void :
 329     return JSVAL_VOID;
 330   case NPVariantType_Null :
 331     return JSVAL_NULL;
 332   case NPVariantType_Bool :
 333     return BOOLEAN_TO_JSVAL(NPVARIANT_TO_BOOLEAN(*variant));
 334   case NPVariantType_Int32 :
 335     {
 336       // Don't use INT_TO_JSVAL directly to prevent bugs when dealing
 337       // with ints larger than what fits in a integer jsval.
 338       jsval val;
 339       if (::JS_NewNumberValue(cx, NPVARIANT_TO_INT32(*variant), &val)) {
 340         return val;
 341       }
 342
 343       break;
 344     }
 345   case NPVariantType_Double :
 346     {
 347       jsval val;
 348       if (::JS_NewNumberValue(cx, NPVARIANT_TO_DOUBLE(*variant), &val)) {
 349         return val;
 350       }
 351
 352       break;
 353     }
 354   case NPVariantType_String :
 355     {
 356       const NPString *s = &NPVARIANT_TO_STRING(*variant);
 357       NS_ConvertUTF8toUTF16 utf16String(s->UTF8Characters, s->UTF8Length);
 358
 359       JSString *str =
 360         ::JS_NewUCStringCopyN(cx, reinterpret_cast<const jschar*>
 361                                                   (utf16String.get()),
 362                               utf16String.Length());
 363
 364       if (str) {
 365         return STRING_TO_JSVAL(str);
 366       }
 367
 368       break;
 369     }
 370   case NPVariantType_Object:
 371     {
 372       if (npp) {
 373         JSObject *obj =
 374           nsNPObjWrapper::GetNewOrUsed(npp, cx, NPVARIANT_TO_OBJECT(*variant));
 375
 376         if (obj) {
 377           return OBJECT_TO_JSVAL(obj);
 378         }
 379       }
 380
 381       NS_ERROR("Error wrapping NPObject!");
 382
 383       break;
 384     }
 385   default:
 386     NS_ERROR("Unknown NPVariant type!");
 387   }
 388
 389   NS_ERROR("Unable to convert NPVariant to jsval!");
 390
 391   return JSVAL_VOID;
 392 }
 393
 394 bool
 395 JSValToNPVariant(NPP npp, JSContext *cx, jsval val, NPVariant *variant)
 396 {
 397   NS_ASSERTION(npp, "Must have an NPP to wrap a jsval!");
 398
 399   if (JSVAL_IS_PRIMITIVE(val)) {
 400     if (val == JSVAL_VOID) {
 401       VOID_TO_NPVARIANT(*variant);
 402     } else if (JSVAL_IS_NULL(val)) {
 403       NULL_TO_NPVARIANT(*variant);
 404     } else if (JSVAL_IS_BOOLEAN(val)) {
 405       BOOLEAN_TO_NPVARIANT(JSVAL_TO_BOOLEAN(val), *variant);
 406     } else if (JSVAL_IS_INT(val)) {
 407       INT32_TO_NPVARIANT(JSVAL_TO_INT(val), *variant);
 408     } else if (JSVAL_IS_DOUBLE(val)) {
 409       DOUBLE_TO_NPVARIANT(*JSVAL_TO_DOUBLE(val), *variant);
 410     } else if (JSVAL_IS_STRING(val)) {
 411       JSString *jsstr = JSVAL_TO_STRING(val);
 412       nsDependentString str((PRUnichar *)::JS_GetStringChars(jsstr),
 413                             ::JS_GetStringLength(jsstr));
 414
 415       PRUint32 len;
 416       char *p = ToNewUTF8String(str, &len);
 417
 418       if (!p) {
 419         return false;
 420       }
 421
 422       STRINGN_TO_NPVARIANT(p, len, *variant);
 423     } else {
 424       NS_ERROR("Unknown primitive type!");
 425
 426       return false;
 427     }
 428
 429     return true;
 430   }
 431
 432   NPObject *npobj =
 433     nsJSObjWrapper::GetNewOrUsed(npp, cx, JSVAL_TO_OBJECT(val));
 434   if (!npobj) {
 435     return false;
 436   }
 437
 438   // Pass over ownership of npobj to *variant
 439   OBJECT_TO_NPVARIANT(npobj, *variant);
 440
 441   return true;
 442 }
 443
 444 static void
 445 ThrowJSException(JSContext *cx, const char *message)
 446 {
 447   const char *ex = PeekException();
 448
 449   if (ex) {
 450     nsAutoString ucex;
 451
 452     if (message) {
 453       AppendASCIItoUTF16(message, ucex);
 454
 455       AppendASCIItoUTF16(" [plugin exception: ", ucex);
 456     }
 457
 458     AppendUTF8toUTF16(ex, ucex);
 459
 460     if (message) {
 461       AppendASCIItoUTF16("].", ucex);
 462     }
 463
 464     JSString *str = ::JS_NewUCStringCopyN(cx, (jschar *)ucex.get(),
 465                                           ucex.Length());
 466
 467     if (str) {
 468       ::JS_SetPendingException(cx, STRING_TO_JSVAL(str));
 469     }
 470
 471     PopException();
 472   } else {
 473     ::JS_ReportError(cx, message);
 474   }
 475 }
 476
 477 static JSBool
 478 ReportExceptionIfPending(JSContext *cx)
 479 {
 480   const char *ex = PeekException();
 481
 482   if (!ex) {
 483     return JS_TRUE;
 484   }
 485
 486   ThrowJSException(cx, nsnull);
 487
 488   return JS_FALSE;
 489 }
 490
 491
 492 nsJSObjWrapper::nsJSObjWrapper(NPP npp)
 493   : nsJSObjWrapperKey(nsnull, npp)
 494 {
 495   OnWrapperCreated();
 496 }
 497
 498 nsJSObjWrapper::~nsJSObjWrapper()
 499 {
 500   // Invalidate first, since it relies on sJSRuntime and sJSObjWrappers.
 501   NP_Invalidate(this);
 502
 503   OnWrapperDestroyed();
 504 }
 505
 506 // static
 507 NPObject *
 508 nsJSObjWrapper::NP_Allocate(NPP npp, NPClass *aClass)
 509 {
 510   NS_ASSERTION(aClass == &sJSObjWrapperNPClass,
 511                "Huh, wrong class passed to NP_Allocate()!!!");
 512
 513   return new nsJSObjWrapper(npp);
 514 }
 515
 516 // static
 517 void
 518 nsJSObjWrapper::NP_Deallocate(NPObject *npobj)
 519 {
 520   // nsJSObjWrapper::~nsJSObjWrapper() will call NP_Invalidate().
 521   delete (nsJSObjWrapper *)npobj;
 522 }
 523
 524 // static
 525 void
 526 nsJSObjWrapper::NP_Invalidate(NPObject *npobj)
 527 {
 528   nsJSObjWrapper *jsnpobj = (nsJSObjWrapper *)npobj;
 529
 530   if (jsnpobj && jsnpobj->mJSObj) {
 531     // Unroot the object's JSObject
 532     ::JS_RemoveRootRT(sJSRuntime, &jsnpobj->mJSObj);
 533
 534     if (sJSObjWrappers.ops) {
 535       // Remove the wrapper from the hash
 536
 537       nsJSObjWrapperKey key(jsnpobj->mJSObj, jsnpobj->mNpp);
 538       PL_DHashTableOperate(&sJSObjWrappers, &key, PL_DHASH_REMOVE);
 539     }
 540
 541     // Forget our reference to the JSObject.
 542     jsnpobj->mJSObj = nsnull;
 543   }
 544 }
 545
 546 static JSBool
 547 GetProperty(JSContext *cx, JSObject *obj, NPIdentifier identifier, jsval *rval)
 548 {
 549   jsval id = (jsval)identifier;
 550
 551   if (JSVAL_IS_STRING(id)) {
 552     JSString *str = JSVAL_TO_STRING(id);
 553
 554     return ::JS_GetUCProperty(cx, obj, ::JS_GetStringChars(str),
 555                               ::JS_GetStringLength(str), rval);
 556   }
 557
 558   NS_ASSERTION(JSVAL_IS_INT(id), "id must be either string or int!\n");
 559
 560   return ::JS_GetElement(cx, obj, JSVAL_TO_INT(id), rval);
 561 }
 562
 563 // static
 564 bool
 565 nsJSObjWrapper::NP_HasMethod(NPObject *npobj, NPIdentifier identifier)
 566 {
 567   NPP npp = NPPStack::Peek();
 568   JSContext *cx = GetJSContext(npp);
 569
 570   if (!cx) {
 571     NS_ERROR("Null cx in nsJSObjWrapper::NP_HasMethod!");
 572     return PR_FALSE;
 573   }
 574
 575   if (!npobj) {
 576     ThrowJSException(cx,
 577                      "Null npobj in nsJSObjWrapper::NP_HasMethod!");
 578
 579     return PR_FALSE;
 580   }
 581
 582   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
 583
 584   AutoCXPusher pusher(cx);
 585   JSAutoRequest ar(cx);
 586   AutoJSExceptionReporter reporter(cx);
 587
 588   jsval v;
 589   JSBool ok = GetProperty(cx, npjsobj->mJSObj, identifier, &v);
 590
 591   return ok && !JSVAL_IS_PRIMITIVE(v) &&
 592     ::JS_ObjectIsFunction(cx, JSVAL_TO_OBJECT(v));
 593 }
 594
 595 static bool
 596 doInvoke(NPObject *npobj, NPIdentifier method, const NPVariant *args,
 597          uint32_t argCount, PRBool ctorCall, NPVariant *result)
 598 {
 599   NPP npp = NPPStack::Peek();
 600   JSContext *cx = GetJSContext(npp);
 601
 602   if (!cx) {
 603     NS_ERROR("Null cx in doInvoke!");
 604     return PR_FALSE;
 605   }
 606
 607   if (!npobj || !result) {
 608     ThrowJSException(cx, "Null npobj, or result in doInvoke!");
 609
 610     return PR_FALSE;
 611   }
 612
 613   // Initialize *result
 614   VOID_TO_NPVARIANT(*result);
 615
 616   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
 617   jsval fv;
 618
 619   AutoCXPusher pusher(cx);
 620   JSAutoRequest ar(cx);
 621   AutoJSExceptionReporter reporter(cx);
 622
 623   if ((jsval)method != JSVAL_VOID) {
 624     if (!GetProperty(cx, npjsobj->mJSObj, method, &fv) ||
 625         ::JS_TypeOfValue(cx, fv) != JSTYPE_FUNCTION) {
 626       return PR_FALSE;
 627     }
 628   } else {
 629     fv = OBJECT_TO_JSVAL(npjsobj->mJSObj);
 630   }
 631
 632   jsval jsargs_buf[8];
 633   jsval *jsargs = jsargs_buf;
 634
 635   if (argCount > (sizeof(jsargs_buf) / sizeof(jsval))) {
 636     // Our stack buffer isn't large enough to hold all arguments,
 637     // malloc a buffer.
 638     jsargs = (jsval *)PR_Malloc(argCount * sizeof(jsval));
 639     if (!jsargs) {
 640       ::JS_ReportOutOfMemory(cx);
 641
 642       return PR_FALSE;
 643     }
 644   }
 645
 646   JSTempValueRooter tvr;
 647   JS_PUSH_TEMP_ROOT(cx, 0, jsargs, &tvr);
 648
 649   // Convert args
 650   for (PRUint32 i = 0; i < argCount; ++i) {
 651     jsargs[i] = NPVariantToJSVal(npp, cx, args + i);
 652     ++tvr.count;
 653   }
 654
 655   jsval v;
 656   JSBool ok;
 657
 658   if (ctorCall) {
 659     JSObject *global = ::JS_GetGlobalForObject(cx, npjsobj->mJSObj);
 660     JSObject *newObj =
 661       ::JS_ConstructObjectWithArguments(cx, JS_GET_CLASS(cx, npjsobj->mJSObj),
 662                                         nsnull, global, argCount, jsargs);
 663
 664     if (newObj) {
 665       v = OBJECT_TO_JSVAL(newObj);
 666       ok = JS_TRUE;
 667     } else {
 668       ok = JS_FALSE;
 669     }
 670   } else {
 671     ok = ::JS_CallFunctionValue(cx, npjsobj->mJSObj, fv, argCount, jsargs, &v);
 672   }
 673
 674   JS_POP_TEMP_ROOT(cx, &tvr);
 675
 676   if (jsargs != jsargs_buf)
 677     PR_Free(jsargs);
 678
 679   if (ok)
 680     ok = JSValToNPVariant(npp, cx, v, result);
 681
 682   // return ok == JS_TRUE to quiet down compiler warning, even if
 683   // return ok is what we really want.
 684   return ok == JS_TRUE;
 685 }
 686
 687 // static
 688 bool
 689 nsJSObjWrapper::NP_Invoke(NPObject *npobj, NPIdentifier method,
 690                           const NPVariant *args, uint32_t argCount,
 691                           NPVariant *result)
 692 {
 693   if ((jsval)method == JSVAL_VOID) {
 694     return PR_FALSE;
 695   }
 696
 697   return doInvoke(npobj, method, args, argCount, PR_FALSE, result);
 698 }
 699
 700 // static
 701 bool
 702 nsJSObjWrapper::NP_InvokeDefault(NPObject *npobj, const NPVariant *args,
 703                                  uint32_t argCount, NPVariant *result)
 704 {
 705   return doInvoke(npobj, (NPIdentifier)JSVAL_VOID, args, argCount, PR_FALSE,
 706                   result);
 707 }
 708
 709 // static
 710 bool
 711 nsJSObjWrapper::NP_HasProperty(NPObject *npobj, NPIdentifier identifier)
 712 {
 713   NPP npp = NPPStack::Peek();
 714   JSContext *cx = GetJSContext(npp);
 715
 716   if (!cx) {
 717     NS_ERROR("Null cx in nsJSObjWrapper::NP_HasProperty!");
 718     return PR_FALSE;
 719   }
 720
 721   if (!npobj) {
 722     ThrowJSException(cx,
 723                      "Null npobj in nsJSObjWrapper::NP_HasProperty!");
 724
 725     return PR_FALSE;
 726   }
 727
 728   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
 729   jsval id = (jsval)identifier;
 730   JSBool found, ok = JS_FALSE;
 731
 732   AutoCXPusher pusher(cx);
 733   JSAutoRequest ar(cx);
 734   AutoJSExceptionReporter reporter(cx);
 735
 736   if (JSVAL_IS_STRING(id)) {
 737     JSString *str = JSVAL_TO_STRING(id);
 738
 739     ok = ::JS_HasUCProperty(cx, npjsobj->mJSObj, ::JS_GetStringChars(str),
 740                             ::JS_GetStringLength(str), &found);
 741   } else {
 742     NS_ASSERTION(JSVAL_IS_INT(id), "id must be either string or int!\n");
 743
 744     ok = ::JS_HasElement(cx, npjsobj->mJSObj, JSVAL_TO_INT(id), &found);
 745   }
 746
 747   return ok && found;
 748 }
 749
 750 // static
 751 bool
 752 nsJSObjWrapper::NP_GetProperty(NPObject *npobj, NPIdentifier identifier,
 753                                NPVariant *result)
 754 {
 755   NPP npp = NPPStack::Peek();
 756   JSContext *cx = GetJSContext(npp);
 757
 758   if (!cx) {
 759     NS_ERROR("Null cx in nsJSObjWrapper::NP_GetProperty!");
 760     return PR_FALSE;
 761   }
 762
 763   if (!npobj) {
 764     ThrowJSException(cx,
 765                      "Null npobj in nsJSObjWrapper::NP_GetProperty!");
 766
 767     return PR_FALSE;
 768   }
 769
 770   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
 771
 772   AutoCXPusher pusher(cx);
 773   JSAutoRequest ar(cx);
 774   AutoJSExceptionReporter reporter(cx);
 775
 776   jsval v;
 777   return (GetProperty(cx, npjsobj->mJSObj, identifier, &v) &&
 778           JSValToNPVariant(npp, cx, v, result));
 779 }
 780
 781 // static
 782 bool
 783 nsJSObjWrapper::NP_SetProperty(NPObject *npobj, NPIdentifier identifier,
 784                                const NPVariant *value)
 785 {
 786   NPP npp = NPPStack::Peek();
 787   JSContext *cx = GetJSContext(npp);
 788
 789   if (!cx) {
 790     NS_ERROR("Null cx in nsJSObjWrapper::NP_SetProperty!");
 791     return PR_FALSE;
 792   }
 793
 794   if (!npobj) {
 795     ThrowJSException(cx,
 796                      "Null npobj in nsJSObjWrapper::NP_SetProperty!");
 797
 798     return PR_FALSE;
 799   }
 800
 801   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
 802   jsval id = (jsval)identifier;
 803   JSBool ok = JS_FALSE;
 804
 805   AutoCXPusher pusher(cx);
 806   JSAutoRequest ar(cx);
 807   AutoJSExceptionReporter reporter(cx);
 808
 809   jsval v = NPVariantToJSVal(npp, cx, value);
 810   JSAutoTempValueRooter tvr(cx, v);
 811
 812   if (JSVAL_IS_STRING(id)) {
 813     JSString *str = JSVAL_TO_STRING(id);
 814
 815     ok = ::JS_SetUCProperty(cx, npjsobj->mJSObj, ::JS_GetStringChars(str),
 816                             ::JS_GetStringLength(str), &v);
 817   } else {
 818     NS_ASSERTION(JSVAL_IS_INT(id), "id must be either string or int!\n");
 819
 820     ok = ::JS_SetElement(cx, npjsobj->mJSObj, JSVAL_TO_INT(id), &v);
 821   }
 822
 823   // return ok == JS_TRUE to quiet down compiler warning, even if
 824   // return ok is what we really want.
 825   return ok == JS_TRUE;
 826 }
 827
 828 // static
 829 bool
 830 nsJSObjWrapper::NP_RemoveProperty(NPObject *npobj, NPIdentifier identifier)
 831 {
 832   NPP npp = NPPStack::Peek();
 833   JSContext *cx = GetJSContext(npp);
 834
 835   if (!cx) {
 836     NS_ERROR("Null cx in nsJSObjWrapper::NP_RemoveProperty!");
 837     return PR_FALSE;
 838   }
 839
 840   if (!npobj) {
 841     ThrowJSException(cx,
 842                      "Null npobj in nsJSObjWrapper::NP_RemoveProperty!");
 843
 844     return PR_FALSE;
 845   }
 846
 847   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
 848   jsval id = (jsval)identifier;
 849   JSBool ok = JS_FALSE;
 850
 851   AutoCXPusher pusher(cx);
 852   JSAutoRequest ar(cx);
 853   AutoJSExceptionReporter reporter(cx);
 854   jsval deleted = JSVAL_FALSE;
 855
 856   if (JSVAL_IS_STRING(id)) {
 857     JSString *str = JSVAL_TO_STRING(id);
 858
 859     ok = ::JS_DeleteUCProperty2(cx, npjsobj->mJSObj, ::JS_GetStringChars(str),
 860                                 ::JS_GetStringLength(str), &deleted);
 861
 862     if (ok && deleted) {
 863       // FIXME: See bug 425823, we shouldn't need to do this, and once
 864       // that bug is fixed we can remove this code.
 865
 866       JSBool hasProp;
 867       ok = ::JS_HasUCProperty(cx, npjsobj->mJSObj, ::JS_GetStringChars(str),
 868                               ::JS_GetStringLength(str), &hasProp);
 869
 870       if (ok && hasProp) {
 871         // The property might have been deleted, but it got
 872         // re-resolved, so no, it's not really deleted.
 873
 874         deleted = JSVAL_FALSE;
 875       }
 876     }
 877   } else {
 878     NS_ASSERTION(JSVAL_IS_INT(id), "id must be either string or int!\n");
 879
 880     ok = ::JS_DeleteElement2(cx, npjsobj->mJSObj, JSVAL_TO_INT(id), &deleted);
 881
 882     if (ok && deleted) {
 883       // FIXME: See bug 425823, we shouldn't need to do this, and once
 884       // that bug is fixed we can remove this code.
 885
 886       JSBool hasProp;
 887       ok = ::JS_HasElement(cx, npjsobj->mJSObj, JSVAL_TO_INT(id), &hasProp);
 888
 889       if (ok && hasProp) {
 890         // The property might have been deleted, but it got
 891         // re-resolved, so no, it's not really deleted.
 892
 893         deleted = JSVAL_FALSE;
 894       }
 895     }
 896   }
 897
 898   // return ok == JS_TRUE to quiet down compiler warning, even if
 899   // return ok is what we really want.
 900   return ok == JS_TRUE && deleted == JSVAL_TRUE;
 901 }
 902
 903 //static
 904 bool
 905 nsJSObjWrapper::NP_Enumerate(NPObject *npobj, NPIdentifier **identifier,
 906                              uint32_t *count)
 907 {
 908   NPP npp = NPPStack::Peek();
 909   JSContext *cx = GetJSContext(npp);
 910
 911   *identifier = 0;
 912   *count = 0;
 913
 914   if (!cx) {
 915     NS_ERROR("Null cx in nsJSObjWrapper::NP_Enumerate!");
 916     return PR_FALSE;
 917   }
 918
 919   if (!npobj) {
 920     ThrowJSException(cx,
 921                      "Null npobj in nsJSObjWrapper::NP_Enumerate!");
 922
 923     return PR_FALSE;
 924   }
 925
 926   nsJSObjWrapper *npjsobj = (nsJSObjWrapper *)npobj;
 927
 928   AutoCXPusher pusher(cx);
 929   JSAutoRequest ar(cx);
 930   AutoJSExceptionReporter reporter(cx);
 931
 932   JSIdArray *ida = ::JS_Enumerate(cx, npjsobj->mJSObj);
 933   if (!ida) {
 934     return PR_FALSE;
 935   }
 936
 937   *count = ida->length;
 938   *identifier = (NPIdentifier *)PR_Malloc(*count * sizeof(NPIdentifier));
 939   if (!*identifier) {
 940     ThrowJSException(cx, "Memory allocation failed for NPIdentifier!");
 941
 942     ::JS_DestroyIdArray(cx, ida);
 943
 944     return PR_FALSE;
 945   }
 946
 947   for (PRUint32 i = 0; i < *count; i++) {
 948     jsval v;
 949     if (!::JS_IdToValue(cx, ida->vector[i], &v)) {
 950       ::JS_DestroyIdArray(cx, ida);
 951       PR_Free(*identifier);
 952       return PR_FALSE;
 953     }
 954
 955     if (JSVAL_IS_STRING(v)) {
 956       JSString *str = JSVAL_TO_STRING(v);
 957
 958       if (!JS_InternUCStringN(cx, ::JS_GetStringChars(str),
 959                               ::JS_GetStringLength(str))) {
 960         ::JS_DestroyIdArray(cx, ida);
 961         PR_Free(*identifier);
 962
 963         return PR_FALSE;
 964       }
 965     } else {
 966       NS_ASSERTION(JSVAL_IS_INT(v),
 967                    "The element in ida must be either string or int!\n");
 968     }
 969
 970     (*identifier)[i] = (NPIdentifier)v;
 971   }
 972
 973   ::JS_DestroyIdArray(cx, ida);
 974
 975   return PR_TRUE;
 976 }
 977
 978 //static
 979 bool
 980 nsJSObjWrapper::NP_Construct(NPObject *npobj, const NPVariant *args,
 981                              uint32_t argCount, NPVariant *result)
 982 {
 983   return doInvoke(npobj, (NPIdentifier)JSVAL_VOID, args, argCount, PR_TRUE,
 984                   result);
 985 }
 986
 987
 988 class JSObjWrapperHashEntry : public PLDHashEntryHdr
 989 {
 990 public:
 991   nsJSObjWrapper *mJSObjWrapper;
 992 };
 993
 994
 995 static PLDHashNumber
 996 JSObjWrapperHash(PLDHashTable *table, const void *key)
 997 {
 998   const nsJSObjWrapperKey *e = static_cast<const nsJSObjWrapperKey *>(key);
 999
1000   return (PLDHashNumber)((PRWord)e->mJSObj ^ (PRWord)e->mNpp) >> 2;
1001 }
1002
1003 static PRBool
1004 JSObjWrapperHashMatchEntry(PLDHashTable *table, const PLDHashEntryHdr *entry,
1005                            const void *key)
1006 {
1007   const nsJSObjWrapperKey *objWrapperKey =
1008     static_cast<const nsJSObjWrapperKey *>(key);
1009   const JSObjWrapperHashEntry *e =
1010     static_cast<const JSObjWrapperHashEntry *>(entry);
1011
1012   return (e->mJSObjWrapper->mJSObj == objWrapperKey->mJSObj &&
1013           e->mJSObjWrapper->mNpp == objWrapperKey->mNpp);
1014 }
1015
1016
1017 // Look up or create an NPObject that wraps the JSObject obj.
1018
1019 // static
1020 NPObject *
1021 nsJSObjWrapper::GetNewOrUsed(NPP npp, JSContext *cx, JSObject *obj)
1022 {
1023   if (!npp) {
1024     NS_ERROR("Null NPP passed to nsJSObjWrapper::GetNewOrUsed()!");
1025
1026     return nsnull;
1027   }
1028
1029   if (!cx) {
1030     cx = GetJSContext(npp);
1031
1032     if (!cx) {
1033       NS_ERROR("Unable to find a JSContext in "
1034                "nsJSObjWrapper::GetNewOrUsed()!");
1035
1036       return nsnull;
1037     }
1038   }
1039
1040   JSClass *clazz = JS_GET_CLASS(cx, obj);
1041
1042   if (clazz == &sNPObjectJSWrapperClass) {
1043     // obj is one of our own, its private data is the NPObject we're
1044     // looking for.
1045
1046     NPObject *npobj = (NPObject *)::JS_GetPrivate(cx, obj);
1047
1048     return _retainobject(npobj);
1049   }
1050
1051   if (!sJSObjWrappers.ops) {
1052     // No hash yet (or any more), initialize it.
1053
1054     static PLDHashTableOps ops =
1055       {
1056         PL_DHashAllocTable,
1057         PL_DHashFreeTable,
1058         JSObjWrapperHash,
1059         JSObjWrapperHashMatchEntry,
1060         PL_DHashMoveEntryStub,
1061         PL_DHashClearEntryStub,
1062         PL_DHashFinalizeStub
1063       };
1064
1065     if (!PL_DHashTableInit(&sJSObjWrappers, &ops, nsnull,
1066                            sizeof(JSObjWrapperHashEntry), 16)) {
1067       NS_ERROR("Error initializing PLDHashTable!");
1068
1069       return nsnull;
1070     }
1071   }
1072
1073   nsJSObjWrapperKey key(obj, npp);
1074
1075   JSObjWrapperHashEntry *entry = static_cast<JSObjWrapperHashEntry *>
1076     (PL_DHashTableOperate(&sJSObjWrappers, &key, PL_DHASH_ADD));
1077
1078   if (!entry) {
1079     // Out of memory.
1080     return nsnull;
1081   }
1082
1083   if (PL_DHASH_ENTRY_IS_BUSY(entry) && entry->mJSObjWrapper) {
1084     // Found a live nsJSObjWrapper, return it.
1085
1086     return _retainobject(entry->mJSObjWrapper);
1087   }
1088
1089   // No existing nsJSObjWrapper, create one.
1090
1091   nsJSObjWrapper *wrapper =
1092     (nsJSObjWrapper *)_createobject(npp, &sJSObjWrapperNPClass);
1093
1094   if (!wrapper) {
1095     // OOM? Remove the stale entry from the hash.
1096
1097     PL_DHashTableRawRemove(&sJSObjWrappers, entry);
1098
1099     return nsnull;
1100   }
1101
1102   wrapper->mJSObj = obj;
1103
1104   entry->mJSObjWrapper = wrapper;
1105
1106   NS_ASSERTION(wrapper->mNpp == npp, "nsJSObjWrapper::mNpp not initialized!");
1107
1108   JSAutoRequest ar(cx);
1109
1110   // Root the JSObject, its lifetime is now tied to that of the
1111   // NPObject.
1112   if (!::JS_AddNamedRoot(cx, &wrapper->mJSObj, "nsJSObjWrapper::mJSObject")) {
1113     NS_ERROR("Failed to root JSObject!");
1114
1115     _releaseobject(wrapper);
1116
1117     PL_DHashTableRawRemove(&sJSObjWrappers, entry);
1118
1119     return nsnull;
1120   }
1121
1122   return wrapper;
1123 }
1124
1125 static NPObject *
1126 GetNPObject(JSContext *cx, JSObject *obj)
1127 {
1128   while (obj && JS_GET_CLASS(cx, obj) != &sNPObjectJSWrapperClass) {
1129     obj = ::JS_GetPrototype(cx, obj);
1130   }
1131
1132   if (!obj) {
1133     return nsnull;
1134   }
1135
1136   return (NPObject *)::JS_GetPrivate(cx, obj);
1137 }
1138
1139 static JSBool
1140 NPObjWrapper_AddProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
1141 {
1142   NPObject *npobj = GetNPObject(cx, obj);
1143
1144   if (!npobj || !npobj->_class || !npobj->_class->hasProperty ||
1145       !npobj->_class->hasMethod) {
1146     ThrowJSException(cx, "Bad NPObject as private data!");
1147
1148     return JS_FALSE;
1149   }
1150
1151   // We must permit methods here since JS_DefineUCFunction() will add
1152   // the function as a property
1153   if (!npobj->_class->hasProperty(npobj, (NPIdentifier)id) &&
1154       !npobj->_class->hasMethod(npobj, (NPIdentifier)id)) {
1155     ThrowJSException(cx, "Trying to add unsupported property on scriptable "
1156                      "plugin object!");
1157
1158     return JS_FALSE;
1159   }
1160
1161   return ReportExceptionIfPending(cx);
1162 }
1163
1164 static JSBool
1165 NPObjWrapper_DelProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
1166 {
1167   NPObject *npobj = GetNPObject(cx, obj);
1168
1169   if (!npobj || !npobj->_class || !npobj->_class->hasProperty) {
1170     ThrowJSException(cx, "Bad NPObject as private data!");
1171
1172     return JS_FALSE;
1173   }
1174
1175   if (!npobj->_class->hasProperty(npobj, (NPIdentifier)id)) {
1176     ThrowJSException(cx, "Trying to remove unsupported property on scriptable "
1177                      "plugin object!");
1178
1179     return JS_FALSE;
1180   }
1181
1182   return ReportExceptionIfPending(cx);
1183 }
1184
1185 static JSBool
1186 NPObjWrapper_SetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
1187 {
1188   NPObject *npobj = GetNPObject(cx, obj);
1189
1190   if (!npobj || !npobj->_class || !npobj->_class->hasProperty ||
1191       !npobj->_class->setProperty) {
1192     ThrowJSException(cx, "Bad NPObject as private data!");
1193
1194     return JS_FALSE;
1195   }
1196
1197   if (!npobj->_class->hasProperty(npobj, (NPIdentifier)id)) {
1198     ThrowJSException(cx, "Trying to set unsupported property on scriptable "
1199                      "plugin object!");
1200
1201     return JS_FALSE;
1202   }
1203
1204   // Find out what plugin (NPP) is the owner of the object we're
1205   // manipulating, and make it own any JSObject wrappers created here.
1206   NPP npp = LookupNPP(npobj);
1207
1208   if (!npp) {
1209     ThrowJSException(cx, "No NPP found for NPObject!");
1210
1211     return JS_FALSE;
1212   }
1213
1214   NPVariant npv;
1215   if (!JSValToNPVariant(npp, cx, *vp, &npv)) {
1216     ThrowJSException(cx, "Error converting jsval to NPVariant!");
1217
1218     return JS_FALSE;
1219   }
1220
1221   JSBool ok = npobj->_class->setProperty(npobj, (NPIdentifier)id, &npv);
1222
1223   // Release the variant
1224   _releasevariantvalue(&npv);
1225
1226   if (!ok) {
1227     ThrowJSException(cx, "Error setting property on scriptable plugin "
1228                      "object!");
1229
1230     return JS_FALSE;
1231   }
1232
1233   return ReportExceptionIfPending(cx);
1234 }
1235
1236 static JSBool
1237 NPObjWrapper_GetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
1238 {
1239   NPObject *npobj = GetNPObject(cx, obj);
1240
1241   if (!npobj || !npobj->_class || !npobj->_class->hasProperty ||
1242       !npobj->_class->hasMethod || !npobj->_class->getProperty) {
1243     ThrowJSException(cx, "Bad NPObject as private data!");
1244
1245     return JS_FALSE;
1246   }
1247
1248   PRBool hasProperty = npobj->_class->hasProperty(npobj, (NPIdentifier)id);
1249   PRBool hasMethod = npobj->_class->hasMethod(npobj, (NPIdentifier)id);
1250   NPP npp = nsnull;
1251   if (hasProperty) {
1252     // Find out what plugin (NPP) is the owner of the object we're
1253     // manipulating, and make it own any JSObject wrappers created
1254     // here.
1255     npp = LookupNPP(npobj);
1256     if (!npp) {
1257       ThrowJSException(cx, "No NPP found for NPObject!");
1258
1259       return JS_FALSE;
1260     }
1261   }
1262
1263   // To support ambiguous members, we return NPObject Member class here.
1264   if (hasProperty && hasMethod)
1265     return CreateNPObjectMember(npp, cx, obj, npobj, id, vp);
1266
1267   if (hasProperty) {
1268     NPVariant npv;
1269     VOID_TO_NPVARIANT(npv);
1270
1271     if (!npobj->_class->getProperty(npobj, (NPIdentifier)id, &npv)) {
1272       ThrowJSException(cx, "Error setting property on scriptable plugin "
1273                        "object!");
1274
1275       return JS_FALSE;
1276     }
1277
1278     *vp = NPVariantToJSVal(npp, cx, &npv);
1279
1280     // *vp now owns the value, release our reference.
1281     _releasevariantvalue(&npv);
1282
1283     return JS_TRUE;
1284   }
1285
1286   return ReportExceptionIfPending(cx);
1287 }
1288
1289 static JSBool
1290 CallNPMethodInternal(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
1291                      jsval *rval, PRBool ctorCall)
1292 {
1293   while (obj && JS_GET_CLASS(cx, obj) != &sNPObjectJSWrapperClass) {
1294     obj = ::JS_GetPrototype(cx, obj);
1295   }
1296
1297   if (!obj) {
1298     ThrowJSException(cx, "NPMethod called on non-NPObject wrapped JSObject!");
1299
1300     return JS_FALSE;
1301   }
1302
1303   NPObject *npobj = (NPObject *)::JS_GetPrivate(cx, obj);
1304
1305   if (!npobj || !npobj->_class || !npobj->_class->invoke) {
1306     ThrowJSException(cx, "Bad NPObject as private data!");
1307
1308     return JS_FALSE;
1309   }
1310
1311   // Find out what plugin (NPP) is the owner of the object we're
1312   // manipulating, and make it own any JSObject wrappers created here.
1313   NPP npp = LookupNPP(npobj);
1314
1315   if (!npp) {
1316     ThrowJSException(cx, "Error finding NPP for NPObject!");
1317
1318     return JS_FALSE;
1319   }
1320
1321   NPVariant npargs_buf[8];
1322   NPVariant *npargs = npargs_buf;
1323
1324   if (argc > (sizeof(npargs_buf) / sizeof(NPVariant))) {
1325     // Our stack buffer isn't large enough to hold all arguments,
1326     // malloc a buffer.
1327     npargs = (NPVariant *)PR_Malloc(argc * sizeof(NPVariant));
1328
1329     if (!npargs) {
1330       ThrowJSException(cx, "Out of memory!");
1331
1332       return JS_FALSE;
1333     }
1334   }
1335
1336   // Convert arguments
1337   PRUint32 i;
1338   for (i = 0; i < argc; ++i) {
1339     if (!JSValToNPVariant(npp, cx, argv[i], npargs + i)) {
1340       ThrowJSException(cx, "Error converting jsvals to NPVariants!");
1341
1342       if (npargs != npargs_buf) {
1343         PR_Free(npargs);
1344       }
1345
1346       return JS_FALSE;
1347     }
1348   }
1349
1350   NPVariant v;
1351   VOID_TO_NPVARIANT(v);
1352
1353   JSObject *funobj = JSVAL_TO_OBJECT(argv[-2]);
1354   JSBool ok;
1355   const char *msg = "Error calling method on NPObject!";
1356
1357   if (ctorCall) {
1358     // construct a new NPObject based on the NPClass in npobj. Fail if
1359     // no construct method is available.
1360
1361     if (NP_CLASS_STRUCT_VERSION_HAS_CTOR(npobj->_class) &&
1362         npobj->_class->construct) {
1363       ok = npobj->_class->construct(npobj, npargs, argc, &v);
1364     } else {
1365       ok = JS_FALSE;
1366
1367       msg = "Attempt to construct object from class with no constructor.";
1368     }
1369   } else if (funobj != obj) {
1370     // A obj.function() style call is made, get the method name from
1371     // the function object.
1372
1373     if (npobj->_class->invoke) {
1374       JSFunction *fun = (JSFunction *)::JS_GetPrivate(cx, funobj);
1375       jsval method = STRING_TO_JSVAL(::JS_GetFunctionId(fun));
1376
1377       ok = npobj->_class->invoke(npobj, (NPIdentifier)method, npargs, argc,
1378                                  &v);
1379     } else {
1380       ok = JS_FALSE;
1381
1382       msg = "Attempt to call a method on object with no invoke method.";
1383     }
1384   } else {
1385     if (npobj->_class->invokeDefault) {
1386       // obj is a callable object that is being called, no method name
1387       // available then. Invoke the default method.
1388
1389       ok = npobj->_class->invokeDefault(npobj, npargs, argc, &v);
1390     } else {
1391       ok = JS_FALSE;
1392
1393       msg = "Attempt to call a default method on object with no "
1394         "invokeDefault method.";
1395     }
1396   }
1397
1398   // Release arguments.
1399   for (i = 0; i < argc; ++i) {
1400     _releasevariantvalue(npargs + i);
1401   }
1402
1403   if (npargs != npargs_buf) {
1404     PR_Free(npargs);
1405   }
1406
1407   if (!ok) {
1408     ThrowJSException(cx, msg);
1409
1410     return JS_FALSE;
1411   }
1412
1413   *rval = NPVariantToJSVal(npp, cx, &v);
1414
1415   // *rval now owns the value, release our reference.
1416   _releasevariantvalue(&v);
1417
1418   return ReportExceptionIfPending(cx);
1419 }
1420
1421 static JSBool
1422 CallNPMethod(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
1423              jsval *rval)
1424 {
1425   return CallNPMethodInternal(cx, obj, argc, argv, rval, PR_FALSE);
1426 }
1427
1428 struct NPObjectEnumerateState {
1429   PRUint32     index;
1430   PRUint32     length;
1431   NPIdentifier *value;
1432 };
1433
1434 static JSBool
1435 NPObjWrapper_newEnumerate(JSContext *cx, JSObject *obj, JSIterateOp enum_op,
1436                           jsval *statep, jsid *idp)
1437 {
1438   NPObject *npobj = GetNPObject(cx, obj);
1439   NPIdentifier *enum_value;
1440   uint32_t length;
1441   NPObjectEnumerateState *state;
1442
1443   if (!npobj || !npobj->_class) {
1444     ThrowJSException(cx, "Bad NPObject as private data!");
1445     return JS_FALSE;
1446   }
1447
1448   NS_ASSERTION(statep, "Must have a statep to enumerate!");
1449
1450   switch(enum_op) {
1451   case JSENUMERATE_INIT:
1452     state = new NPObjectEnumerateState();
1453     if (!state) {
1454       ThrowJSException(cx, "Memory allocation failed for "
1455                        "NPObjectEnumerateState!");
1456
1457       return JS_FALSE;
1458     }
1459
1460     if (!NP_CLASS_STRUCT_VERSION_HAS_ENUM(npobj->_class) ||
1461         !npobj->_class->enumerate) {
1462       enum_value = 0;
1463       length = 0;
1464     } else if (!npobj->_class->enumerate(npobj, &enum_value, &length)) {
1465       ThrowJSException(cx, "Error enumerating properties on scriptable "
1466                        "plugin object");
1467       delete state;
1468
1469       return JS_FALSE;
1470     }
1471
1472     state->value = enum_value;
1473     state->length = length;
1474     state->index = 0;
1475     *statep = PRIVATE_TO_JSVAL(state);
1476     if (idp) {
1477       *idp = INT_TO_JSVAL(length);
1478     }
1479
1480     break;
1481
1482   case JSENUMERATE_NEXT:
1483     state = (NPObjectEnumerateState *)JSVAL_TO_PRIVATE(*statep);
1484     enum_value = state->value;
1485     length = state->length;
1486     if (state->index != length) {
1487       return ::JS_ValueToId(cx, (jsval)enum_value[state->index++], idp);
1488     }
1489
1490     // FALL THROUGH
1491
1492   case JSENUMERATE_DESTROY:
1493     state = (NPObjectEnumerateState *)JSVAL_TO_PRIVATE(*statep);
1494     if (state->value)
1495       PR_Free(state->value);
1496     delete state;
1497     *statep = JSVAL_NULL;
1498
1499     break;
1500   }
1501
1502   return JS_TRUE;
1503 }
1504
1505 static JSBool
1506 NPObjWrapper_NewResolve(JSContext *cx, JSObject *obj, jsval id, uintN flags,
1507                         JSObject **objp)
1508 {
1509   NPObject *npobj = GetNPObject(cx, obj);
1510
1511   if (!npobj || !npobj->_class || !npobj->_class->hasProperty ||
1512       !npobj->_class->hasMethod) {
1513     ThrowJSException(cx, "Bad NPObject as private data!");
1514
1515     return JS_FALSE;
1516   }
1517
1518   if (npobj->_class->hasProperty(npobj, (NPIdentifier)id)) {
1519     JSBool ok;
1520
1521     if (JSVAL_IS_STRING(id)) {
1522       JSString *str = JSVAL_TO_STRING(id);
1523
1524       ok = ::JS_DefineUCProperty(cx, obj, ::JS_GetStringChars(str),
1525                                  ::JS_GetStringLength(str), JSVAL_VOID, nsnull,
1526                                  nsnull, JSPROP_ENUMERATE);
1527     } else {
1528       ok = ::JS_DefineElement(cx, obj, JSVAL_TO_INT(id), JSVAL_VOID, nsnull,
1529                               nsnull, JSPROP_ENUMERATE);
1530     }
1531
1532     if (!ok) {
1533       return JS_FALSE;
1534     }
1535
1536     *objp = obj;
1537   } else if (npobj->_class->hasMethod(npobj, (NPIdentifier)id)) {
1538     JSString *str = nsnull;
1539
1540     if (JSVAL_IS_STRING(id)) {
1541       str = JSVAL_TO_STRING(id);
1542     } else {
1543       NS_ASSERTION(JSVAL_IS_INT(id), "id must be either string or int!\n");
1544
1545       str = ::JS_ValueToString(cx, id);
1546
1547       if (!str) {
1548         // OOM. The JS engine throws exceptions for us in this case.
1549
1550         return JS_FALSE;
1551       }
1552     }
1553
1554     JSFunction *fnc =
1555       ::JS_DefineUCFunction(cx, obj, ::JS_GetStringChars(str),
1556                             ::JS_GetStringLength(str), CallNPMethod, 0,
1557                             JSPROP_ENUMERATE);
1558
1559     *objp = obj;
1560
1561     return fnc != nsnull;
1562   }
1563
1564   return ReportExceptionIfPending(cx);
1565 }
1566
1567 static JSBool
1568 NPObjWrapper_Convert(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
1569 {
1570   // The sole reason we implement this hook is to prevent the JS
1571   // engine from calling valueOf() on NPObject's. Some NPObject's may
1572   // actually implement a method named valueOf, but it's unlikely to
1573   // behave as the JS engine expects it to. IOW, this is an empty hook
1574   // that overrides what the default hook does.
1575
1576   return JS_TRUE;
1577 }
1578
1579 static void
1580 NPObjWrapper_Finalize(JSContext *cx, JSObject *obj)
1581 {
1582   NPObject *npobj = (NPObject *)::JS_GetPrivate(cx, obj);
1583
1584   if (npobj) {
1585     if (sNPObjWrappers.ops) {
1586       PL_DHashTableOperate(&sNPObjWrappers, npobj, PL_DHASH_REMOVE);
1587     }
1588
1589     // Let go of our NPObject
1590     _releaseobject(npobj);
1591   }
1592
1593   OnWrapperDestroyed();
1594 }
1595
1596 static JSBool
1597 NPObjWrapper_Call(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
1598                   jsval *rval)
1599 {
1600   return CallNPMethodInternal(cx, JSVAL_TO_OBJECT(argv[-2]), argc, argv, rval,
1601                               PR_FALSE);
1602 }
1603
1604 static JSBool
1605 NPObjWrapper_Construct(JSContext *cx, JSObject *obj, uintN argc, jsval *argv,
1606                        jsval *rval)
1607 {
1608   return CallNPMethodInternal(cx, JSVAL_TO_OBJECT(argv[-2]), argc, argv, rval,
1609                               PR_TRUE);
1610 }
1611
1612 class NPObjWrapperHashEntry : public PLDHashEntryHdr
1613 {
1614 public:
1615   NPObject *mNPObj; // Must be the first member for the PLDHash stubs to work
1616   JSObject *mJSObj;
1617   NPP mNpp;
1618 };
1619
1620
1621 // An NPObject is going away, make sure we null out the JS object's
1622 // private data in case this is an NPObject that came from a plugin
1623 // and it's destroyed prematurely.
1624
1625 // static
1626 void
1627 nsNPObjWrapper::OnDestroy(NPObject *npobj)
1628 {
1629   if (!npobj) {
1630     return;
1631   }
1632
1633   if (npobj->_class == &nsJSObjWrapper::sJSObjWrapperNPClass) {
1634     // npobj is one of our own, no private data to clean up here.
1635
1636     return;
1637   }
1638
1639   if (!sNPObjWrappers.ops) {
1640     // No hash yet (or any more), no used wrappers available.
1641
1642     return;
1643   }
1644
1645   NPObjWrapperHashEntry *entry = static_cast<NPObjWrapperHashEntry *>
1646     (PL_DHashTableOperate(&sNPObjWrappers, npobj, PL_DHASH_LOOKUP));
1647
1648   if (PL_DHASH_ENTRY_IS_BUSY(entry) && entry->mJSObj) {
1649     // Found a live NPObject wrapper, null out its JSObjects' private
1650     // data.
1651
1652     JSContext *cx = GetJSContext(entry->mNpp);
1653
1654     if (cx) {
1655       ::JS_SetPrivate(cx, entry->mJSObj, nsnull);
1656     }
1657
1658     // Remove the npobj from the hash now that it went away.
1659     PL_DHashTableRawRemove(&sNPObjWrappers, entry);
1660
1661     OnWrapperDestroyed();
1662   }
1663 }
1664
1665 // Look up or create a JSObject that wraps the NPObject npobj.
1666
1667 // static
1668 JSObject *
1669 nsNPObjWrapper::GetNewOrUsed(NPP npp, JSContext *cx, NPObject *npobj)
1670 {
1671   if (!npobj) {
1672     NS_ERROR("Null NPObject passed to nsNPObjWrapper::GetNewOrUsed()!");
1673
1674     return nsnull;
1675   }
1676
1677   if (npobj->_class == &nsJSObjWrapper::sJSObjWrapperNPClass) {
1678     // npobj is one of our own, return its existing JSObject.
1679
1680     return ((nsJSObjWrapper *)npobj)->mJSObj;
1681   }
1682
1683   if (!npp) {
1684     NS_ERROR("No npp passed to nsNPObjWrapper::GetNewOrUsed()!");
1685
1686     return nsnull;
1687   }
1688
1689   if (!sNPObjWrappers.ops) {
1690     // No hash yet (or any more), initialize it.
1691
1692     if (!PL_DHashTableInit(&sNPObjWrappers, PL_DHashGetStubOps(), nsnull,
1693                            sizeof(NPObjWrapperHashEntry), 16)) {
1694       NS_ERROR("Error initializing PLDHashTable!");
1695
1696       return nsnull;
1697     }
1698   }
1699
1700   NPObjWrapperHashEntry *entry = static_cast<NPObjWrapperHashEntry *>
1701     (PL_DHashTableOperate(&sNPObjWrappers, npobj, PL_DHASH_ADD));
1702
1703   if (!entry) {
1704     // Out of memory
1705     JS_ReportOutOfMemory(cx);
1706
1707     return nsnull;
1708   }
1709
1710   if (PL_DHASH_ENTRY_IS_BUSY(entry) && entry->mJSObj) {
1711     // Found a live NPObject wrapper, return it.
1712     return entry->mJSObj;
1713   }
1714
1715   entry->mNPObj = npobj;
1716   entry->mNpp = npp;
1717
1718   JSAutoRequest ar(cx);
1719
1720   PRUint32 generation = sNPObjWrappers.generation;
1721
1722   // No existing JSObject, create one.
1723
1724   JSObject *obj = ::JS_NewObject(cx, &sNPObjectJSWrapperClass, nsnull, nsnull);
1725
1726   if (generation != sNPObjWrappers.generation) {
1727       // Reload entry if the JS_NewObject call caused a GC and reallocated
1728       // the table (see bug 445229). This is guaranteed to succeed.
1729
1730       entry = static_cast<NPObjWrapperHashEntry *>
1731         (PL_DHashTableOperate(&sNPObjWrappers, npobj, PL_DHASH_LOOKUP));
1732       NS_ASSERTION(entry && PL_DHASH_ENTRY_IS_BUSY(entry),
1733                    "Hashtable didn't find what we just added?");
1734   }
1735
1736   if (!obj) {
1737     // OOM? Remove the stale entry from the hash.
1738
1739     PL_DHashTableRawRemove(&sNPObjWrappers, entry);
1740
1741     return nsnull;
1742   }
1743
1744   OnWrapperCreated();
1745
1746   entry->mJSObj = obj;
1747
1748   // JS_SetPrivate() never fails.
1749   ::JS_SetPrivate(cx, obj, npobj);
1750
1751   // The new JSObject now holds on to npobj
1752   _retainobject(npobj);
1753
1754   return obj;
1755 }
1756
1757
1758 // PLDHashTable enumeration callbacks for destruction code.
1759 static PLDHashOperator
1760 JSObjWrapperPluginDestroyedCallback(PLDHashTable *table, PLDHashEntryHdr *hdr,
1761                                     PRUint32 number, void *arg)
1762 {
1763   JSObjWrapperHashEntry *entry = (JSObjWrapperHashEntry *)hdr;
1764
1765   nsJSObjWrapper *npobj = entry->mJSObjWrapper;
1766
1767   if (npobj->mNpp == arg) {
1768     // Prevent invalidate() and _releaseobject() from touching the hash
1769     // we're enumerating.
1770     const PLDHashTableOps *ops = table->ops;
1771     table->ops = nsnull;
1772
1773     if (npobj->_class && npobj->_class->invalidate) {
1774       npobj->_class->invalidate(npobj);
1775     }
1776
1777     _releaseobject(npobj);
1778
1779     table->ops = ops;
1780
1781     return PL_DHASH_REMOVE;
1782   }
1783
1784   return PL_DHASH_NEXT;
1785 }
1786
1787 // Struct for passing an NPP and a JSContext to
1788 // NPObjWrapperPluginDestroyedCallback
1789 struct NppAndCx
1790 {
1791   NPP npp;
1792   JSContext *cx;
1793 };
1794
1795 static PLDHashOperator
1796 NPObjWrapperPluginDestroyedCallback(PLDHashTable *table, PLDHashEntryHdr *hdr,
1797                                     PRUint32 number, void *arg)
1798 {
1799   NPObjWrapperHashEntry *entry = (NPObjWrapperHashEntry *)hdr;
1800   NppAndCx *nppcx = reinterpret_cast<NppAndCx *>(arg);
1801
1802   if (entry->mNpp == nppcx->npp) {
1803     // Prevent invalidate() and deallocate() from touching the hash
1804     // we're enumerating.
1805     const PLDHashTableOps *ops = table->ops;
1806     table->ops = nsnull;
1807
1808     NPObject *npobj = entry->mNPObj;
1809
1810     if (npobj->_class && npobj->_class->invalidate) {
1811       npobj->_class->invalidate(npobj);
1812     }
1813
1814     // Force deallocation of plugin objects since the plugin they came
1815     // from is being torn down.
1816     if (npobj->_class && npobj->_class->deallocate) {
1817       npobj->_class->deallocate(npobj);
1818     } else {
1819       PR_Free(npobj);
1820     }
1821
1822     ::JS_SetPrivate(nppcx->cx, entry->mJSObj, nsnull);
1823
1824     table->ops = ops;
1825
1826     return PL_DHASH_REMOVE;
1827   }
1828
1829   return PL_DHASH_NEXT;
1830 }
1831
1832 // static
1833 void
1834 nsJSNPRuntime::OnPluginDestroy(NPP npp)
1835 {
1836   if (sJSObjWrappers.ops) {
1837     PL_DHashTableEnumerate(&sJSObjWrappers,
1838                            JSObjWrapperPluginDestroyedCallback, npp);
1839   }
1840
1841   // Use the safe JSContext here as we're not always able to find the
1842   // JSContext associated with the NPP any more.
1843
1844   nsCOMPtr<nsIThreadJSContextStack> stack =
1845     do_GetService("@mozilla.org/js/xpc/ContextStack;1");
1846   if (!stack) {
1847     NS_ERROR("No context stack available!");
1848
1849     return;
1850   }
1851
1852   JSContext *cx;
1853   stack->GetSafeJSContext(&cx);
1854   if (!cx) {
1855     NS_ERROR("No safe JS context available!");
1856
1857     return;
1858   }
1859
1860   JSAutoRequest ar(cx);
1861
1862   if (sNPObjWrappers.ops) {
1863     NppAndCx nppcx = { npp, cx };
1864     PL_DHashTableEnumerate(&sNPObjWrappers,
1865                            NPObjWrapperPluginDestroyedCallback, &nppcx);
1866   }
1867
1868   // If this plugin was scripted from a webpage, the plugin's
1869   // scriptable object will be on the DOM element's prototype
1870   // chain. Now that the plugin is being destroyed we need to pull the
1871   // plugin's scriptable object out of that prototype chain.
1872   if (!npp) {
1873     return;
1874   }
1875
1876   // Find the plugin instance so that we can (eventually) get to the
1877   // DOM element
1878   nsNPAPIPluginInstance *inst = (nsNPAPIPluginInstance *)npp->ndata;
1879   if (!inst) {
1880     return;
1881   }
1882
1883   nsCOMPtr<nsIPluginInstancePeer> pip;
1884   inst->GetPeer(getter_AddRefs(pip));
1885   nsCOMPtr<nsIPluginTagInfo2> pti2(do_QueryInterface(pip));
1886   if (!pti2) {
1887     return;
1888   }
1889
1890   nsCOMPtr<nsIDOMElement> element;
1891   pti2->GetDOMElement(getter_AddRefs(element));
1892   if (!element) {
1893     return;
1894   }
1895
1896   // Get the DOM element's JS object.
1897   nsCOMPtr<nsIXPConnect> xpc(do_GetService(nsIXPConnect::GetCID()));
1898   if (!xpc) {
1899     return;
1900   }
1901
1902   // OK.  Now we have to get our hands on the right scope object, since
1903   // GetWrappedNativeOfNativeObject doesn't call PreCreate and hence won't get
1904   // the right scope if we pass in something bogus.  The right scope lives on
1905   // the script global of the element's document.
1906   // XXXbz we MUST have a better way of doing this... perhaps
1907   // GetWrappedNativeOfNativeObject _should_ call preCreate?
1908   nsCOMPtr<nsIContent> content(do_QueryInterface(element));
1909   if (!content) {
1910     return;
1911   }
1912
1913   nsIDocument* doc = content->GetOwnerDoc();
1914   if (!doc) {
1915     return;
1916   }
1917
1918   nsIScriptGlobalObject* sgo = doc->GetScriptGlobalObject();
1919   if (!sgo) {
1920     return;
1921   }
1922
1923   nsCOMPtr<nsISupports> supp(do_QueryInterface(element));
1924   nsCOMPtr<nsIXPConnectWrappedNative> holder;
1925   xpc->GetWrappedNativeOfNativeObject(cx, sgo->GetGlobalJSObject(), supp,
1926                                       NS_GET_IID(nsISupports),
1927                                       getter_AddRefs(holder));
1928   if (!holder) {
1929     return;
1930   }
1931
1932   JSObject *obj, *proto;
1933   holder->GetJSObject(&obj);
1934
1935   // Loop over the DOM element's JS object prototype chain and remove
1936   // all JS objects of the class sNPObjectJSWrapperClass (there should
1937   // be only one, but remove all instances found in case the page put
1938   // more than one of the plugin's scriptable objects on the prototype
1939   // chain).
1940   while (obj && (proto = ::JS_GetPrototype(cx, obj))) {
1941     if (JS_GET_CLASS(cx, proto) == &sNPObjectJSWrapperClass) {
1942       // We found an NPObject on the proto chain, get its prototype...
1943       proto = ::JS_GetPrototype(cx, proto);
1944
1945       // ... and pull it out of the chain.
1946       ::JS_SetPrototype(cx, obj, proto);
1947     }
1948
1949     obj = proto;
1950   }
1951 }
1952
1953
1954 // Find the NPP for a NPObject.
1955 static NPP
1956 LookupNPP(NPObject *npobj)
1957 {
1958   if (npobj->_class == &nsJSObjWrapper::sJSObjWrapperNPClass) {
1959     NS_ERROR("NPP requested for NPObject of class "
1960              "nsJSObjWrapper::sJSObjWrapperNPClass!\n");
1961
1962     return nsnull;
1963   }
1964
1965   NPObjWrapperHashEntry *entry = static_cast<NPObjWrapperHashEntry *>
1966     (PL_DHashTableOperate(&sNPObjWrappers, npobj, PL_DHASH_ADD));
1967
1968   if (PL_DHASH_ENTRY_IS_FREE(entry)) {
1969     return nsnull;
1970   }
1971
1972   NS_ASSERTION(entry->mNpp, "Live NPObject entry w/o an NPP!");
1973
1974   return entry->mNpp;
1975 }
1976
1977 bool
1978 CreateNPObjectMember(NPP npp, JSContext *cx, JSObject *obj,
1979                      NPObject* npobj, jsval id, jsval *vp)
1980 {
1981   NS_ENSURE_TRUE(vp, false);
1982
1983   if (!npobj || !npobj->_class || !npobj->_class->getProperty ||
1984       !npobj->_class->invoke) {
1985     ThrowJSException(cx, "Bad NPObject");
1986
1987     return false;
1988   }
1989
1990   NPObjectMemberPrivate *memberPrivate =
1991     (NPObjectMemberPrivate *)PR_Malloc(sizeof(NPObjectMemberPrivate));
1992   if (!memberPrivate)
1993     return false;
1994
1995   // Make sure to clear all members in case something fails here
1996   // during initialization.
1997   memset(memberPrivate, 0, sizeof(NPObjectMemberPrivate));
1998
1999   JSObject *memobj = ::JS_NewObject(cx, &sNPObjectMemberClass, nsnull, nsnull);
2000   if (!memobj) {
2001     PR_Free(memberPrivate);
2002     return false;
2003   }
2004
2005   *vp = OBJECT_TO_JSVAL(memobj);
2006   ::JS_AddRoot(cx, vp);
2007
2008   ::JS_SetPrivate(cx, memobj, (void *)memberPrivate);
2009
2010   jsval fieldValue;
2011   NPVariant npv;
2012   VOID_TO_NPVARIANT(npv);
2013   if (!npobj->_class->getProperty(npobj, (NPIdentifier)id, &npv)) {
2014     ::JS_RemoveRoot(cx, vp);
2015     return false;
2016   }
2017
2018   fieldValue = NPVariantToJSVal(npp, cx, &npv);
2019
2020   // npobjWrapper is the JSObject through which we make sure we don't
2021   // outlive the underlying NPObject, so make sure it points to the
2022   // real JSObject wrapper for the NPObject.
2023   while (JS_GET_CLASS(cx, obj) != &sNPObjectJSWrapperClass) {
2024     obj = ::JS_GetPrototype(cx, obj);
2025   }
2026
2027   memberPrivate->npobjWrapper = obj;
2028
2029   memberPrivate->fieldValue = fieldValue;
2030   memberPrivate->methodName = id;
2031   memberPrivate->npp = npp;
2032
2033   ::JS_RemoveRoot(cx, vp);
2034
2035   return true;
2036 }
2037
2038 static JSBool
2039 NPObjectMember_Convert(JSContext *cx, JSObject *obj, JSType type, jsval *vp)
2040 {
2041   NPObjectMemberPrivate *memberPrivate =
2042     (NPObjectMemberPrivate *)::JS_GetInstancePrivate(cx, obj,
2043                                                      &sNPObjectMemberClass,
2044                                                      nsnull);
2045   NS_ASSERTION(memberPrivate, "no Ambiguous Member Private data!");
2046
2047   switch (type) {
2048   case JSTYPE_VOID:
2049   case JSTYPE_STRING:
2050   case JSTYPE_NUMBER:
2051   case JSTYPE_BOOLEAN:
2052   case JSTYPE_OBJECT:
2053     *vp = memberPrivate->fieldValue;
2054     return JS_TRUE;
2055   case JSTYPE_FUNCTION:
2056     // Leave this to NPObjectMember_Call.
2057     return JS_TRUE;
2058   default:
2059     NS_ERROR("illegal operation on JSObject prototype object");
2060     return JS_FALSE;
2061   }
2062 }
2063
2064 static void
2065 NPObjectMember_Finalize(JSContext *cx, JSObject *obj)
2066 {
2067   NPObjectMemberPrivate *memberPrivate;
2068
2069   memberPrivate = (NPObjectMemberPrivate *)::JS_GetPrivate(cx, obj);
2070   if (!memberPrivate)
2071     return;
2072
2073   PR_Free(memberPrivate);
2074 }
2075
2076 static JSBool
2077 NPObjectMember_Call(JSContext *cx, JSObject *obj,
2078                     uintN argc, jsval *argv, jsval *rval)
2079 {
2080   JSObject *memobj = JSVAL_TO_OBJECT(argv[-2]);
2081   NS_ENSURE_TRUE(memobj, JS_FALSE);
2082
2083   NPObjectMemberPrivate *memberPrivate =
2084     (NPObjectMemberPrivate *)::JS_GetInstancePrivate(cx, memobj,
2085                                                      &sNPObjectMemberClass,
2086                                                      argv);
2087   if (!memberPrivate || !memberPrivate->npobjWrapper)
2088     return JS_FALSE;
2089
2090   NPObject *npobj = GetNPObject(cx, memberPrivate->npobjWrapper);
2091   if (!npobj) {
2092     ThrowJSException(cx, "Call on invalid member object");
2093
2094     return JS_FALSE;
2095   }
2096
2097   NPVariant npargs_buf[8];
2098   NPVariant *npargs = npargs_buf;
2099
2100   if (argc > (sizeof(npargs_buf) / sizeof(NPVariant))) {
2101     // Our stack buffer isn't large enough to hold all arguments,
2102     // malloc a buffer.
2103     npargs = (NPVariant *)PR_Malloc(argc * sizeof(NPVariant));
2104
2105     if (!npargs) {
2106       ThrowJSException(cx, "Out of memory!");
2107
2108       return JS_FALSE;
2109     }
2110   }
2111
2112   // Convert arguments
2113   PRUint32 i;
2114   for (i = 0; i < argc; ++i) {
2115     if (!JSValToNPVariant(memberPrivate->npp, cx, argv[i], npargs + i)) {
2116       ThrowJSException(cx, "Error converting jsvals to NPVariants!");
2117
2118       if (npargs != npargs_buf) {
2119         PR_Free(npargs);
2120       }
2121
2122       return JS_FALSE;
2123     }
2124   }
2125
2126   NPVariant npv;
2127   JSBool ok;
2128   ok = npobj->_class->invoke(npobj, (NPIdentifier)memberPrivate->methodName,
2129                              npargs, argc, &npv);
2130
2131   // Release arguments.
2132   for (i = 0; i < argc; ++i) {
2133     _releasevariantvalue(npargs + i);
2134   }
2135
2136   if (npargs != npargs_buf) {
2137     PR_Free(npargs);
2138   }
2139
2140   if (!ok) {
2141     ThrowJSException(cx, "Error calling method on NPObject!");
2142
2143     return JS_FALSE;
2144   }
2145
2146   *rval = NPVariantToJSVal(memberPrivate->npp, cx, &npv);
2147
2148   // *rval now owns the value, release our reference.
2149   _releasevariantvalue(&npv);
2150
2151   return ReportExceptionIfPending(cx);
2152 }
2153
2154 static uint32
2155 NPObjectMember_Mark(JSContext *cx, JSObject *obj, void *arg)
2156 {
2157   NPObjectMemberPrivate *memberPrivate =
2158     (NPObjectMemberPrivate *)::JS_GetInstancePrivate(cx, obj,
2159                                                      &sNPObjectMemberClass,
2160                                                      nsnull);
2161   if (!memberPrivate)
2162     return 0;
2163
2164   if (!JSVAL_IS_PRIMITIVE(memberPrivate->fieldValue)) {
2165     ::JS_MarkGCThing(cx, JSVAL_TO_OBJECT(memberPrivate->fieldValue),
2166                      "NPObject Member => fieldValue", arg);
2167   }
2168
2169   // There's no strong reference from our private data to the
2170   // NPObject, so make sure to mark the NPObject wrapper to keep the
2171   // NPObject alive as long as this NPObjectMember is alive.
2172   if (memberPrivate->npobjWrapper) {
2173     ::JS_MarkGCThing(cx, memberPrivate->npobjWrapper,
2174                      "NPObject Member => npobjWrapper", arg);
2175   }
2176
2177   return 0;
2178 }