Changeset 2093 in vbox for trunk/src/libs/xpcom18a4/ipc/ipcd

Timestamp:

Apr 16, 2007 11:38:48 AM (18 years ago)

Author:

vboxsync

Message:

Committed back changeset:20231 to find out the exact problem on test boxes (couldn't reproduce locally).

Location:

trunk/src/libs/xpcom18a4/ipc/ipcd/extensions/dconnect/src

Files:

• ipcDConnectService.cpp (modified) (14 diffs)
• ipcDConnectService.h (modified) (3 diffs)

trunk/src/libs/xpcom18a4/ipc/ipcd/extensions/dconnect/src/ipcDConnectService.cpp

@@ -21 +21 @@
  * Contributor(s):
  *   Darin Fisher <[email protected]>
+ *   Dmitry A. Kuminov <[email protected]>
  *
  * Alternatively, the contents of this file may be used under the terms of
@@ -45 +46 @@
 #include "nsIInterfaceInfoManager.h"
 #include "nsIExceptionService.h"
-#include "nsAutoPtr.h"
 #include "nsString.h"
 #include "nsVoidArray.h"
@@ -158 +158 @@
   DConAddr instance;
   nsresult status;
+  // followed by a specially serialized nsIException instance if
+  // NS_FAILED(status) (see ipcDConnectService::SerializeException)
 };
 
@@ -181 +183 @@
 {
   nsresult result;
-  // followed by an array of out-param blobs if NS_SUCCEEDED (result)
-  // or by an nsIException instance if NS_FAILED (result) and the called
-  // method has set an exception for the current thread using nsIExceptionManager
+  // followed by an array of out-param blobs if NS_SUCCEEDED(result), or by a
+  // specially serialized nsIException instance if NS_FAILED(result)
+  // (see ipcDConnectService::SerializeException)
 };
 
@@ -1116 +1118 @@
 }
 
