--- a/accessible/android/AccessibleWrap.cpp
+++ b/accessible/android/AccessibleWrap.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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/. */
 
 #include "AccessibleWrap.h"
 
 #include "JavaBuiltins.h"
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "HyperTextAccessible-inl.h"
 #include "AccEvent.h"
 #include "AndroidInputType.h"
 #include "DocAccessibleWrap.h"
 #include "IDSet.h"
 #include "SessionAccessibility.h"
 #include "TextLeafAccessible.h"
 #include "TraversalRule.h"
@@ -40,17 +40,17 @@ using namespace mozilla::a11y;
 
 // IDs should be a positive 32bit integer.
 IDSet sIDSet(31UL);
 
 //-----------------------------------------------------
 // construction
 //-----------------------------------------------------
 AccessibleWrap::AccessibleWrap(nsIContent* aContent, DocAccessible* aDoc)
-    : Accessible(aContent, aDoc) {
+    : LocalAccessible(aContent, aDoc) {
   if (aDoc) {
     mID = AcquireID();
     DocAccessibleWrap* doc = static_cast<DocAccessibleWrap*>(aDoc);
     doc->AddID(mID, this);
   }
 }
 
 //-----------------------------------------------------
@@ -95,17 +95,17 @@ nsresult AccessibleWrap::HandleAccEvent(
         if (accessible != aEvent->Document() && !aEvent->IsFromUserInput()) {
           AccCaretMoveEvent* caretEvent = downcast_accEvent(aEvent);
           HyperTextAccessible* ht = AsHyperText();
           // Pivot to the caret's position if it has an expanded selection.
           // This is used mostly for find in page.
           if ((ht && ht->SelectionCount())) {
             DOMPoint point =
                 AsHyperText()->OffsetToDOMPoint(caretEvent->GetCaretOffset());
-            if (Accessible* newPos =
+            if (LocalAccessible* newPos =
                     doc->GetAccessibleOrContainer(point.node)) {
               static_cast<AccessibleWrap*>(newPos)->PivotTo(
                   java::SessionAccessibility::HTML_GRANULARITY_DEFAULT, true,
                   true);
             }
           }
         }
         break;
@@ -115,17 +115,17 @@ nsresult AccessibleWrap::HandleAccEvent(
             java::SessionAccessibility::HTML_GRANULARITY_DEFAULT, true, true);
         break;
       }
       default:
         break;
     }
   }
 
-  nsresult rv = Accessible::HandleAccEvent(aEvent);
+  nsresult rv = LocalAccessible::HandleAccEvent(aEvent);
   NS_ENSURE_SUCCESS(rv, rv);
 
   accessible->HandleLiveRegionEvent(aEvent);
 
   if (IPCAccessibilityActive()) {
     return NS_OK;
   }
 
@@ -242,22 +242,22 @@ void AccessibleWrap::Shutdown() {
       if (auto doc = static_cast<DocAccessibleWrap*>(mDoc.get())) {
         doc->RemoveID(mID);
       }
       ReleaseID(mID);
       mID = 0;
     }
   }
 
