Changeset 31259 in vbox for trunk/src/libs/xpcom18a4/xpcom/proxy

Timestamp:

Jul 30, 2010 8:02:05 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

64275

Message:

xpcom: Use RTMem* for memory alloc so that we can more easily wrap direct it to the electric fence heap.

File:

• trunk/src/libs/xpcom18a4/xpcom/proxy/src/nsProxyEvent.cpp (modified) (34 diffs)

trunk/src/libs/xpcom18a4/xpcom/proxy/src/nsProxyEvent.cpp

@@ -76 +76 @@
 
 static NS_DEFINE_CID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
-        
+
 static void* PR_CALLBACK EventHandler(PLEvent *self);
 static void  PR_CALLBACK DestroyHandler(PLEvent *self);
@@ -86 +86 @@
 nsProxyObjectCallInfo::nsProxyObjectCallInfo( nsProxyObject* owner,
                                               nsXPTMethodInfo *methodInfo,
-                                              PRUint32 methodIndex, 
-                                              nsXPTCVariant* parameterList, 
-                                              PRUint32 parameterCount, 
+                                              PRUint32 methodIndex,
+                                              nsXPTCVariant* parameterList,
+                                              PRUint32 parameterCount,
                                               PLEvent *event)
 {
@@ -94 +94 @@
     NS_ASSERTION(methodInfo, "No nsXPTMethodInfo!");
     NS_ASSERTION(event, "No PLEvent!");
-    
+
     mCompleted        = 0;
     mMethodIndex      = methodIndex;
@@ -104 +104 @@
 
     mOwner            = owner;
-    
+
     RefCountInInterfacePointers(PR_TRUE);
     if (mOwner->GetProxyType() & PROXY_ASYNC)
@@ -118 +118 @@
 
     mOwner = nsnull;
-    
+
     PR_FREEIF(mEvent);
-    
-    if (mParameterList)  
+
+    if (mParameterList)
+#ifdef VBOX_USE_IPRT_IN_XPCOM
+        nsMemory::Free((void*) mParameterList);
+#else
         free( (void*) mParameterList);
+#endif
 }
 
@@ -139 +143 @@
             {
                 anInterface = ((nsISupports*)mParameterList[i].val.p);
-                
+
                 if (anInterface)
                 {
@@ -146 +150 @@
                     else
                         anInterface->Release();
-            
+
                 }
             }
@@ -170 +174 @@
 
             if (copy)
-            {                
-                switch (type_tag) 
+            {
+                switch (type_tag)
                 {
-                    case nsXPTType::T_CHAR_STR:                                
+                    case nsXPTType::T_CHAR_STR:
                         mParameterList[i].val.p =
                             PL_strdup((const char *)ptr);
@@ -183 +187 @@
                     case nsXPTType::T_DOMSTRING:
                     case nsXPTType::T_ASTRING:
-                        mParameterList[i].val.p = 
+                        mParameterList[i].val.p =
                             new nsString(*((nsAString*) ptr));
                         break;
                     case nsXPTType::T_CSTRING:
-                        mParameterList[i].val.p = 
+                        mParameterList[i].val.p =
                             new nsCString(*((nsACString*) ptr));
                         break;
-                    case nsXPTType::T_UTF8STRING:                        
-                        mParameterList[i].val.p = 
+                    case nsXPTType::T_UTF8STRING:
+                        mParameterList[i].val.p =
                             new nsUTF8String(*((nsAUTF8String*) ptr));
                         break;
                     default:
                         // Other types are ignored
-                        break;                    
+                        break;
                 }
             }
             else
             {
-                switch (type_tag) 
+                switch (type_tag)
                 {
                     case nsXPTType::T_CHAR_STR:
@@ -226 +230 @@
 }
 
-PRBool                
+PRBool
 nsProxyObjectCallInfo::GetCompleted()
 {
@@ -238 +242 @@
 }
 
-void                
+void
 nsProxyObjectCallInfo::PostCompleted()
 {
@@ -244 +248 @@
     {
         PLEvent *event = PR_NEW(PLEvent);
-    
-        PL_InitEvent(event, 
+
+        PL_InitEvent(event,
                      this,
                      CompletedEventHandler,
                      CompletedDestroyHandler);
-   
+
         mCallersEventQ->PostSynchronousEvent(event, nsnull);
         PR_FREEIF(event);
@@ -259 +263 @@
     }
 }
-  
-nsIEventQueue*      
-nsProxyObjectCallInfo::GetCallersQueue() 
-{ 
+
+nsIEventQueue*
+nsProxyObjectCallInfo::GetCallersQueue()
+{
     return mCallersEventQ;
-}   
+}
 void
 nsProxyObjectCallInfo::SetCallersQueue(nsIEventQueue* queue)
 {
     mCallersEventQ = queue;
-}   
+}
 
 
@@ -286 +290 @@
     mEventQService = do_GetService(kEventQueueServiceCID);
 
-    nsComponentManager::CreateInstance(aClass, 
+    nsComponentManager::CreateInstance(aClass,
                                        aDelegate,
                                        aIID,
@@ -296 +300 @@
 
 nsProxyObject::~nsProxyObject()
-{   
-    // I am worried about order of destruction here.  
+{
+    // I am worried about order of destruction here.
     // do not remove assignments.
-    
+
     mRealObject = 0;
     mDestQueue  = 0;
@@ -315 +319 @@
 nsProxyObject::Release(void)
 {
-  NS_PRECONDITION(0 != mRefCnt, "dup release");             
+  NS_PRECONDITION(0 != mRefCnt, "dup release");
 
   nsrefcnt count = PR_AtomicDecrement((PRInt32 *)&mRefCnt);
@@ -343 +347 @@
            return;  // if this happens we are going to leak.
        }
-       
-       PL_InitEvent(event, 
+
+       PL_InitEvent(event,
                     this,
                     ProxyDestructorEventHandler,
-                    ProxyDestructorDestroyHandler);  
+                    ProxyDestructorDestroyHandler);
 
        mDestQueue->PostEvent(event);
-  }                          
-}                
+  }
+}
 
 
@@ -357 +361 @@
 nsProxyObject::PostAndWait(nsProxyObjectCallInfo *proxyInfo)
 {
-    if (proxyInfo == nsnull || mEventQService == nsnull) 
+    if (proxyInfo == nsnull || mEventQService == nsnull)
         return NS_ERROR_NULL_POINTER;
-    
+
     PRBool eventLoopCreated = PR_FALSE;
-    nsresult rv; 
+    nsresult rv;
 
     nsCOMPtr<nsIEventQueue> eventQ;
@@ -371 +375 @@
         if (NS_FAILED(rv))
             return rv;
-        
+
         rv = mEventQService->GetThreadEventQueue(NS_CURRENT_THREAD, getter_AddRefs(eventQ));
     }
@@ -377 +381 @@
     if (NS_FAILED(rv))
         return rv;
-    
+
     proxyInfo->SetCallersQueue(eventQ);
 
@@ -383 +387 @@
     if (!event)
         return NS_ERROR_NULL_POINTER;
-    
+
     mDestQueue->PostEvent(event);
 
@@ -391 +395 @@
         rv = eventQ->WaitForEvent(&nextEvent);
         if (NS_FAILED(rv)) break;
-                
+
         eventQ->HandleEvent(nextEvent);
-    }  
+    }
 
     if (eventLoopCreated)