+//-----------------------------------------------------------------------------
+
+#define EXCEPTION_STUB_ID                          \
+{ /* 70578d68-b25e-4370-a70c-89bbe56e6699 */       \
+  0x70578d68,                                      \
+  0xb25e,                                          \
+  0x4370,                                          \
+  {0xa7, 0x0c, 0x89, 0xbb, 0xe5, 0x6e, 0x66, 0x99} \
+}
+static NS_DEFINE_IID(kExceptionStubID, EXCEPTION_STUB_ID);
+
+// ExceptionStub is used to cache all primitive-typed bits of a remote nsIException
+// instance (such as the error message or line number) to:
+//
+// a) reduce the number of IPC calls;
+// b) make sure exception information is available to the calling party even if
+//    the called party terminates immediately after returning an exception.
+//    To achieve this, all cacheable information is serialized together with
+//    the instance wrapper itself.
+
+class ExceptionStub : public nsIException
+{
+public:
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIEXCEPTION
+
+  ExceptionStub(const nsACString &aMessage, nsresult aResult,
+                const nsACString &aName, const nsACString &aFilename,
+                PRUint32 aLineNumber, PRUint32 aColumnNumber,
+                DConnectStub *aXcptStub)
+    : mMessage(aMessage), mResult(aResult)
+    , mName(aName), mFilename(aFilename)
+    , mLineNumber (aLineNumber), mColumnNumber (aColumnNumber)
+    , mXcptStub (aXcptStub) { NS_ASSERTION(aXcptStub, "NULL"); }
+
+  ~ExceptionStub() {}
+
+  nsIException *Exception() { return (nsIException *)(nsISupports *) mXcptStub; }
+  DConnectStub *Stub() { return mXcptStub; }
+
+private:
+
+  nsCString mMessage;
+  nsresult mResult;
+  nsCString mName;
+  nsCString mFilename;
+  PRUint32 mLineNumber;
+  PRUint32 mColumnNumber;
+  nsRefPtr<DConnectStub> mXcptStub;
+};
+
+NS_IMPL_ADDREF(ExceptionStub)
+NS_IMPL_RELEASE(ExceptionStub)
+
+NS_IMETHODIMP
+ExceptionStub::QueryInterface(const nsID &aIID, void **aInstancePtr)
+{
+  NS_ASSERTION(aInstancePtr,
+               "QueryInterface requires a non-NULL destination!");
+
+  // used to discover if this is an ExceptionStub instance.
+  if (aIID.Equals(kExceptionStubID))
+  {
+    *aInstancePtr = this;
+    NS_ADDREF_THIS();
+    return NS_OK;
+  }
+
+  // regular NS_IMPL_QUERY_INTERFACE1 sequence
+
+  nsISupports* foundInterface = 0;
+
+  if (aIID.Equals(NS_GET_IID(nsIException)))
+    foundInterface = NS_STATIC_CAST(nsIException*, this);
+  else
+  if (aIID.Equals(NS_GET_IID(nsISupports)))
+    foundInterface = NS_STATIC_CAST(nsISupports*,
+                                    NS_STATIC_CAST(nsIException *, this));
+  else
+  if (mXcptStub)
+  {
+    // ask the real nsIException object
+    return mXcptStub->QueryInterface(aIID, aInstancePtr);
+  }
+
+  nsresult status;
+  if (!foundInterface)
+    status = NS_NOINTERFACE;
+  else
+  {
+    NS_ADDREF(foundInterface);
+    status = NS_OK;
+  }
+  *aInstancePtr = foundInterface;
+  return status;
+}
+
+/* readonly attribute string message; */
+NS_IMETHODIMP ExceptionStub::GetMessage(char **aMessage)
+{
+  if (!aMessage)
+    return NS_ERROR_INVALID_POINTER;
+  *aMessage = ToNewCString(mMessage);
+  return NS_OK;
+}
+
+/* readonly attribute nsresult result; */
+NS_IMETHODIMP ExceptionStub::GetResult(nsresult *aResult)
+{
+  if (!aResult)
+    return NS_ERROR_INVALID_POINTER;
+  *aResult = mResult;
+  return NS_OK;
+}
+
+/* readonly attribute string name; */
+NS_IMETHODIMP ExceptionStub::GetName(char **aName)
+{
+  if (!aName)
+    return NS_ERROR_INVALID_POINTER;
+  *aName = ToNewCString(mName);
+  return NS_OK;
+}
+
+/* readonly attribute string filename; */
+NS_IMETHODIMP ExceptionStub::GetFilename(char **aFilename)
+{
+  if (!aFilename)
+    return NS_ERROR_INVALID_POINTER;
+  *aFilename = ToNewCString(mFilename);
+  return NS_OK;
+}
+
+/* readonly attribute PRUint32 lineNumber; */
+NS_IMETHODIMP ExceptionStub::GetLineNumber(PRUint32 *aLineNumber)
+{
+  if (!aLineNumber)
+    return NS_ERROR_INVALID_POINTER;
+  *aLineNumber = mLineNumber;
+  return NS_OK;
+}
+
+/* readonly attribute PRUint32 columnNumber; */
+NS_IMETHODIMP ExceptionStub::GetColumnNumber(PRUint32 *aColumnNumber)
+{
+  if (!aColumnNumber)
+    return NS_ERROR_INVALID_POINTER;
+  *aColumnNumber = mColumnNumber;
+  return NS_OK;
+}
+
+/* readonly attribute nsIStackFrame location; */
+NS_IMETHODIMP ExceptionStub::GetLocation(nsIStackFrame **aLocation)
+{
+  if (Exception())
+    return Exception()->GetLocation (aLocation);
+  return NS_ERROR_UNEXPECTED;
+}
+
+/* readonly attribute nsIException inner; */
+NS_IMETHODIMP ExceptionStub::GetInner(nsIException **aInner)
+{
+  if (Exception())
+    return Exception()->GetInner (aInner);
+  return NS_ERROR_UNEXPECTED;
+}
+
+/* readonly attribute nsISupports data; */
+NS_IMETHODIMP ExceptionStub::GetData(nsISupports * *aData)
+{
+  if (Exception())
+    return Exception()->GetData (aData);
+  return NS_ERROR_UNEXPECTED;
+}
+
+/* string toString (); */
+NS_IMETHODIMP ExceptionStub::ToString(char **_retval)
+{
+  if (Exception())
+    return Exception()->ToString (_retval);
+  return NS_ERROR_UNEXPECTED;
+}
+
+nsresult
+ipcDConnectService::SerializeException(ipcMessageWriter &writer,
+                                       PRUint32 peer, nsIException *xcpt,
+                                       nsVoidArray &wrappers)
+{
+  PRBool cache_fields = PR_FALSE;
+
+  // first, seralize the nsIException pointer.  The code is merely the same as
+  // in SerializeInterfaceParam() except that when the exception to serialize
+  // is an ExceptionStub instance and the real instance it stores as mXcpt
+  // is a DConnectStub corresponding to an object in the address space of the
+  // peer, we simply pass that object back instead of creating a new wrapper.
+
+  {
+    nsAutoLock lock (mLock);
+
+    if (mDisconnected)
+      return NS_ERROR_NOT_INITIALIZED;
+
+    if (!xcpt)
+    {
+      // write null address
+      writer.PutBytes(&xcpt, sizeof(xcpt));
+    }
+    else
+    {
+      ExceptionStub *stub = nsnull;
+      nsresult rv = xcpt->QueryInterface(kExceptionStubID, (void **) &stub);
+      if (NS_SUCCEEDED(rv) && (stub->Stub()->PeerID() == peer))
+      {
+        // send the wrapper instance back to the peer
+        void *p = stub->Stub()->Instance();
+        writer.PutBytes(&p, sizeof(p));
+      }
+      else
+      {
+        // create instance wrapper
+
+        const nsID &iid = nsIException::GetIID();
+        nsCOMPtr<nsIInterfaceInfo> iinfo;
+        rv = GetInterfaceInfo(iid, getter_AddRefs(iinfo));
+        if (NS_FAILED(rv))
+          return rv;
+
+        DConnectInstance *wrapper = nsnull;
+
+        // first try to find an existing wrapper for the given object
+        if (!FindInstanceAndAddRef(peer, xcpt, &iid, &wrapper))
+        {
+          wrapper = new DConnectInstance(peer, iinfo, xcpt);
+          if (!wrapper)
+            return NS_ERROR_OUT_OF_MEMORY;
+
+          rv = StoreInstance(wrapper);
+          if (NS_FAILED(rv))
+          {
+            delete wrapper;
+            return rv;
+          }
+
+          // reference the newly created wrapper
+          wrapper->AddRef();
+        }
+        
+        if (!wrappers.AppendElement(wrapper))
+        {
+          wrapper->Release();
+          return NS_ERROR_OUT_OF_MEMORY;
+        }
+
+        // wrapper remains referenced when passing it to the client
+        // (will be released upon DCON_OP_RELEASE)
+      
+        // send address of the instance wrapper, and set the low bit
+        // to indicate that this is an instance wrapper.
+        PtrBits bits = ((PtrBits) wrapper) | 0x1;
+        writer.PutBytes(&bits, sizeof(bits));
+
+        // we want to cache fields to minimize the number of IPC calls when
+        // accessing exception data on the peer side
+        cache_fields = PR_TRUE;
+      }
+      NS_IF_RELEASE(stub);
+    }
+  }
+
+  if (!cache_fields)
+    return NS_OK;
+
+  nsresult rv;
+  nsXPIDLCString str;
+  PRUint32 num;
+
+  // message
+  rv = xcpt->GetMessage(getter_Copies(str));
+  if (NS_SUCCEEDED (rv))
+  {
+    PRUint32 len = str.Length();
+    nsACString::const_iterator begin;
+    const char *data = str.BeginReading(begin).get();
+    writer.PutInt32(len);
+    writer.PutBytes(data, len);
+  }
+  else
+    writer.PutInt32(0);
+
+  // result
+  nsresult res = 0;
+  xcpt->GetResult(&res);
+  writer.PutInt32(res);
+
+  // name
+  rv = xcpt->GetName(getter_Copies(str));
+  if (NS_SUCCEEDED (rv))
+  {
+    PRUint32 len = str.Length();
+    nsACString::const_iterator begin;
+    const char *data = str.BeginReading(begin).get();
+    writer.PutInt32(len);
+    writer.PutBytes(data, len);
+  }
+  else
+    writer.PutInt32(0);
+
+  // filename
+  rv = xcpt->GetFilename(getter_Copies(str));
+  if (NS_SUCCEEDED (rv))
+  {
+    PRUint32 len = str.Length();
+    nsACString::const_iterator begin;
+    const char *data = str.BeginReading(begin).get();
+    writer.PutInt32(len);
+    writer.PutBytes(data, len);
+  }
+  else
+    writer.PutInt32(0);
+
+  // lineNumber
+  num = 0;
+  xcpt->GetLineNumber(&num);
+  writer.PutInt32(num);
+
+  // columnNumber
+  num = 0;
+  xcpt->GetColumnNumber(&num);
+  writer.PutInt32(num);
+
+  return writer.HasError() ? NS_ERROR_OUT_OF_MEMORY : NS_OK;
+}
+
+nsresult
+ipcDConnectService::DeserializeException(const PRUint8 *data,
+                                         PRUint32 dataLen,
+                                         PRUint32 peer,
+                                         nsIException **xcpt)
+{
+  NS_ASSERTION (xcpt, "NULL");
+  if (!xcpt)
+    return NS_ERROR_INVALID_POINTER;
+
+  ipcMessageReader reader(data, dataLen);
+
+  nsresult rv;
+  PRUint32 len;
+
+  void *instance = 0;
+  reader.GetBytes(&instance, sizeof(void *));
+  if (reader.HasError())
+    return NS_ERROR_INVALID_ARG;
+
+  PtrBits bits = (PtrBits) (instance);
+
+  if (bits & 0x1)
+  {
+    // pointer is a peer-side exception instance wrapper,
+    // read cahced exception data and create a stub for it.
+
+    nsCAutoString message;
+    len = reader.GetInt32();
+    if (len)
+    {
+      message.SetLength(len);
+      char *buf = message.BeginWriting();
+      reader.GetBytes(buf, len);
+    }
+
+    nsresult result = reader.GetInt32();
+
+    nsCAutoString name;
+    len = reader.GetInt32();
+    if (len)
+    {
+      name.SetLength(len);
+      char *buf = name.BeginWriting();
+      reader.GetBytes(buf, len);
+    }
+
+    nsCAutoString filename;
+    len = reader.GetInt32();
+    if (len)
+    {
+      filename.SetLength(len);
+      char *buf = filename.BeginWriting();
+      reader.GetBytes(buf, len);
+    }
+
+    PRUint32 lineNumber = reader.GetInt32();
+    PRUint32 columnNumber = reader.GetInt32();
+
+    if (reader.HasError())
+      rv = NS_ERROR_INVALID_ARG;
+    else
+    {
+      DConAddr addr = (DConAddr) (bits & ~0x1);
+      nsRefPtr<DConnectStub> stub;
+      rv = CreateStub(nsIException::GetIID(), peer, addr,
+                      getter_AddRefs(stub));
+      if (NS_SUCCEEDED(rv))
+      {
+        // create a special exception "stub" with cached error info
+        ExceptionStub *xcptStub =
+          new ExceptionStub (message, result,
+                             name, filename,
+                             lineNumber, columnNumber,
+                             stub);
+        if (xcptStub)
+        {
+          *xcpt = xcptStub;
+          NS_ADDREF(xcptStub);
+        }
+        else
+          rv = NS_ERROR_OUT_OF_MEMORY;
+      }
+    }
+  }
+  else if (bits)
+  {
+    // pointer is to our instance wrapper for nsIException we've sent before
+    // (the remote method we've called had called us back and got an exception
+    // from us that it decided to return as its own result). Replace it with
+    // the real instance.
+    DConnectInstance *wrapper = (DConnectInstance *) bits;
+    if (CheckInstanceAndAddRef(wrapper))
+    {
+      *xcpt = (nsIException *) wrapper->RealInstance();
+      NS_ADDREF(wrapper->RealInstance());
+      wrapper->Release();
+    }
+    else
+    {
+      NS_NOTREACHED("instance wrapper not found");
+      rv = NS_ERROR_INVALID_ARG;
+    }
+  }
+  else
+  {
+    // the peer explicitly passed us a NULL exception to indicate that the
+    // exception on the current thread should be reset
+    *xcpt = NULL;
+    return NS_OK;
+  }
+
+
+  return rv;
+}
+
+//-----------------------------------------------------------------------------
+
 DConnectStub::~DConnectStub()
 {
@@ -1278 +1732 @@
 
   // reset the exception early.  this is necessary because we may return a
-  // failure from here without setting an exception (which might be expected by
-  // the caller because the interface we are stubbing may indicate in some way
-  // that it always sets the exception info on failure).  besides that, resetting
-  // the excetion before every IPC call is exactly the same thing as Win32 RPC
-  // does, so doing this is useful for getting similarity in behaviors.
+  // failure from here without setting an exception (which might be expected
+  // by the caller to detect the error origin: the interface we are stubbing
+  // may indicate in some way that it always sets the exception info on
+  // failure, therefore an "infoless" failure means the origin is RPC).
+  // besides that, resetting the excetion before every IPC call is exactly the
+  // same thing as Win32 RPC does, so doing this is useful for getting
+  // similarity in behaviors.
 
   nsCOMPtr <nsIExceptionService> es;
@@ -1399 +1855 @@
   if (NS_FAILED(rv))
   {
-    if (completion.ParamsLen() > 0)
-    {
-      // we've got an nsIException instance, deserialize it and set in the
-      // current thread
-      nsresult invoke_rv = rv;
-      PtrBits bits = (PtrBits) *((void **) completion.Params());
-
-      LOG(("got nsIException instance (%p), will create a stub\n", bits));
-
-      NS_ASSERTION(completion.ParamsLen() == sizeof(void*),
-                   "wrong nsIException serialization");
-
-      if (bits & 0x1)
-      {
-        DConAddr addr = (DConAddr) (bits & ~0x1);
-        nsRefPtr<DConnectStub> stub;
-        rv = dConnect->CreateStub(nsIException::GetIID(), mPeerID, addr,
-                                  getter_AddRefs(stub));
-        if (NS_SUCCEEDED(rv))
-        {
-          rv = em->SetCurrentException((nsIException *)(nsISupports *) stub);
-          // restore the method's result
-          rv = invoke_rv;
-        }
-      }
-      else if (bits)
-      {
-        // pointer is to our instance wrapper for nsIException we've set
-        // before (the remote method we've just called had called us back
-        // and got an exception from us that it decided to return as its
-        // own result). Replace it with the real instance.
-        DConnectInstance *wrapper = (DConnectInstance *) bits;
-        if (dConnect->CheckInstanceAndAddRef(wrapper))
-        {
-          rv = em->SetCurrentException((nsIException *) wrapper->RealInstance());
-          // restore the method's result
-          rv = invoke_rv;
-          wrapper->Release();
-        }
-        else
-        {
-          NS_NOTREACHED("instance wrapper not found");
-          rv = NS_ERROR_INVALID_ARG;
-        }
-      }
-      else
-      {
-        // reset the exception (as requested by the peer)
-        // (it doesn't seem to be really necessary since we always reset it at
-        // the beginning, but leave it here for clarity)
-        rv = em->SetCurrentException(NULL);
-        // restore the method's result
-        rv = invoke_rv;
-      }
+    NS_ASSERTION(completion.ParamsLen() >= sizeof(void*),
+                 "invalid nsIException serialization length");
+    if (completion.ParamsLen() >= sizeof(void*))
+    {
+      LOG(("got nsIException instance (%p), will create a stub\n",
+           *((void **) completion.Params())));
+
+      nsIException *xcpt = nsnull;
+      rv = dConnect->DeserializeException (completion.Params(),
+                                           completion.ParamsLen(),
+                                           mPeerID, &xcpt);
+      if (NS_SUCCEEDED(rv))
+      {
+        rv = em->SetCurrentException(xcpt);
+        NS_IF_RELEASE(xcpt);
+      }
+      NS_ASSERTION(NS_SUCCEEDED(rv), "failed to deserialize/set exception");
     }
   }
@@ -1546 +1965 @@
     }
 
+    if (opLen < sizeof(DConnectSetupReply))
+    {
+      NS_NOTREACHED("unexpected response size");
+      mStatus = NS_ERROR_UNEXPECTED;
+      return;
+    }
+
     const DConnectSetupReply *reply = (const DConnectSetupReply *) op;
 
@@ -1554 +1980 @@
       mStatus = reply->status;
 
-      // we've been sent an nsIException (that can be null) in case of any error,
-      // set it in the current thread
-      LOG(("got nsIException instance (%p), will create a stub\n", reply->instance));
-
-      nsresult rv;
-      nsCOMPtr <nsIExceptionService> es;
-      es = do_GetService (NS_EXCEPTIONSERVICE_CONTRACTID, &rv);
-      if (NS_SUCCEEDED(rv))
-      {
-        nsCOMPtr <nsIExceptionManager> em;
-        rv = es->GetCurrentExceptionManager (getter_AddRefs(em));
+      const PRUint8 *params = ((const PRUint8 *) op) + sizeof (DConnectSetupReply);
+      const PRUint32 paramsLen = opLen - sizeof (DConnectSetupReply);
+
+      NS_ASSERTION(paramsLen >= sizeof(void*),
+                   "invalid nsIException serialization length");
+      if (paramsLen >= sizeof(void*))
+      {
+        LOG(("got nsIException instance (%p), will create a stub\n",
+             *((void **) params)));
+
+        nsresult rv;
+        nsCOMPtr <nsIExceptionService> es;
+        es = do_GetService (NS_EXCEPTIONSERVICE_CONTRACTID, &rv);
         if (NS_SUCCEEDED(rv))
         {
-          if (reply->instance)
+          nsCOMPtr <nsIExceptionManager> em;
+          rv = es->GetCurrentExceptionManager (getter_AddRefs(em));
+          if (NS_SUCCEEDED(rv))
           {
             // ensure ipcDConnectService is not deleted before we finish
             nsRefPtr <ipcDConnectService> dConnect (ipcDConnectService::GetInstance());
             if (dConnect)
-              rv = dConnect->CreateStub(nsIException::GetIID(), sender, reply->instance,
-                                        getter_AddRefs(mStub));
+            {
+              nsIException *xcpt = nsnull;
+              rv = dConnect->DeserializeException (params, paramsLen,
+                                                   sender, &xcpt);
+              if (NS_SUCCEEDED(rv))
+              {
+                rv = em->SetCurrentException(xcpt);
+                NS_IF_RELEASE(xcpt);
+              }
+            }
             else
-              rv = NS_ERROR_FAILURE;
-            if (NS_SUCCEEDED(rv))
-            {
-              rv = em->SetCurrentException((nsIException *)(nsISupports *) mStub);
-            }
-          }
-          else
-          {
-            // reset the exception (as requested by the peer)
-            rv = em->SetCurrentException(NULL);
+              rv = NS_ERROR_UNEXPECTED;
           }
         }
-      }
-
-      if (NS_FAILED(rv))
-        mStatus = rv;
+        NS_ASSERTION(NS_SUCCEEDED(rv), "failed to deserialize/set exception");
+      }
     }
     else
