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 321894 841f82fde3b4bf44d2b01a5f9635e89b17ad6443
parent 321893 e1f230913306b5ab63a64438c12f76e8fbde8c62
child 321895 bf2c61e0283e5a55988b6ee2524c809d97a98e59
push id83712
push userphilringnalda@gmail.com
push dateThu, 10 Nov 2016 03:33:32 +0000
treeherdermozilla-inbound@841f82fde3b4 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1314707
milestone52.0a1
backs out43835f5fa2b217ba7e2a59fb9f52910a2e06a28a
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
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);