@@ -400 +404 @@
          eventQ = 0;
     }
-    
+
     return rv;
 }
-        
-        
+
+
 nsresult
-nsProxyObject::convertMiniVariantToVariant(nsXPTMethodInfo *methodInfo, 
-                                           nsXPTCMiniVariant * params, 
-                                           nsXPTCVariant **fullParam, 
+nsProxyObject::convertMiniVariantToVariant(nsXPTMethodInfo *methodInfo,
+                                           nsXPTCMiniVariant * params,
+                                           nsXPTCVariant **fullParam,
                                            uint8 *outParamCount)
 {
@@ -416 +420 @@
 
     if (!paramCount) return NS_OK;
-        
+
+#ifdef VBOX_USE_IPRT_IN_XPCOM
+    *fullParam = (nsXPTCVariant*)nsMemory::Alloc(sizeof(nsXPTCVariant) * paramCount);
+#else
     *fullParam = (nsXPTCVariant*)malloc(sizeof(nsXPTCVariant) * paramCount);
-    
+#endif
+
     if (*fullParam == nsnull)
         return NS_ERROR_OUT_OF_MEMORY;
-    
+
     for (int i = 0; i < paramCount; i++)
     {
@@ -427 +435 @@
         if ((mProxyType & PROXY_ASYNC) && paramInfo.IsDipper())
         {
-            NS_WARNING("Async proxying of out parameters is not supported"); 
+            NS_WARNING("Async proxying of out parameters is not supported");
             return NS_ERROR_PROXY_INVALID_OUT_PARAMETER;
         }
@@ -433 +441 @@
         (*fullParam)[i].Init(params[i], paramInfo.GetType(), flags);
     }
-    
+
     return NS_OK;
 }
-        
+
 nsresult
-nsProxyObject::Post( PRUint32 methodIndex, 
-                     nsXPTMethodInfo *methodInfo, 
-                     nsXPTCMiniVariant * params, 
-                     nsIInterfaceInfo *interfaceInfo)            
-{
-    nsresult rv = NS_OK; 
+nsProxyObject::Post( PRUint32 methodIndex,
+                     nsXPTMethodInfo *methodInfo,
+                     nsXPTCMiniVariant * params,
+                     nsIInterfaceInfo *interfaceInfo)
+{
+    nsresult rv = NS_OK;
 
     if (! mDestQueue  || ! mRealObject)
@@ -450 +458 @@
     if (methodInfo->IsNotXPCOM())
         return NS_ERROR_PROXY_INVALID_IN_PARAMETER;
-    
+
     nsXPTCVariant *fullParam;
-    uint8 paramCount; 
+    uint8 paramCount;
     rv = convertMiniVariantToVariant(methodInfo, params, &fullParam, &paramCount);
-    
+
     if (NS_FAILED(rv))
         return rv;
@@ -462 +470 @@
     // see if we should call into the method directly. Either it is a QI function call
     // (methodIndex == 0), or it is a sync proxy and this code is running on the same thread
-    // as the destination event queue. 
+    // as the destination event queue.
     if ( (methodIndex == 0) ||
-         (mProxyType & PROXY_SYNC && 
+         (mProxyType & PROXY_SYNC &&
           NS_SUCCEEDED(mDestQueue->IsOnCurrentThread(&callDirectly)) &&
           callDirectly))
@@ -470 +478 @@
 
         // invoke the magic of xptc...
-        nsresult rv = XPTC_InvokeByIndex( mRealObject, 
+        nsresult rv = XPTC_InvokeByIndex( mRealObject,
                                           methodIndex,
-                                          paramCount, 
+                                          paramCount,
                                           fullParam);
-        
-        if (fullParam) 
+
+        if (fullParam)
+#ifdef VBOX_USE_IPRT_IN_XPCOM
+            nsMemory::Free(fullParam);
+#else
             free(fullParam);
+#endif
         return rv;
     }
 
     PLEvent *event = PR_NEW(PLEvent);
-    
+
     if (event == nsnull) {
-        if (fullParam) 
+        if (fullParam)
+#ifdef VBOX_USE_IPRT_IN_XPCOM
+            nsMemory::Free(fullParam);
+#else
             free(fullParam);
-        return NS_ERROR_OUT_OF_MEMORY;   
-    }
-
-    nsProxyObjectCallInfo *proxyInfo = new nsProxyObjectCallInfo(this, 
-                                                                 methodInfo, 
-                                                                 methodIndex, 
+#endif
+        return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    nsProxyObjectCallInfo *proxyInfo = new nsProxyObjectCallInfo(this,
+                                                                 methodInfo,
+                                                                 methodIndex,
                                                                  fullParam,   // will be deleted by ~()
-                                                                 paramCount, 
+                                                                 paramCount,
                                                                  event);      // will be deleted by ~()
-    
+
     if (proxyInfo == nsnull) {
         PR_DELETE(event);
         if (fullParam)
+#ifdef VBOX_USE_IPRT_IN_XPCOM
+            nsMemory::Free(fullParam);
+#else
             free(fullParam);
-        return NS_ERROR_OUT_OF_MEMORY;  
-    }
-
-    PL_InitEvent(event, 
+#endif
+        return NS_ERROR_OUT_OF_MEMORY;
+    }
+
+    PL_InitEvent(event,
                  proxyInfo,
                  EventHandler,
                  DestroyHandler);
-   
+
     if (mProxyType & PROXY_SYNC)
     {
         rv = PostAndWait(proxyInfo);
-        
+
         if (NS_SUCCEEDED(rv))
             rv = proxyInfo->GetResult();
@@ -516 +536 @@
         return rv;
     }
-    
+
     if (mProxyType & PROXY_ASYNC)
     {
@@ -527 +547 @@
 
 
-static void DestroyHandler(PLEvent *self) 
+static void DestroyHandler(PLEvent *self)
 {
     nsProxyObjectCallInfo* owner = (nsProxyObjectCallInfo*)PL_GetEventOwner(self);
     nsProxyObject* proxyObject = owner->GetProxyObject();
-    
+
     if (proxyObject == nsnull)
         return;
- 
+
     if (proxyObject->GetProxyType() & PROXY_ASYNC)
-    {        
+    {
         delete owner;
     }
@@ -546 +566 @@
 }
 
-static void* EventHandler(PLEvent *self) 
+static void* EventHandler(PLEvent *self)
 {
     nsProxyObjectCallInfo *info = (nsProxyObjectCallInfo*)PL_GetEventOwner(self);
     NS_ASSERTION(info, "No nsProxyObjectCallInfo!");
-    
+
     nsProxyObject *proxyObject = info->GetProxyObject();
-        
+
     if (proxyObject)
     {
         // invoke the magic of xptc...
-        nsresult rv = XPTC_InvokeByIndex( proxyObject->GetRealObject(), 
+        nsresult rv = XPTC_InvokeByIndex( proxyObject->GetRealObject(),
                                           info->GetMethodIndex(),
-                                          info->GetParameterCount(), 
+                                          info->GetParameterCount(),
                                           info->GetParameterList());
         info->SetResult(rv);
@@ -569 +589 @@
 }
 
-static void CompletedDestroyHandler(PLEvent *self) 
-{
-}
-
-static void* CompletedEventHandler(PLEvent *self) 
+static void CompletedDestroyHandler(PLEvent *self)
+{
+}
+
+static void* CompletedEventHandler(PLEvent *self)
 {
     nsProxyObjectCallInfo* owner = (nsProxyObjectCallInfo*)PL_GetEventOwner(self);
@@ -581 +601 @@
 
 static void* ProxyDestructorEventHandler(PLEvent *self)
-{              
+{
     nsProxyObject* owner = (nsProxyObject*) PL_GetEventOwner(self);
     NS_DELETEXPCOM(owner);
-    return nsnull;                                            
+    return nsnull;
 }