xpcom/proxy/src/nsProxyEvent.cpp

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /* vim:set ts=4 sw=4 sts=4 ci et: */
   3 /*
   4  *
   5  * ***** BEGIN LICENSE BLOCK *****
   6  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   7  *
   8  * The contents of this file are subject to the Mozilla Public License Version
   9  * 1.1 (the "License"); you may not use this file except in compliance with
  10  * the License. You may obtain a copy of the License at
  11  * http://www.mozilla.org/MPL/
  12  *
  13  * Software distributed under the License is distributed on an "AS IS" basis,
  14  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  15  * for the specific language governing rights and limitations under the
  16  * License.
  17  *
  18  * The Original Code is mozilla.org code.
  19  *
  20  * The Initial Developer of the Original Code is
  21  * Netscape Communications Corporation.
  22  * Portions created by the Initial Developer are Copyright (C) 1998
  23  * the Initial Developer. All Rights Reserved.
  24  *
  25  * Contributor(s):
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either of the GNU General Public License Version 2 or later (the "GPL"),
  29  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK *****
  40  *
  41  * This Original Code has been modified by IBM Corporation.
  42  * Modifications made by IBM described herein are
  43  * Copyright (c) International Business Machines
  44  * Corporation, 2000
  45  *
  46  * Modifications to Mozilla code or documentation
  47  * identified per MPL Section 3.3
  48  *
  49  * Date             Modified by     Description of modification
  50  * 04/20/2000       IBM Corp.      Added PR_CALLBACK for Optlink use in OS2
  51  */
  52
  53 #include "nsProxyEventPrivate.h"
  54 #include "nsProxyRelease.h"
  55 #include "nsIProxyObjectManager.h"
  56 #include "nsCRT.h"
  57
  58 #include "pratom.h"
  59 #include "prmem.h"
  60 #include "xptcall.h"
  61
  62 #include "nsAutoLock.h"
  63 #include "nsXPCOMCID.h"
  64 #include "nsServiceManagerUtils.h"
  65 #include "nsIComponentManager.h"
  66 #include "nsThreadUtils.h"
  67 #include "nsEventQueue.h"
  68 #include "nsMemory.h"
  69
  70 /**
  71  * Map the nsAUTF8String, nsUTF8String classes to the nsACString and
  72  * nsCString classes respectively for now.  These defines need to be removed
  73  * once Jag lands his nsUTF8String implementation.
  74  */
  75 #define nsAUTF8String nsACString
  76 #define nsUTF8String nsCString
  77
  78 class nsProxyCallCompletedEvent : public nsRunnable
  79 {
  80 public:
  81     nsProxyCallCompletedEvent(nsProxyObjectCallInfo *info)
  82         : mInfo(info)
  83     {}
  84
  85     NS_DECL_NSIRUNNABLE
  86
  87     NS_IMETHOD QueryInterface(REFNSIID aIID, void **aResult);
  88
  89 private:
  90     nsProxyObjectCallInfo *mInfo;
  91 };
  92
  93 NS_IMETHODIMP
  94 nsProxyCallCompletedEvent::Run()
  95 {
  96     NS_ASSERTION(mInfo, "no info");
  97     mInfo->SetCompleted();
  98     return NS_OK;
  99 }
 100
 101 NS_DEFINE_IID(kFilterIID, NS_PROXYEVENT_FILTER_IID);
 102
 103 NS_IMETHODIMP
 104 nsProxyCallCompletedEvent::QueryInterface(REFNSIID aIID, void **aResult)
 105 {
 106     // We are explicitly breaking XPCOM rules here by returning a different
 107     // object from QueryInterface. We do this so that
 108     // nsProxyThreadFilter::AcceptEvent can know whether we are an event that
 109     // needs to be allowed through during a synchronous proxy call.
 110     if (aIID.Equals(kFilterIID)) {
 111         *aResult = mInfo;
 112         mInfo->AddRef();
 113         return NS_OK;
 114     }
 115     return nsRunnable::QueryInterface(aIID, aResult);
 116 }
 117
 118 //-----------------------------------------------------------------------------
 119
 120 NS_IMETHODIMP
 121 nsProxyObject::nsProxyObjectDestructorEvent::Run()
 122 {
 123     delete mDoomed;
 124     return NS_OK;
 125 }
 126
 127 //-----------------------------------------------------------------------------
 128
 129 nsProxyObjectCallInfo::nsProxyObjectCallInfo(nsProxyEventObject* owner,
 130                                              const XPTMethodDescriptor *methodInfo,
 131                                              PRUint32 methodIndex,
 132                                              nsXPTCVariant* parameterList,
 133                                              PRUint32 parameterCount) :
 134     mResult(NS_ERROR_FAILURE),
 135     mMethodInfo(methodInfo),
 136     mMethodIndex(methodIndex),
 137     mParameterList(parameterList),
 138     mParameterCount(parameterCount),
 139     mCompleted(0),
 140     mOwner(owner)
 141 {
 142     NS_ASSERTION(owner, "No nsProxyObject!");
 143     NS_ASSERTION(methodInfo, "No nsXPTMethodInfo!");
 144
 145     RefCountInInterfacePointers(PR_TRUE);
 146     if (mOwner->GetProxyType() & NS_PROXY_ASYNC)
 147         CopyStrings(PR_TRUE);
 148 }
 149
 150 nsProxyObjectCallInfo::~nsProxyObjectCallInfo()
 151 {
 152     RefCountInInterfacePointers(PR_FALSE);
 153     if (mOwner->GetProxyType() & NS_PROXY_ASYNC)
 154         CopyStrings(PR_FALSE);
 155
 156     mOwner = nsnull;
 157
 158     if (mParameterList)
 159         free(mParameterList);
 160 }
 161
 162 NS_IMETHODIMP
 163 nsProxyObjectCallInfo::QueryInterface(REFNSIID aIID, void **aResult)
 164 {
 165     if (aIID.Equals(kFilterIID)) {
 166         *aResult = this;
 167         AddRef();
 168         return NS_OK;
 169     }
 170     return nsRunnable::QueryInterface(aIID, aResult);
 171 }
 172
 173 NS_IMETHODIMP
 174 nsProxyObjectCallInfo::Run()
 175 {
 176     PROXY_LOG(("PROXY(%p): Run\n", this));
 177
 178     mResult = NS_InvokeByIndex(mOwner->GetProxiedInterface(),
 179                                mMethodIndex,
 180                                mParameterCount,
 181                                mParameterList);
 182
 183     if (IsSync()) {
 184         PostCompleted();
 185     }
 186
 187     return NS_OK;
 188 }
 189
 190 void
 191 nsProxyObjectCallInfo::RefCountInInterfacePointers(PRBool addRef)
 192 {
 193     for (PRUint32 i = 0; i < mParameterCount; i++)
 194     {
 195         nsXPTParamInfo paramInfo = mMethodInfo->params[i];
 196
 197         if (paramInfo.GetType().IsInterfacePointer() )
 198         {
 199             nsISupports* anInterface = nsnull;
 200
 201             if (paramInfo.IsIn())
 202             {
 203                 anInterface = ((nsISupports*)mParameterList[i].val.p);
 204
 205                 if (anInterface)
 206                 {
 207                     if (addRef)
 208                         anInterface->AddRef();
 209                     else
 210                         anInterface->Release();
 211
 212                 }
 213             }
 214         }
 215     }
 216 }
 217
 218 void
 219 nsProxyObjectCallInfo::CopyStrings(PRBool copy)
 220 {
 221     for (PRUint32 i = 0; i < mParameterCount; i++)
 222     {
 223         const nsXPTParamInfo paramInfo = mMethodInfo->params[i];
 224
 225         if (paramInfo.IsIn())
 226         {
 227             const nsXPTType& type = paramInfo.GetType();
 228             uint8 type_tag = type.TagPart();
 229             void *ptr = mParameterList[i].val.p;
 230
 231             if (!ptr)
 232                 continue;
 233
 234             if (copy)
 235             {
 236                 switch (type_tag)
 237                 {
 238                     case nsXPTType::T_CHAR_STR:
 239                         mParameterList[i].val.p =
 240                             PL_strdup((const char *)ptr);
 241                         break;
 242                     case nsXPTType::T_WCHAR_STR:
 243                         mParameterList[i].val.p =
 244                             nsCRT::strdup((const PRUnichar *)ptr);
 245                         break;
 246                     case nsXPTType::T_DOMSTRING:
 247                     case nsXPTType::T_ASTRING:
 248                         mParameterList[i].val.p =
 249                             new nsString(*((nsAString*) ptr));
 250                         break;
 251                     case nsXPTType::T_CSTRING:
 252                         mParameterList[i].val.p =
 253                             new nsCString(*((nsACString*) ptr));
 254                         break;
 255                     case nsXPTType::T_UTF8STRING:
 256                         mParameterList[i].val.p =
 257                             new nsUTF8String(*((nsAUTF8String*) ptr));
 258                         break;
 259                     default:
 260                         // Other types are ignored
 261                         break;
 262                 }
 263             }
 264             else
 265             {
 266                 switch (type_tag)
 267                 {
 268                     case nsXPTType::T_CHAR_STR:
 269                         PL_strfree((char*) ptr);
 270                         break;
 271                     case nsXPTType::T_WCHAR_STR:
 272                         nsCRT::free((PRUnichar*)ptr);
 273                         break;
 274                     case nsXPTType::T_DOMSTRING:
 275                     case nsXPTType::T_ASTRING:
 276                         delete (nsString*) ptr;
 277                         break;
 278                     case nsXPTType::T_CSTRING:
 279                         delete (nsCString*) ptr;
 280                         break;
 281                     case nsXPTType::T_UTF8STRING:
 282                         delete (nsUTF8String*) ptr;
 283                         break;
 284                     default:
 285                         // Other types are ignored
 286                         break;
 287                 }
 288             }
 289         }
 290     }
 291 }
 292
 293 PRBool
 294 nsProxyObjectCallInfo::GetCompleted()
 295 {
 296     return !!mCompleted;
 297 }
 298
 299 void
 300 nsProxyObjectCallInfo::SetCompleted()
 301 {
 302     PROXY_LOG(("PROXY(%p): SetCompleted\n", this));
 303     PR_AtomicSet(&mCompleted, 1);
 304 }
 305
 306 void
 307 nsProxyObjectCallInfo::PostCompleted()
 308 {
 309     PROXY_LOG(("PROXY(%p): PostCompleted\n", this));
 310
 311     if (mCallersTarget) {
 312         nsCOMPtr<nsIRunnable> event =
 313                 new nsProxyCallCompletedEvent(this);
 314         if (event &&
 315             NS_SUCCEEDED(mCallersTarget->Dispatch(event, NS_DISPATCH_NORMAL)))
 316             return;
 317     }
 318
 319     // OOM?  caller does not have a target?  This is an error!
 320     NS_WARNING("Failed to dispatch nsProxyCallCompletedEvent");
 321     SetCompleted();
 322 }
 323
 324 nsIEventTarget*
 325 nsProxyObjectCallInfo::GetCallersTarget()
 326 {
 327     return mCallersTarget;
 328 }
 329
 330 void
 331 nsProxyObjectCallInfo::SetCallersTarget(nsIEventTarget* target)
 332 {
 333     mCallersTarget = target;
 334 }
 335
 336 nsProxyObject::nsProxyObject(nsIEventTarget *target, PRInt32 proxyType,
 337                              nsISupports *realObject) :
 338   mProxyType(proxyType),
 339   mTarget(target),
 340   mRealObject(realObject),
 341   mFirst(nsnull)
 342 {
 343     MOZ_COUNT_CTOR(nsProxyObject);
 344
 345 #ifdef DEBUG
 346     nsCOMPtr<nsISupports> canonicalTarget = do_QueryInterface(target);
 347     NS_ASSERTION(target == canonicalTarget,
 348                  "Non-canonical nsISupports passed to nsProxyObject constructor");
 349 #endif
 350
 351     nsProxyObjectManager *pom = nsProxyObjectManager::GetInstance();
 352     NS_ASSERTION(pom, "Creating a proxy without a global proxy-object-manager.");
 353     pom->AddRef();
 354 }
 355
 356 nsProxyObject::~nsProxyObject()
 357 {
 358     // Proxy the release of mRealObject to protect against it being deleted on
 359     // the wrong thread.
 360     nsISupports *doomed = nsnull;
 361     mRealObject.swap(doomed);
 362     NS_ProxyRelease(mTarget, doomed);
 363
 364     MOZ_COUNT_DTOR(nsProxyObject);
 365 }
 366
 367 NS_IMETHODIMP_(nsrefcnt)
 368 nsProxyObject::AddRef()
 369 {
 370     nsAutoLock lock(nsProxyObjectManager::GetInstance()->GetLock());
 371     return LockedAddRef();
 372 }
 373
 374 NS_IMETHODIMP_(nsrefcnt)
 375 nsProxyObject::Release()
 376 {
 377     nsAutoLock lock(nsProxyObjectManager::GetInstance()->GetLock());
 378     return LockedRelease();
 379 }
 380
 381 nsrefcnt
 382 nsProxyObject::LockedAddRef()
 383 {
 384     ++mRefCnt;
 385     NS_LOG_ADDREF(this, mRefCnt, "nsProxyObject", sizeof(nsProxyObject));
 386     return mRefCnt;
 387 }
 388
 389 nsrefcnt
 390 nsProxyObject::LockedRelease()
 391 {
 392     NS_PRECONDITION(0 != mRefCnt, "dup release");
 393     --mRefCnt;
 394     NS_LOG_RELEASE(this, mRefCnt, "nsProxyObject");
 395     if (mRefCnt)
 396         return mRefCnt;
 397
 398     nsProxyObjectManager *pom = nsProxyObjectManager::GetInstance();
 399     pom->LockedRemove(this);
 400
 401     nsAutoUnlock unlock(pom->GetLock());
 402     delete this;
 403     pom->Release();
 404
 405     return 0;
 406 }
 407
 408 NS_IMETHODIMP
 409 nsProxyObject::QueryInterface(REFNSIID aIID, void **aResult)
 410 {
 411     if (aIID.Equals(GetIID())) {
 412         *aResult = this;
 413         AddRef();
 414         return NS_OK;
 415     }
 416
 417     if (aIID.Equals(NS_GET_IID(nsISupports))) {
 418         *aResult = static_cast<nsISupports*>(this);
 419         AddRef();
 420         return NS_OK;
 421     }
 422
 423     nsProxyObjectManager *pom = nsProxyObjectManager::GetInstance();
 424     NS_ASSERTION(pom, "Deleting a proxy without a global proxy-object-manager.");
 425
 426     nsAutoLock lock(pom->GetLock());
 427     return LockedFind(aIID, aResult);
 428 }
 429
 430 nsresult
 431 nsProxyObject::LockedFind(REFNSIID aIID, void **aResult)
 432 {
 433     // This method is only called when the global lock is held.
 434     // XXX assert this
 435
 436     nsProxyEventObject *peo;
 437
 438     for (peo = mFirst; peo; peo = peo->mNext) {
 439         if (peo->GetClass()->GetProxiedIID().Equals(aIID)) {
 440             *aResult = static_cast<nsISupports*>(peo->mXPTCStub);
 441             peo->LockedAddRef();
 442             return NS_OK;
 443         }
 444     }
 445
 446     nsProxyEventObject *newpeo;
 447
 448     // Both GetClass and QueryInterface call out to XPCOM, so we unlock for them
 449     {
 450         nsProxyObjectManager* pom = nsProxyObjectManager::GetInstance();
 451         nsAutoUnlock unlock(pom->GetLock());
 452
 453         nsProxyEventClass *pec;
 454         nsresult rv = pom->GetClass(aIID, &pec);
 455         if (NS_FAILED(rv))
 456             return rv;
 457
 458         nsISomeInterface* newInterface;
 459         rv = mRealObject->QueryInterface(aIID, (void**) &newInterface);
 460         if (NS_FAILED(rv))
 461             return rv;
 462
 463         newpeo = new nsProxyEventObject(this, pec,
 464                        already_AddRefed<nsISomeInterface>(newInterface), &rv);
 465         if (!newpeo) {
 466             NS_RELEASE(newInterface);
 467             return NS_ERROR_OUT_OF_MEMORY;
 468         }
 469
 470         if (NS_FAILED(rv)) {
 471             delete newpeo;
 472             return rv;
 473         }
 474     }
 475
 476     // Now that we're locked again, check for races by repeating the
 477     // linked-list check.
 478     for (peo = mFirst; peo; peo = peo->mNext) {
 479         if (peo->GetClass()->GetProxiedIID().Equals(aIID)) {
 480             delete newpeo;
 481             *aResult = static_cast<nsISupports*>(peo->mXPTCStub);
 482             peo->LockedAddRef();
 483             return NS_OK;
 484         }
 485     }
 486
 487     newpeo->mNext = mFirst;
 488     mFirst = newpeo;
 489
 490     newpeo->LockedAddRef();
 491
 492     *aResult = static_cast<nsISupports*>(newpeo->mXPTCStub);
 493     return NS_OK;
 494 }
 495
 496 void
 497 nsProxyObject::LockedRemove(nsProxyEventObject *peo)
 498 {
 499     nsProxyEventObject **i;
 500     for (i = &mFirst; *i; i = &((*i)->mNext)) {
 501         if (*i == peo) {
 502             *i = peo->mNext;
 503             return;
 504         }
 505     }
 506     NS_ERROR("Didn't find nsProxyEventObject in nsProxyObject chain!");
 507 }