More nsresult -> bool fixes, and fix windows bustage from NPEvent stub impl.

dom/plugins/BrowserStreamParent.cpp

@@ -23,7 +23,7 @@ BrowserStreamParent::AnswerNPN_RequestRead(const IPCByteRanges& ranges,
 
   if (ranges.size() > PR_INT32_MAX) {
     // TODO: abort all processing!
-    return NS_ERROR_INVALID_ARG;
+    return false;
   }
 
   nsAutoArrayPtr<NPByteRange> rp(new NPByteRange[ranges.size()]);
@@ -41,9 +41,10 @@ int32_t
 BrowserStreamParent::WriteReady()
 {
   int32_t result;
-  nsresult rv = CallNPP_WriteReady(mStream->end, &result);
+  if (!CallNPP_WriteReady(mStream->end, &result)) {
-  if (NS_FAILED(rv)) {
     mNPP->mNPNIface->destroystream(mNPP->mNPP, mStream, NPRES_NETWORK_ERR);
+    // XXX is this right?
+    return -1;
   }
   return result;
 }
@@ -54,11 +55,11 @@ BrowserStreamParent::Write(int32_t offset,
                            void* buffer)
 {
   int32_t result;
-  nsresult rv = CallNPP_Write(offset,
+  if (!CallNPP_Write(offset,
-                           nsDependentCString(static_cast<char*>(buffer), len),
+                     nsDependentCString(static_cast<char*>(buffer), len),
-                           &result);
+                     &result)) {
-  if (NS_FAILED(rv))
     return -1;
+  }
 
   if (result == -1)
     mNPP->CallPBrowserStreamDestructor(this, NPRES_USER_BREAK, true);

dom/plugins/NPEventWindows.h

@@ -42,7 +42,9 @@
 
 #include "npapi.h"
 
-#warning This is only a stub implementation IMPLEMENT ME
+#pragma message(__FILE__ ":  This is only a stub implementation IMPLEMENT ME")
+
+namespace IPC {
 
 template <>
 struct ParamTraits<NPEvent>
@@ -63,5 +65,6 @@ struct ParamTraits<NPEvent>
     }
 };
 
+} // namespace IPC
 
 #endif // ifndef mozilla_dom_plugins_NPEventWindows_h

dom/plugins/PluginInstanceChild.cpp

@@ -130,7 +130,9 @@ PluginInstanceChild::NPN_GetValue(NPNVariable aVar,
     case NPNVjavascriptEnabledBool: {
         bool v = false;
         NPError result;
-        CallNPN_GetValue_NPNVjavascriptEnabledBool(&v, &result);
+        if (!CallNPN_GetValue_NPNVjavascriptEnabledBool(&v, &result)) {
+            return NPERR_GENERIC_ERROR;
+        }
         *static_cast<NPBool*>(aValue) = v;
         return result;
     }
@@ -138,7 +140,9 @@ PluginInstanceChild::NPN_GetValue(NPNVariable aVar,
     case NPNVisOfflineBool: {
         bool v = false;
         NPError result;
-        CallNPN_GetValue_NPNVisOfflineBool(&v, &result);
+        if (!CallNPN_GetValue_NPNVisOfflineBool(&v, &result)) {
+            return NPERR_GENERIC_ERROR;
+        }
         *static_cast<NPBool*>(aValue) = v;
         return result;
     }
@@ -146,7 +150,9 @@ PluginInstanceChild::NPN_GetValue(NPNVariable aVar,
     case NPNVprivateModeBool: {
         bool v = false;
         NPError result;
-        CallNPN_GetValue_NPNVprivateModeBool(&v, &result);
+        if (!CallNPN_GetValue_NPNVprivateModeBool(&v, &result)) {
+            return NPERR_GENERIC_ERROR;
+        }
         *static_cast<NPBool*>(aValue) = v;
         return result;
     }

dom/plugins/PluginInstanceParent.cpp

@@ -203,20 +203,19 @@ PluginInstanceParent::NPP_GetValue(NPPVariable variable, void *ret_value)
     // FIXME/cjones: HACK ALERT! should forward to child
     switch(variable) {
 #ifdef OS_LINUX
-    case NPPVpluginNeedsXEmbed:
+        case NPPVpluginNeedsXEmbed:
-        (*(PRBool*)ret_value) = PR_TRUE;
+            (*(PRBool*)ret_value) = PR_TRUE;
-        return NPERR_NO_ERROR;
+            return NPERR_NO_ERROR;
 #endif
 
-#if 0 //Coming soon!
+        case NPPVpluginScriptableNPObject: {
-    case NPPVpluginScriptableNPObject:
+            PPluginScriptableObjectParent* actor;
-        PPluginScriptableObjectParent* actor;
+            NPError rv;
-        NPError rv;
+            if (!CallNPP_GetValue_NPPVpluginScriptableNPObject(&actor, &rv)) {
-        CallNPP_GetValue_NPPVpluginScriptableNPObject(&actor, &rv);
+                return NPERR_GENERIC_ERROR;
-        break;
+            }
-#endif
+            return rv;
-    default:
+        }
-        return NPERR_GENERIC_ERROR;
     }
 
     NS_NOTREACHED("Don't get here!");
@@ -244,25 +243,31 @@ PluginInstanceParent::NPP_NewStream(NPMIMEType type, NPStream* stream,
     _MOZ_LOG(__FUNCTION__);
         
     NPError err;
-    CallPBrowserStreamConstructor(new BrowserStreamParent(this, stream),
+    if (!CallPBrowserStreamConstructor(new BrowserStreamParent(this, stream),
-                                  nsCString(stream->url),
+                                       nsCString(stream->url),
-                                  stream->end,
+                                       stream->end,
-                                  stream->lastmodified,
+                                       stream->lastmodified,
-                                  static_cast<PStreamNotifyParent*>(stream->notifyData),
+                                       static_cast<PStreamNotifyParent*>(stream->notifyData),
-                                  nsCString(stream->headers),
+                                       nsCString(stream->headers),
-                                  nsCString(type), seekable, &err, stype);
+                                       nsCString(type), seekable, &err, stype)) {
+        return NPERR_GENERIC_ERROR;
+    }
     return err;
-}    
+}
 
 NPError
 PluginInstanceParent::NPP_DestroyStream(NPStream* stream, NPReason reason)
 {
     BrowserStreamParent* sp =
         static_cast<BrowserStreamParent*>(stream->pdata);
-    if (sp->mNPP != this)
+    if (sp->mNPP != this) {
         NS_RUNTIMEABORT("Mismatched plugin data");
+    }
 
-    return CallPBrowserStreamDestructor(sp, reason, false);
+    if (!CallPBrowserStreamDestructor(sp, reason, false)) {
+        return NPERR_GENERIC_ERROR;
+    }
+    return NPERR_NO_ERROR;
 }
 
 PPluginScriptableObjectParent*

dom/plugins/PluginModuleChild.cpp

@@ -647,9 +647,11 @@ _getstringidentifier(const NPUTF8* aName)
     _MOZ_LOG(__FUNCTION__);
 
     NPRemoteIdentifier ident;
-    nsresult rv = PluginModuleChild::current()->
+    if (!PluginModuleChild::current()->
-        SendNPN_GetStringIdentifier(nsDependentCString(aName), &ident);
+             SendNPN_GetStringIdentifier(nsDependentCString(aName), &ident)) {
-    NS_ENSURE_SUCCESS(rv, 0);
+        NS_WARNING("Failed to send message!");
+        ident = 0;
+    }
 
     return (NPIdentifier)ident;
 }
@@ -668,20 +670,14 @@ _getstringidentifiers(const NPUTF8** aNames,
     nsAutoTArray<nsCString, 10> names;
     nsAutoTArray<NPRemoteIdentifier, 10> ids;
 
-    PRBool ok = names.SetCapacity(aNameCount);
+    if (names.SetCapacity(aNameCount)) {
-    NS_WARN_IF_FALSE(ok, "Out of memory!");
-
-    if (ok) {
         for (int32_t index = 0; index < aNameCount; index++) {
             names.AppendElement(nsDependentCString(aNames[index]));
         }
         NS_ASSERTION(names.Length() == aNameCount, "Should equal here!");
 
-        nsresult rv = PluginModuleChild::current()->
+        if (PluginModuleChild::current()->
-            SendNPN_GetStringIdentifiers(names, &ids);
+                SendNPN_GetStringIdentifiers(names, &ids)) {
-        NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "Failed to send message!");
-
-        if (NS_SUCCEEDED(rv)) {
             NS_ASSERTION(ids.Length() == aNameCount, "Bad length!");
 
             for (int32_t index = 0; index < aNameCount; index++) {
@@ -689,6 +685,7 @@ _getstringidentifiers(const NPUTF8** aNames,
             }
             return;
         }
+        NS_WARNING("Failed to send message!");
     }
 
     // Something must have failed above.
@@ -703,9 +700,12 @@ _identifierisstring(NPIdentifier aIdentifier)
     _MOZ_LOG(__FUNCTION__);
 
     bool isString;
-    nsresult rv = PluginModuleChild::current()->
+    if (!PluginModuleChild::current()->
-        SendNPN_IdentifierIsString((NPRemoteIdentifier)aIdentifier, &isString);
+             SendNPN_IdentifierIsString((NPRemoteIdentifier)aIdentifier,
-    NS_ENSURE_SUCCESS(rv, false);
+                                        &isString)) {
+        NS_WARNING("Failed to send message!");
+        isString = false;
+    }
 
     return isString;
 }
@@ -716,9 +716,11 @@ _getintidentifier(int32_t aIntId)
     _MOZ_LOG(__FUNCTION__);
 
     NPRemoteIdentifier ident;
-    nsresult rv = PluginModuleChild::current()->
+    if (!PluginModuleChild::current()->
-        SendNPN_GetIntIdentifier(aIntId, &ident);
+             SendNPN_GetIntIdentifier(aIntId, &ident)) {
-    NS_ENSURE_SUCCESS(rv, 0);
+        NS_WARNING("Failed to send message!");
+        ident = 0;
+    }
 
     return (NPIdentifier)ident;
 }
@@ -730,10 +732,12 @@ _utf8fromidentifier(NPIdentifier aIdentifier)
 
     NPError err;
     nsCAutoString val;
-    nsresult rv = PluginModuleChild::current()->
+    if (!PluginModuleChild::current()->
-        SendNPN_UTF8FromIdentifier((NPRemoteIdentifier)aIdentifier,
+             SendNPN_UTF8FromIdentifier((NPRemoteIdentifier)aIdentifier,
-                                   &err, &val);
+                                         &err, &val)) {
-    NS_ENSURE_SUCCESS(rv, 0);
+        NS_WARNING("Failed to send message!");
+        return 0;
+    }
 
     return (NPERR_NO_ERROR == err) ? strdup(val.get()) : 0;
 }
@@ -745,10 +749,12 @@ _intfromidentifier(NPIdentifier aIdentifier)
 
     NPError err;
     int32_t val;
-    nsresult rv = PluginModuleChild::current()->
+    if (!PluginModuleChild::current()->
-        SendNPN_IntFromIdentifier((NPRemoteIdentifier)aIdentifier,
+             SendNPN_IntFromIdentifier((NPRemoteIdentifier)aIdentifier,
-                                  &err, &val);
+                                       &err, &val)) {
-    NS_ENSURE_SUCCESS(rv, 0);
+        NS_WARNING("Failed to send message!");
+        return -1;
+    }
 
     // -1 for consistency
     return (NPERR_NO_ERROR == err) ? val : -1;

dom/plugins/PluginModuleParent.cpp

@@ -131,7 +131,7 @@ PluginModuleParent::SetPluginFuncs(NPPluginFuncs* aFuncs)
 #ifdef OS_LINUX
 NPError
 PluginModuleParent::NP_Initialize(const NPNetscapeFuncs* npnIface,
-                                 NPPluginFuncs* nppIface)
+                                  NPPluginFuncs* nppIface)
 {
     _MOZ_LOG(__FUNCTION__);
 
@@ -152,7 +152,7 @@ PluginModuleParent::NP_Initialize(const NPNetscapeFuncs* npnIface)
 
     NPError prv;
     if (!CallNP_Initialize(&prv))
-        return NP_ERR_GENERIC_ERROR;
+        return NPERR_GENERIC_ERROR;
     return prv;
 }
 
@@ -325,8 +325,10 @@ bool
 PluginModuleParent::RecvNPN_GetStringIdentifier(const nsCString& aString,
                                                 NPRemoteIdentifier* aId)
 {
-    if (aString.IsVoid())
+    if (aString.IsVoid()) {
+        NS_ERROR("Someone sent over a void string?!");
         return false;
+    }
 
     NPIdentifier ident = _getstringidentifier(aString.BeginReading());
     if (!ident) {
@@ -335,8 +337,10 @@ PluginModuleParent::RecvNPN_GetStringIdentifier(const nsCString& aString,
     }
 
     nsVoidPtrHashKey* newEntry = mValidIdentifiers.PutEntry(ident);
-    if (!newEntry)
+    if (!newEntry) {
+        NS_ERROR("Out of memory?");
         return false;
+    }
 
     *aId = (NPRemoteIdentifier)ident;
     return true;
@@ -353,8 +357,10 @@ PluginModuleParent::RecvNPN_GetIntIdentifier(const int32_t& aInt,
     }
 
     nsVoidPtrHashKey* newEntry = mValidIdentifiers.PutEntry(ident);
-    if (!newEntry)
+    if (!newEntry) {
+        NS_ERROR("Out of memory?");
         return false;
+    }
 
     *aId = (NPRemoteIdentifier)ident;
     return true;
@@ -419,18 +425,20 @@ PluginModuleParent::RecvNPN_GetStringIdentifiers(const nsTArray<nsCString>& aNam
     NS_ASSERTION(aIds->IsEmpty(), "Non-empty array!");
 
     PRUint32 count = aNames.Length();
-    NS_ENSURE_ARG_MIN(count, 1);
+    if (!count) {
+        NS_ERROR("No names to get!");
+        return false;
+    }
 
     nsAutoTArray<NPUTF8*, 10> buffers;
-    PRBool ok = buffers.SetLength(count);
-    NS_ENSURE_TRUE(ok, NS_ERROR_OUT_OF_MEMORY);
-
     nsAutoTArray<NPIdentifier, 10> ids;
-    ok = ids.SetLength(count);
-    NS_ENSURE_TRUE(ok, NS_ERROR_OUT_OF_MEMORY);
 
-    ok = aIds->SetCapacity(count);
+    if (!(buffers.SetLength(count) &&
-    NS_ENSURE_TRUE(ok, NS_ERROR_OUT_OF_MEMORY);
+          ids.SetLength(count) &&
+          aIds->SetCapacity(count))) {
+        NS_ERROR("Out of memory?");
+        return false;
+    }
 
     for (PRUint32 index = 0; index < count; index++) {
         buffers[index] = const_cast<NPUTF8*>(aNames[index].BeginReading());
@@ -442,12 +450,13 @@ PluginModuleParent::RecvNPN_GetStringIdentifiers(const nsTArray<nsCString>& aNam
 
     for (PRUint32 index = 0; index < count; index++) {
         NPIdentifier& id = ids[index];
-
         if (id) {
             nsVoidPtrHashKey* newEntry = mValidIdentifiers.PutEntry(id);
-            NS_ENSURE_TRUE(ok, NS_ERROR_OUT_OF_MEMORY);
+            if (!newEntry) {
+                NS_ERROR("Out of memory?");
+                return false;
+            }
         }
-
         aIds->AppendElement((NPRemoteIdentifier)id);
     }
 

dom/plugins/PluginScriptableObjectChild.cpp

@@ -41,7 +41,6 @@
 #include "npapi.h"
 #include "npruntime.h"
 #include "nsDebug.h"
-#include "nsThreadUtils.h"
 
 #include "PluginModuleChild.h"
 #include "PluginInstanceChild.h"
@@ -83,27 +82,27 @@ ConvertToVariant(const NPRemoteVariant& aRemoteVariant,
   switch (aRemoteVariant.type()) {
     case NPRemoteVariant::Tvoid_t: {
       VOID_TO_NPVARIANT(aVariant);
-      return true;
+      break;
     }
 
     case NPRemoteVariant::Tnull_t: {
       NULL_TO_NPVARIANT(aVariant);
-      return true;
+      break;
     }
 
     case NPRemoteVariant::Tbool: {
       BOOLEAN_TO_NPVARIANT(aRemoteVariant.get_bool(), aVariant);
-      return true;
+      break;
     }
 
     case NPRemoteVariant::Tint: {
       INT32_TO_NPVARIANT(aRemoteVariant.get_int(), aVariant);
-      return true;
+      break;
     }
 
     case NPRemoteVariant::Tdouble: {
       DOUBLE_TO_NPVARIANT(aRemoteVariant.get_double(), aVariant);
-      return true;
+      break;
     }
 
     case NPRemoteVariant::TnsCString: {
@@ -114,24 +113,25 @@ ConvertToVariant(const NPRemoteVariant& aRemoteVariant,
         return false;
       }
       STRINGN_TO_NPVARIANT(buffer, string.Length(), aVariant);
-      return true;
+      break;
     }
 
     case NPRemoteVariant::TPPluginScriptableObjectChild: {
       NPObject* object = NPObjectFromVariant(aRemoteVariant);
       if (!object) {
+        NS_ERROR("Er, this shouldn't fail!");
         return false;
       }
       OBJECT_TO_NPVARIANT(object, aVariant);
-      return true;
+      break;
     }
 
-  default:
+    default:
-      break;                    // break to NOTREACHED
+      NS_NOTREACHED("Shouldn't get here!");
+      return false;
   }
 
-  NS_NOTREACHED("Shouldn't get here!");
+  return true;
-  return false;
 }
 
 bool
@@ -141,49 +141,40 @@ ConvertToRemoteVariant(const NPVariant& aVariant,
 {
   if (NPVARIANT_IS_VOID(aVariant)) {
     aRemoteVariant = mozilla::void_t();
-    return true;
   }
-
+  else if (NPVARIANT_IS_NULL(aVariant)) {
-  if (NPVARIANT_IS_NULL(aVariant)) {
     aRemoteVariant = mozilla::null_t();
-    return true;
   }
-
+  else if (NPVARIANT_IS_BOOLEAN(aVariant)) {
-  if (NPVARIANT_IS_BOOLEAN(aVariant)) {
     aRemoteVariant = NPVARIANT_TO_BOOLEAN(aVariant);
-    return true;
   }
-
+  else if (NPVARIANT_IS_INT32(aVariant)) {
-  if (NPVARIANT_IS_INT32(aVariant)) {
     aRemoteVariant = NPVARIANT_TO_INT32(aVariant);
-    return true;
   }
-
+  else if (NPVARIANT_IS_DOUBLE(aVariant)) {
-  if (NPVARIANT_IS_DOUBLE(aVariant)) {
     aRemoteVariant = NPVARIANT_TO_DOUBLE(aVariant);
-    return true;
   }
-
+  else if (NPVARIANT_IS_STRING(aVariant)) {
-  if (NPVARIANT_IS_STRING(aVariant)) {
     NPString str = NPVARIANT_TO_STRING(aVariant);
     nsCString string(str.UTF8Characters, str.UTF8Length);
     aRemoteVariant = string;
-    return true;
   }
-
+  else if (NPVARIANT_IS_OBJECT(aVariant)) {
-  if (NPVARIANT_IS_OBJECT(aVariant)) {
     NS_ASSERTION(aInstance, "Must have an instance to wrap!");
     PluginScriptableObjectChild* actor =
       CreateActorForNPObject(aInstance, NPVARIANT_TO_OBJECT(aVariant));
     if (!actor) {
+      NS_ERROR("Failed to create actor!");
       return false;
     }
     aRemoteVariant = actor;
-    return true;
+  }
+  else {
+    NS_NOTREACHED("Shouldn't get here!");
+    return false;
   }
 
-  NS_NOTREACHED("Shouldn't get here!");
+  return true;
-  return false;
 }
 
 } // anonymous namespace
@@ -205,7 +196,6 @@ void
 PluginScriptableObjectChild::Initialize(PluginInstanceChild* aInstance,
                                         NPObject* aObject)
 {
-  NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
   NS_ASSERTION(!(mInstance && mObject), "Calling Initialize class twice!");
   mInstance = aInstance;
   mObject = PluginModuleChild::sBrowserFuncs.retainobject(aObject);
@@ -214,21 +204,22 @@ PluginScriptableObjectChild::Initialize(PluginInstanceChild* aInstance,
 bool
 PluginScriptableObjectChild::AnswerInvalidate()
 {
-  NS_ENSURE_STATE(NS_IsMainThread());
   if (mObject) {
     PluginModuleChild::sBrowserFuncs.releaseobject(mObject);
     mObject = nsnull;
-    return true;
   }
-  return NS_ERROR_UNEXPECTED;
+  return true;
 }
 
 bool
 PluginScriptableObjectChild::AnswerHasMethod(const NPRemoteIdentifier& aId,
                                              bool* aHasMethod)
 {
-  NS_ENSURE_STATE(NS_IsMainThread());
+  if (!mObject) {
-  NS_ENSURE_STATE(mObject);
+    NS_WARNING("Calling " __FUNCTION__ "with an invalidated object!");
+    *aHasMethod = false;
+    return true;
+  }
 
   if (!(mObject->_class && mObject->_class->hasMethod)) {
     *aHasMethod = false;
@@ -245,8 +236,11 @@ PluginScriptableObjectChild::AnswerInvoke(const NPRemoteIdentifier& aId,
                                           NPRemoteVariant* aResult,
                                           bool* aSuccess)
 {
-  NS_ENSURE_STATE(NS_IsMainThread());
+  if (!mObject) {
-  NS_ENSURE_STATE(mObject);
+    NS_WARNING("Calling " __FUNCTION__ "with an invalidated object!");
+    *aSuccess = false;
+    return true;
+  }
 
   if (!(mObject->_class && mObject->_class->invoke)) {
     *aSuccess = false;
@@ -293,8 +287,11 @@ PluginScriptableObjectChild::AnswerInvokeDefault(const nsTArray<NPRemoteVariant>
                                                  NPRemoteVariant* aResult,
                                                  bool* aSuccess)
 {
-  NS_ENSURE_STATE(NS_IsMainThread());
+  if (!mObject) {
-  NS_ENSURE_STATE(mObject);
+    NS_WARNING("Calling " __FUNCTION__ "with an invalidated object!");
+    *aSuccess = false;
+    return true;
+  }
 
   if (!(mObject->_class && mObject->_class->invokeDefault)) {
     *aSuccess = false;
@@ -340,8 +337,11 @@ bool
 PluginScriptableObjectChild::AnswerHasProperty(const NPRemoteIdentifier& aId,
                                                bool* aHasProperty)
 {
-  NS_ENSURE_STATE(NS_IsMainThread());
+  if (!mObject) {
-  NS_ENSURE_STATE(mObject);
+    NS_WARNING("Calling " __FUNCTION__ "with an invalidated object!");
+    *aHasProperty = false;
+    return true;
+  }
 
   if (!(mObject->_class && mObject->_class->hasProperty)) {
     *aHasProperty = false;
@@ -357,8 +357,11 @@ PluginScriptableObjectChild::AnswerGetProperty(const NPRemoteIdentifier& aId,
                                                NPRemoteVariant* aResult,
                                                bool* aSuccess)
 {
-  NS_ENSURE_STATE(NS_IsMainThread());
+  if (!mObject) {
-  NS_ENSURE_STATE(mObject);
+    NS_WARNING("Calling " __FUNCTION__ "with an invalidated object!");
+    *aSuccess = false;
+    return true;
+  }
 
   if (!(mObject->_class && mObject->_class->getProperty)) {
     *aSuccess = false;
@@ -383,8 +386,11 @@ PluginScriptableObjectChild::AnswerSetProperty(const NPRemoteIdentifier& aId,
                                                const NPRemoteVariant& aValue,
                                                bool* aSuccess)
 {
-  NS_ENSURE_STATE(NS_IsMainThread());
+  if (!mObject) {
-  NS_ENSURE_STATE(mObject);
+    NS_WARNING("Calling " __FUNCTION__ "with an invalidated object!");
+    *aSuccess = false;
+    return true;
+  }
 
   if (!(mObject->_class && mObject->_class->setProperty)) {
     *aSuccess = false;
@@ -406,8 +412,11 @@ bool
 PluginScriptableObjectChild::AnswerRemoveProperty(const NPRemoteIdentifier& aId,
                                                   bool* aSuccess)
 {
-  NS_ENSURE_STATE(NS_IsMainThread());
+  if (!mObject) {
-  NS_ENSURE_STATE(mObject);
+    NS_WARNING("Calling " __FUNCTION__ "with an invalidated object!");
+    *aSuccess = false;
+    return true;
+  }
 
   if (!(mObject->_class && mObject->_class->removeProperty)) {
     *aSuccess = false;
@@ -422,8 +431,11 @@ bool
 PluginScriptableObjectChild::AnswerEnumerate(nsTArray<NPRemoteIdentifier>* aProperties,
                                              bool* aSuccess)
 {
-  NS_ENSURE_STATE(NS_IsMainThread());
+  if (!mObject) {
-  NS_ENSURE_STATE(mObject);
+    NS_WARNING("Calling " __FUNCTION__ "with an invalidated object!");
+    *aSuccess = false;
+    return true;
+  }
 
   if (!(mObject->_class && mObject->_class->enumerate)) {
     *aSuccess = false;
@@ -461,8 +473,11 @@ PluginScriptableObjectChild::AnswerConstruct(const nsTArray<NPRemoteVariant>& aA
                                              NPRemoteVariant* aResult,
                                              bool* aSuccess)
 {
-  NS_ENSURE_STATE(NS_IsMainThread());
+  if (!mObject) {
-  NS_ENSURE_STATE(mObject);
+    NS_WARNING("Calling " __FUNCTION__ "with an invalidated object!");
+    *aSuccess = false;
+    return true;
+  }
 
   if (!(mObject->_class && mObject->_class->construct)) {
     *aSuccess = false;