@@ -2339 +2766 @@
       break;
   }
+
+  nsVoidArray wrappers;
 
   // now, create instance wrapper, and store it in our instances set.
@@ -2371 +2800 @@
             // reference the newly created wrapper
             wrapper->AddRef();
+
+            if (!wrappers.AppendElement(wrapper))
+            {
+              NS_RELEASE(wrapper);
+              rv = NS_ERROR_OUT_OF_MEMORY;
+            }
           }
         }
@@ -2379 +2814 @@
     }
   }
-  else
+
+  NS_IF_RELEASE(instance);
+
+  ipcMessageWriter writer(64);
+
+  DConnectSetupReply msg;
+  msg.opcode_major = DCON_OP_SETUP_REPLY;
+  msg.opcode_minor = 0;
+  msg.request_index = setup->request_index;
+  msg.instance = wrapper;
+  msg.status = rv;
+
+  writer.PutBytes(&msg, sizeof(msg));
+
+  if (NS_FAILED(rv))
   {
     // try to fetch an nsIException possibly set by one of the setup methods
     // and send it instead of the failed instance (even if it is null)
-    nsresult setup_rv = rv;
     nsCOMPtr <nsIExceptionService> es;
     es = do_GetService(NS_EXCEPTIONSERVICE_CONTRACTID, &rv);
@@ -2399 +2847 @@
                (nsIException *)exception));
 
