Backed out changeset 43835f5fa2b2 (bug 1314707) for crashes @ mozilla::a11y::ProxyDestroyed
authorPhil Ringnalda <philringnalda@gmail.com>
Wed, 09 Nov 2016 19:33:25 -0800
changeset 352007 841f82fde3b4bf44d2b01a5f9635e89b17ad6443
parent 352006 e1f230913306b5ab63a64438c12f76e8fbde8c62
child 352008 bf2c61e0283e5a55988b6ee2524c809d97a98e59
push id6795
push userjlund@mozilla.com
push dateMon, 23 Jan 2017 14:19:46 +0000
treeherdermozilla-esr52@76101b503191 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1314707
milestone52.0a1
backs out43835f5fa2b217ba7e2a59fb9f52910a2e06a28a
Backed out changeset 43835f5fa2b2 (bug 1314707) for crashes @ mozilla::a11y::ProxyDestroyed MozReview-Commit-ID: 9jIOao58gMQ
accessible/base/DocManager.cpp
accessible/base/NotificationController.cpp
accessible/ipc/DocAccessibleChildBase.cpp
accessible/ipc/DocAccessibleChildBase.h
accessible/ipc/DocAccessibleParent.cpp
accessible/ipc/DocAccessibleParent.h
accessible/ipc/IPCTypes.h
accessible/ipc/moz.build
accessible/ipc/win/DocAccessibleChild.cpp
accessible/ipc/win/DocAccessibleChild.h
accessible/ipc/win/PDocAccessible.ipdl
dom/ipc/PBrowser.ipdl
dom/ipc/TabChild.cpp
dom/ipc/TabChild.h
dom/ipc/TabParent.cpp
dom/ipc/TabParent.h
--- a/accessible/base/DocManager.cpp
+++ b/accessible/base/DocManager.cpp
@@ -509,29 +509,29 @@ DocManager::CreateDocOrRootAccessible(ns
 
         // XXX We may need to handle the case that we don't have a tab child
         // differently.  It may be that this will cause us to fail to notify
         // the parent process about important accessible documents.
         if (tabChild) {
           DocAccessibleChild* ipcDoc = new DocAccessibleChild(docAcc);
           docAcc->SetIPCDoc(ipcDoc);
 
-#if defined(XP_WIN)
-          IAccessibleHolder holder(CreateHolderFromAccessible(docAcc));
-#endif
-
           static_cast<TabChild*>(tabChild.get())->
             SendPDocAccessibleConstructor(ipcDoc, nullptr, 0,
 #if defined(XP_WIN)
-                                          AccessibleWrap::GetChildIDFor(docAcc),
-                                          holder
+                                          AccessibleWrap::GetChildIDFor(docAcc)
 #else
-                                          0, 0
+                                          0
 #endif
                                           );
+
+#if defined(XP_WIN)
+          IAccessibleHolder holder(CreateHolderFromAccessible(docAcc));
+          ipcDoc->SendCOMProxy(holder);
+#endif
         }
       }
     }
   } else {
     parentDocAcc->BindChildDocument(docAcc);
   }
 
 #ifdef A11Y_LOG
--- a/accessible/base/NotificationController.cpp
+++ b/accessible/base/NotificationController.cpp
@@ -421,20 +421,19 @@ NotificationController::WillRefresh(mozi
       childDoc->SetIPCDoc(ipcDoc);
       nsCOMPtr<nsITabChild> tabChild =
         do_GetInterface(mDocument->DocumentNode()->GetDocShell());
       if (tabChild) {
         MOZ_ASSERT(parentIPCDoc);
         static_cast<TabChild*>(tabChild.get())->
           SendPDocAccessibleConstructor(ipcDoc, parentIPCDoc, id,
 #if defined(XP_WIN)
-                                        AccessibleWrap::GetChildIDFor(childDoc),
-                                        IAccessibleHolder()
+                                        AccessibleWrap::GetChildIDFor(childDoc)
 #else
-                                        0, 0
+                                        0
 #endif
                                         );
       }
     }
   }
 
   mObservingState = eRefreshObserving;
   if (!mDocument)
