--- a/accessible/ipc/DocAccessibleParent.cpp
+++ b/accessible/ipc/DocAccessibleParent.cpp
@@ -10,79 +10,79 @@
 #include "xpcAccessibleDocument.h"
 #include "xpcAccEvents.h"
 #include "nsAccUtils.h"
 #include "nsCoreUtils.h"
 
 namespace mozilla {
 namespace a11y {
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleParent::RecvShowEvent(const ShowEventData& aData,
                                    const bool& aFromUser)
 {
   if (mShutdown)
-    return true;
+    return IPC_OK();
 
   MOZ_DIAGNOSTIC_ASSERT(CheckDocTree());
 
   if (aData.NewTree().IsEmpty()) {
     NS_ERROR("no children being added");
-    return false;
+    return IPC_FAIL_NO_REASON(this);
   }
 
   ProxyAccessible* parent = GetAccessible(aData.ID());
 
   // XXX This should really never happen, but sometimes we fail to fire the
   // required show events.
   if (!parent) {
     NS_ERROR("adding child to unknown accessible");
-    return true;
+    return IPC_OK();
   }
 
   uint32_t newChildIdx = aData.Idx();
   if (newChildIdx > parent->ChildrenCount()) {
     NS_ERROR("invalid index to add child at");
-    return true;
+    return IPC_OK();
   }
 
   uint32_t consumed = AddSubtree(parent, aData.NewTree(), 0, newChildIdx);
   MOZ_ASSERT(consumed == aData.NewTree().Length());
 
   // XXX This shouldn't happen, but if we failed to add children then the below
   // is pointless and can crash.
   if (!consumed) {
-    return true;
+    return IPC_OK();
   }
 
 #ifdef DEBUG
   for (uint32_t i = 0; i < consumed; i++) {
     uint64_t id = aData.NewTree()[i].ID();
     MOZ_ASSERT(mAccessibles.GetEntry(id));
   }
 #endif
 
   MOZ_DIAGNOSTIC_ASSERT(CheckDocTree());
 
   ProxyAccessible* target = parent->ChildAt(newChildIdx);
   ProxyShowHideEvent(target, parent, true, aFromUser);
 
   if (!nsCoreUtils::AccEventObserversExist()) {
-    return true;
+    return IPC_OK();
   }
 
   uint32_t type = nsIAccessibleEvent::EVENT_SHOW;
   xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(target);
   xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);
   nsIDOMNode* node = nullptr;
   RefPtr<xpcAccEvent> event = new xpcAccEvent(type, xpcAcc, doc, node,
                                               aFromUser);
   nsCoreUtils::DispatchAccEvent(Move(event));
 
-  return true;
+  return IPC_OK();
 }
 
 uint32_t
 DocAccessibleParent::AddSubtree(ProxyAccessible* aParent,
                                 const nsTArray<a11y::AccessibleData>& aNewTree,
                                 uint32_t aIdx, uint32_t aIdxInParent)
 {
   if (aNewTree.Length() <= aIdx) {
@@ -125,42 +125,42 @@ DocAccessibleParent::AddSubtree(ProxyAcc
     accessibles += consumed;
   }
 
   MOZ_ASSERT(newProxy->ChildrenCount() == kids);
 
   return accessibles;
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleParent::RecvHideEvent(const uint64_t& aRootID,
                                    const bool& aFromUser)
 {
   if (mShutdown)
-    return true;
+    return IPC_OK();
 
   MOZ_DIAGNOSTIC_ASSERT(CheckDocTree());
 
   // We shouldn't actually need this because mAccessibles shouldn't have an
   // entry for the document itself, but it doesn't hurt to be explicit.
   if (!aRootID) {
     NS_ERROR("trying to hide entire document?");
-    return false;
+    return IPC_FAIL_NO_REASON(this);
   }
 
   ProxyEntry* rootEntry = mAccessibles.GetEntry(aRootID);
   if (!rootEntry) {
     NS_ERROR("invalid root being removed!");
-    return true;
+    return IPC_OK();
   }
 
   ProxyAccessible* root = rootEntry->mProxy;
   if (!root) {
     NS_ERROR("invalid root being removed!");
-    return true;
+    return IPC_OK();
   }
 
   ProxyAccessible* parent = root->Parent();
   ProxyShowHideEvent(root, parent, false, aFromUser);
 
   RefPtr<xpcAccHideEvent> event = nullptr;
   if (nsCoreUtils::AccEventObserversExist()) {
     uint32_t type = nsIAccessibleEvent::EVENT_HIDE;
@@ -180,191 +180,194 @@ DocAccessibleParent::RecvHideEvent(const
   root->Shutdown();
 
   MOZ_DIAGNOSTIC_ASSERT(CheckDocTree());
 
   if (event) {
     nsCoreUtils::DispatchAccEvent(Move(event));
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleParent::RecvEvent(const uint64_t& aID, const uint32_t& aEventType)
 {
   ProxyAccessible* proxy = GetAccessible(aID);
   if (!proxy) {
     NS_ERROR("no proxy for event!");
-    return true;
+    return IPC_OK();
   }
 
   ProxyEvent(proxy, aEventType);
 
   if (!nsCoreUtils::AccEventObserversExist()) {
-    return true;
+    return IPC_OK();
   }
 
   xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(proxy);
   xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);
   nsIDOMNode* node = nullptr;
   bool fromUser = true; // XXX fix me
   RefPtr<xpcAccEvent> event = new xpcAccEvent(aEventType, xpcAcc, doc, node,
                                               fromUser);
   nsCoreUtils::DispatchAccEvent(Move(event));
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleParent::RecvStateChangeEvent(const uint64_t& aID,
                                           const uint64_t& aState,
                                           const bool& aEnabled)
 {
   ProxyAccessible* target = GetAccessible(aID);
   if (!target) {
     NS_ERROR("we don't know about the target of a state change event!");
-    return true;
+    return IPC_OK();
   }
 
   ProxyStateChangeEvent(target, aState, aEnabled);
 
   if (!nsCoreUtils::AccEventObserversExist()) {
-    return true;
+    return IPC_OK();
   }
 
   xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(target);
   xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);
   uint32_t type = nsIAccessibleEvent::EVENT_STATE_CHANGE;
   bool extra;
   uint32_t state = nsAccUtils::To32States(aState, &extra);
   bool fromUser = true; // XXX fix this
   nsIDOMNode* node = nullptr; // XXX can we do better?
   RefPtr<xpcAccStateChangeEvent> event =
     new xpcAccStateChangeEvent(type, xpcAcc, doc, node, fromUser, state, extra,
                                aEnabled);
   nsCoreUtils::DispatchAccEvent(Move(event));
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleParent::RecvCaretMoveEvent(const uint64_t& aID, const int32_t& aOffset)
 {
   ProxyAccessible* proxy = GetAccessible(aID);
   if (!proxy) {
     NS_ERROR("unknown caret move event target!");
-    return true;
+    return IPC_OK();
   }
 
   ProxyCaretMoveEvent(proxy, aOffset);
 
   if (!nsCoreUtils::AccEventObserversExist()) {
-    return true;
+    return IPC_OK();
   }
 
   xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(proxy);
   xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);
   nsIDOMNode* node = nullptr;
   bool fromUser = true; // XXX fix me
   uint32_t type = nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED;
   RefPtr<xpcAccCaretMoveEvent> event =
     new xpcAccCaretMoveEvent(type, xpcAcc, doc, node, fromUser, aOffset);
   nsCoreUtils::DispatchAccEvent(Move(event));
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleParent::RecvTextChangeEvent(const uint64_t& aID,
                                          const nsString& aStr,
                                          const int32_t& aStart,
                                          const uint32_t& aLen,
                                          const bool& aIsInsert,
                                          const bool& aFromUser)
 {
   ProxyAccessible* target = GetAccessible(aID);
   if (!target) {
     NS_ERROR("text change event target is unknown!");
-    return true;
+    return IPC_OK();
   }
 
   ProxyTextChangeEvent(target, aStr, aStart, aLen, aIsInsert, aFromUser);
 
   if (!nsCoreUtils::AccEventObserversExist()) {
-    return true;
+    return IPC_OK();
   }
 
   xpcAccessibleGeneric* xpcAcc = GetXPCAccessible(target);
   xpcAccessibleDocument* doc = GetAccService()->GetXPCDocument(this);
   uint32_t type = aIsInsert ? nsIAccessibleEvent::EVENT_TEXT_INSERTED :
                               nsIAccessibleEvent::EVENT_TEXT_REMOVED;
   nsIDOMNode* node = nullptr;
   RefPtr<xpcAccTextChangeEvent> event =
     new xpcAccTextChangeEvent(type, xpcAcc, doc, node, aFromUser, aStart, aLen,
                               aIsInsert, aStr);
   nsCoreUtils::DispatchAccEvent(Move(event));
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleParent::RecvSelectionEvent(const uint64_t& aID,
                                         const uint64_t& aWidgetID,
                                         const uint32_t& aType)
 {
   ProxyAccessible* target = GetAccessible(aID);
   ProxyAccessible* widget = GetAccessible(aWidgetID);
   if (!target || !widget) {
     NS_ERROR("invalid id in selection event");
-    return true;
+    return IPC_OK();
   }
 
   ProxySelectionEvent(target, widget, aType);
   if (!nsCoreUtils::AccEventObserversExist()) {
-    return true;
+    return IPC_OK();
   }
   xpcAccessibleGeneric* xpcTarget = GetXPCAccessible(target);
   xpcAccessibleDocument* xpcDoc = GetAccService()->GetXPCDocument(this);
   RefPtr<xpcAccEvent> event = new xpcAccEvent(aType, xpcTarget, xpcDoc,
                                               nullptr, false);
   nsCoreUtils::DispatchAccEvent(Move(event));
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleParent::RecvRoleChangedEvent(const uint32_t& aRole)
 {
  if (aRole >= roles::LAST_ROLE) {
    NS_ERROR("child sent bad role in RoleChangedEvent");
-   return false;
+   return IPC_FAIL_NO_REASON(this);
  }
 
  mRole = static_cast<a11y::role>(aRole);
- return true;
+ return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleParent::RecvBindChildDoc(PDocAccessibleParent* aChildDoc, const uint64_t& aID)
 {
   // One document should never directly be the child of another.
   // We should always have at least an outer doc accessible in between.
   MOZ_ASSERT(aID);
   if (!aID)
-    return false;
+    return IPC_FAIL_NO_REASON(this);
 
   MOZ_DIAGNOSTIC_ASSERT(CheckDocTree());
 
   auto childDoc = static_cast<DocAccessibleParent*>(aChildDoc);
   childDoc->Unbind();
   bool result = AddChildDoc(childDoc, aID, false);
   MOZ_ASSERT(result);
   MOZ_DIAGNOSTIC_ASSERT(CheckDocTree());
-  return result;
+  if (!result) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
 }
 
 bool
 DocAccessibleParent::AddChildDoc(DocAccessibleParent* aChildDoc,
                                  uint64_t aParentID, bool aCreating)
 {
   // We do not use GetAccessible here because we want to be sure to not get the
   // document it self.
@@ -390,26 +393,28 @@ DocAccessibleParent::AddChildDoc(DocAcce
 
   if (aCreating) {
     ProxyCreated(aChildDoc, Interfaces::DOCUMENT | Interfaces::HYPERTEXT);
   }
 
   return true;
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleParent::RecvShutdown()
 {
   Destroy();
 
   if (!static_cast<dom::TabParent*>(Manager())->IsDestroyed()) {
-  return PDocAccessibleParent::Send__delete__(this);
+    if (!PDocAccessibleParent::Send__delete__(this)) {
+      return IPC_FAIL_NO_REASON(this);
+    }
   }
 
-  return true;
+  return IPC_OK();
 }
 
 void
 DocAccessibleParent::Destroy()
 {
   NS_ASSERTION(mChildDocs.IsEmpty(),
                "why weren't the child docs destroyed already?");
   MOZ_ASSERT(!mShutdown);
@@ -460,28 +465,28 @@ DocAccessibleParent::GetXPCAccessible(Pr
 
 #if defined(XP_WIN)
 /**
  * @param aCOMProxy COM Proxy to the document in the content process.
  * @param aParentCOMProxy COM Proxy to the OuterDocAccessible that is
  *        the parent of the document. The content process will use this
  *        proxy when traversing up across the content/chrome boundary.
  */
-bool
+mozilla::ipc::IPCResult
 DocAccessibleParent::RecvCOMProxy(const IAccessibleHolder& aCOMProxy,
                                   IAccessibleHolder* aParentCOMProxy)
 {
   RefPtr<IAccessible> ptr(aCOMProxy.Get());
   SetCOMInterface(ptr);
 
   Accessible* outerDoc = OuterDocOfRemoteBrowser();
   IAccessible* rawNative = nullptr;
   if (outerDoc) {
     outerDoc->GetNativeInterface((void**) &rawNative);
   }
 
   aParentCOMProxy->Set(IAccessibleHolder::COMPtrType(rawNative));
-  return true;
+  return IPC_OK();
 }
 #endif // defined(XP_WIN)
 
 } // a11y
 } // mozilla

--- a/accessible/ipc/DocAccessibleParent.h
+++ b/accessible/ipc/DocAccessibleParent.h
@@ -42,54 +42,54 @@ public:
   bool IsTopLevel() const { return mTopLevel; }
 
   bool IsShutdown() const { return mShutdown; }
 
   /*
    * Called when a message from a document in a child process notifies the main
    * process it is firing an event.
    */
-  virtual bool RecvEvent(const uint64_t& aID, const uint32_t& aType)
+  virtual mozilla::ipc::IPCResult RecvEvent(const uint64_t& aID, const uint32_t& aType)
     override;
 
-  virtual bool RecvShowEvent(const ShowEventData& aData, const bool& aFromUser)
+  virtual mozilla::ipc::IPCResult RecvShowEvent(const ShowEventData& aData, const bool& aFromUser)
     override;
-  virtual bool RecvHideEvent(const uint64_t& aRootID, const bool& aFromUser)
+  virtual mozilla::ipc::IPCResult RecvHideEvent(const uint64_t& aRootID, const bool& aFromUser)
     override;
-  virtual bool RecvStateChangeEvent(const uint64_t& aID,
-                                    const uint64_t& aState,
-                                    const bool& aEnabled) override final;
+  virtual mozilla::ipc::IPCResult RecvStateChangeEvent(const uint64_t& aID,
+                                                       const uint64_t& aState,
+                                                       const bool& aEnabled) override final;
 
-  virtual bool RecvCaretMoveEvent(const uint64_t& aID, const int32_t& aOffset)
+  virtual mozilla::ipc::IPCResult RecvCaretMoveEvent(const uint64_t& aID, const int32_t& aOffset)
     override final;
 
-  virtual bool RecvTextChangeEvent(const uint64_t& aID, const nsString& aStr,
-                                   const int32_t& aStart, const uint32_t& aLen,
-                                   const bool& aIsInsert,
-                                   const bool& aFromUser) override;
+  virtual mozilla::ipc::IPCResult RecvTextChangeEvent(const uint64_t& aID, const nsString& aStr,
+                                                      const int32_t& aStart, const uint32_t& aLen,
+                                                      const bool& aIsInsert,
+                                                      const bool& aFromUser) override;
 
-  virtual bool RecvSelectionEvent(const uint64_t& aID,
-                                  const uint64_t& aWidgetID,
-                                  const uint32_t& aType) override;
+  virtual mozilla::ipc::IPCResult RecvSelectionEvent(const uint64_t& aID,
+                                                     const uint64_t& aWidgetID,
+                                                     const uint32_t& aType) override;
 
-  virtual bool RecvRoleChangedEvent(const uint32_t& aRole) override final;
+  virtual mozilla::ipc::IPCResult RecvRoleChangedEvent(const uint32_t& aRole) override final;
 
-  virtual bool RecvBindChildDoc(PDocAccessibleParent* aChildDoc, const uint64_t& aID) override;
+  virtual mozilla::ipc::IPCResult RecvBindChildDoc(PDocAccessibleParent* aChildDoc, const uint64_t& aID) override;
 
   void Unbind()
   {
     mParent = nullptr;
     if (DocAccessibleParent* parent = ParentDoc()) {
       parent->mChildDocs.RemoveElement(this);
     }
 
     mParentDoc = nullptr;
   }
 
-  virtual bool RecvShutdown() override;
+  virtual mozilla::ipc::IPCResult RecvShutdown() override;
   void Destroy();
   virtual void ActorDestroy(ActorDestroyReason aWhy) override
   {
     MOZ_DIAGNOSTIC_ASSERT(CheckDocTree());
     if (!mShutdown)
       Destroy();
   }
 
@@ -139,18 +139,18 @@ public:
   const ProxyAccessible* GetAccessible(uintptr_t aID) const
     { return const_cast<DocAccessibleParent*>(this)->GetAccessible(aID); }
 
   size_t ChildDocCount() const { return mChildDocs.Length(); }
   const DocAccessibleParent* ChildDocAt(size_t aIdx) const
     { return mChildDocs[aIdx]; }
 
 #if defined(XP_WIN)
-  virtual bool RecvCOMProxy(const IAccessibleHolder& aCOMProxy,
-                            IAccessibleHolder* aParentCOMProxy) override;
+  virtual mozilla::ipc::IPCResult RecvCOMProxy(const IAccessibleHolder& aCOMProxy,
+                                               IAccessibleHolder* aParentCOMProxy) override;
 #endif
 
 private:
 
   class ProxyEntry : public PLDHashEntryHdr
   {
   public:
     explicit ProxyEntry(const void*) : mProxy(nullptr) {}

--- a/accessible/ipc/other/DocAccessibleChild.cpp
+++ b/accessible/ipc/other/DocAccessibleChild.cpp
@@ -80,99 +80,102 @@ DocAccessibleChild::IdToTableCellAccessi
 
 TableAccessible*
 DocAccessibleChild::IdToTableAccessible(const uint64_t& aID) const
 {
   Accessible* acc = IdToAccessible(aID);
   return (acc && acc->IsTable()) ? acc->AsTable() : nullptr;
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvState(const uint64_t& aID, uint64_t* aState)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc) {
     *aState = states::DEFUNCT;
-    return true;
+    return IPC_OK();
   }
 
   *aState = acc->State();
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvNativeState(const uint64_t& aID, uint64_t* aState)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc) {
     *aState = states::DEFUNCT;
-    return true;
+    return IPC_OK();
   }
 
   *aState = acc->NativeState();
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvName(const uint64_t& aID, nsString* aName)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc)
-    return true;
+    return IPC_OK();
 
   acc->Name(*aName);
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvValue(const uint64_t& aID, nsString* aValue)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc) {
-    return true;
+    return IPC_OK();
   }
 
   acc->Value(*aValue);
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvHelp(const uint64_t& aID, nsString* aHelp)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc) {
-    return true;
+    return IPC_OK();
   }
 
   acc->Help(*aHelp);
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvDescription(const uint64_t& aID, nsString* aDesc)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc)
-    return true;
+    return IPC_OK();
 
   acc->Description(*aDesc);
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvAttributes(const uint64_t& aID, nsTArray<Attribute>* aAttributes)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc)
-    return true;
+    return IPC_OK();
 
   nsCOMPtr<nsIPersistentProperties> props = acc->Attributes();
-  return PersistentPropertiesToArray(props, aAttributes);
+  if (!PersistentPropertiesToArray(props, aAttributes)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
 }
 
 bool
 DocAccessibleChild::PersistentPropertiesToArray(nsIPersistentProperties* aProps,
                                                 nsTArray<Attribute>* aAttributes)
 {
   if (!aProps) {
     return true;
@@ -199,31 +202,31 @@ DocAccessibleChild::PersistentProperties
     NS_ENSURE_SUCCESS(rv, false);
 
     aAttributes->AppendElement(Attribute(name, value));
     }
 
   return true;
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvRelationByType(const uint64_t& aID,
                                        const uint32_t& aType,
                                        nsTArray<uint64_t>* aTargets)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc)
-    return true;
+    return IPC_OK();
 
   auto type = static_cast<RelationType>(aType);
   Relation rel = acc->RelationByType(type);
   while (Accessible* target = rel.Next())
     aTargets->AppendElement(reinterpret_cast<uintptr_t>(target));
 
-  return true;
+  return IPC_OK();
 }
 
 static void
 AddRelation(Accessible* aAcc, RelationType aType,
             nsTArray<RelationTargets>* aTargets)
 {
   Relation rel = aAcc->RelationByType(aType);
   nsTArray<uint64_t> targets;
@@ -233,309 +236,315 @@ AddRelation(Accessible* aAcc, RelationTy
   if (!targets.IsEmpty()) {
     RelationTargets* newRelation =
       aTargets->AppendElement(RelationTargets(static_cast<uint32_t>(aType),
                                               nsTArray<uint64_t>()));
     newRelation->Targets().SwapElements(targets);
   }
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvRelations(const uint64_t& aID,
                                   nsTArray<RelationTargets>* aRelations)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc)
-    return true;
+    return IPC_OK();
 
 #define RELATIONTYPE(gecko, s, a, m, i) AddRelation(acc, RelationType::gecko, aRelations);
 
 #include "RelationTypeMap.h"
 #undef RELATIONTYPE
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvIsSearchbox(const uint64_t& aID, bool* aRetVal)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc)
-    return true;
+    return IPC_OK();
 
   *aRetVal = acc->IsSearchbox();
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvLandmarkRole(const uint64_t& aID, nsString* aLandmark)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc) {
-    return true;
+    return IPC_OK();
   }
 
   if (nsIAtom* roleAtom = acc->LandmarkRole()) {
     roleAtom->ToString(*aLandmark);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvARIARoleAtom(const uint64_t& aID, nsString* aRole)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc) {
-    return true;
+    return IPC_OK();
   }
 
   if (const nsRoleMapEntry* roleMap = acc->ARIARoleMap()) {
     if (nsIAtom* roleAtom = *(roleMap->roleAtom)) {
       roleAtom->ToString(*aRole);
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvGetLevelInternal(const uint64_t& aID, int32_t* aLevel)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     *aLevel = acc->GetLevelInternal();
   }
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvScrollTo(const uint64_t& aID,
                                  const uint32_t& aScrollType)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     nsCoreUtils::ScrollTo(acc->Document()->PresShell(), acc->GetContent(),
                           aScrollType);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvScrollToPoint(const uint64_t& aID, const uint32_t& aScrollType, const int32_t& aX, const int32_t& aY)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     acc->ScrollToPoint(aScrollType, aX, aY);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvCaretLineNumber(const uint64_t& aID, int32_t* aLineNumber)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   *aLineNumber = acc && acc->IsTextRole() ? acc->CaretLineNumber() : 0;
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvCaretOffset(const uint64_t& aID, int32_t* aOffset)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   *aOffset = acc && acc->IsTextRole() ? acc->CaretOffset() : 0;
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvSetCaretOffset(const uint64_t& aID,
                                        const int32_t& aOffset)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole() && acc->IsValidOffset(aOffset)) {
     acc->SetCaretOffset(aOffset);
   }
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvCharacterCount(const uint64_t& aID, int32_t* aCount)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   *aCount = acc ? acc->CharacterCount() : 0;
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvSelectionCount(const uint64_t& aID, int32_t* aCount)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   *aCount = acc ? acc->SelectionCount() : 0;
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTextSubstring(const uint64_t& aID,
                                       const int32_t& aStartOffset,
                                       const int32_t& aEndOffset,
                                       nsString* aText, bool* aValid)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (!acc) {
-    return true;
+    return IPC_OK();
   }
 
   *aValid = acc->IsValidRange(aStartOffset, aEndOffset);
   acc->TextSubstring(aStartOffset, aEndOffset, *aText);
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvGetTextAfterOffset(const uint64_t& aID,
                                            const int32_t& aOffset,
                                            const int32_t& aBoundaryType,
                                            nsString* aText,
                                            int32_t* aStartOffset,
                                            int32_t* aEndOffset)
 {
   *aStartOffset = 0;
   *aEndOffset = 0;
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc) {
     acc->TextAfterOffset(aOffset, aBoundaryType,
                          aStartOffset, aEndOffset, *aText);
   }
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvGetTextAtOffset(const uint64_t& aID,
                                         const int32_t& aOffset,
                                         const int32_t& aBoundaryType,
                                         nsString* aText,
                                         int32_t* aStartOffset,
                                         int32_t* aEndOffset)
 {
   *aStartOffset = 0;
   *aEndOffset = 0;
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc) {
     acc->TextAtOffset(aOffset, aBoundaryType,
                       aStartOffset, aEndOffset, *aText);
   }
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvGetTextBeforeOffset(const uint64_t& aID,
                                             const int32_t& aOffset,
                                             const int32_t& aBoundaryType,
                                             nsString* aText,
                                             int32_t* aStartOffset,
                                             int32_t* aEndOffset)
 {
   *aStartOffset = 0;
   *aEndOffset = 0;
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc) {
     acc->TextBeforeOffset(aOffset, aBoundaryType,
                           aStartOffset, aEndOffset, *aText);
   }
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvCharAt(const uint64_t& aID,
                                const int32_t& aOffset,
                                uint16_t* aChar)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   *aChar = acc && acc->IsTextRole() ?
     static_cast<uint16_t>(acc->CharAt(aOffset)) : 0;
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTextAttributes(const uint64_t& aID,
                                        const bool& aIncludeDefAttrs,
                                        const int32_t& aOffset,
                                        nsTArray<Attribute>* aAttributes,
                                        int32_t* aStartOffset,
                                        int32_t* aEndOffset)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (!acc || !acc->IsTextRole()) {
-    return true;
+    return IPC_OK();
   }
 
   nsCOMPtr<nsIPersistentProperties> props =
     acc->TextAttributes(aIncludeDefAttrs, aOffset, aStartOffset, aEndOffset);
-  return PersistentPropertiesToArray(props, aAttributes);
+  if (!PersistentPropertiesToArray(props, aAttributes)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvDefaultTextAttributes(const uint64_t& aID,
                                               nsTArray<Attribute> *aAttributes)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (!acc || !acc->IsTextRole()) {
-    return true;
+    return IPC_OK();
   }
 
   nsCOMPtr<nsIPersistentProperties> props = acc->DefaultTextAttributes();
-  return PersistentPropertiesToArray(props, aAttributes);
+  if (!PersistentPropertiesToArray(props, aAttributes)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTextBounds(const uint64_t& aID,
                                    const int32_t& aStartOffset,
                                    const int32_t& aEndOffset,
                                    const uint32_t& aCoordType,
                                    nsIntRect* aRetVal)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole()) {
     *aRetVal = acc->TextBounds(aStartOffset, aEndOffset, aCoordType);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvCharBounds(const uint64_t& aID,
                                    const int32_t& aOffset,
                                    const uint32_t& aCoordType,
                                    nsIntRect* aRetVal)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole()) {
     *aRetVal = acc->CharBounds(aOffset, aCoordType);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvOffsetAtPoint(const uint64_t& aID,
                                       const int32_t& aX,
                                       const int32_t& aY,
                                       const uint32_t& aCoordType,
                                       int32_t* aRetVal)
 {
   *aRetVal = -1;
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole()) {
     *aRetVal = acc->OffsetAtPoint(aX, aY, aCoordType);
   }
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvSelectionBoundsAt(const uint64_t& aID,
                                           const int32_t& aSelectionNum,
                                           bool* aSucceeded,
                                           nsString* aData,
                                           int32_t* aStartOffset,
                                           int32_t* aEndOffset)
 {
   *aSucceeded = false;
@@ -545,581 +554,581 @@ DocAccessibleChild::RecvSelectionBoundsA
   if (acc && acc->IsTextRole()) {
     *aSucceeded =
       acc->SelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset);
     if (*aSucceeded) {
       acc->TextSubstring(*aStartOffset, *aEndOffset, *aData);
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvSetSelectionBoundsAt(const uint64_t& aID,
                                              const int32_t& aSelectionNum,
                                              const int32_t& aStartOffset,
                                              const int32_t& aEndOffset,
                                              bool* aSucceeded)
 {
   *aSucceeded = false;
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole()) {
     *aSucceeded =
       acc->SetSelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvAddToSelection(const uint64_t& aID,
                                        const int32_t& aStartOffset,
                                        const int32_t& aEndOffset,
                                        bool* aSucceeded)
 {
   *aSucceeded = false;
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole()) {
     *aSucceeded = acc->AddToSelection(aStartOffset, aEndOffset);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvRemoveFromSelection(const uint64_t& aID,
                                             const int32_t& aSelectionNum,
                                             bool* aSucceeded)
 {
   *aSucceeded = false;
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole()) {
     *aSucceeded = acc->RemoveFromSelection(aSelectionNum);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvScrollSubstringTo(const uint64_t& aID,
                                           const int32_t& aStartOffset,
                                           const int32_t& aEndOffset,
                                           const uint32_t& aScrollType)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc) {
     acc->ScrollSubstringTo(aStartOffset, aEndOffset, aScrollType);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvScrollSubstringToPoint(const uint64_t& aID,
                                                const int32_t& aStartOffset,
                                                const int32_t& aEndOffset,
                                                const uint32_t& aCoordinateType,
                                                const int32_t& aX,
                                                const int32_t& aY)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc) {
     acc->ScrollSubstringToPoint(aStartOffset, aEndOffset, aCoordinateType,
                                 aX, aY);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvText(const uint64_t& aID,
                              nsString* aText)
 {
   TextLeafAccessible* acc = IdToTextLeafAccessible(aID);
   if (acc) {
     *aText = acc->Text();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvReplaceText(const uint64_t& aID,
                                     const nsString& aText)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole()) {
     acc->ReplaceText(aText);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvInsertText(const uint64_t& aID,
                                    const nsString& aText,
                                    const int32_t& aPosition, bool* aValid)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole()) {
     *aValid = acc->IsValidOffset(aPosition);
     acc->InsertText(aText, aPosition);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvCopyText(const uint64_t& aID,
                                  const int32_t& aStartPos,
                                  const int32_t& aEndPos, bool* aValid)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole()) {
     acc->CopyText(aStartPos, aEndPos);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvCutText(const uint64_t& aID,
                                 const int32_t& aStartPos,
                                 const int32_t& aEndPos, bool* aValid)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole()) {
     *aValid = acc->IsValidRange(aStartPos, aEndPos);
     acc->CutText(aStartPos, aEndPos);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvDeleteText(const uint64_t& aID,
                                    const int32_t& aStartPos,
                                    const int32_t& aEndPos, bool* aValid)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole()) {
     *aValid = acc->IsValidRange(aStartPos, aEndPos);
     acc->DeleteText(aStartPos, aEndPos);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvPasteText(const uint64_t& aID,
                                   const int32_t& aPosition, bool* aValid)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc && acc->IsTextRole()) {
     *aValid = acc->IsValidOffset(aPosition);
     acc->PasteText(aPosition);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvImagePosition(const uint64_t& aID,
                                       const uint32_t& aCoordType,
                                       nsIntPoint* aRetVal)
 {
   ImageAccessible* acc = IdToImageAccessible(aID);
   if (acc) {
     *aRetVal = acc->Position(aCoordType);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvImageSize(const uint64_t& aID,
                                   nsIntSize* aRetVal)
 {
 
   ImageAccessible* acc = IdToImageAccessible(aID);
   if (acc) {
     *aRetVal = acc->Size();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvStartOffset(const uint64_t& aID,
                                     uint32_t* aRetVal,
                                     bool* aOk)
 {
   Accessible* acc = IdToAccessibleLink(aID);
   if (acc) {
     *aRetVal = acc->StartOffset();
     *aOk = true;
   } else {
     *aRetVal = 0;
     *aOk = false;
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvEndOffset(const uint64_t& aID,
                                   uint32_t* aRetVal,
                                   bool* aOk)
 {
   Accessible* acc = IdToAccessibleLink(aID);
   if (acc) {
     *aRetVal = acc->EndOffset();
     *aOk = true;
   } else {
     *aRetVal = 0;
     *aOk = false;
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvIsLinkValid(const uint64_t& aID,
                                     bool* aRetVal)
 {
   Accessible* acc = IdToAccessibleLink(aID);
   if (acc) {
     *aRetVal = acc->IsLinkValid();
   } else {
     *aRetVal = false;
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvAnchorCount(const uint64_t& aID,
                                     uint32_t* aRetVal,
                                     bool* aOk)
 {
   Accessible* acc = IdToAccessibleLink(aID);
   if (acc) {
     *aRetVal = acc->AnchorCount();
     *aOk = true;
   } else {
     *aRetVal = 0;
     *aOk = false;
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvAnchorURIAt(const uint64_t& aID,
                                     const uint32_t& aIndex,
                                     nsCString* aURI,
                                     bool* aOk)
 {
   Accessible* acc = IdToAccessibleLink(aID);
   *aOk = false;
   if (acc) {
     nsCOMPtr<nsIURI> uri = acc->AnchorURIAt(aIndex);
     if (uri) {
       uri->GetSpec(*aURI);
       *aOk = true;
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvAnchorAt(const uint64_t& aID,
                                  const uint32_t& aIndex,
                                  uint64_t* aIDOfAnchor,
                                  bool* aOk)
 {
   *aIDOfAnchor = 0;
   *aOk = false;
   Accessible* acc = IdToAccessibleLink(aID);
   if (acc) {
     Accessible* anchor = acc->AnchorAt(aIndex);
     if (anchor) {
       *aIDOfAnchor = reinterpret_cast<uint64_t>(anchor->UniqueID());
       *aOk = true;
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvLinkCount(const uint64_t& aID,
                                   uint32_t* aCount)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   *aCount = acc ? acc->LinkCount() : 0;
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvLinkAt(const uint64_t& aID,
                                const uint32_t& aIndex,
                                uint64_t* aIDOfLink,
                                bool* aOk)
 {
   *aIDOfLink = 0;
   *aOk = false;
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   if (acc) {
     Accessible* link = acc->LinkAt(aIndex);
     if (link) {
       *aIDOfLink = reinterpret_cast<uint64_t>(link->UniqueID());
       *aOk = true;
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvLinkIndexOf(const uint64_t& aID,
                                     const uint64_t& aLinkID,
                                     int32_t* aIndex)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   Accessible* link = IdToAccessible(aLinkID);
   *aIndex = -1;
   if (acc && link) {
     *aIndex = acc->LinkIndexOf(link);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvLinkIndexAtOffset(const uint64_t& aID,
                                           const uint32_t& aOffset,
                                           int32_t* aIndex)
 {
   HyperTextAccessible* acc = IdToHyperTextAccessible(aID);
   *aIndex = acc ? acc->LinkIndexAtOffset(aOffset) : -1;
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableOfACell(const uint64_t& aID,
                                      uint64_t* aTableID,
                                      bool* aOk)
 {
   *aTableID = 0;
   *aOk = false;
   TableCellAccessible* acc = IdToTableCellAccessible(aID);
   if (acc) {
     TableAccessible* table = acc->Table();
     if (table) {
       *aTableID = reinterpret_cast<uint64_t>(table->AsAccessible()->UniqueID());
       *aOk = true;
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvColIdx(const uint64_t& aID,
                                uint32_t* aIndex)
 {
   *aIndex = 0;
   TableCellAccessible* acc = IdToTableCellAccessible(aID);
   if (acc) {
     *aIndex = acc->ColIdx();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvRowIdx(const uint64_t& aID,
                                uint32_t* aIndex)
 {
   *aIndex = 0;
   TableCellAccessible* acc = IdToTableCellAccessible(aID);
   if (acc) {
     *aIndex = acc->RowIdx();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvGetPosition(const uint64_t& aID,
                                uint32_t* aColIdx, uint32_t* aRowIdx)
 {
   *aColIdx = 0;
   *aRowIdx = 0;
   TableCellAccessible* acc = IdToTableCellAccessible(aID);
   if (acc) {
     *aColIdx = acc->ColIdx();
     *aRowIdx = acc->RowIdx();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvGetColRowExtents(const uint64_t& aID,
                                          uint32_t* aColIdx, uint32_t* aRowIdx,
                                          uint32_t* aColExtent, uint32_t* aRowExtent)
 {
   *aColIdx = 0;
   *aRowIdx = 0;
   *aColExtent = 0;
   *aRowExtent = 0;
   TableCellAccessible* acc = IdToTableCellAccessible(aID);
   if (acc) {
     *aColIdx = acc->ColIdx();
     *aRowIdx = acc->RowIdx();
     *aColExtent = acc->ColExtent();
     *aRowExtent = acc->RowExtent();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvColExtent(const uint64_t& aID,
                                   uint32_t* aExtent)
 {
   *aExtent = 0;
   TableCellAccessible* acc = IdToTableCellAccessible(aID);
   if (acc) {
     *aExtent = acc->ColExtent();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvRowExtent(const uint64_t& aID,
                                   uint32_t* aExtent)
 {
   *aExtent = 0;
   TableCellAccessible* acc = IdToTableCellAccessible(aID);
   if (acc) {
     *aExtent = acc->RowExtent();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvColHeaderCells(const uint64_t& aID,
                                        nsTArray<uint64_t>* aCells)
 {
   TableCellAccessible* acc = IdToTableCellAccessible(aID);
   if (acc) {
     AutoTArray<Accessible*, 10> headerCells;
     acc->ColHeaderCells(&headerCells);
     aCells->SetCapacity(headerCells.Length());
     for (uint32_t i = 0; i < headerCells.Length(); ++i) {
       aCells->AppendElement(
         reinterpret_cast<uint64_t>(headerCells[i]->UniqueID()));
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvRowHeaderCells(const uint64_t& aID,
                                        nsTArray<uint64_t>* aCells)
 {
   TableCellAccessible* acc = IdToTableCellAccessible(aID);
   if (acc) {
     AutoTArray<Accessible*, 10> headerCells;
     acc->RowHeaderCells(&headerCells);
     aCells->SetCapacity(headerCells.Length());
     for (uint32_t i = 0; i < headerCells.Length(); ++i) {
       aCells->AppendElement(
         reinterpret_cast<uint64_t>(headerCells[i]->UniqueID()));
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvIsCellSelected(const uint64_t& aID,
                                        bool* aSelected)
 {
   TableCellAccessible* acc = IdToTableCellAccessible(aID);
   *aSelected = acc && acc->Selected();
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableCaption(const uint64_t& aID,
                                      uint64_t* aCaptionID,
                                      bool* aOk)
 {
   *aCaptionID = 0;
   *aOk = false;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     Accessible* caption = acc->Caption();
     if (caption) {
       *aCaptionID = reinterpret_cast<uint64_t>(caption->UniqueID());
       *aOk = true;
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableSummary(const uint64_t& aID,
                                      nsString* aSummary)
 {
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     acc->Summary(*aSummary);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableColumnCount(const uint64_t& aID,
                                          uint32_t* aColCount)
 {
   *aColCount = 0;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aColCount = acc->ColCount();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableRowCount(const uint64_t& aID,
                                       uint32_t* aRowCount)
 {
   *aRowCount = 0;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aRowCount = acc->RowCount();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableCellAt(const uint64_t& aID,
                                     const uint32_t& aRow,
                                     const uint32_t& aCol,
                                     uint64_t* aCellID,
                                     bool* aOk)
 {
   *aCellID = 0;
   *aOk = false;
@@ -1127,332 +1136,332 @@ DocAccessibleChild::RecvTableCellAt(cons
   if (acc) {
     Accessible* cell = acc->CellAt(aRow, aCol);
     if (cell) {
       *aCellID = reinterpret_cast<uint64_t>(cell->UniqueID());
       *aOk = true;
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableCellIndexAt(const uint64_t& aID,
                                          const uint32_t& aRow,
                                          const uint32_t& aCol,
                                          int32_t* aIndex)
 {
   *aIndex = -1;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aIndex = acc->CellIndexAt(aRow, aCol);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableColumnIndexAt(const uint64_t& aID,
                                            const uint32_t& aCellIndex,
                                            int32_t* aCol)
 {
   *aCol = -1;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aCol = acc->ColIndexAt(aCellIndex);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableRowIndexAt(const uint64_t& aID,
                                         const uint32_t& aCellIndex,
                                         int32_t* aRow)
 {
   *aRow = -1;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aRow = acc->RowIndexAt(aCellIndex);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableRowAndColumnIndicesAt(const uint64_t& aID,
                                                   const uint32_t& aCellIndex,
                                                   int32_t* aRow,
                                                   int32_t* aCol)
 {
   *aRow = -1;
   *aCol = -1;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     acc->RowAndColIndicesAt(aCellIndex, aRow, aCol);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableColumnExtentAt(const uint64_t& aID,
                                             const uint32_t& aRow,
                                             const uint32_t& aCol,
                                             uint32_t* aExtent)
 {
   *aExtent = 0;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aExtent = acc->ColExtentAt(aRow, aCol);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableRowExtentAt(const uint64_t& aID,
                                          const uint32_t& aRow,
                                          const uint32_t& aCol,
                                          uint32_t* aExtent)
 {
   *aExtent = 0;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aExtent = acc->RowExtentAt(aRow, aCol);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableColumnDescription(const uint64_t& aID,
                                                const uint32_t& aCol,
                                                nsString* aDescription)
 {
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     acc->ColDescription(aCol, *aDescription);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableRowDescription(const uint64_t& aID,
                                             const uint32_t& aRow,
                                             nsString* aDescription)
 {
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     acc->RowDescription(aRow, *aDescription);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableColumnSelected(const uint64_t& aID,
                                             const uint32_t& aCol,
                                             bool* aSelected)
 {
   *aSelected = false;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aSelected = acc->IsColSelected(aCol);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableRowSelected(const uint64_t& aID,
                                          const uint32_t& aRow,
                                          bool* aSelected)
 {
   *aSelected = false;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aSelected = acc->IsRowSelected(aRow);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableCellSelected(const uint64_t& aID,
                                           const uint32_t& aRow,
                                           const uint32_t& aCol,
                                           bool* aSelected)
 {
   *aSelected = false;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aSelected = acc->IsCellSelected(aRow, aCol);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableSelectedCellCount(const uint64_t& aID,
                                                uint32_t* aSelectedCells)
 {
   *aSelectedCells = 0;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aSelectedCells = acc->SelectedCellCount();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableSelectedColumnCount(const uint64_t& aID,
                                                  uint32_t* aSelectedColumns)
 {
   *aSelectedColumns = 0;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aSelectedColumns = acc->SelectedColCount();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableSelectedRowCount(const uint64_t& aID,
                                               uint32_t* aSelectedRows)
 {
   *aSelectedRows = 0;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aSelectedRows = acc->SelectedRowCount();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableSelectedCells(const uint64_t& aID,
                                            nsTArray<uint64_t>* aCellIDs)
 {
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     AutoTArray<Accessible*, 30> cells;
     acc->SelectedCells(&cells);
     aCellIDs->SetCapacity(cells.Length());
     for (uint32_t i = 0; i < cells.Length(); ++i) {
       aCellIDs->AppendElement(
         reinterpret_cast<uint64_t>(cells[i]->UniqueID()));
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableSelectedCellIndices(const uint64_t& aID,
                                                  nsTArray<uint32_t>* aCellIndices)
 {
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     acc->SelectedCellIndices(aCellIndices);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableSelectedColumnIndices(const uint64_t& aID,
                                                    nsTArray<uint32_t>* aColumnIndices)
 {
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     acc->SelectedColIndices(aColumnIndices);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableSelectedRowIndices(const uint64_t& aID,
                                                 nsTArray<uint32_t>* aRowIndices)
 {
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     acc->SelectedRowIndices(aRowIndices);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableSelectColumn(const uint64_t& aID,
                                           const uint32_t& aCol)
 {
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     acc->SelectCol(aCol);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableSelectRow(const uint64_t& aID,
                                        const uint32_t& aRow)
 {
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     acc->SelectRow(aRow);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableUnselectColumn(const uint64_t& aID,
                                             const uint32_t& aCol)
 {
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     acc->UnselectCol(aCol);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableUnselectRow(const uint64_t& aID,
                                          const uint32_t& aRow)
 {
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     acc->UnselectRow(aRow);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTableIsProbablyForLayout(const uint64_t& aID,
                                                  bool* aForLayout)
 {
   *aForLayout = false;
   TableAccessible* acc = IdToTableAccessible(aID);
   if (acc) {
     *aForLayout = acc->IsProbablyLayoutTable();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvAtkTableColumnHeader(const uint64_t& aID,
                                              const int32_t& aCol,
                                              uint64_t* aHeader,
                                              bool* aOk)
 {
   *aHeader = 0;
   *aOk = false;
 
@@ -1462,20 +1471,20 @@ DocAccessibleChild::RecvAtkTableColumnHe
     Accessible* header = AccessibleWrap::GetColumnHeader(acc, aCol);
     if (header) {
       *aHeader = reinterpret_cast<uint64_t>(header->UniqueID());
       *aOk = true;
     }
   }
 #endif
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvAtkTableRowHeader(const uint64_t& aID,
                                           const int32_t& aRow,
                                           uint64_t* aHeader,
                                           bool* aOk)
 {
   *aHeader = 0;
   *aOk = false;
 
@@ -1485,434 +1494,434 @@ DocAccessibleChild::RecvAtkTableRowHeade
     Accessible* header = AccessibleWrap::GetRowHeader(acc, aRow);
     if (header) {
       *aHeader = reinterpret_cast<uint64_t>(header->UniqueID());
       *aOk = true;
     }
   }
 #endif
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvSelectedItems(const uint64_t& aID,
                                       nsTArray<uint64_t>* aSelectedItemIDs)
 {
   Accessible* acc = IdToAccessibleSelect(aID);
   if (acc) {
     AutoTArray<Accessible*, 10> selectedItems;
     acc->SelectedItems(&selectedItems);
     aSelectedItemIDs->SetCapacity(selectedItems.Length());
     for (size_t i = 0; i < selectedItems.Length(); ++i) {
       aSelectedItemIDs->AppendElement(
         reinterpret_cast<uint64_t>(selectedItems[i]->UniqueID()));
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvSelectedItemCount(const uint64_t& aID,
                                           uint32_t* aCount)
 {
   *aCount = 0;
   Accessible* acc = IdToAccessibleSelect(aID);
   if (acc) {
     *aCount = acc->SelectedItemCount();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvGetSelectedItem(const uint64_t& aID,
                                         const uint32_t& aIndex,
                                         uint64_t* aSelected,
                                         bool* aOk)
 {
   *aSelected = 0;
   *aOk = false;
   Accessible* acc = IdToAccessibleSelect(aID);
   if (acc) {
     Accessible* item = acc->GetSelectedItem(aIndex);
     if (item) {
       *aSelected = reinterpret_cast<uint64_t>(item->UniqueID());
       *aOk = true;
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvIsItemSelected(const uint64_t& aID,
                                        const uint32_t& aIndex,
                                        bool* aSelected)
 {
   *aSelected = false;
   Accessible* acc = IdToAccessibleSelect(aID);
   if (acc) {
     *aSelected = acc->IsItemSelected(aIndex);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvAddItemToSelection(const uint64_t& aID,
                                            const uint32_t& aIndex,
                                            bool* aSuccess)
 {
   *aSuccess = false;
   Accessible* acc = IdToAccessibleSelect(aID);
   if (acc) {
     *aSuccess = acc->AddItemToSelection(aIndex);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvRemoveItemFromSelection(const uint64_t& aID,
                                                 const uint32_t& aIndex,
                                                 bool* aSuccess)
 {
   *aSuccess = false;
   Accessible* acc = IdToAccessibleSelect(aID);
   if (acc) {
     *aSuccess = acc->RemoveItemFromSelection(aIndex);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvSelectAll(const uint64_t& aID,
                                   bool* aSuccess)
 {
   *aSuccess = false;
   Accessible* acc = IdToAccessibleSelect(aID);
   if (acc) {
     *aSuccess = acc->SelectAll();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvUnselectAll(const uint64_t& aID,
                                     bool* aSuccess)
 {
   *aSuccess = false;
   Accessible* acc = IdToAccessibleSelect(aID);
   if (acc) {
     *aSuccess = acc->UnselectAll();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTakeSelection(const uint64_t& aID)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     acc->TakeSelection();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvSetSelected(const uint64_t& aID, const bool& aSelect)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     acc->SetSelected(aSelect);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvDoAction(const uint64_t& aID,
                                  const uint8_t& aIndex,
                                  bool* aSuccess)
 {
   *aSuccess = false;
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     *aSuccess = acc->DoAction(aIndex);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvActionCount(const uint64_t& aID,
                                     uint8_t* aCount)
 {
   *aCount = 0;
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     *aCount = acc->ActionCount();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvActionDescriptionAt(const uint64_t& aID,
                                             const uint8_t& aIndex,
                                             nsString* aDescription)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     acc->ActionDescriptionAt(aIndex, *aDescription);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvActionNameAt(const uint64_t& aID,
                                      const uint8_t& aIndex,
                                      nsString* aName)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     acc->ActionNameAt(aIndex, *aName);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvAccessKey(const uint64_t& aID,
                                   uint32_t* aKey,
                                   uint32_t* aModifierMask)
 {
   *aKey = 0;
   *aModifierMask = 0;
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     KeyBinding kb = acc->AccessKey();
     *aKey = kb.Key();
     *aModifierMask = kb.ModifierMask();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvKeyboardShortcut(const uint64_t& aID,
                                          uint32_t* aKey,
                                          uint32_t* aModifierMask)
 {
   *aKey = 0;
   *aModifierMask = 0;
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     KeyBinding kb = acc->KeyboardShortcut();
     *aKey = kb.Key();
     *aModifierMask = kb.ModifierMask();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvAtkKeyBinding(const uint64_t& aID,
                                       nsString* aResult)
 {
 #ifdef MOZ_ACCESSIBILITY_ATK
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     AccessibleWrap::GetKeyBinding(acc, *aResult);
   }
 #endif
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvCurValue(const uint64_t& aID,
                                  double* aValue)
 {
   *aValue = UnspecifiedNaN<double>();
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     *aValue = acc->CurValue();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvSetCurValue(const uint64_t& aID,
                                     const double& aValue,
                                     bool* aRetVal)
 {
   *aRetVal = false;
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     *aRetVal = acc->SetCurValue(aValue);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvMinValue(const uint64_t& aID,
                                  double* aValue)
 {
   *aValue = UnspecifiedNaN<double>();
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     *aValue = acc->MinValue();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvMaxValue(const uint64_t& aID,
                                  double* aValue)
 {
   *aValue = UnspecifiedNaN<double>();
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     *aValue = acc->MaxValue();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvStep(const uint64_t& aID,
                              double* aStep)
 {
   *aStep = UnspecifiedNaN<double>();
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     *aStep = acc->Step();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTakeFocus(const uint64_t& aID)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     acc->TakeFocus();
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvFocusedChild(const uint64_t& aID,
                                        uint64_t* aChild,
                                        bool* aOk)
 {
   *aChild = 0;
   *aOk = false;
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     Accessible* child = acc->FocusedChild();
     if (child) {
       *aChild = reinterpret_cast<uint64_t>(child->UniqueID());
       *aOk = true;
     }
   }
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvLanguage(const uint64_t& aID,
                                  nsString* aLocale)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     acc->Language(*aLocale);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvDocType(const uint64_t& aID,
                                 nsString* aType)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc && acc->IsDoc()) {
     acc->AsDoc()->DocType(*aType);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvTitle(const uint64_t& aID,
                             nsString* aTitle)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc) {
     mozilla::ErrorResult rv;
     acc->GetContent()->GetTextContent(*aTitle, rv);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvURL(const uint64_t& aID,
                             nsString* aURL)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc && acc->IsDoc()) {
     acc->AsDoc()->URL(*aURL);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvMimeType(const uint64_t& aID,
                                  nsString* aMime)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc && acc->IsDoc()) {
     acc->AsDoc()->MimeType(*aMime);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvURLDocTypeMimeType(const uint64_t& aID,
                                            nsString* aURL,
                                            nsString* aDocType,
                                            nsString* aMimeType)
 {
   Accessible* acc = IdToAccessible(aID);
   if (acc && acc->IsDoc()) {
     DocAccessible* doc = acc->AsDoc();
     doc->URL(*aURL);
     doc->DocType(*aDocType);
     doc->MimeType(*aMimeType);
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvAccessibleAtPoint(const uint64_t& aID,
                                           const int32_t& aX,
                                           const int32_t& aY,
                                           const bool& aNeedsScreenCoords,
                                           const uint32_t& aWhich,
                                           uint64_t* aResult,
                                           bool* aOk)
 {
@@ -1933,20 +1942,20 @@ DocAccessibleChild::RecvAccessibleAtPoin
       acc->ChildAtPoint(x, y,
                         static_cast<Accessible::EWhichChildAtPoint>(aWhich));
     if (result) {
       *aResult = reinterpret_cast<uint64_t>(result->UniqueID());
       *aOk = true;
     }
   }
 
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvExtents(const uint64_t& aID,
                                 const bool& aNeedsScreenCoords,
                                 int32_t* aX,
                                 int32_t* aY,
                                 int32_t* aWidth,
                                 int32_t* aHeight)
 {
   *aX = 0;
@@ -1965,34 +1974,34 @@ DocAccessibleChild::RecvExtents(const ui
       }
 
       *aX = screenRect.x;
       *aY = screenRect.y;
       *aWidth = screenRect.width;
       *aHeight = screenRect.height;
     }
   }
-  return true;
+  return IPC_OK();
 }
 
-bool
+mozilla::ipc::IPCResult
 DocAccessibleChild::RecvDOMNodeID(const uint64_t& aID, nsString* aDOMNodeID)
 {
   Accessible* acc = IdToAccessible(aID);
   if (!acc) {
-    return true;
+    return IPC_OK();
   }
 
   nsIContent* content = acc->GetContent();
   if (!content) {
-    return true;
+    return IPC_OK();
   }
 
   nsIAtom* id = content->GetID();
   if (id) {
     id->ToString(*aDOMNodeID);
   }
 
-  return true;
+  return IPC_OK();
 }
 
 }
 }