-          if (exception)
-          {
-            nsCOMPtr<nsIInterfaceInfo> iinfo;
-            rv = GetInterfaceInfo(nsIException::GetIID(), getter_AddRefs(iinfo));
-            if (NS_SUCCEEDED(rv))
-            {
-              nsAutoLock lock (mLock);
-
-              // first try to find an existing wrapper for the given object
-              if (!FindInstanceAndAddRef(peer, exception,
-                                         &nsIException::GetIID(), &wrapper))
-              {
-                wrapper = new DConnectInstance(peer, iinfo, exception);
-                if (!wrapper)
-                  rv = NS_ERROR_OUT_OF_MEMORY;
-                else
-                {
-                  rv = StoreInstance(wrapper);
-                  if (NS_FAILED(rv))
-                  {
-                    delete wrapper;
-                    wrapper = nsnull;
-                  }
-                  else
-                  {
-                    // reference the newly created wrapper
-                    wrapper->AddRef();
-                  }
-                }
-              }
-
-              // wrapper remains referenced when passing it to the client
-              // (will be released upon DCON_OP_RELEASE)
-            }
-          }
-          // otherwise, wrapper = nsnull, which will indicate a null nsIException
-
-          // restore the setup result
-          if (NS_SUCCEEDED(rv))
-            rv = setup_rv;
+          rv = SerializeException(writer, peer, exception, wrappers);
         }
       }
     }