--- a/accessible/ipc/DocAccessibleChildBase.cpp
+++ b/accessible/ipc/DocAccessibleChildBase.cpp
@@ -84,14 +84,14 @@ void
 DocAccessibleChildBase::ShowEvent(AccShowEvent* aShowEvent)
 {
   Accessible* parent = aShowEvent->Parent();
   uint64_t parentID = parent->IsDoc() ? 0 : reinterpret_cast<uint64_t>(parent->UniqueID());
   uint32_t idxInParent = aShowEvent->InsertionIndex();
   nsTArray<AccessibleData> shownTree;
   ShowEventData data(parentID, idxInParent, shownTree);
   SerializeTree(aShowEvent->GetAccessible(), data.NewTree());
-  MaybeSendShowEvent(data, aShowEvent->IsFromUserInput());
+  SendShowEvent(data, aShowEvent->IsFromUserInput());
 }
 
 } // namespace a11y
 } // namespace mozilla
 
--- a/accessible/ipc/DocAccessibleChildBase.h
+++ b/accessible/ipc/DocAccessibleChildBase.h
@@ -4,17 +4,16 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef mozilla_a11y_DocAccessibleChildBase_h
 #define mozilla_a11y_DocAccessibleChildBase_h
 
 #include "mozilla/a11y/DocAccessible.h"
 #include "mozilla/a11y/PDocAccessibleChild.h"
-#include "mozilla/Unused.h"
 #include "nsISupportsImpl.h"
 
 namespace mozilla {
 namespace a11y {
 
 class Accessible;
 class AccShowEvent;
 
@@ -57,18 +56,15 @@ public:
     mDoc->SetIPCDoc(nullptr);
     mDoc = nullptr;
   }
 
 protected:
   static uint32_t InterfacesFor(Accessible* aAcc);
   static void SerializeTree(Accessible* aRoot, nsTArray<AccessibleData>& aTree);
 
-  virtual void MaybeSendShowEvent(ShowEventData& aData, bool aFromUser)
-  { Unused << SendShowEvent(aData, aFromUser); }
-
   DocAccessible*  mDoc;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif // mozilla_a11y_DocAccessibleChildBase_h
--- a/accessible/ipc/DocAccessibleParent.cpp
+++ b/accessible/ipc/DocAccessibleParent.cpp
@@ -456,31 +456,32 @@ DocAccessibleParent::GetXPCAccessible(Pr
   MOZ_ASSERT(doc);
 
   return doc->GetXPCAccessible(aProxy);
 }
 
 #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.
  */
-void
-DocAccessibleParent::SetCOMProxy(const RefPtr<IAccessible>& aCOMProxy)
+bool
+DocAccessibleParent::RecvCOMProxy(const IAccessibleHolder& aCOMProxy,
+                                  IAccessibleHolder* aParentCOMProxy)
 {
-  SetCOMInterface(aCOMProxy);
+  RefPtr<IAccessible> ptr(aCOMProxy.Get());
+  SetCOMInterface(ptr);
 
   Accessible* outerDoc = OuterDocOfRemoteBrowser();
-  MOZ_ASSERT(outerDoc);
-
   IAccessible* rawNative = nullptr;
   if (outerDoc) {
     outerDoc->GetNativeInterface((void**) &rawNative);
-    MOZ_ASSERT(rawNative);
   }
 
-  IAccessibleHolder::COMPtrType ptr(rawNative);
-  IAccessibleHolder holder(Move(ptr));
-  Unused << SendParentCOMProxy(holder);
+  aParentCOMProxy->Set(IAccessibleHolder::COMPtrType(rawNative));
+  return true;
 }
 #endif // defined(XP_WIN)
 
 } // a11y
 } // mozilla