-  Accessible::Shutdown();
+  LocalAccessible::Shutdown();
 }
 
 bool AccessibleWrap::DoAction(uint8_t aIndex) const {
   if (ActionCount()) {
-    return Accessible::DoAction(aIndex);
+    return LocalAccessible::DoAction(aIndex);
   }
 
   if (mContent) {
     // We still simulate a click on an accessible even if there is no
     // known actions. For the sake of bad markup.
     DoCommand();
     return true;
   }
@@ -295,34 +295,34 @@ bool AccessibleWrap::GetSelectionBounds(
 }
 
 void AccessibleWrap::PivotTo(int32_t aGranularity, bool aForward,
                              bool aInclusive) {
   AccessibleOrProxy accOrProxyRoot = AccessibleOrProxy(RootAccessible());
   a11y::Pivot pivot(accOrProxyRoot);
   TraversalRule rule(aGranularity);
   AccessibleOrProxy accOrProxy = AccessibleOrProxy(this);
-  Accessible* result =
+  LocalAccessible* result =
       aForward ? pivot.Next(accOrProxy, rule, aInclusive).AsAccessible()
                : pivot.Prev(accOrProxy, rule, aInclusive).AsAccessible();
   if (result && (result != this || aInclusive)) {
     PivotMoveReason reason = aForward ? nsIAccessiblePivot::REASON_NEXT
                                       : nsIAccessiblePivot::REASON_PREV;
     RefPtr<AccEvent> event = new AccVCChangeEvent(
         result->Document(), this, -1, -1, result, -1, -1, reason,
         nsIAccessiblePivot::NO_BOUNDARY, eFromUserInput);
     nsEventShell::FireEvent(event);
   }
 }
 
 void AccessibleWrap::ExploreByTouch(float aX, float aY) {
   a11y::Pivot pivot(RootAccessible());
   TraversalRule rule;
 
-  Accessible* result = pivot.AtPoint(aX, aY, rule).AsAccessible();
+  LocalAccessible* result = pivot.AtPoint(aX, aY, rule).AsAccessible();
 
   if (result && result != this) {
     RefPtr<AccEvent> event =
         new AccVCChangeEvent(result->Document(), this, -1, -1, result, -1, -1,
                              nsIAccessiblePivot::REASON_POINT,
                              nsIAccessiblePivot::NO_BOUNDARY, eFromUserInput);
     nsEventShell::FireEvent(event);
   }
@@ -352,17 +352,17 @@ void AccessibleWrap::NavigateText(int32_
     case 2:  // MOVEMENT_GRANULARITY_WORD
       pivotGranularity = nsIAccessiblePivot::WORD_BOUNDARY;
       break;
     default:
       break;
   }
 
   int32_t newOffset;
-  Accessible* newAnchor = nullptr;
+  LocalAccessible* newAnchor = nullptr;
   if (aForward) {
     newAnchor = pivot.NextText(this, &start, &end, pivotGranularity);
     newOffset = end;
   } else {
     newAnchor = pivot.PrevText(this, &start, &end, pivotGranularity);
     newOffset = start;
   }
 
@@ -904,21 +904,21 @@ bool AccessibleWrap::HandleLiveRegionEve
 
   uint16_t priority = live.EqualsIgnoreCase("assertive")
                           ? nsIAccessibleAnnouncementEvent::ASSERTIVE
                           : nsIAccessibleAnnouncementEvent::POLITE;
 
   nsString atomic;
   rv = attributes->GetStringProperty("container-atomic"_ns, atomic);
 
-  Accessible* announcementTarget = this;
+  LocalAccessible* announcementTarget = this;
   nsAutoString announcement;
   if (atomic.EqualsIgnoreCase("true")) {
-    Accessible* atomicAncestor = nullptr;
-    for (Accessible* parent = announcementTarget; parent;
+    LocalAccessible* atomicAncestor = nullptr;
+    for (LocalAccessible* parent = announcementTarget; parent;
          parent = parent->LocalParent()) {
       dom::Element* element = parent->Elm();
       if (element &&
           element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::aria_atomic,
                                nsGkAtoms::_true, eCaseMatters)) {
         atomicAncestor = parent;
         break;
       }

--- a/accessible/android/AccessibleWrap.h
+++ b/accessible/android/AccessibleWrap.h
@@ -1,26 +1,26 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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_AccessibleWrap_h_
 #define mozilla_a11y_AccessibleWrap_h_
 
-#include "Accessible.h"
+#include "LocalAccessible.h"
 #include "mozilla/a11y/ProxyAccessible.h"
 #include "mozilla/java/GeckoBundleWrappers.h"
 #include "mozilla/java/SessionAccessibilityWrappers.h"
 #include "nsCOMPtr.h"
 
 namespace mozilla {
 namespace a11y {
 
-class AccessibleWrap : public Accessible {
+class AccessibleWrap : public LocalAccessible {
  public:
   AccessibleWrap(nsIContent* aContent, DocAccessible* aDoc);
   virtual ~AccessibleWrap();
 
   MOZ_CAN_RUN_SCRIPT_BOUNDARY  // TODO: Mark this as MOZ_CAN_RUN_SCRIPT
       virtual nsresult
       HandleAccEvent(AccEvent* aEvent) override;
 

--- a/accessible/android/DocAccessibleWrap.cpp
+++ b/accessible/android/DocAccessibleWrap.cpp
@@ -1,15 +1,15 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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/. */
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "AccessibleOrProxy.h"
 #include "DocAccessibleChild.h"
 #include "DocAccessibleWrap.h"
 #include "nsIDocShell.h"
 #include "nsIScrollableFrame.h"
 #include "nsLayoutUtils.h"
 #include "nsAccessibilityService.h"
 #include "nsAccUtils.h"
@@ -105,35 +105,35 @@ void DocAccessibleWrap::CacheViewportCal
       {nsLayoutUtils::FrameForPointOption::OnlyVisible});
   AccessibleHashtable inViewAccs;
   for (size_t i = 0; i < frames.Length(); i++) {
     nsIContent* content = frames.ElementAt(i)->GetContent();
     if (!content) {
       continue;
     }
 
-    Accessible* visibleAcc = docAcc->GetAccessibleOrContainer(content);
+    LocalAccessible* visibleAcc = docAcc->GetAccessibleOrContainer(content);
     if (!visibleAcc) {
       continue;
     }
 
-    for (Accessible* acc = visibleAcc; acc && acc != docAcc->LocalParent();
+    for (LocalAccessible* acc = visibleAcc; acc && acc != docAcc->LocalParent();
          acc = acc->LocalParent()) {
       if (inViewAccs.Contains(acc->UniqueID())) {
         break;
       }
       inViewAccs.Put(acc->UniqueID(), RefPtr{acc});
     }
   }
 
   if (IPCAccessibilityActive()) {
     DocAccessibleChild* ipcDoc = docAcc->IPCDoc();
     nsTArray<BatchData> cacheData(inViewAccs.Count());
     for (auto iter = inViewAccs.Iter(); !iter.Done(); iter.Next()) {
-      Accessible* accessible = iter.Data();
+      LocalAccessible* accessible = iter.Data();
       nsAutoString name;
       accessible->Name(name);
       nsAutoString textValue;
       accessible->Value(textValue);
       nsAutoString nodeID;
       static_cast<AccessibleWrap*>(accessible)->WrapperDOMNodeID(nodeID);
       nsAutoString description;
       accessible->Description(description);
@@ -157,18 +157,18 @@ void DocAccessibleWrap::CacheViewportCal
 
     sessionAcc->ReplaceViewportCache(accessibles);
   }
 
   if (docAcc->mCachePivotBoundaries) {
     AccessibleOrProxy accOrProxy = AccessibleOrProxy(docAcc);
     a11y::Pivot pivot(accOrProxy);
     TraversalRule rule(java::SessionAccessibility::HTML_GRANULARITY_DEFAULT);
-    Accessible* first = pivot.First(rule).AsAccessible();
-    Accessible* last = pivot.Last(rule).AsAccessible();
+    LocalAccessible* first = pivot.First(rule).AsAccessible();
+    LocalAccessible* last = pivot.Last(rule).AsAccessible();
 
     // If first/last are null, pass the root document as pivot boundary.
     if (IPCAccessibilityActive()) {
       DocAccessibleChild* ipcDoc = docAcc->IPCDoc();
       DocAccessibleChild* firstDoc =
           first ? first->Document()->IPCDoc() : ipcDoc;
       DocAccessibleChild* lastDoc = last ? last->Document()->IPCDoc() : ipcDoc;
       if (ipcDoc && firstDoc && lastDoc) {
@@ -261,17 +261,17 @@ void DocAccessibleWrap::UpdateFocusPathB
   if (!mFocusPath.Count()) {
     return;
   }
 
   if (IPCAccessibilityActive()) {
     DocAccessibleChild* ipcDoc = IPCDoc();
     nsTArray<BatchData> boundsData(mFocusPath.Count());
     for (auto iter = mFocusPath.Iter(); !iter.Done(); iter.Next()) {
-      Accessible* accessible = iter.Data();
+      LocalAccessible* accessible = iter.Data();
       if (!accessible || accessible->IsDefunct()) {
         MOZ_ASSERT_UNREACHABLE("Focus path cached accessible is gone.");
         continue;
       }
 
       boundsData.AppendElement(
           BatchData(accessible->Document()->IPCDoc(), UNIQUE_ID(accessible), 0,
                     accessible->Bounds(), 0, nsString(), nsString(), nsString(),
@@ -280,17 +280,17 @@ void DocAccessibleWrap::UpdateFocusPathB
                     UnspecifiedNaN<double>(), nsTArray<Attribute>()));
     }
 
     ipcDoc->SendBatch(eBatch_BoundsUpdate, boundsData);
   } else if (RefPtr<SessionAccessibility> sessionAcc =
                  SessionAccessibility::GetInstanceFor(this)) {
     nsTArray<AccessibleWrap*> accessibles(mFocusPath.Count());
     for (auto iter = mFocusPath.Iter(); !iter.Done(); iter.Next()) {
-      Accessible* accessible = iter.Data();
+      LocalAccessible* accessible = iter.Data();
       if (!accessible || accessible->IsDefunct()) {
         MOZ_ASSERT_UNREACHABLE("Focus path cached accessible is gone.");
         continue;
       }
 
       accessibles.AppendElement(static_cast<AccessibleWrap*>(accessible));
     }
 

--- a/accessible/android/ProxyAccessibleWrap.cpp
+++ b/accessible/android/ProxyAccessibleWrap.cpp
@@ -1,15 +1,15 @@
 /* -*- Mode: c++; c-basic-offset: 2; tab-width: 20; indent-tabs-mode: nil; -*-
  * 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/. */
 
 #include "ProxyAccessibleWrap.h"
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 
 #include "nsPersistentProperties.h"
 
 #include "mozilla/a11y/DocAccessiblePlatformExtParent.h"
 
 using namespace mozilla::a11y;
 
 ProxyAccessibleWrap::ProxyAccessibleWrap(ProxyAccessible* aProxy)
@@ -45,29 +45,29 @@ void ProxyAccessibleWrap::Shutdown() {
     ReleaseID(mID);
     mID = 0;
   }
 
   mBits.proxy = nullptr;
   mStateFlags |= eIsDefunct;
 }
 
-// Accessible
+// LocalAccessible
 
 already_AddRefed<nsIPersistentProperties> ProxyAccessibleWrap::Attributes() {
   AutoTArray<Attribute, 10> attrs;
   Proxy()->Attributes(&attrs);
   return AttributeArrayToProperties(attrs);
 }
 
 uint32_t ProxyAccessibleWrap::ChildCount() const {
   return Proxy()->ChildrenCount();
 }
 
-Accessible* ProxyAccessibleWrap::LocalChildAt(uint32_t aIndex) const {
+LocalAccessible* ProxyAccessibleWrap::LocalChildAt(uint32_t aIndex) const {
   ProxyAccessible* child = Proxy()->RemoteChildAt(aIndex);
   return child ? WrapperFor(child) : nullptr;
 }
 
 ENameValueFlag ProxyAccessibleWrap::Name(nsString& aName) const {
   Proxy()->Name(aName);
   return eNameOK;
 }

--- a/accessible/android/ProxyAccessibleWrap.h
+++ b/accessible/android/ProxyAccessibleWrap.h
@@ -10,35 +10,35 @@
 
 #include "AccessibleWrap.h"
 #include "DocAccessibleParent.h"
 
 namespace mozilla {
 namespace a11y {
 
 /**
- * A wrapper for Accessible proxies. The public methods here should be overriden
- * from AccessibleWrap or its super classes.
- * This gives us an abstraction layer so SessionAccessibility doesn't have
- * to distinguish between a local or remote accessibles.
- * NOTE: This shouldn't be regarded as a full Accessible implementation.
+ * A wrapper for Accessible proxies. The public methods here should be
+ * overriden from AccessibleWrap or its super classes. This gives us an
+ * abstraction layer so SessionAccessibility doesn't have to distinguish between
+ * a local or remote accessibles. NOTE: This shouldn't be regarded as a full
+ * Accessible implementation.
  */
 class ProxyAccessibleWrap : public AccessibleWrap {
  public:
   explicit ProxyAccessibleWrap(ProxyAccessible* aProxy);
 
   virtual void Shutdown() override;
 
-  // Accessible
+  // LocalAccessible
 
   virtual already_AddRefed<nsIPersistentProperties> Attributes() override;
 
   virtual uint32_t ChildCount() const override;
 
-  virtual Accessible* LocalChildAt(uint32_t aIndex) const override;
+  virtual LocalAccessible* LocalChildAt(uint32_t aIndex) const override;
 
   virtual ENameValueFlag Name(nsString& aName) const override;
 
   virtual void Value(nsString& aValue) const override;
 
   virtual uint64_t State() override;
 
   virtual nsIntRect Bounds() const override;

--- a/accessible/android/RootAccessibleWrap.cpp
+++ b/accessible/android/RootAccessibleWrap.cpp
@@ -1,16 +1,16 @@
 /* -*- Mode: c++; c-basic-offset: 2; tab-width: 20; indent-tabs-mode: nil; -*-
  * 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/. */
 
 #include "RootAccessibleWrap.h"
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "AccessibleOrProxy.h"
 #include "DocAccessibleParent.h"
 #include "DocAccessible-inl.h"
 #include "ProxyAccessibleWrap.h"
 #include "SessionAccessibility.h"
 #include "mozilla/PresShell.h"
 
 using namespace mozilla;

--- a/accessible/android/SessionAccessibility.cpp
+++ b/accessible/android/SessionAccessibility.cpp
@@ -1,15 +1,15 @@
 /* -*- Mode: c++; c-basic-offset: 2; tab-width: 20; indent-tabs-mode: nil; -*-
  * 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/. */
 
 #include "SessionAccessibility.h"
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "AndroidUiThread.h"
 #include "DocAccessibleParent.h"
 #include "nsThreadUtils.h"
 #include "AccessibilityEvent.h"
 #include "HyperTextAccessible.h"
 #include "JavaBuiltins.h"
 #include "RootAccessibleWrap.h"
 #include "nsAccessibilityService.h"
@@ -165,22 +165,22 @@ RefPtr<SessionAccessibility> SessionAcce
   auto tab =
       static_cast<dom::BrowserParent*>(aAccessible->Document()->Manager());
   dom::Element* frame = tab->GetOwnerElement();
   MOZ_ASSERT(frame);
   if (!frame) {
     return nullptr;
   }
 
-  Accessible* chromeDoc = GetExistingDocAccessible(frame->OwnerDoc());
+  LocalAccessible* chromeDoc = GetExistingDocAccessible(frame->OwnerDoc());
   return chromeDoc ? GetInstanceFor(chromeDoc) : nullptr;
 }
 
 RefPtr<SessionAccessibility> SessionAccessibility::GetInstanceFor(
-    Accessible* aAccessible) {
+    LocalAccessible* aAccessible) {
   RootAccessible* rootAcc = aAccessible->RootAccessible();
   nsViewManager* vm = rootAcc->PresShellPtr()->GetViewManager();
   if (!vm) {
     return nullptr;
   }
 
   nsCOMPtr<nsIWidget> rootWidget;
   vm->GetRootWidget(getter_AddRefs(rootWidget));

--- a/accessible/android/SessionAccessibility.h
+++ b/accessible/android/SessionAccessibility.h
@@ -39,17 +39,18 @@ class SessionAccessibility final
   const java::SessionAccessibility::NativeProvider::Ref&
   GetJavaAccessibility() {
     return mSessionAccessibility;
   }
 
   static void Init();
   static RefPtr<SessionAccessibility> GetInstanceFor(
       ProxyAccessible* aAccessible);
-  static RefPtr<SessionAccessibility> GetInstanceFor(Accessible* aAccessible);
+  static RefPtr<SessionAccessibility> GetInstanceFor(
+      LocalAccessible* aAccessible);
 
   // Native implementations
   using Base::AttachNative;
   using Base::DisposeNative;
   jni::Object::LocalRef GetNodeInfo(int32_t aID);
   void SetText(int32_t aID, jni::String::Param aText);
   void Click(int32_t aID);
   void Pivot(int32_t aID, int32_t aGranularity, bool aForward, bool aInclusive);

--- a/accessible/android/TraversalRule.cpp
+++ b/accessible/android/TraversalRule.cpp
@@ -4,18 +4,18 @@
  * 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/. */
 
 #include "TraversalRule.h"
 
 #include "mozilla/ArrayUtils.h"
 
 #include "Role.h"
-#include "Accessible.h"
-#include "Accessible-inl.h"
+#include "LocalAccessible.h"
+#include "LocalAccessible-inl.h"
 #include "HTMLListAccessible.h"
 #include "SessionAccessibility.h"
 #include "nsAccUtils.h"
 #include "nsIAccessiblePivot.h"
 
 using namespace mozilla;
 using namespace mozilla::a11y;
 
@@ -23,17 +23,17 @@ TraversalRule::TraversalRule()
     : TraversalRule(java::SessionAccessibility::HTML_GRANULARITY_DEFAULT) {}
 
 TraversalRule::TraversalRule(int32_t aGranularity)
     : mGranularity(aGranularity) {}
 
 uint16_t TraversalRule::Match(const AccessibleOrProxy& aAccOrProxy) {
   MOZ_ASSERT(aAccOrProxy.IsAccessible(),
              "Should only receive accessibles when processing on android.");
-  Accessible* aAccessible = aAccOrProxy.AsAccessible();
+  LocalAccessible* aAccessible = aAccOrProxy.AsAccessible();
   uint16_t result = nsIAccessibleTraversalRule::FILTER_IGNORE;
 
   if (nsAccUtils::MustPrune(aAccessible)) {
     result |= nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
   }
 
   uint64_t state = aAccessible->State();
 
@@ -67,109 +67,109 @@ uint16_t TraversalRule::Match(const Acce
     default:
       result |= DefaultMatch(aAccessible);
       break;
   }
 
   return result;
 }
 
-bool TraversalRule::IsSingleLineage(Accessible* aAccessible) {
-  Accessible* child = aAccessible;
+bool TraversalRule::IsSingleLineage(LocalAccessible* aAccessible) {
+  LocalAccessible* child = aAccessible;
   while (child) {
     switch (child->ChildCount()) {
       case 0:
         return true;
       case 1:
         child = child->LocalFirstChild();
         break;
       case 2:
-        if (Accessible* bullet =
+        if (LocalAccessible* bullet =
                 child->LocalParent()->IsHTMLListItem()
                     ? child->LocalParent()->AsHTMLListItem()->Bullet()
                     : nullptr) {
           child = bullet->LocalNextSibling();
         } else {
           return false;
         }
         break;
       default:
         return false;
     }
   }
 
   return true;
 }
 
-bool TraversalRule::IsListItemBullet(const Accessible* aAccessible) {
-  Accessible* parent = aAccessible->LocalParent();
+bool TraversalRule::IsListItemBullet(const LocalAccessible* aAccessible) {
+  LocalAccessible* parent = aAccessible->LocalParent();
   return parent && parent->IsHTMLListItem() &&
          parent->AsHTMLListItem()->Bullet() == aAccessible;
 }
 
-bool TraversalRule::IsFlatSubtree(const Accessible* aAccessible) {
+bool TraversalRule::IsFlatSubtree(const LocalAccessible* aAccessible) {
   for (auto child = aAccessible->LocalFirstChild(); child;
        child = child->LocalNextSibling()) {
     roles::Role role = child->Role();
     if (role == roles::TEXT_LEAF || role == roles::STATICTEXT) {
       continue;
     }
 
     if (child->ChildCount() > 0 || child->ActionCount() > 0) {
       return false;
     }
   }
 
   return true;
 }
 
-bool TraversalRule::HasName(const Accessible* aAccessible) {
+bool TraversalRule::HasName(const LocalAccessible* aAccessible) {
   nsAutoString name;
   aAccessible->Name(name);
   name.CompressWhitespace();
   return !name.IsEmpty();
 }
 
-uint16_t TraversalRule::LinkMatch(Accessible* aAccessible) {
+uint16_t TraversalRule::LinkMatch(LocalAccessible* aAccessible) {
   if (aAccessible->Role() == roles::LINK &&
       (aAccessible->State() & states::LINKED) != 0) {
     return nsIAccessibleTraversalRule::FILTER_MATCH |
            nsIAccessibleTraversalRule::FILTER_IGNORE_SUBTREE;
   }
 
   return nsIAccessibleTraversalRule::FILTER_IGNORE;
 }
 
-uint16_t TraversalRule::HeadingMatch(Accessible* aAccessible) {
+uint16_t TraversalRule::HeadingMatch(LocalAccessible* aAccessible) {
   if (aAccessible->Role() == roles::HEADING && aAccessible->ChildCount()) {
     return nsIAccessibleTraversalRule::FILTER_MATCH;
   }
 
   return nsIAccessibleTraversalRule::FILTER_IGNORE;
 }
 
-uint16_t TraversalRule::SectionMatch(Accessible* aAccessible) {
+uint16_t TraversalRule::SectionMatch(LocalAccessible* aAccessible) {
   roles::Role role = aAccessible->Role();
   if (role == roles::HEADING || role == roles::LANDMARK ||
       aAccessible->LandmarkRole()) {
     return nsIAccessibleTraversalRule::FILTER_MATCH;
   }
 
   return nsIAccessibleTraversalRule::FILTER_IGNORE;
 }
 
-uint16_t TraversalRule::LandmarkMatch(Accessible* aAccessible) {
+uint16_t TraversalRule::LandmarkMatch(LocalAccessible* aAccessible) {
   if (aAccessible->LandmarkRole()) {
     return nsIAccessibleTraversalRule::FILTER_MATCH;
   }
 
   return nsIAccessibleTraversalRule::FILTER_IGNORE;
 }
 
-uint16_t TraversalRule::ControlMatch(Accessible* aAccessible) {
+uint16_t TraversalRule::ControlMatch(LocalAccessible* aAccessible) {
   switch (aAccessible->Role()) {
     case roles::PUSHBUTTON:
     case roles::SPINBUTTON:
     case roles::TOGGLE_BUTTON:
     case roles::BUTTONDROPDOWN:
     case roles::BUTTONDROPDOWNGRID:
     case roles::COMBOBOX:
     case roles::LISTBOX:
@@ -198,17 +198,17 @@ uint16_t TraversalRule::ControlMatch(Acc
       break;
     default:
       break;
   }
 
   return nsIAccessibleTraversalRule::FILTER_IGNORE;
 }
 
-uint16_t TraversalRule::DefaultMatch(Accessible* aAccessible) {
+uint16_t TraversalRule::DefaultMatch(LocalAccessible* aAccessible) {
   switch (aAccessible->Role()) {
     case roles::COMBOBOX:
       // We don't want to ignore the subtree because this is often
       // where the list box hangs out.
       return nsIAccessibleTraversalRule::FILTER_MATCH;
     case roles::EDITCOMBOBOX:
       if (aAccessible->NativeState() & states::EDITABLE) {
         // Only match ARIA 1.0 comboboxes; i.e. where the combobox itself is

--- a/accessible/android/TraversalRule.h
+++ b/accessible/android/TraversalRule.h
@@ -7,50 +7,50 @@
 #ifndef _TraversalRule_H_
 #define _TraversalRule_H_
 
 #include "Pivot.h"
 
 namespace mozilla {
 namespace a11y {
 
-class Accessible;
+class LocalAccessible;
 
 /**
  * Class represents a simple traversal rule.
  */
 class TraversalRule final : public PivotRule {
  public:
   TraversalRule();
   explicit TraversalRule(int32_t aGranularity);
 
   ~TraversalRule() = default;
 
   virtual uint16_t Match(const AccessibleOrProxy& aAccOrProxy) override;
 
  private:
-  bool IsSingleLineage(Accessible* aAccessible);
+  bool IsSingleLineage(LocalAccessible* aAccessible);
 
-  bool IsFlatSubtree(const Accessible* aAccessible);
+  bool IsFlatSubtree(const LocalAccessible* aAccessible);
 
-  bool IsListItemBullet(const Accessible* aAccessible);
+  bool IsListItemBullet(const LocalAccessible* aAccessible);
 
-  bool HasName(const Accessible* aAccessible);
+  bool HasName(const LocalAccessible* aAccessible);
 
-  uint16_t DefaultMatch(Accessible* aAccessible);
+  uint16_t DefaultMatch(LocalAccessible* aAccessible);
 
-  uint16_t LinkMatch(Accessible* aAccessible);
+  uint16_t LinkMatch(LocalAccessible* aAccessible);
 
-  uint16_t HeadingMatch(Accessible* aAccessible);
+  uint16_t HeadingMatch(LocalAccessible* aAccessible);
 
-  uint16_t ControlMatch(Accessible* aAccessible);
+  uint16_t ControlMatch(LocalAccessible* aAccessible);
 
-  uint16_t SectionMatch(Accessible* aAccessible);
+  uint16_t SectionMatch(LocalAccessible* aAccessible);
 
-  uint16_t LandmarkMatch(Accessible* aAccessible);
+  uint16_t LandmarkMatch(LocalAccessible* aAccessible);
 
   int32_t mGranularity;
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #endif

--- a/accessible/aom/AccessibleNode.cpp
+++ b/accessible/aom/AccessibleNode.cpp
@@ -7,17 +7,17 @@
 #include "mozilla/dom/AccessibleNodeBinding.h"
 #include "mozilla/dom/BindingDeclarations.h"
 #include "mozilla/dom/DOMStringList.h"
 #include "mozilla/StaticPrefs_accessibility.h"
 #include "nsContentUtils.h"
 #include "nsIPersistentProperties2.h"
 #include "nsISimpleEnumerator.h"
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "nsAccessibilityService.h"
 #include "DocAccessible.h"
 
 #include "mozilla/dom/Document.h"  // for inline nsINode::GetParentObject
 #include "mozilla/dom/ToJSValue.h"
 
 using namespace mozilla;
 using namespace mozilla::a11y;

--- a/accessible/aom/AccessibleNode.h
+++ b/accessible/aom/AccessibleNode.h
@@ -16,17 +16,17 @@
 
 class nsINode;
 
 namespace mozilla {
 
 class ErrorResult;
 
 namespace a11y {
-class Accessible;
+class LocalAccessible;
 }
 
 namespace dom {
 
 class DOMStringList;
 struct ParentObject;
 
 #define ANODE_ENUM(name) e##name,
@@ -195,17 +195,17 @@ class AccessibleNode : public nsISupport
   }
 
   // The 2k'th bit indicates whether the k'th boolean property is used(1) or
   // not(0) and 2k+1'th bit contains the property's value(1:true, 0:false)
   uint32_t mBooleanProperties;
   nsRefPtrHashtable<nsUint32HashKey, AccessibleNode> mRelationProperties;
   nsDataHashtable<nsUint32HashKey, nsString> mStringProperties;
 
-  RefPtr<a11y::Accessible> mIntl;
+  RefPtr<a11y::LocalAccessible> mIntl;
   RefPtr<nsINode> mDOMNode;
   RefPtr<dom::DOMStringList> mStates;
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
 #endif  // A11Y_JSAPI_ACCESSIBLENODE

--- a/accessible/atk/AccessibleWrap.cpp
+++ b/accessible/atk/AccessibleWrap.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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/. */
 
 #include "AccessibleWrap.h"
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "ApplicationAccessibleWrap.h"
 #include "InterfaceInitFuncs.h"
 #include "nsAccUtils.h"
 #include "mozilla/a11y/PDocAccessible.h"
 #include "OuterDocAccessible.h"
 #include "ProxyAccessible.h"
 #include "DocAccessibleParent.h"
 #include "RootAccessible.h"
@@ -242,17 +242,17 @@ GType mai_atk_object_get_type(void) {
     type = g_type_register_static(ATK_TYPE_OBJECT, "MaiAtkObject", &tinfo,
                                   GTypeFlags(0));
     quark_mai_hyperlink = g_quark_from_static_string("MaiHyperlink");
   }
   return type;
 }
 
 AccessibleWrap::AccessibleWrap(nsIContent* aContent, DocAccessible* aDoc)
-    : Accessible(aContent, aDoc), mAtkObject(nullptr) {}
+    : LocalAccessible(aContent, aDoc), mAtkObject(nullptr) {}
 
 AccessibleWrap::~AccessibleWrap() {
   NS_ASSERTION(!mAtkObject, "ShutdownAtkObject() is not called");
 }
 
 void AccessibleWrap::ShutdownAtkObject() {
   if (!mAtkObject) return;
 
@@ -260,17 +260,17 @@ void AccessibleWrap::ShutdownAtkObject()
   if (IS_MAI_OBJECT(mAtkObject)) MAI_ATK_OBJECT(mAtkObject)->Shutdown();
 
   g_object_unref(mAtkObject);
   mAtkObject = nullptr;
 }
 
 void AccessibleWrap::Shutdown() {
   ShutdownAtkObject();
-  Accessible::Shutdown();
+  LocalAccessible::Shutdown();
 }
 
 void AccessibleWrap::GetNativeInterface(void** aOutAccessible) {
   *aOutAccessible = nullptr;
 
   if (!mAtkObject) {
     if (IsDefunct() || IsText()) {
       // We don't create ATK objects for node which has been shutdown or
@@ -293,19 +293,19 @@ void AccessibleWrap::GetNativeInterface(
 }
 
 AtkObject* AccessibleWrap::GetAtkObject(void) {
   void* atkObj = nullptr;
   GetNativeInterface(&atkObj);
   return static_cast<AtkObject*>(atkObj);
 }
 
-// Get AtkObject from Accessible interface
+// Get AtkObject from LocalAccessible interface
 /* static */
-AtkObject* AccessibleWrap::GetAtkObject(Accessible* acc) {
+AtkObject* AccessibleWrap::GetAtkObject(LocalAccessible* acc) {
   void* atkObjPtr = nullptr;
   acc->GetNativeInterface(&atkObjPtr);
   return atkObjPtr ? ATK_OBJECT(atkObjPtr) : nullptr;
 }
 
 /* private */
 uint16_t AccessibleWrap::CreateMaiInterfaces(void) {
   uint16_t interfacesBits = 0;
@@ -671,17 +671,17 @@ static AtkAttributeSet* ConvertToAtkAttr
     objAttr->value = g_strdup(NS_ConvertUTF16toUTF8(value).get());
     objAttributeSet = g_slist_prepend(objAttributeSet, objAttr);
   }
 
   // libspi will free it
   return objAttributeSet;
 }
 
-AtkAttributeSet* GetAttributeSet(Accessible* aAccessible) {
+AtkAttributeSet* GetAttributeSet(LocalAccessible* aAccessible) {
   nsCOMPtr<nsIPersistentProperties> attributes = aAccessible->Attributes();
   if (attributes) return ConvertToAtkAttributeSet(attributes);
 
   return nullptr;
 }
 
 AtkAttributeSet* getAttributesCB(AtkObject* aAtkObj) {
   AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
@@ -766,17 +766,17 @@ AtkObject* refChildCB(AtkObject* aAtkObj
 
   AtkObject* childAtkObj = nullptr;
   AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
   if (accWrap) {
     if (nsAccUtils::MustPrune(accWrap)) {
       return nullptr;
     }
 
-    Accessible* accChild = accWrap->GetEmbeddedChildAt(aChildIndex);
+    LocalAccessible* accChild = accWrap->GetEmbeddedChildAt(aChildIndex);
     if (accChild) {
       childAtkObj = AccessibleWrap::GetAtkObject(accChild);
     } else {
       OuterDocAccessible* docOwner = accWrap->AsOuterDoc();
       if (docOwner) {
         ProxyAccessible* proxyDoc = docOwner->RemoteChildDoc();
         if (proxyDoc) childAtkObj = GetWrapperFor(proxyDoc);
       }
@@ -800,17 +800,17 @@ AtkObject* refChildCB(AtkObject* aAtkObj
   if (aAtkObj != childAtkObj->accessible_parent) {
     atk_object_set_parent(childAtkObj, aAtkObj);
   }
 
   return childAtkObj;
 }
 
 gint getIndexInParentCB(AtkObject* aAtkObj) {
-  // We don't use Accessible::IndexInParent() because we don't include text
+  // We don't use LocalAccessible::IndexInParent() because we don't include text
   // leaf nodes as children in ATK.
   if (ProxyAccessible* proxy = GetProxy(aAtkObj)) {
     if (ProxyAccessible* parent = proxy->RemoteParent()) {
       return parent->IndexOfEmbeddedChild(proxy);
     }
 
     if (proxy->OuterDocOfRemoteBrowser()) {
       return 0;
@@ -819,17 +819,17 @@ gint getIndexInParentCB(AtkObject* aAtkO
     return -1;
   }
 
   AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
   if (!accWrap) {
     return -1;
   }
 
-  Accessible* parent = accWrap->LocalParent();
+  LocalAccessible* parent = accWrap->LocalParent();
   if (!parent) return -1;  // No parent
 
   return parent->GetIndexOfEmbeddedChild(accWrap);
 }
 
 static void TranslateStates(uint64_t aState, roles::Role aRole,
                             AtkStateSet* aStateSet) {
   // atk doesn't have a read only state so read only things shouldn't be
@@ -867,28 +867,28 @@ AtkStateSet* refStateSetCB(AtkObject* aA
     TranslateStates(proxy->State(), proxy->Role(), state_set);
   } else {
     TranslateStates(states::DEFUNCT, roles::NOTHING, state_set);
   }
 
   return state_set;
 }
 
-static void UpdateAtkRelation(RelationType aType, Accessible* aAcc,
+static void UpdateAtkRelation(RelationType aType, LocalAccessible* aAcc,
                               AtkRelationType aAtkType,
                               AtkRelationSet* aAtkSet) {
   if (aAtkType == ATK_RELATION_NULL) return;
 
   AtkRelation* atkRelation =
       atk_relation_set_get_relation_by_type(aAtkSet, aAtkType);
   if (atkRelation) atk_relation_set_remove(aAtkSet, atkRelation);
 
   Relation rel(aAcc->RelationByType(aType));
   nsTArray<AtkObject*> targets;
-  Accessible* tempAcc = nullptr;
+  LocalAccessible* tempAcc = nullptr;
   while ((tempAcc = rel.Next())) {
     targets.AppendElement(AccessibleWrap::GetAtkObject(tempAcc));
   }
 
   if (aType == RelationType::EMBEDS && aAcc->IsRoot()) {
     if (ProxyAccessible* proxyDoc =
             aAcc->AsRoot()->GetPrimaryRemoteTopLevelContentDoc()) {
       targets.AppendElement(GetWrapperFor(proxyDoc));
@@ -958,17 +958,17 @@ AtkRelationSet* refRelationSetCB(AtkObje
 // Check if aAtkObj is a valid MaiAtkObject, and return the AccessibleWrap
 // for it.
 AccessibleWrap* GetAccessibleWrap(AtkObject* aAtkObj) {
   bool isMAIObject = IS_MAI_OBJECT(aAtkObj);
   NS_ENSURE_TRUE(isMAIObject || MAI_IS_ATK_SOCKET(aAtkObj), nullptr);
 
   AccessibleWrap* accWrap = nullptr;
   if (isMAIObject) {
-    Accessible* acc = MAI_ATK_OBJECT(aAtkObj)->accWrap.AsAccessible();
+    LocalAccessible* acc = MAI_ATK_OBJECT(aAtkObj)->accWrap.AsAccessible();
     accWrap = static_cast<AccessibleWrap*>(acc);
   } else {
     accWrap = MAI_ATK_SOCKET(aAtkObj)->accWrap;
   }
 
   // Check if the accessible was deconstructed.
   if (!accWrap) return nullptr;
 
@@ -1060,24 +1060,24 @@ void a11y::ProxyDestroyed(ProxyAccessibl
   }
 
   obj->Shutdown();
   g_object_unref(obj);
   aProxy->SetWrapper(0);
 }
 
 nsresult AccessibleWrap::HandleAccEvent(AccEvent* aEvent) {
-  nsresult rv = Accessible::HandleAccEvent(aEvent);
+  nsresult rv = LocalAccessible::HandleAccEvent(aEvent);
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (IPCAccessibilityActive()) {
     return NS_OK;
   }
 
-  Accessible* accessible = aEvent->GetAccessible();
+  LocalAccessible* accessible = aEvent->GetAccessible();
   NS_ENSURE_TRUE(accessible, NS_ERROR_FAILURE);
 
   // The accessible can become defunct if we have an xpcom event listener
   // which decides it would be fun to change the DOM and flush layout.
   if (accessible->IsDefunct()) return NS_OK;
 
   uint32_t type = aEvent->GetEventType();
 
@@ -1235,17 +1235,17 @@ nsresult AccessibleWrap::HandleAccEvent(
       break;
 
     case nsIAccessibleEvent::EVENT_SECTION_CHANGED:
       g_signal_emit_by_name(atkObj, "visible_data_changed");
       break;
 
     case nsIAccessibleEvent::EVENT_SHOW: {
       AccMutationEvent* event = downcast_accEvent(aEvent);
-      Accessible* parentAcc =
+      LocalAccessible* parentAcc =
           event ? event->LocalParent() : accessible->LocalParent();
       AtkObject* parent = AccessibleWrap::GetAtkObject(parentAcc);
       NS_ENSURE_STATE(parent);
       auto obj = reinterpret_cast<MaiAtkObject*>(atkObj);
       obj->FireAtkShowHideEvent(parent, true, aEvent->IsFromUserInput());
       return NS_OK;
     }
 
@@ -1253,17 +1253,17 @@ nsresult AccessibleWrap::HandleAccEvent(
       // XXX - Handle native dialog accessibles.
       if (!accessible->IsRoot() && accessible->HasARIARole() &&
           accessible->ARIARole() == roles::DIALOG) {
         guint id = g_signal_lookup("deactivate", MAI_TYPE_ATK_OBJECT);
         g_signal_emit(atkObj, id, 0);
       }
 
       AccMutationEvent* event = downcast_accEvent(aEvent);
-      Accessible* parentAcc =
+      LocalAccessible* parentAcc =
           event ? event->LocalParent() : accessible->LocalParent();
       AtkObject* parent = AccessibleWrap::GetAtkObject(parentAcc);
       NS_ENSURE_STATE(parent);
       auto obj = reinterpret_cast<MaiAtkObject*>(atkObj);
       obj->FireAtkShowHideEvent(parent, false, aEvent->IsFromUserInput());
       return NS_OK;
     }
 
@@ -1492,27 +1492,27 @@ void MaiAtkObject::FireAtkShowHideEvent(
 
 void a11y::ProxySelectionEvent(ProxyAccessible*, ProxyAccessible* aWidget,
                                uint32_t) {
   MaiAtkObject* obj = MAI_ATK_OBJECT(GetWrapperFor(aWidget));
   g_signal_emit_by_name(obj, "selection_changed");
 }
 
 // static
-void AccessibleWrap::GetKeyBinding(Accessible* aAccessible,
+void AccessibleWrap::GetKeyBinding(LocalAccessible* aAccessible,
                                    nsAString& aResult) {
   // Return all key bindings including access key and keyboard shortcut.
 
   // Get access key.
   nsAutoString keyBindingsStr;
   KeyBinding keyBinding = aAccessible->AccessKey();
   if (!keyBinding.IsEmpty()) {
     keyBinding.AppendToString(keyBindingsStr, KeyBinding::eAtkFormat);
 
-    Accessible* parent = aAccessible->LocalParent();
+    LocalAccessible* parent = aAccessible->LocalParent();
     roles::Role role = parent ? parent->Role() : roles::NOTHING;
     if (role == roles::PARENT_MENUITEM || role == roles::MENUITEM ||
         role == roles::RADIO_MENU_ITEM || role == roles::CHECK_MENU_ITEM) {
       // It is submenu, expose keyboard shortcuts from menu hierarchy like
       // "s;<Alt>f:s"
       nsAutoString keysInHierarchyStr = keyBindingsStr;
       do {
         KeyBinding parentKeyBinding = parent->AccessKey();
@@ -1539,72 +1539,72 @@ void AccessibleWrap::GetKeyBinding(Acces
   keyBinding = aAccessible->KeyboardShortcut();
   if (!keyBinding.IsEmpty()) {
     keyBinding.AppendToString(keyBindingsStr, KeyBinding::eAtkFormat);
   }
   aResult = keyBindingsStr;
 }
 
 // static
-Accessible* AccessibleWrap::GetColumnHeader(TableAccessible* aAccessible,
-                                            int32_t aColIdx) {
+LocalAccessible* AccessibleWrap::GetColumnHeader(TableAccessible* aAccessible,
+                                                 int32_t aColIdx) {
   if (!aAccessible) {
     return nullptr;
   }
 
-  Accessible* cell = aAccessible->CellAt(0, aColIdx);
+  LocalAccessible* cell = aAccessible->CellAt(0, aColIdx);
   if (!cell) {
     return nullptr;
   }
 
   // If the cell at the first row is column header then assume it is column
   // header for all rows,
   if (cell->Role() == roles::COLUMNHEADER) {
     return cell;
   }
 
   // otherwise get column header for the data cell at the first row.
   TableCellAccessible* tableCell = cell->AsTableCell();
   if (!tableCell) {
     return nullptr;
   }
 
-  AutoTArray<Accessible*, 10> headerCells;
+  AutoTArray<LocalAccessible*, 10> headerCells;
   tableCell->ColHeaderCells(&headerCells);
   if (headerCells.IsEmpty()) {
     return nullptr;
   }
 
   return headerCells[0];
 }
 
 // static
-Accessible* AccessibleWrap::GetRowHeader(TableAccessible* aAccessible,
-                                         int32_t aRowIdx) {
+LocalAccessible* AccessibleWrap::GetRowHeader(TableAccessible* aAccessible,
+                                              int32_t aRowIdx) {
   if (!aAccessible) {
     return nullptr;
   }
 
-  Accessible* cell = aAccessible->CellAt(aRowIdx, 0);
+  LocalAccessible* cell = aAccessible->CellAt(aRowIdx, 0);
   if (!cell) {
     return nullptr;
   }
 
   // If the cell at the first column is row header then assume it is row
   // header for all columns,
   if (cell->Role() == roles::ROWHEADER) {
     return cell;
   }
 
   // otherwise get row header for the data cell at the first column.
   TableCellAccessible* tableCell = cell->AsTableCell();
   if (!tableCell) {
     return nullptr;
   }
 
-  AutoTArray<Accessible*, 10> headerCells;
+  AutoTArray<LocalAccessible*, 10> headerCells;
   tableCell->RowHeaderCells(&headerCells);
   if (headerCells.IsEmpty()) {
     return nullptr;
   }
 
   return headerCells[0];
 }

--- a/accessible/atk/AccessibleWrap.h
+++ b/accessible/atk/AccessibleWrap.h
@@ -3,17 +3,17 @@
 /* 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 __NS_ACCESSIBLE_WRAP_H__
 #define __NS_ACCESSIBLE_WRAP_H__
 
 #include "nsCOMPtr.h"
-#include "Accessible.h"
+#include "LocalAccessible.h"
 
 struct _AtkObject;
 typedef struct _AtkObject AtkObject;
 
 enum AtkProperty {
   PROP_0,  // gobject convention
   PROP_NAME,
   PROP_DESCRIPTION,
@@ -40,45 +40,45 @@ namespace mozilla {
 namespace a11y {
 
 class MaiHyperlink;
 
 /**
  * AccessibleWrap, and its descendents in atk directory provide the
  * implementation of AtkObject.
  */
-class AccessibleWrap : public Accessible {
+class AccessibleWrap : public LocalAccessible {
  public:
   AccessibleWrap(nsIContent* aContent, DocAccessible* aDoc);
   virtual ~AccessibleWrap();
   void ShutdownAtkObject();
 
   virtual void Shutdown() override;
 
   // return the atk object for this AccessibleWrap
   virtual void GetNativeInterface(void** aOutAccessible) override;
   virtual nsresult HandleAccEvent(AccEvent* aEvent) override;
 
   AtkObject* GetAtkObject(void);
-  static AtkObject* GetAtkObject(Accessible* aAccessible);
+  static AtkObject* GetAtkObject(LocalAccessible* aAccessible);
 
   bool IsValidObject();
 
   static const char* ReturnString(nsAString& aString) {
     static nsCString returnedString;
     CopyUTF16toUTF8(aString, returnedString);
     return returnedString.get();
   }
 
-  static void GetKeyBinding(Accessible* aAccessible, nsAString& aResult);
+  static void GetKeyBinding(LocalAccessible* aAccessible, nsAString& aResult);
 
-  static Accessible* GetColumnHeader(TableAccessible* aAccessible,
-                                     int32_t aColIdx);
-  static Accessible* GetRowHeader(TableAccessible* aAccessible,
-                                  int32_t aRowIdx);
+  static LocalAccessible* GetColumnHeader(TableAccessible* aAccessible,
+                                          int32_t aColIdx);
+  static LocalAccessible* GetRowHeader(TableAccessible* aAccessible,
+                                       int32_t aRowIdx);
 
  protected:
   nsresult FireAtkStateChangeEvent(AccEvent* aEvent, AtkObject* aObject);
   nsresult FireAtkTextChangedEvent(AccEvent* aEvent, AtkObject* aObject);
 
   AtkObject* mAtkObject;
 
  private:

--- a/accessible/atk/ApplicationAccessibleWrap.cpp
+++ b/accessible/atk/ApplicationAccessibleWrap.cpp
@@ -44,23 +44,24 @@ gboolean toplevel_event_watcher(GSignalI
   AtkRole role = atk_object_get_role(child);
 
   // GTK native dialog
   if (!IS_MAI_OBJECT(child) &&
       (role == ATK_ROLE_DIALOG || role == ATK_ROLE_FILE_CHOOSER ||
        role == ATK_ROLE_COLOR_CHOOSER || role == ATK_ROLE_FONT_CHOOSER)) {
     if (data == reinterpret_cast<gpointer>(nsIAccessibleEvent::EVENT_SHOW)) {
       // Attach the dialog accessible to app accessible tree
-      Accessible* windowAcc = GetAccService()->AddNativeRootAccessible(child);
+      LocalAccessible* windowAcc =
+          GetAccService()->AddNativeRootAccessible(child);
       g_object_set_qdata(G_OBJECT(child), sQuark_gecko_acc_obj,
                          reinterpret_cast<gpointer>(windowAcc));
 
     } else {
       // Deattach the dialog accessible
-      Accessible* windowAcc = reinterpret_cast<Accessible*>(
+      LocalAccessible* windowAcc = reinterpret_cast<LocalAccessible*>(
           g_object_get_qdata(G_OBJECT(child), sQuark_gecko_acc_obj));
       if (windowAcc) {
         GetAccService()->RemoveNativeRootAccessible(windowAcc);
         g_object_set_qdata(G_OBJECT(child), sQuark_gecko_acc_obj, nullptr);
       }
     }
   }
 
@@ -105,17 +106,17 @@ gboolean fireRootAccessibleAddedCB(gpoin
   g_object_unref(eventData->app_accessible);
   g_object_unref(eventData->root_accessible);
   free(data);
 
   return FALSE;
 }
 
 bool ApplicationAccessibleWrap::InsertChildAt(uint32_t aIdx,
-                                              Accessible* aChild) {
+                                              LocalAccessible* aChild) {
   if (!ApplicationAccessible::InsertChildAt(aIdx, aChild)) return false;
 
   AtkObject* atkAccessible = AccessibleWrap::GetAtkObject(aChild);
   atk_object_set_parent(atkAccessible, mAtkObject);
 
   uint32_t count = mChildren.Length();
 
   // Emit children_changed::add in a timeout
@@ -129,17 +130,17 @@ bool ApplicationAccessibleWrap::InsertCh
     g_object_ref(mAtkObject);
     g_object_ref(atkAccessible);
     g_timeout_add(0, fireRootAccessibleAddedCB, eventData);
   }
 
   return true;
 }
 
-bool ApplicationAccessibleWrap::RemoveChild(Accessible* aChild) {
+bool ApplicationAccessibleWrap::RemoveChild(LocalAccessible* aChild) {
   int32_t index = aChild->IndexInParent();
 
   AtkObject* atkAccessible = AccessibleWrap::GetAtkObject(aChild);
   atk_object_set_parent(atkAccessible, nullptr);
   g_signal_emit_by_name(mAtkObject, "children_changed::remove", index,
                         atkAccessible, nullptr);
 
   return ApplicationAccessible::RemoveChild(aChild);

--- a/accessible/atk/ApplicationAccessibleWrap.h
+++ b/accessible/atk/ApplicationAccessibleWrap.h
@@ -12,20 +12,20 @@
 namespace mozilla {
 namespace a11y {
 
 class ApplicationAccessibleWrap : public ApplicationAccessible {
  public:
   ApplicationAccessibleWrap();
   virtual ~ApplicationAccessibleWrap();
 
-  // Accessible
+  // LocalAccessible
   virtual mozilla::a11y::ENameValueFlag Name(nsString& aName) const override;
-  virtual bool InsertChildAt(uint32_t aIdx, Accessible* aChild) override;
-  virtual bool RemoveChild(Accessible* aChild) override;
+  virtual bool InsertChildAt(uint32_t aIdx, LocalAccessible* aChild) override;
+  virtual bool RemoveChild(LocalAccessible* aChild) override;
 
   /**
    * Return the atk object for app root accessible.
    */
   virtual void GetNativeInterface(void** aOutAccessible) override;
 };
 
 }  // namespace a11y

--- a/accessible/atk/nsMaiHyperlink.cpp
+++ b/accessible/atk/nsMaiHyperlink.cpp
@@ -141,17 +141,17 @@ void finalizeCB(GObject* aObj) {
   }
 }
 
 gchar* getUriCB(AtkHyperlink* aLink, gint aLinkIndex) {
   MaiHyperlink* maiLink = GetMaiHyperlink(aLink);
   if (!maiLink) return nullptr;
 
   nsAutoCString cautoStr;
-  if (Accessible* hyperlink = maiLink->GetAccHyperlink()) {
+  if (LocalAccessible* hyperlink = maiLink->GetAccHyperlink()) {
     nsCOMPtr<nsIURI> uri = hyperlink->AnchorURIAt(aLinkIndex);
     if (!uri) return nullptr;
 
     nsresult rv = uri->GetSpec(cautoStr);
     NS_ENSURE_SUCCESS(rv, nullptr);
 
     return g_strdup(cautoStr.get());
   }
@@ -164,68 +164,68 @@ gchar* getUriCB(AtkHyperlink* aLink, gin
 }
 
 AtkObject* getObjectCB(AtkHyperlink* aLink, gint aLinkIndex) {
   MaiHyperlink* maiLink = GetMaiHyperlink(aLink);
   if (!maiLink) {
     return nullptr;
   }
 
-  if (Accessible* hyperlink = maiLink->GetAccHyperlink()) {
-    Accessible* anchor = hyperlink->AnchorAt(aLinkIndex);
+  if (LocalAccessible* hyperlink = maiLink->GetAccHyperlink()) {
+    LocalAccessible* anchor = hyperlink->AnchorAt(aLinkIndex);
     NS_ENSURE_TRUE(anchor, nullptr);
 
     return AccessibleWrap::GetAtkObject(anchor);
   }
 
   ProxyAccessible* anchor = maiLink->Proxy()->AnchorAt(aLinkIndex);
   return anchor ? GetWrapperFor(anchor) : nullptr;
 }
 
 gint getEndIndexCB(AtkHyperlink* aLink) {
   MaiHyperlink* maiLink = GetMaiHyperlink(aLink);
   if (!maiLink) return false;
 
-  if (Accessible* hyperlink = maiLink->GetAccHyperlink()) {
+  if (LocalAccessible* hyperlink = maiLink->GetAccHyperlink()) {
     return static_cast<gint>(hyperlink->EndOffset());
   }
 
   bool valid = false;
   uint32_t endIdx = maiLink->Proxy()->EndOffset(&valid);
   return valid ? static_cast<gint>(endIdx) : -1;
 }
 
 gint getStartIndexCB(AtkHyperlink* aLink) {
   MaiHyperlink* maiLink = GetMaiHyperlink(aLink);
   if (!maiLink) return -1;
 
-  if (Accessible* hyperlink = maiLink->GetAccHyperlink()) {
+  if (LocalAccessible* hyperlink = maiLink->GetAccHyperlink()) {
     return static_cast<gint>(hyperlink->StartOffset());
   }
 
   bool valid = false;
   uint32_t startIdx = maiLink->Proxy()->StartOffset(&valid);
   return valid ? static_cast<gint>(startIdx) : -1;
 }
 
 gboolean isValidCB(AtkHyperlink* aLink) {
   MaiHyperlink* maiLink = GetMaiHyperlink(aLink);
   if (!maiLink) return false;
 
-  if (Accessible* hyperlink = maiLink->GetAccHyperlink()) {
+  if (LocalAccessible* hyperlink = maiLink->GetAccHyperlink()) {
     return static_cast<gboolean>(hyperlink->IsLinkValid());
   }
 
   return static_cast<gboolean>(maiLink->Proxy()->IsLinkValid());
 }
 
 gint getAnchorCountCB(AtkHyperlink* aLink) {
   MaiHyperlink* maiLink = GetMaiHyperlink(aLink);
   if (!maiLink) return -1;
 
-  if (Accessible* hyperlink = maiLink->GetAccHyperlink()) {
+  if (LocalAccessible* hyperlink = maiLink->GetAccHyperlink()) {
     return static_cast<gint>(hyperlink->AnchorCount());
   }
 
   bool valid = false;
   uint32_t anchorCount = maiLink->Proxy()->AnchorCount(&valid);
   return valid ? static_cast<gint>(anchorCount) : -1;
 }

--- a/accessible/atk/nsMaiHyperlink.h
+++ b/accessible/atk/nsMaiHyperlink.h
@@ -3,17 +3,17 @@
 /* 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 __MAI_HYPERLINK_H__
 #define __MAI_HYPERLINK_H__
 
 #include "nsMai.h"
-#include "Accessible.h"
+#include "LocalAccessible.h"
 
 struct _AtkHyperlink;
 typedef struct _AtkHyperlink AtkHyperlink;
 
 namespace mozilla {
 namespace a11y {
 
 /*
@@ -22,20 +22,20 @@ namespace a11y {
 
 class MaiHyperlink {
  public:
   explicit MaiHyperlink(AccessibleOrProxy aHyperLink);
   ~MaiHyperlink();
 
  public:
   AtkHyperlink* GetAtkHyperlink() const { return mMaiAtkHyperlink; }
-  Accessible* GetAccHyperlink() {
+  LocalAccessible* GetAccHyperlink() {
     if (!mHyperlink.IsAccessible()) return nullptr;
 
-    Accessible* link = mHyperlink.AsAccessible();
+    LocalAccessible* link = mHyperlink.AsAccessible();
     if (!link) {
       return nullptr;
     }
 
     NS_ASSERTION(link->IsLink(), "Why isn't it a link!");
     return link;
   }
 

--- a/accessible/atk/nsMaiInterfaceAction.cpp
+++ b/accessible/atk/nsMaiInterfaceAction.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "nsMai.h"
 #include "Role.h"
 #include "mozilla/Likely.h"
 #include "ProxyAccessible.h"
 #include "nsString.h"
 
 using namespace mozilla::a11y;
 

--- a/accessible/atk/nsMaiInterfaceComponent.cpp
+++ b/accessible/atk/nsMaiInterfaceComponent.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "AccessibleWrap.h"
 #include "nsAccUtils.h"
 #include "nsCoreUtils.h"
 #include "nsMai.h"
 #include "mozilla/Likely.h"
 #include "mozilla/a11y/DocAccessibleParent.h"
 #include "mozilla/a11y/ProxyAccessible.h"
 #include "mozilla/dom/BrowserParent.h"
@@ -113,17 +113,17 @@ AtkObject* refAccessibleAtPointHelper(At
     }
     MOZ_ASSERT(node);
     nsIntPoint winCoords = nsCoreUtils::GetScreenCoordsForWindow(node);
     aX += winCoords.x;
     aY += winCoords.y;
   }
 
   AccessibleOrProxy accAtPoint =
-      acc.ChildAtPoint(aX, aY, Accessible::eDeepestChild);
+      acc.ChildAtPoint(aX, aY, LocalAccessible::eDeepestChild);
   if (accAtPoint.IsNull()) {
     return nullptr;
   }
   roles::Role role = accAtPoint.Role();
   if (role == roles::TEXT_LEAF || role == roles::STATICTEXT) {
     // We don't include text leaf nodes in the ATK tree, so return the parent.
     accAtPoint = accAtPoint.Parent();
     MOZ_ASSERT(!accAtPoint.IsNull(), "Text leaf should always have a parent");

--- a/accessible/atk/nsMaiInterfaceDocument.cpp
+++ b/accessible/atk/nsMaiInterfaceDocument.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "AccessibleWrap.h"
 #include "DocAccessible.h"
 #include "nsMai.h"
 #include "ProxyAccessible.h"
 #include "mozilla/Likely.h"
 
 using namespace mozilla::a11y;
 

--- a/accessible/atk/nsMaiInterfaceEditableText.cpp
+++ b/accessible/atk/nsMaiInterfaceEditableText.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "HyperTextAccessible-inl.h"
 #include "nsMai.h"
 #include "ProxyAccessible.h"
 #include "nsString.h"
 #include "mozilla/Likely.h"
 
 using namespace mozilla::a11y;
 

--- a/accessible/atk/nsMaiInterfaceHypertext.cpp
+++ b/accessible/atk/nsMaiInterfaceHypertext.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "HyperTextAccessible.h"
 #include "nsMai.h"
 #include "nsMaiHyperlink.h"
 #include "ProxyAccessible.h"
 #include "mozilla/Likely.h"
 
 using namespace mozilla::a11y;
 
@@ -19,17 +19,17 @@ extern "C" {
 
 static AtkHyperlink* getLinkCB(AtkHypertext* aText, gint aLinkIndex) {
   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
   AtkObject* atkHyperLink = nullptr;
   if (accWrap) {
     HyperTextAccessible* hyperText = accWrap->AsHyperText();
     NS_ENSURE_TRUE(hyperText, nullptr);
 
-    Accessible* hyperLink = hyperText->LinkAt(aLinkIndex);
+    LocalAccessible* hyperLink = hyperText->LinkAt(aLinkIndex);
     if (!hyperLink || !hyperLink->IsLink()) {
       return nullptr;
     }
 
     atkHyperLink = AccessibleWrap::GetAtkObject(hyperLink);
   } else if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aText))) {
     ProxyAccessible* proxyLink = proxy->LinkAt(aLinkIndex);
     if (!proxyLink) return nullptr;

--- a/accessible/atk/nsMaiInterfaceSelection.cpp
+++ b/accessible/atk/nsMaiInterfaceSelection.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "AccessibleWrap.h"
 #include "nsMai.h"
 #include "ProxyAccessible.h"
 #include "mozilla/Likely.h"
 
 #include <atk/atk.h>
 
 using namespace mozilla::a11y;
@@ -43,17 +43,17 @@ static gboolean clearSelectionCB(AtkSele
 
   return FALSE;
 }
 
 static AtkObject* refSelectionCB(AtkSelection* aSelection, gint i) {
   AtkObject* atkObj = nullptr;
   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
   if (accWrap && accWrap->IsSelect()) {
-    Accessible* selectedItem = accWrap->GetSelectedItem(i);
+    LocalAccessible* selectedItem = accWrap->GetSelectedItem(i);
     if (!selectedItem) {
       return nullptr;
     }
 
     atkObj = AccessibleWrap::GetAtkObject(selectedItem);
   } else if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aSelection))) {
     ProxyAccessible* selectedItem = proxy->GetSelectedItem(i);
     if (selectedItem) {

--- a/accessible/atk/nsMaiInterfaceTable.cpp
+++ b/accessible/atk/nsMaiInterfaceTable.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "AccessibleWrap.h"
 #include "nsAccUtils.h"
 #include "TableAccessible.h"
 #include "TableCellAccessible.h"
 #include "nsMai.h"
 #include "ProxyAccessible.h"
 #include "nsArrayUtils.h"
 
@@ -23,17 +23,17 @@ extern "C" {
 static AtkObject* refAtCB(AtkTable* aTable, gint aRowIdx, gint aColIdx) {
   if (aRowIdx < 0 || aColIdx < 0) {
     return nullptr;
   }
 
   AtkObject* cellAtkObj = nullptr;
   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
   if (accWrap) {
-    Accessible* cell = accWrap->AsTable()->CellAt(aRowIdx, aColIdx);
+    LocalAccessible* cell = accWrap->AsTable()->CellAt(aRowIdx, aColIdx);
     if (!cell) {
       return nullptr;
     }
 
     cellAtkObj = AccessibleWrap::GetAtkObject(cell);
   } else if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aTable))) {
     ProxyAccessible* cell = proxy->TableCellAt(aRowIdx, aColIdx);
     if (!cell) {
@@ -155,17 +155,17 @@ static gint getRowExtentAtCB(AtkTable* a
   }
 
   return -1;
 }
 
 static AtkObject* getCaptionCB(AtkTable* aTable) {
   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
   if (accWrap) {
-    Accessible* caption = accWrap->AsTable()->Caption();
+    LocalAccessible* caption = accWrap->AsTable()->Caption();
     return caption ? AccessibleWrap::GetAtkObject(caption) : nullptr;
   }
 
   if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aTable))) {
     ProxyAccessible* caption = proxy->TableCaption();
     return caption ? GetWrapperFor(caption) : nullptr;
   }
 
@@ -184,17 +184,17 @@ static const gchar* getColumnDescription
   }
 
   return AccessibleWrap::ReturnString(autoStr);
 }
 
 static AtkObject* getColumnHeaderCB(AtkTable* aTable, gint aColIdx) {
   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
   if (accWrap) {
-    Accessible* header =
+    LocalAccessible* header =
         AccessibleWrap::GetColumnHeader(accWrap->AsTable(), aColIdx);
     return header ? AccessibleWrap::GetAtkObject(header) : nullptr;
   }
 
   if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aTable))) {
     ProxyAccessible* header = proxy->AtkTableColumnHeader(aColIdx);
     return header ? GetWrapperFor(header) : nullptr;
   }
@@ -214,17 +214,17 @@ static const gchar* getRowDescriptionCB(
   }
 
   return AccessibleWrap::ReturnString(autoStr);
 }
 
 static AtkObject* getRowHeaderCB(AtkTable* aTable, gint aRowIdx) {
   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
   if (accWrap) {
-    Accessible* header =
+    LocalAccessible* header =
         AccessibleWrap::GetRowHeader(accWrap->AsTable(), aRowIdx);
     return header ? AccessibleWrap::GetAtkObject(header) : nullptr;
   }
 
   if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aTable))) {
     ProxyAccessible* header = proxy->AtkTableRowHeader(aRowIdx);
     return header ? GetWrapperFor(header) : nullptr;
   }

--- a/accessible/atk/nsMaiInterfaceTableCell.cpp
+++ b/accessible/atk/nsMaiInterfaceTableCell.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "AccessibleWrap.h"
 #include "nsAccUtils.h"
 #include "TableAccessible.h"
 #include "TableCellAccessible.h"
 #include "nsMai.h"
 #include "ProxyAccessible.h"
 #include "nsArrayUtils.h"
 
@@ -98,38 +98,38 @@ static gboolean GetColumnRowSpanCB(AtkTa
 static AtkObject* GetTableCB(AtkTableCell* aTableCell) {
   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTableCell));
   if (accWrap) {
     TableAccessible* table = accWrap->AsTableCell()->Table();
     if (!table) {
       return nullptr;
     }
 
-    Accessible* tableAcc = table->AsAccessible();
+    LocalAccessible* tableAcc = table->AsAccessible();
     return tableAcc ? AccessibleWrap::GetAtkObject(tableAcc) : nullptr;
   }
 
   if (ProxyAccessible* proxy = GetProxy(ATK_OBJECT(aTableCell))) {
     ProxyAccessible* table = proxy->TableOfACell();
     return table ? GetWrapperFor(table) : nullptr;
   }
 
   return nullptr;
 }
 
 static GPtrArray* GetColumnHeaderCellsCB(AtkTableCell* aCell) {
   if (AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aCell))) {
-    AutoTArray<Accessible*, 10> headers;
+    AutoTArray<LocalAccessible*, 10> headers;
     accWrap->AsTableCell()->ColHeaderCells(&headers);
     if (headers.IsEmpty()) {
       return nullptr;
     }
 
     GPtrArray* atkHeaders = g_ptr_array_sized_new(headers.Length());
-    for (Accessible* header : headers) {
+    for (LocalAccessible* header : headers) {
       AtkObject* atkHeader = AccessibleWrap::GetAtkObject(header);
       g_object_ref(atkHeader);
       g_ptr_array_add(atkHeaders, atkHeader);
     }
 
     return atkHeaders;
   }
 
@@ -150,24 +150,24 @@ static GPtrArray* GetColumnHeaderCellsCB
     return atkHeaders;
   }
 
   return nullptr;
 }
 
 static GPtrArray* GetRowHeaderCellsCB(AtkTableCell* aCell) {
   if (AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aCell))) {
-    AutoTArray<Accessible*, 10> headers;
+    AutoTArray<LocalAccessible*, 10> headers;
     accWrap->AsTableCell()->RowHeaderCells(&headers);
     if (headers.IsEmpty()) {
       return nullptr;
     }
 
     GPtrArray* atkHeaders = g_ptr_array_sized_new(headers.Length());
-    for (Accessible* header : headers) {
+    for (LocalAccessible* header : headers) {
       AtkObject* atkHeader = AccessibleWrap::GetAtkObject(header);
       g_object_ref(atkHeader);
       g_ptr_array_add(atkHeaders, atkHeader);
     }
 
     return atkHeaders;
   }
 

--- a/accessible/atk/nsMaiInterfaceText.cpp
+++ b/accessible/atk/nsMaiInterfaceText.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=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/. */
 
 #include "InterfaceInitFuncs.h"
 #include "mozilla/a11y/PDocAccessible.h"
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 #include "HyperTextAccessible-inl.h"
 #include "nsMai.h"
 #include "ProxyAccessible.h"
 
 #include "nsIAccessibleTypes.h"
 #include "nsIPersistentProperties2.h"
 #include "nsISimpleEnumerator.h"
 #include "nsUTF8Utils.h"

--- a/accessible/base/ARIAMap.h
+++ b/accessible/base/ARIAMap.h
@@ -167,17 +167,17 @@ struct nsRoleMapEntry {
 
   // Action mapping rule, how to expose accessible action
   EActionRule actionRule;
 
   // 'live' and 'container-live' object attributes mapping rule: how to expose
   // these object attributes if ARIA 'live' attribute is missed.
   ELiveAttrRule liveAttRule;
 
-  // Accessible types this role belongs to.
+  // LocalAccessible types this role belongs to.
   uint32_t accTypes;
 
   // Automatic state mapping rule: always include in states
   uint64_t state;  // or kNoReqStates if no default state for this role
 
   // ARIA properties supported for this role (in other words, the aria-foo
   // attribute to accessible states mapping rules).
   // Currently you cannot have unlimited mappings, because

--- a/accessible/base/AccEvent.cpp
+++ b/accessible/base/AccEvent.cpp
@@ -29,17 +29,17 @@ static_assert(static_cast<bool>(eNoUserI
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccEvent
 ////////////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccEvent constructors
 
-AccEvent::AccEvent(uint32_t aEventType, Accessible* aAccessible,
+AccEvent::AccEvent(uint32_t aEventType, LocalAccessible* aAccessible,
                    EIsFromUserInput aIsFromUserInput, EEventRule aEventRule)
     : mEventType(aEventType), mEventRule(aEventRule), mAccessible(aAccessible) {
   if (aIsFromUserInput == eAutoDetect) {
     mIsFromUserInput = dom::UserActivation::IsHandlingUserInput();
   } else {
     mIsFromUserInput = aIsFromUserInput == eFromUserInput ? true : false;
   }
 }
@@ -75,17 +75,18 @@ NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(A
 
 // Note: we pass in eAllowDupes to the base class because we don't support text
 // events coalescence. We fire delayed text change events in DocAccessible but
 // we continue to base the event off the accessible object rather than just the
 // node. This means we won't try to create an accessible based on the node when
 // we are ready to fire the event and so we will no longer assert at that point
 // if the node was removed from the document. Either way, the AT won't work with
 // a defunct accessible so the behaviour should be equivalent.
-AccTextChangeEvent::AccTextChangeEvent(Accessible* aAccessible, int32_t aStart,
+AccTextChangeEvent::AccTextChangeEvent(LocalAccessible* aAccessible,
+                                       int32_t aStart,
                                        const nsAString& aModifiedText,
                                        bool aIsInserted,
                                        EIsFromUserInput aIsFromUserInput)
     : AccEvent(
           aIsInserted
               ? static_cast<uint32_t>(nsIAccessibleEvent::EVENT_TEXT_INSERTED)
               : static_cast<uint32_t>(nsIAccessibleEvent::EVENT_TEXT_REMOVED),
           aAccessible, aIsFromUserInput, eAllowDupes),
@@ -97,28 +98,28 @@ AccTextChangeEvent::AccTextChangeEvent(A
   mIsFromUserInput =
       mAccessible->State() & (states::FOCUSED | states::EDITABLE);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccHideEvent
 ////////////////////////////////////////////////////////////////////////////////
 
-AccHideEvent::AccHideEvent(Accessible* aTarget, bool aNeedsShutdown)
+AccHideEvent::AccHideEvent(LocalAccessible* aTarget, bool aNeedsShutdown)
     : AccMutationEvent(::nsIAccessibleEvent::EVENT_HIDE, aTarget),
       mNeedsShutdown(aNeedsShutdown) {
   mNextSibling = mAccessible->LocalNextSibling();
   mPrevSibling = mAccessible->LocalPrevSibling();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccShowEvent
 ////////////////////////////////////////////////////////////////////////////////
 
-AccShowEvent::AccShowEvent(Accessible* aTarget)
+AccShowEvent::AccShowEvent(LocalAccessible* aTarget)
     : AccMutationEvent(::nsIAccessibleEvent::EVENT_SHOW, aTarget) {
   int32_t idx = aTarget->IndexInParent();
   MOZ_ASSERT(idx >= 0);
   mInsertionIndex = idx;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccTextSelChangeEvent
@@ -144,17 +145,18 @@ void AccTextSelChangeEvent::SelectionRan
     nsTArray<TextRange>* aRanges) const {
   TextRange::TextRangesFromSelection(mSel, aRanges);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccSelChangeEvent
 ////////////////////////////////////////////////////////////////////////////////
 
-AccSelChangeEvent::AccSelChangeEvent(Accessible* aWidget, Accessible* aItem,
+AccSelChangeEvent::AccSelChangeEvent(LocalAccessible* aWidget,
+                                     LocalAccessible* aItem,
                                      SelChangeType aSelChangeType)
     : AccEvent(0, aItem, eAutoDetect, eCoalesceSelectionChange),
       mWidget(aWidget),
       mItem(aItem),
       mSelChangeType(aSelChangeType),
       mPreceedingCount(0),
       mPackedEvent(nullptr) {
   if (aSelChangeType == eSelectionAdd) {
@@ -167,49 +169,49 @@ AccSelChangeEvent::AccSelChangeEvent(Acc
     mEventType = nsIAccessibleEvent::EVENT_SELECTION_REMOVE;
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccTableChangeEvent
 ////////////////////////////////////////////////////////////////////////////////
 
-AccTableChangeEvent::AccTableChangeEvent(Accessible* aAccessible,
+AccTableChangeEvent::AccTableChangeEvent(LocalAccessible* aAccessible,
                                          uint32_t aEventType,
                                          int32_t aRowOrColIndex,
                                          int32_t aNumRowsOrCols)
     : AccEvent(aEventType, aAccessible),
       mRowOrColIndex(aRowOrColIndex),
       mNumRowsOrCols(aNumRowsOrCols) {}
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccVCChangeEvent
 ////////////////////////////////////////////////////////////////////////////////
 
-AccVCChangeEvent::AccVCChangeEvent(Accessible* aAccessible,
-                                   Accessible* aOldAccessible,
+AccVCChangeEvent::AccVCChangeEvent(LocalAccessible* aAccessible,
+                                   LocalAccessible* aOldAccessible,
                                    int32_t aOldStart, int32_t aOldEnd,
-                                   Accessible* aNewAccessible,
+                                   LocalAccessible* aNewAccessible,
                                    int32_t aNewStart, int32_t aNewEnd,
                                    int16_t aReason, int16_t aBoundaryType,
                                    EIsFromUserInput aIsFromUserInput)
     : AccEvent(::nsIAccessibleEvent::EVENT_VIRTUALCURSOR_CHANGED, aAccessible,
                aIsFromUserInput),
       mOldAccessible(aOldAccessible),
       mNewAccessible(aNewAccessible),
       mOldStart(aOldStart),
       mNewStart(aNewStart),
       mOldEnd(aOldEnd),
       mNewEnd(aNewEnd),
       mReason(aReason),
       mBoundaryType(aBoundaryType) {}
 
 already_AddRefed<nsIAccessibleEvent> a11y::MakeXPCEvent(AccEvent* aEvent) {
   DocAccessible* doc = aEvent->Document();
-  Accessible* acc = aEvent->GetAccessible();
+  LocalAccessible* acc = aEvent->GetAccessible();
   nsINode* node = acc->GetNode();
   bool fromUser = aEvent->IsFromUserInput();
   uint32_t type = aEvent->GetEventType();
   uint32_t eventGroup = aEvent->GetEventGroups();
   nsCOMPtr<nsIAccessibleEvent> xpEvent;
 
   if (eventGroup & (1 << AccEvent::eStateChangeEvent)) {
     AccStateChangeEvent* sc = downcast_accEvent(aEvent);

--- a/accessible/base/AccEvent.h
+++ b/accessible/base/AccEvent.h
@@ -3,17 +3,17 @@
  * 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 _AccEvent_H_
 #define _AccEvent_H_
 
 #include "nsIAccessibleEvent.h"
 
-#include "mozilla/a11y/Accessible.h"
+#include "mozilla/a11y/LocalAccessible.h"
 
 class nsEventShell;
 namespace mozilla {
 
 namespace dom {
 class Selection;
 }
 
@@ -67,29 +67,29 @@ class AccEvent {
     //    will be emitted.
     eRemoveDupes,
 
     // eDoNotEmit : This event is confirmed as a duplicate, do not emit it.
     eDoNotEmit
   };
 
   // Initialize with an accessible.
-  AccEvent(uint32_t aEventType, Accessible* aAccessible,
+  AccEvent(uint32_t aEventType, LocalAccessible* aAccessible,
            EIsFromUserInput aIsFromUserInput = eAutoDetect,
            EEventRule aEventRule = eRemoveDupes);
 
   // AccEvent
   uint32_t GetEventType() const { return mEventType; }
   EEventRule GetEventRule() const { return mEventRule; }
   bool IsFromUserInput() const { return mIsFromUserInput; }
   EIsFromUserInput FromUserInput() const {
     return static_cast<EIsFromUserInput>(mIsFromUserInput);
   }
 
-  Accessible* GetAccessible() const { return mAccessible; }
+  LocalAccessible* GetAccessible() const { return mAccessible; }
   DocAccessible* Document() const { return mAccessible->Document(); }
 
   /**
    * Down casting.
    */
   enum EventGroup {
     eGenericEvent,
     eStateChangeEvent,
@@ -119,37 +119,38 @@ class AccEvent {
   NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(AccEvent)
 
  protected:
   virtual ~AccEvent() {}
 
   bool mIsFromUserInput;
   uint32_t mEventType;
   EEventRule mEventRule;
-  RefPtr<Accessible> mAccessible;
+  RefPtr<LocalAccessible> mAccessible;
 
   friend class EventQueue;
   friend class EventTree;
   friend class ::nsEventShell;
   friend class NotificationController;
 };
 
 /**
  * Accessible state change event.
  */
 class AccStateChangeEvent : public AccEvent {
  public:
-  AccStateChangeEvent(Accessible* aAccessible, uint64_t aState, bool aIsEnabled,
+  AccStateChangeEvent(LocalAccessible* aAccessible, uint64_t aState,
+                      bool aIsEnabled,
                       EIsFromUserInput aIsFromUserInput = eAutoDetect)
       : AccEvent(nsIAccessibleEvent::EVENT_STATE_CHANGE, aAccessible,
                  aIsFromUserInput, eCoalesceStateChange),
         mState(aState),
         mIsEnabled(aIsEnabled) {}
 
-  AccStateChangeEvent(Accessible* aAccessible, uint64_t aState)
+  AccStateChangeEvent(LocalAccessible* aAccessible, uint64_t aState)
       : AccEvent(::nsIAccessibleEvent::EVENT_STATE_CHANGE, aAccessible,
                  eAutoDetect, eCoalesceStateChange),
         mState(aState) {
     mIsEnabled = (mAccessible->State() & mState) != 0;
   }
 
   // AccEvent
   static const EventGroup kEventGroup = eStateChangeEvent;
@@ -168,17 +169,17 @@ class AccStateChangeEvent : public AccEv
   friend class EventQueue;
 };
 
 /**
  * Accessible text change event.
  */
 class AccTextChangeEvent : public AccEvent {
  public:
-  AccTextChangeEvent(Accessible* aAccessible, int32_t aStart,
+  AccTextChangeEvent(LocalAccessible* aAccessible, int32_t aStart,
                      const nsAString& aModifiedText, bool aIsInserted,
                      EIsFromUserInput aIsFromUserInput = eAutoDetect);
 
   // AccEvent
   static const EventGroup kEventGroup = eTextChangeEvent;
   virtual unsigned int GetEventGroups() const override {
     return AccEvent::GetEventGroups() | (1U << eTextChangeEvent);
   }
@@ -202,17 +203,17 @@ class AccTextChangeEvent : public AccEve
 };
 
 /**
  * A base class for events related to tree mutation, either an AccMutation
  * event, or an AccReorderEvent.
  */
 class AccTreeMutationEvent : public AccEvent {
  public:
-  AccTreeMutationEvent(uint32_t aEventType, Accessible* aTarget)
+  AccTreeMutationEvent(uint32_t aEventType, LocalAccessible* aTarget)
       : AccEvent(aEventType, aTarget, eAutoDetect, eCoalesceReorder),
         mGeneration(0) {}
 
   // Event
   static const EventGroup kEventGroup = eTreeMutationEvent;
   virtual unsigned int GetEventGroups() const override {
     return AccEvent::GetEventGroups() | (1U << eTreeMutationEvent);
   }
@@ -234,17 +235,17 @@ class AccTreeMutationEvent : public AccE
   uint32_t mGeneration;
 };
 
 /**
  * Base class for show and hide accessible events.
  */
 class AccMutationEvent : public AccTreeMutationEvent {
  public:
-  AccMutationEvent(uint32_t aEventType, Accessible* aTarget)
+  AccMutationEvent(uint32_t aEventType, LocalAccessible* aTarget)
       : AccTreeMutationEvent(aEventType, aTarget) {
     // Don't coalesce these since they are coalesced by reorder event. Coalesce
     // contained text change events.
     mParent = mAccessible->LocalParent();
   }
   virtual ~AccMutationEvent() {}
 
   // Event
@@ -252,61 +253,61 @@ class AccMutationEvent : public AccTreeM
   virtual unsigned int GetEventGroups() const override {
     return AccTreeMutationEvent::GetEventGroups() | (1U << eMutationEvent);
   }
 
   // MutationEvent
   bool IsShow() const { return mEventType == nsIAccessibleEvent::EVENT_SHOW; }
   bool IsHide() const { return mEventType == nsIAccessibleEvent::EVENT_HIDE; }
 
-  Accessible* LocalParent() const { return mParent; }
+  LocalAccessible* LocalParent() const { return mParent; }
 
  protected:
   nsCOMPtr<nsINode> mNode;
-  RefPtr<Accessible> mParent;
+  RefPtr<LocalAccessible> mParent;
   RefPtr<AccTextChangeEvent> mTextChangeEvent;
 
   friend class EventTree;
   friend class NotificationController;
 };
 
 /**
  * Accessible hide event.
  */
 class AccHideEvent : public AccMutationEvent {
  public:
-  explicit AccHideEvent(Accessible* aTarget, bool aNeedsShutdown = true);
+  explicit AccHideEvent(LocalAccessible* aTarget, bool aNeedsShutdown = true);
 
   // Event
   static const EventGroup kEventGroup = eHideEvent;
   virtual unsigned int GetEventGroups() const override {
     return AccMutationEvent::GetEventGroups() | (1U << eHideEvent);
   }
 
   // AccHideEvent
-  Accessible* TargetParent() const { return mParent; }
-  Accessible* TargetNextSibling() const { return mNextSibling; }
-  Accessible* TargetPrevSibling() const { return mPrevSibling; }
+  LocalAccessible* TargetParent() const { return mParent; }
+  LocalAccessible* TargetNextSibling() const { return mNextSibling; }
+  LocalAccessible* TargetPrevSibling() const { return mPrevSibling; }
   bool NeedsShutdown() const { return mNeedsShutdown; }
 
  protected:
   bool mNeedsShutdown;
-  RefPtr<Accessible> mNextSibling;
-  RefPtr<Accessible> mPrevSibling;
+  RefPtr<LocalAccessible> mNextSibling;
+  RefPtr<LocalAccessible> mPrevSibling;
 
   friend class EventTree;
   friend class NotificationController;
 };
 
 /**
  * Accessible show event.
  */
 class AccShowEvent : public AccMutationEvent {
  public:
-  explicit AccShowEvent(Accessible* aTarget);
+  explicit AccShowEvent(LocalAccessible* aTarget);
 
   // Event
   static const EventGroup kEventGroup = eShowEvent;
   virtual unsigned int GetEventGroups() const override {
     return AccMutationEvent::GetEventGroups() | (1U << eShowEvent);
   }
 
   uint32_t InsertionIndex() const { return mInsertionIndex; }
@@ -318,33 +319,33 @@ class AccShowEvent : public AccMutationE
   friend class EventTree;
 };
 
 /**
  * Class for reorder accessible event. Takes care about
  */
 class AccReorderEvent : public AccTreeMutationEvent {
  public:
-  explicit AccReorderEvent(Accessible* aTarget)
+  explicit AccReorderEvent(LocalAccessible* aTarget)
       : AccTreeMutationEvent(::nsIAccessibleEvent::EVENT_REORDER, aTarget) {}
   virtual ~AccReorderEvent() {}
 
   // Event
   static const EventGroup kEventGroup = eReorderEvent;
   virtual unsigned int GetEventGroups() const override {
     return AccTreeMutationEvent::GetEventGroups() | (1U << eReorderEvent);
   }
 };
 
 /**
  * Accessible caret move event.
  */
 class AccCaretMoveEvent : public AccEvent {
  public:
-  AccCaretMoveEvent(Accessible* aAccessible, int32_t aCaretOffset,
+  AccCaretMoveEvent(LocalAccessible* aAccessible, int32_t aCaretOffset,
                     bool aIsSelectionCollapsed,
                     EIsFromUserInput aIsFromUserInput = eAutoDetect)
       : AccEvent(::nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED, aAccessible,
                  aIsFromUserInput),
         mCaretOffset(aCaretOffset),
         mIsSelectionCollapsed(aIsSelectionCollapsed) {}
   virtual ~AccCaretMoveEvent() {}
 
@@ -402,46 +403,46 @@ class AccTextSelChangeEvent : public Acc
 
 /**
  * Accessible widget selection change event.
  */
 class AccSelChangeEvent : public AccEvent {
  public:
   enum SelChangeType { eSelectionAdd, eSelectionRemove };
 
-  AccSelChangeEvent(Accessible* aWidget, Accessible* aItem,
+  AccSelChangeEvent(LocalAccessible* aWidget, LocalAccessible* aItem,
                     SelChangeType aSelChangeType);
 
   virtual ~AccSelChangeEvent() {}
 
   // AccEvent
   static const EventGroup kEventGroup = eSelectionChangeEvent;
   virtual unsigned int GetEventGroups() const override {
     return AccEvent::GetEventGroups() | (1U << eSelectionChangeEvent);
   }
 
   // AccSelChangeEvent
-  Accessible* Widget() const { return mWidget; }
+  LocalAccessible* Widget() const { return mWidget; }
 
  private:
-  RefPtr<Accessible> mWidget;
-  RefPtr<Accessible> mItem;
+  RefPtr<LocalAccessible> mWidget;
+  RefPtr<LocalAccessible> mItem;
   SelChangeType mSelChangeType;
   uint32_t mPreceedingCount;
   AccSelChangeEvent* mPackedEvent;
 
   friend class EventQueue;
 };
 
 /**
  * Accessible table change event.
  */
 class AccTableChangeEvent : public AccEvent {
  public:
-  AccTableChangeEvent(Accessible* aAccessible, uint32_t aEventType,
+  AccTableChangeEvent(LocalAccessible* aAccessible, uint32_t aEventType,
                       int32_t aRowOrColIndex, int32_t aNumRowsOrCols);
 
   // AccEvent
   static const EventGroup kEventGroup = eTableChangeEvent;
   virtual unsigned int GetEventGroups() const override {
     return AccEvent::GetEventGroups() | (1U << eTableChangeEvent);
   }
 
@@ -455,57 +456,58 @@ class AccTableChangeEvent : public AccEv
   uint32_t mNumRowsOrCols;  // the number of inserted/deleted rows/columns
 };
 
 /**
  * Accessible virtual cursor change event.
  */
 class AccVCChangeEvent : public AccEvent {
  public:
-  AccVCChangeEvent(Accessible* aAccessible, Accessible* aOldAccessible,
-                   int32_t aOldStart, int32_t aOldEnd,
-                   Accessible* aNewAccessible, int32_t aNewStart,
-                   int32_t aNewEnd, int16_t aReason, int16_t aBoundaryType,
+  AccVCChangeEvent(LocalAccessible* aAccessible,
+                   LocalAccessible* aOldAccessible, int32_t aOldStart,
+                   int32_t aOldEnd, LocalAccessible* aNewAccessible,
+                   int32_t aNewStart, int32_t aNewEnd, int16_t aReason,
+                   int16_t aBoundaryType,
                    EIsFromUserInput aIsFromUserInput = eFromUserInput);
 
   virtual ~AccVCChangeEvent() {}
 
   // AccEvent
   static const EventGroup kEventGroup = eVirtualCursorChangeEvent;
   virtual unsigned int GetEventGroups() const override {
     return AccEvent::GetEventGroups() | (1U << eVirtualCursorChangeEvent);
   }
 
   // AccVCChangeEvent
-  Accessible* OldAccessible() const { return mOldAccessible; }
+  LocalAccessible* OldAccessible() const { return mOldAccessible; }
   int32_t OldStartOffset() const { return mOldStart; }
   int32_t OldEndOffset() const { return mOldEnd; }
-  Accessible* NewAccessible() const { return mNewAccessible; }
+  LocalAccessible* NewAccessible() const { return mNewAccessible; }
   int32_t NewStartOffset() const { return mNewStart; }
   int32_t NewEndOffset() const { return mNewEnd; }
   int32_t Reason() const { return mReason; }
   int32_t BoundaryType() const { return mBoundaryType; }
 
  private:
-  RefPtr<Accessible> mOldAccessible;
-  RefPtr<Accessible> mNewAccessible;
+  RefPtr<LocalAccessible> mOldAccessible;
+  RefPtr<LocalAccessible> mNewAccessible;
   int32_t mOldStart;
   int32_t mNewStart;
   int32_t mOldEnd;
   int32_t mNewEnd;
   int16_t mReason;
   int16_t mBoundaryType;
 };
 
 /**
  * Accessible object attribute changed event.
  */
 class AccObjectAttrChangedEvent : public AccEvent {
  public:
-  AccObjectAttrChangedEvent(Accessible* aAccessible, nsAtom* aAttribute)
+  AccObjectAttrChangedEvent(LocalAccessible* aAccessible, nsAtom* aAttribute)
       : AccEvent(::nsIAccessibleEvent::EVENT_OBJECT_ATTRIBUTE_CHANGED,
                  aAccessible),
         mAttribute(aAttribute) {}
 
   // AccEvent
   static const EventGroup kEventGroup = eObjectAttrChangedEvent;
   virtual unsigned int GetEventGroups() const override {
     return AccEvent::GetEventGroups() | (1U << eObjectAttrChangedEvent);
@@ -520,17 +522,17 @@ class AccObjectAttrChangedEvent : public
   virtual ~AccObjectAttrChangedEvent() {}
 };
 
 /**
  * Accessible scroll event.
  */
 class AccScrollingEvent : public AccEvent {
  public:
-  AccScrollingEvent(uint32_t aEventType, Accessible* aAccessible,
+  AccScrollingEvent(uint32_t aEventType, LocalAccessible* aAccessible,
                     uint32_t aScrollX, uint32_t aScrollY, uint32_t aMaxScrollX,
                     uint32_t aMaxScrollY)
       : AccEvent(aEventType, aAccessible),
         mScrollX(aScrollX),
         mScrollY(aScrollY),
         mMaxScrollX(aMaxScrollX),
         mMaxScrollY(aMaxScrollY) {}
 
@@ -558,18 +560,18 @@ class AccScrollingEvent : public AccEven
   uint32_t mMaxScrollY;
 };
 
 /**
  * Accessible announcement event.
  */
 class AccAnnouncementEvent : public AccEvent {
  public:
-  AccAnnouncementEvent(Accessible* aAccessible, const nsAString& aAnnouncement,
-                       uint16_t aPriority)
+  AccAnnouncementEvent(LocalAccessible* aAccessible,
+                       const nsAString& aAnnouncement, uint16_t aPriority)
       : AccEvent(nsIAccessibleEvent::EVENT_ANNOUNCEMENT, aAccessible),
         mAnnouncement(aAnnouncement),
         mPriority(aPriority) {}
 
   virtual ~AccAnnouncementEvent() {}
 
   // AccEvent
   static const EventGroup kEventGroup = eAnnouncementEvent;

--- a/accessible/base/AccGroupInfo.cpp
+++ b/accessible/base/AccGroupInfo.cpp
@@ -6,42 +6,42 @@
 #include "nsAccUtils.h"
 #include "TableAccessible.h"
 
 #include "Role.h"
 #include "States.h"
 
 using namespace mozilla::a11y;
 
-AccGroupInfo::AccGroupInfo(const Accessible* aItem, role aRole)
+AccGroupInfo::AccGroupInfo(const LocalAccessible* aItem, role aRole)
     : mPosInSet(0), mSetSize(0), mParent(nullptr), mItem(aItem), mRole(aRole) {
   MOZ_COUNT_CTOR(AccGroupInfo);
   Update();
 }
 
 void AccGroupInfo::Update() {
   mParent = nullptr;
 
-  Accessible* parent = mItem->LocalParent();
+  LocalAccessible* parent = mItem->LocalParent();
   if (!parent) return;
 
   int32_t indexInParent = mItem->IndexInParent();
   uint32_t siblingCount = parent->ChildCount();
   if (indexInParent == -1 ||
       indexInParent >= static_cast<int32_t>(siblingCount)) {
     NS_ERROR("Wrong index in parent! Tree invalidation problem.");
     return;
   }
 
   int32_t level = nsAccUtils::GetARIAOrDefaultLevel(mItem);
 
   // Compute position in set.
   mPosInSet = 1;
   for (int32_t idx = indexInParent - 1; idx >= 0; idx--) {
-    Accessible* sibling = parent->LocalChildAt(idx);
+    LocalAccessible* sibling = parent->LocalChildAt(idx);
     roles::Role siblingRole = sibling->Role();
 
     // If the sibling is separator then the group is ended.
     if (siblingRole == roles::SEPARATOR) break;
 
     if (BaseRole(siblingRole) != mRole) {
       continue;
     }
@@ -77,17 +77,17 @@ void AccGroupInfo::Update() {
 
     mPosInSet++;
   }
 
   // Compute set size.
   mSetSize = mPosInSet;
 
   for (uint32_t idx = indexInParent + 1; idx < siblingCount; idx++) {
-    Accessible* sibling = parent->LocalChildAt(idx);
+    LocalAccessible* sibling = parent->LocalChildAt(idx);
 
     roles::Role siblingRole = sibling->Role();
 
     // If the sibling is separator then the group is ended.
     if (siblingRole == roles::SEPARATOR) break;
 
     if (BaseRole(siblingRole) != mRole) {
       continue;
@@ -126,37 +126,37 @@ void AccGroupInfo::Update() {
   // ARIA tree and list can be arranged by using ARIA groups to organize levels.
   if (parentRole != roles::GROUPING) return;
 
   // Way #1 for ARIA tree (not ARIA treegrid): previous sibling of a group is a
   // parent. In other words the parent of the tree item will be a group and
   // the previous tree item of the group is a conceptual parent of the tree
   // item.
   if (mRole == roles::OUTLINEITEM) {
-    Accessible* parentPrevSibling = parent->LocalPrevSibling();
+    LocalAccessible* parentPrevSibling = parent->LocalPrevSibling();
     if (parentPrevSibling && parentPrevSibling->Role() == mRole) {
       mParent = parentPrevSibling;
       return;
     }
   }
 
   // Way #2 for ARIA list and tree: group is a child of an item. In other words
   // the parent of the item will be a group and containing item of the group is
   // a conceptual parent of the item.
   if (mRole == roles::LISTITEM || mRole == roles::OUTLINEITEM) {
-    Accessible* grandParent = parent->LocalParent();
+    LocalAccessible* grandParent = parent->LocalParent();
     if (grandParent && grandParent->Role() == mRole) mParent = grandParent;
   }
 }
 
-Accessible* AccGroupInfo::FirstItemOf(const Accessible* aContainer) {
+LocalAccessible* AccGroupInfo::FirstItemOf(const LocalAccessible* aContainer) {
   // ARIA tree can be arranged by ARIA groups case #1 (previous sibling of a
   // group is a parent) or by aria-level.
   a11y::role containerRole = aContainer->Role();
-  Accessible* item = aContainer->LocalNextSibling();
+  LocalAccessible* item = aContainer->LocalNextSibling();
   if (item) {
     if (containerRole == roles::OUTLINEITEM &&
         item->Role() == roles::GROUPING) {
       item = item->LocalFirstChild();
     }
 
     if (item) {
       AccGroupInfo* itemGroupInfo = item->GetGroupInfo();
@@ -185,34 +185,34 @@ Accessible* AccGroupInfo::FirstItemOf(co
 
   // Otherwise, it can be a direct child if the container is a list or tree.
   item = aContainer->LocalFirstChild();
   if (ShouldReportRelations(item->Role(), containerRole)) return item;
 
   return nullptr;
 }
 
-uint32_t AccGroupInfo::TotalItemCount(Accessible* aContainer,
+uint32_t AccGroupInfo::TotalItemCount(LocalAccessible* aContainer,
                                       bool* aIsHierarchical) {
   uint32_t itemCount = 0;
   switch (aContainer->Role()) {
     case roles::TABLE:
       if (nsCoreUtils::GetUIntAttr(aContainer->GetContent(),
                                    nsGkAtoms::aria_rowcount,
                                    (int32_t*)&itemCount)) {
         break;
       }
 
       if (TableAccessible* tableAcc = aContainer->AsTable()) {
         return tableAcc->RowCount();
       }
 
       break;
     case roles::ROW:
-      if (Accessible* table = nsAccUtils::TableFor(aContainer)) {
+      if (LocalAccessible* table = nsAccUtils::TableFor(aContainer)) {
         if (nsCoreUtils::GetUIntAttr(table->GetContent(),
                                      nsGkAtoms::aria_colcount,
                                      (int32_t*)&itemCount)) {
           break;
         }
 
         if (TableAccessible* tableAcc = table->AsTable()) {
           return tableAcc->ColCount();
@@ -228,17 +228,17 @@ uint32_t AccGroupInfo::TotalItemCount(Ac
     case roles::GROUPING:
     case roles::TREE_TABLE:
     case roles::COMBOBOX_LIST:
     case roles::LISTBOX:
     case roles::DEFINITION_LIST:
     case roles::EDITCOMBOBOX:
     case roles::RADIO_GROUP:
     case roles::PAGETABLIST: {
-      Accessible* childItem = AccGroupInfo::FirstItemOf(aContainer);
+      LocalAccessible* childItem = AccGroupInfo::FirstItemOf(aContainer);
       if (!childItem) {
         childItem = aContainer->LocalFirstChild();
         if (childItem && childItem->IsTextLeaf()) {
           // First child can be a text leaf, check its sibling for an item.
           childItem = childItem->LocalNextSibling();
         }
       }
 
@@ -253,27 +253,27 @@ uint32_t AccGroupInfo::TotalItemCount(Ac
     }
     default:
       break;
   }
 
   return itemCount;
 }
 
-Accessible* AccGroupInfo::NextItemTo(Accessible* aItem) {
+LocalAccessible* AccGroupInfo::NextItemTo(LocalAccessible* aItem) {
   AccGroupInfo* groupInfo = aItem->GetGroupInfo();
   if (!groupInfo) return nullptr;
 
   // If the item in middle of the group then search next item in siblings.
   if (groupInfo->PosInSet() >= groupInfo->SetSize()) return nullptr;
 
-  Accessible* parent = aItem->LocalParent();
+  LocalAccessible* parent = aItem->LocalParent();
   uint32_t childCount = parent->ChildCount();
   for (uint32_t idx = aItem->IndexInParent() + 1; idx < childCount; idx++) {
-    Accessible* nextItem = parent->LocalChildAt(idx);
+    LocalAccessible* nextItem = parent->LocalChildAt(idx);
     AccGroupInfo* nextGroupInfo = nextItem->GetGroupInfo();
     if (nextGroupInfo &&
         nextGroupInfo->ConceptualParent() == groupInfo->ConceptualParent()) {
       return nextItem;
     }
   }
 
   MOZ_ASSERT_UNREACHABLE(

--- a/accessible/base/AccGroupInfo.h
+++ b/accessible/base/AccGroupInfo.h
@@ -1,16 +1,16 @@
 /* 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 AccGroupInfo_h_
 #define AccGroupInfo_h_
 
-#include "Accessible-inl.h"
+#include "LocalAccessible-inl.h"
 
 namespace mozilla {
 namespace a11y {
 
 /**
  * Calculate and store group information.
  */
 class AccGroupInfo {
@@ -26,27 +26,27 @@ class AccGroupInfo {
    * Return a number of items in the group.
    */
   uint32_t SetSize() const { return mSetSize; }
 
   /**
    * Return a direct or logical parent of the accessible that this group info is
    * created for.
    */
-  Accessible* ConceptualParent() const { return mParent; }
+  LocalAccessible* ConceptualParent() const { return mParent; }
 
   /**
    * Update group information.
    */
   void Update();
 
   /**
    * Create group info.
    */
-  static AccGroupInfo* CreateGroupInfo(const Accessible* aAccessible) {
+  static AccGroupInfo* CreateGroupInfo(const LocalAccessible* aAccessible) {
     mozilla::a11y::role role = aAccessible->Role();
     if (role != mozilla::a11y::roles::ROW &&
         role != mozilla::a11y::roles::OUTLINEITEM &&
         role != mozilla::a11y::roles::OPTION &&
         role != mozilla::a11y::roles::LISTITEM &&
         role != mozilla::a11y::roles::MENUITEM &&
         role != mozilla::a11y::roles::COMBOBOX_OPTION &&
         role != mozilla::a11y::roles::RICH_OPTION &&
@@ -62,31 +62,32 @@ class AccGroupInfo {
 
     AccGroupInfo* info = new AccGroupInfo(aAccessible, BaseRole(role));
     return info;
   }
 
   /**
    * Return a first item for the given container.
    */
-  static Accessible* FirstItemOf(const Accessible* aContainer);
+  static LocalAccessible* FirstItemOf(const LocalAccessible* aContainer);
 
   /**
    * Return total number of items in container, and if it is has nested
    * collections.
    */
-  static uint32_t TotalItemCount(Accessible* aContainer, bool* aIsHierarchical);
+  static uint32_t TotalItemCount(LocalAccessible* aContainer,
+                                 bool* aIsHierarchical);
 
   /**
    * Return next item of the same group to the given item.
    */
-  static Accessible* NextItemTo(Accessible* aItem);
+  static LocalAccessible* NextItemTo(LocalAccessible* aItem);
 
  protected:
-  AccGroupInfo(const Accessible* aItem, a11y::role aRole);
+  AccGroupInfo(const LocalAccessible* aItem, a11y::role aRole);
 
  private:
   AccGroupInfo() = delete;
   AccGroupInfo(const AccGroupInfo&) = delete;
   AccGroupInfo& operator=(const AccGroupInfo&) = delete;
 
   static mozilla::a11y::role BaseRole(mozilla::a11y::role aRole) {
     if (aRole == mozilla::a11y::roles::CHECK_MENU_ITEM ||
@@ -105,17 +106,17 @@ class AccGroupInfo {
   /**
    * Return true if the given parent and child roles should have their node
    * relations reported.
    */
   static bool ShouldReportRelations(a11y::role aRole, a11y::role aParentRole);
 
   uint32_t mPosInSet;
   uint32_t mSetSize;
-  Accessible* mParent;
-  const Accessible* mItem;
+  LocalAccessible* mParent;
+  const LocalAccessible* mItem;
   a11y::role mRole;
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #endif