-  }
-
-  NS_IF_RELEASE(instance);
-
-  DConnectSetupReply msg;
-  msg.opcode_major = DCON_OP_SETUP_REPLY;
-  msg.opcode_minor = 0;
-  msg.request_index = setup->request_index;
-  msg.instance = wrapper;
-  msg.status = rv;
+    NS_ASSERTION(NS_SUCCEEDED(rv), "failed to get/serialze exception");
+  }
 
   // fire off SETUP_REPLY, don't wait for a response
-  IPC_SendMessage(peer, kDConnectTargetID,
-                  (const PRUint8 *) &msg, sizeof(msg));
+  if (NS_FAILED(rv))
+    rv = IPC_SendMessage(peer, kDConnectTargetID,
+                         (const PRUint8 *) &msg, sizeof(msg));
+  else
+    rv = IPC_SendMessage(peer, kDConnectTargetID,
+                         writer.GetBuffer(), writer.GetSize());
+
+  if (NS_FAILED(rv))
+  {
+    LOG(("unable to send SETUP_REPLY: rv=%x\n", rv));
+    ReleaseWrappers(wrappers);
+  }
 }
 
@@ -2650 +3061 @@
   if (got_exception)
   {
-    // serialize the exception
-    rv = SerializeInterfaceParam(writer, peer, nsIException::GetIID(),
-                                 exception, wrappers);
+    rv = SerializeException(writer, peer, exception, wrappers);
+    NS_ASSERTION(NS_SUCCEEDED(rv), "failed to get/serialze exception");
   }
   else if (NS_SUCCEEDED(rv) && params)

trunk/src/libs/xpcom18a4/ipc/ipcd/extensions/dconnect/src/ipcDConnectService.h

@@ -21 +21 @@
  * Contributor(s):
  *   Darin Fisher <[email protected]>
+ *   Dmitry A. Kuminov <[email protected]>
  *
  * Alternatively, the contents of this file may be used under the terms of
@@ -79 +80 @@
 };
 
-#endif
-
+#endif // DCONNECT_MULTITHREADED
+
+class nsIException;
 class ipcMessageWriter;
 
@@ -216 +218 @@
                                                nsISupports *obj,
                                                nsVoidArray &wrappers);
+
+  NS_HIDDEN_(nsresult) SerializeException(ipcMessageWriter &writer,
+                                          PRUint32 peer, nsIException *xcpt,
+                                          nsVoidArray &wrappers);
+  NS_HIDDEN_(nsresult) DeserializeException(const PRUint8 *data, PRUint32 dataLen,
+                                            PRUint32 peer, nsIException **xcpt);
 
   NS_HIDDEN_(void)     ReleaseWrappers(nsVoidArray &wrappers);