--- a/accessible/ipc/DocAccessibleParent.h
+++ b/accessible/ipc/DocAccessibleParent.h
@@ -139,17 +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)
-  void SetCOMProxy(const RefPtr<IAccessible>& aCOMProxy);
+  virtual bool RecvCOMProxy(const IAccessibleHolder& aCOMProxy,
+                            IAccessibleHolder* aParentCOMProxy) override;
 #endif
 
 private:
 
   class ProxyEntry : public PLDHashEntryHdr
   {
   public:
     explicit ProxyEntry(const void*) : mProxy(nullptr) {}
deleted file mode 100644
--- a/accessible/ipc/IPCTypes.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* vim: set ts=8 sts=2 et sw=2 tw=80: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-#ifndef mozilla_a11y_IPCTypes_h
-#define mozilla_a11y_IPCTypes_h
-
-/**
- * Since IPDL does not support preprocessing, this header file allows us to
- * define types used by PDocAccessible differently depending on platform.
- */
-
-#if defined(XP_WIN) && defined(ACCESSIBILITY)
-
-// So that we don't include a bunch of other Windows junk.
-#if !defined(COM_NO_WINDOWS_H)
-#define COM_NO_WINDOWS_H
-#endif // !defined(COM_NO_WINDOWS_H)
-
-// COM headers pull in MSXML which conflicts with our own XMLDocument class.
-// This define excludes those conflicting definitions.
-#if !defined(__XMLDocument_FWD_DEFINED__)
-#define __XMLDocument_FWD_DEFINED__
-#endif // !defined(__XMLDocument_FWD_DEFINED__)
-
-#include "mozilla/a11y/COMPtrTypes.h"
-
-// This define in rpcndr.h messes up our code, so we must undefine it after
-// COMPtrTypes.h has been included.
-#if defined(small)
-#undef small
-#endif // defined(small)
-
-#else
-
-namespace mozilla {
-namespace a11y {
-
-typedef uint32_t IAccessibleHolder;
-
-} // namespace a11y
-} // namespace mozilla
-
-#endif // defined(XP_WIN) && defined(ACCESSIBILITY)
-
-#endif // mozilla_a11y_IPCTypes_h
-
--- a/accessible/ipc/moz.build
+++ b/accessible/ipc/moz.build
@@ -24,20 +24,16 @@ else:
         LOCAL_INCLUDES += [
             '/accessible/mac',
         ]
     else:
         LOCAL_INCLUDES += [
             '/accessible/other',
         ]
 
-EXPORTS.mozilla.a11y += [
-    'IPCTypes.h',
-]
-
 if CONFIG['GNU_CXX']:
     CXXFLAGS += ['-Wno-error=shadow']
 
 if CONFIG['ACCESSIBILITY']:
     EXPORTS.mozilla.a11y += [
         'DocAccessibleChildBase.h',
         'DocAccessibleParent.h',
         'ProxyAccessibleBase.h',
--- a/accessible/ipc/win/DocAccessibleChild.cpp
+++ b/accessible/ipc/win/DocAccessibleChild.cpp
@@ -25,121 +25,19 @@ DocAccessibleChild::DocAccessibleChild(D
   }
 }
 
 DocAccessibleChild::~DocAccessibleChild()
 {
   MOZ_COUNT_DTOR_INHERITED(DocAccessibleChild, DocAccessibleChildBase);
 }
 
-bool
-DocAccessibleChild::RecvParentCOMProxy(const IAccessibleHolder& aParentCOMProxy)
-{
-  MOZ_ASSERT(!mParentProxy && !aParentCOMProxy.IsNull());
-  mParentProxy.reset(const_cast<IAccessibleHolder&>(aParentCOMProxy).Release());
-
-  for (uint32_t i = 0, l = mDeferredEvents.Length(); i < l; ++i) {
-    mDeferredEvents[i]->Dispatch(this);
-  }
-
-  mDeferredEvents.Clear();
-
-  return true;
-}
-
-bool
-DocAccessibleChild::SendEvent(const uint64_t& aID, const uint32_t& aType)
-{
-  if (mParentProxy) {
-    return PDocAccessibleChild::SendEvent(aID, aType);
-  }
-
-  mDeferredEvents.AppendElement(MakeUnique<SerializedEvent>(aID, aType));
-  return false;
-}
-
 void
-DocAccessibleChild::MaybeSendShowEvent(ShowEventData& aData, bool aFromUser)
-{
-  if (mParentProxy) {
-    Unused << SendShowEvent(aData, aFromUser);
-    return;
-  }
-
-  mDeferredEvents.AppendElement(MakeUnique<SerializedShow>(aData, aFromUser));
-}
-
-bool
-DocAccessibleChild::SendHideEvent(const uint64_t& aRootID,
-                                  const bool& aFromUser)
-{
-  if (mParentProxy) {
-    return PDocAccessibleChild::SendHideEvent(aRootID, aFromUser);
-  }
-
-  mDeferredEvents.AppendElement(MakeUnique<SerializedHide>(aRootID, aFromUser));
-  return true;
-}
-
-bool
-DocAccessibleChild::SendStateChangeEvent(const uint64_t& aID,
-                                         const uint64_t& aState,
-                                         const bool& aEnabled)
+DocAccessibleChild::SendCOMProxy(const IAccessibleHolder& aProxy)
 {
-  if (mParentProxy) {
-    return PDocAccessibleChild::SendStateChangeEvent(aID, aState, aEnabled);
-  }
-
-  mDeferredEvents.AppendElement(MakeUnique<SerializedStateChange>(aID, aState,
-                                                                  aEnabled));
-  return true;
-}
-
-bool
-DocAccessibleChild::SendCaretMoveEvent(const uint64_t& aID,
-                                       const int32_t& aOffset)
-{
-  if (mParentProxy) {
-    return PDocAccessibleChild::SendCaretMoveEvent(aID, aOffset);
-  }
-
-  mDeferredEvents.AppendElement(MakeUnique<SerializedCaretMove>(aID, aOffset));
-  return true;
+  IAccessibleHolder parentProxy;
+  PDocAccessibleChild::SendCOMProxy(aProxy, &parentProxy);
+  mParentProxy.reset(parentProxy.Release());
 }
 
-bool
-DocAccessibleChild::SendTextChangeEvent(const uint64_t& aID,
-                                        const nsString& aStr,
-                                        const int32_t& aStart,
-                                        const uint32_t& aLen,
-                                        const bool& aIsInsert,
-                                        const bool& aFromUser)
-{
-  if (mParentProxy) {
-    return PDocAccessibleChild::SendTextChangeEvent(aID, aStr, aStart,
-                                                    aLen, aIsInsert, aFromUser);
-  }
-
-  mDeferredEvents.AppendElement(MakeUnique<SerializedTextChange>(aID, aStr,
-                                                                 aStart, aLen,
-                                                                 aIsInsert,
-                                                                 aFromUser));
-  return true;
-}
-
-bool
-DocAccessibleChild::SendSelectionEvent(const uint64_t& aID,
-                                       const uint64_t& aWidgetID,
-                                       const uint32_t& aType)
-{
-  if (mParentProxy) {
-    return PDocAccessibleChild::SendSelectionEvent(aID, aWidgetID, aType);
-  }
-
-  mDeferredEvents.AppendElement(MakeUnique<SerializedSelection>(aID, aWidgetID,
-                                                                aType));
-  return true;
-}
-
-
 } // namespace a11y
 } // namespace mozilla
 
--- a/accessible/ipc/win/DocAccessibleChild.h
+++ b/accessible/ipc/win/DocAccessibleChild.h
@@ -19,181 +19,19 @@ namespace a11y {
  * and their lifetime is the same as the document they represent.
  */
 class DocAccessibleChild : public DocAccessibleChildBase
 {
 public:
   explicit DocAccessibleChild(DocAccessible* aDoc);
   ~DocAccessibleChild();
 
-  virtual bool RecvParentCOMProxy(const IAccessibleHolder& aParentCOMProxy) override;
-
+  void SendCOMProxy(const IAccessibleHolder& aProxy);
   IAccessible* GetParentIAccessible() const { return mParentProxy.get(); }
 
-  bool SendEvent(const uint64_t& aID, const uint32_t& type);
-  bool SendHideEvent(const uint64_t& aRootID, const bool& aFromUser);
-  bool SendStateChangeEvent(const uint64_t& aID, const uint64_t& aState,
-                            const bool& aEnabled);
-  bool SendCaretMoveEvent(const uint64_t& aID, const int32_t& aOffset);
-  bool SendTextChangeEvent(const uint64_t& aID, const nsString& aStr,
-                           const int32_t& aStart, const uint32_t& aLen,
-                           const bool& aIsInsert, const bool& aFromUser);
-  bool SendSelectionEvent(const uint64_t& aID, const uint64_t& aWidgetID,
-                          const uint32_t& aType);
-
-protected:
-  virtual void MaybeSendShowEvent(ShowEventData& aData, bool aFromUser) override;
-
 private:
-  /**
-   * DocAccessibleChild should not fire events until it has asynchronously
-   * received the COM proxy for its parent. OTOH, content a11y may still be
-   * attempting to fire events during this window of time. If this object does
-   * not yet have its parent proxy, instead of immediately sending the events to
-   * our parent, we enqueue them to mDeferredEvents. As soon as
-   * RecvParentCOMProxy is called, we play back mDeferredEvents.
-   */
-  struct DeferredEvent
-  {
-    virtual void Dispatch(DocAccessibleChild* aIPCDoc) = 0;
-    virtual ~DeferredEvent() {}
-  };
-
-  struct SerializedShow final : public DeferredEvent
-  {
-    SerializedShow(ShowEventData& aEventData, bool aFromUser)
-      : mEventData(aEventData.ID(), aEventData.Idx(), nsTArray<AccessibleData>())
-      , mFromUser(aFromUser)
-    {
-      // Since IPDL doesn't generate a move constructor for ShowEventData,
-      // we move NewTree manually (ugh). We still construct with an empty
-      // NewTree above so that the compiler catches any changes made to the
-      // ShowEventData structure in IPDL.
-      mEventData.NewTree() = Move(aEventData.NewTree());
-    }
-
-    void Dispatch(DocAccessibleChild* aIPCDoc) override
-    {
-      Unused << aIPCDoc->SendShowEvent(mEventData, mFromUser);
-    }
-
-    ShowEventData mEventData;
-    bool          mFromUser;
-  };
-
-  struct SerializedHide final : public DeferredEvent
-  {
-    SerializedHide(uint64_t aRootID, bool aFromUser)
-      : mRootID(aRootID)
-      , mFromUser(aFromUser)
-    {}
-
-    void Dispatch(DocAccessibleChild* aIPCDoc) override
-    {
-      Unused << aIPCDoc->SendHideEvent(mRootID, mFromUser);
-    }
-
-    uint64_t  mRootID;
-    bool      mFromUser;
-  };
-
-  struct SerializedStateChange final : public DeferredEvent
-  {
-    SerializedStateChange(uint64_t aID, uint64_t aState, bool aEnabled)
-      : mID(aID)
-      , mState(aState)
-      , mEnabled(aEnabled)
-    {}
-
-    void Dispatch(DocAccessibleChild* aIPCDoc) override
-    {
-      Unused << aIPCDoc->SendStateChangeEvent(mID, mState, mEnabled);
-    }
-
-    uint64_t  mID;
-    uint64_t  mState;
-    bool      mEnabled;
-  };
-
-  struct SerializedCaretMove final : public DeferredEvent
-  {
-    SerializedCaretMove(uint64_t aID, int32_t aOffset)
-      : mID(aID)
-      , mOffset(aOffset)
-    {}
-
-    void Dispatch(DocAccessibleChild* aIPCDoc) override
-    {
-      Unused << aIPCDoc->SendCaretMoveEvent(mID, mOffset);
-    }
-
-    uint64_t  mID;
-    int32_t   mOffset;
-  };
-
-  struct SerializedTextChange final : public DeferredEvent
-  {
-    SerializedTextChange(uint64_t aID, const nsString& aStr, int32_t aStart,
-                         uint32_t aLen, bool aIsInsert, bool aFromUser)
-      : mID(aID)
-      , mStr(aStr)
-      , mStart(aStart)
-      , mLen(aLen)
-      , mIsInsert(aIsInsert)
-      , mFromUser(aFromUser)
-    {}
-
-    void Dispatch(DocAccessibleChild* aIPCDoc) override
-    {
-      Unused << aIPCDoc->SendTextChangeEvent(mID, mStr, mStart, mLen, mIsInsert,
-                                             mFromUser);
-    }
-
-    uint64_t  mID;
-    nsString  mStr;
-    int32_t   mStart;
-    uint32_t  mLen;
-    bool      mIsInsert;
-    bool      mFromUser;
-  };
-
-  struct SerializedSelection final : public DeferredEvent
-  {
-    SerializedSelection(uint64_t aID, uint64_t aWidgetID, uint32_t aType)
-      : mID(aID)
-      , mWidgetID(aWidgetID)
-      , mType(aType)
-    {}
-
-    void Dispatch(DocAccessibleChild* aIPCDoc) override
-    {
-      Unused << aIPCDoc->SendSelectionEvent(mID, mWidgetID, mType);
-    }
-
-    uint64_t  mID;
-    uint64_t  mWidgetID;
-    uint32_t  mType;
-  };
-
-  struct SerializedEvent final : public DeferredEvent
-  {
-    SerializedEvent(uint64_t aID, uint32_t aType)
-      : mID(aID)
-      , mType(aType)
-    {}
-
-    void Dispatch(DocAccessibleChild* aIPCDoc) override
-    {
-      Unused << aIPCDoc->SendEvent(mID, mType);
-    }
-
-    uint64_t  mID;
-    uint32_t  mType;
-  };
-
   mscom::ProxyUniquePtr<IAccessible> mParentProxy;
-  nsTArray<UniquePtr<DeferredEvent>> mDeferredEvents;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif // mozilla_a11y_DocAccessibleChild_h
--- a/accessible/ipc/win/PDocAccessible.ipdl
+++ b/accessible/ipc/win/PDocAccessible.ipdl
@@ -56,16 +56,19 @@ parent:
   async RoleChangedEvent(uint32_t aRole);
 
   /*
    * Tell the parent document to bind the existing document as a new child
    * document.
    */
   async BindChildDoc(PDocAccessible aChildDoc, uint64_t aID);
 
+  // For now we'll add the command to send the proxy here. This might move to
+  // PDocAccessible constructor in PBrowser.
+  sync COMProxy(IAccessibleHolder aDocCOMProxy)
+    returns(IAccessibleHolder aParentCOMProxy);
+
 child:
-  async ParentCOMProxy(IAccessibleHolder aParentCOMProxy);
-
   async __delete__();
 };
 
 }
 }
--- a/dom/ipc/PBrowser.ipdl
+++ b/dom/ipc/PBrowser.ipdl
@@ -71,17 +71,16 @@ using class mozilla::dom::MessagePort fr
 using class mozilla::dom::ipc::StructuredCloneData from "mozilla/dom/ipc/StructuredCloneData.h";
 using mozilla::EventMessage from "mozilla/EventForwards.h";
 using nsEventStatus from "mozilla/EventForwards.h";
 using mozilla::Modifiers from "mozilla/EventForwards.h";
 using nsSizeMode from "nsIWidgetListener.h";
 using mozilla::widget::CandidateWindowPosition from "ipc/nsGUIEventIPC.h";
 using class mozilla::NativeEventData from "ipc/nsGUIEventIPC.h";
 using mozilla::FontRange from "ipc/nsGUIEventIPC.h";
-using mozilla::a11y::IAccessibleHolder from "mozilla/a11y/IPCTypes.h";
 
 namespace mozilla {
 namespace dom {
 
 struct NativeKeyBinding
 {
   CommandInt[] singleLineCommands;
   CommandInt[] multiLineCommands;
@@ -136,21 +135,20 @@ both:
     async PRenderFrame();
 
 parent:
     /**
      * Tell the parent process a new accessible document has been created.
      * aParentDoc is the accessible document it was created in if any, and
      * aParentAcc is the id of the accessible in that document the new document
      * is a child of. aMsaaID is the MSAA id for this content process, and
-     * is only valid on Windows. Set to 0 on other platforms. aDocCOMProxy
-     * is also Windows-specific and should be set to 0 on other platforms.
+     * is only valid on Windows. Set to 0 on other platforms.
      */
     async PDocAccessible(nullable PDocAccessible aParentDoc, uint64_t aParentAcc,
-                         uint32_t aMsaaID, IAccessibleHolder aDocCOMProxy);
+                         uint32_t aMsaaID);
 
     /*
      * Creates a new remoted nsIWidget connection for windowed plugins
      * in e10s mode. This is always initiated from the child in response
      * to windowed plugin creation.
      */
     sync PPluginWidget();
 
--- a/dom/ipc/TabChild.cpp
+++ b/dom/ipc/TabChild.cpp
@@ -1976,17 +1976,17 @@ TabChild::RecvPasteTransferable(const IP
 
   ourDocShell->DoCommandWithParams("cmd_pasteTransferable", params);
   return true;
 }
 
 
 a11y::PDocAccessibleChild*
 TabChild::AllocPDocAccessibleChild(PDocAccessibleChild*, const uint64_t&,
-                                   const uint32_t&, const IAccessibleHolder&)
+                                   const uint32_t&)
 {
   MOZ_ASSERT(false, "should never call this!");
   return nullptr;
 }
 
 bool
 TabChild::DeallocPDocAccessibleChild(a11y::PDocAccessibleChild* aChild)
 {
--- a/dom/ipc/TabChild.h
+++ b/dom/ipc/TabChild.h
@@ -436,17 +436,17 @@ public:
                                 const IPC::Principal& aPrincipal,
                                 const ClonedMessageData& aData) override;
 
   virtual bool
   RecvSwappedWithOtherRemoteLoader(const IPCTabContext& aContext) override;
 
   virtual PDocAccessibleChild*
   AllocPDocAccessibleChild(PDocAccessibleChild*, const uint64_t&,
-                           const uint32_t&, const IAccessibleHolder&) override;
+                           const uint32_t&) override;
 
   virtual bool DeallocPDocAccessibleChild(PDocAccessibleChild*) override;
 
   virtual PDocumentRendererChild*
   AllocPDocumentRendererChild(const nsRect& aDocumentRect,
                               const gfx::Matrix& aTransform,
                               const nsString& aBggcolor,
                               const uint32_t& aRenderFlags,
--- a/dom/ipc/TabParent.cpp
+++ b/dom/ipc/TabParent.cpp
@@ -865,18 +865,17 @@ TabParent::SetDocShell(nsIDocShell *aDoc
 {
   NS_ENSURE_ARG(aDocShell);
   NS_WARNING("No mDocShell member in TabParent so there is no docShell to set");
   return NS_OK;
 }
 
   a11y::PDocAccessibleParent*
 TabParent::AllocPDocAccessibleParent(PDocAccessibleParent* aParent,
-                                     const uint64_t&, const uint32_t&,
-                                     const IAccessibleHolder&)
+                                     const uint64_t&, const uint32_t&)
 {
 #ifdef ACCESSIBILITY
   return new a11y::DocAccessibleParent();
 #else
   return nullptr;
 #endif
 }
 
@@ -888,34 +887,32 @@ TabParent::DeallocPDocAccessibleParent(P
 #endif
   return true;
 }
 
 bool
 TabParent::RecvPDocAccessibleConstructor(PDocAccessibleParent* aDoc,
                                          PDocAccessibleParent* aParentDoc,
                                          const uint64_t& aParentID,
-                                         const uint32_t& aMsaaID,
-                                         const IAccessibleHolder& aDocCOMProxy)
+                                         const uint32_t& aMsaaID)
 {
 #ifdef ACCESSIBILITY
   auto doc = static_cast<a11y::DocAccessibleParent*>(aDoc);
   if (aParentDoc) {
     // A document should never directly be the parent of another document.
     // There should always be an outer doc accessible child of the outer
     // document containing the child.
     MOZ_ASSERT(aParentID);
     if (!aParentID) {
       return false;
     }
 
     auto parentDoc = static_cast<a11y::DocAccessibleParent*>(aParentDoc);
     bool added = parentDoc->AddChildDoc(doc, aParentID);
 #ifdef XP_WIN
-    MOZ_ASSERT(aDocCOMProxy.IsNull());
     if (added) {
       a11y::WrapperFor(doc)->SetID(aMsaaID);
     }
 #endif
     return added;
   } else {
     // null aParentDoc means this document is at the top level in the child
     // process.  That means it makes no sense to get an id for an accessible
@@ -924,19 +921,16 @@ TabParent::RecvPDocAccessibleConstructor
     if (aParentID) {
       return false;
     }
 
     doc->SetTopLevel();
     a11y::DocManager::RemoteDocAdded(doc);
 #ifdef XP_WIN
     a11y::WrapperFor(doc)->SetID(aMsaaID);
-    MOZ_ASSERT(!aDocCOMProxy.IsNull());
-    RefPtr<IAccessible> proxy(aDocCOMProxy.Get());
-    doc->SetCOMProxy(proxy);
 #endif
   }
 #endif
   return true;
 }
 
 a11y::DocAccessibleParent*
 TabParent::GetTopLevelDocAccessible() const
--- a/dom/ipc/TabParent.h
+++ b/dom/ipc/TabParent.h
@@ -348,26 +348,25 @@ public:
   DeallocPColorPickerParent(PColorPickerParent* aColorPicker) override;
 
   virtual PDatePickerParent*
   AllocPDatePickerParent(const nsString& aTitle, const nsString& aInitialDate) override;
   virtual bool DeallocPDatePickerParent(PDatePickerParent* aDatePicker) override;
 
   virtual PDocAccessibleParent*
   AllocPDocAccessibleParent(PDocAccessibleParent*, const uint64_t&,
-                            const uint32_t&, const IAccessibleHolder&) override;
+                            const uint32_t&) override;
 
   virtual bool DeallocPDocAccessibleParent(PDocAccessibleParent*) override;
 
   virtual bool
   RecvPDocAccessibleConstructor(PDocAccessibleParent* aDoc,
                                 PDocAccessibleParent* aParentDoc,
                                 const uint64_t& aParentID,
-                                const uint32_t& aMsaaID,
-                                const IAccessibleHolder& aDocCOMProxy) override;
+                                const uint32_t& aMsaaID) override;
 
   /**
    * Return the top level doc accessible parent for this tab.
    */
   a11y::DocAccessibleParent* GetTopLevelDocAccessible() const;
 
   void LoadURL(nsIURI* aURI);