Bug 1076816 - segregate XPCOM tree, r=davidb
authorAlexander Surkov <surkov.alexander@gmail.com>
Tue, 21 Oct 2014 20:49:28 -0400
changeset 235949 ef5d07a500fdb98ce847a637bc50f65174a599cc
parent 235948 dffed5d2a79974e8352a3718b8f6691e230f4255
child 235950 352cdd69b5c6f605606ba1d6eea8a638d37442e7
push id4311
push userraliiev@mozilla.com
push dateMon, 12 Jan 2015 19:37:41 +0000
treeherdermozilla-beta@150c9fed433b [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersdavidb
bugs1076816
milestone36.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1076816 - segregate XPCOM tree, r=davidb
accessible/atk/AccessibleWrap.cpp
accessible/atk/AccessibleWrap.h
accessible/atk/ApplicationAccessibleWrap.cpp
accessible/atk/ApplicationAccessibleWrap.h
accessible/atk/AtkSocketAccessible.cpp
accessible/atk/AtkSocketAccessible.h
accessible/atk/nsMaiInterfaceAction.cpp
accessible/atk/nsMaiInterfaceDocument.cpp
accessible/atk/nsMaiInterfaceImage.cpp
accessible/atk/nsStateMap.h
accessible/base/ARIAMap.cpp
accessible/base/ARIAMap.h
accessible/base/AccEvent.cpp
accessible/base/AccEvent.h
accessible/base/DocManager.cpp
accessible/base/DocManager.h
accessible/base/nsAccCache.h
accessible/base/nsAccUtils.cpp
accessible/base/nsAccessibilityService.cpp
accessible/base/nsAccessibilityService.h
accessible/base/nsAccessiblePivot.cpp
accessible/generic/ARIAGridAccessible.cpp
accessible/generic/ARIAGridAccessible.h
accessible/generic/Accessible.cpp
accessible/generic/Accessible.h
accessible/generic/ApplicationAccessible.cpp
accessible/generic/ApplicationAccessible.h
accessible/generic/BaseAccessibles.cpp
accessible/generic/BaseAccessibles.h
accessible/generic/DocAccessible.cpp
accessible/generic/DocAccessible.h
accessible/generic/FormControlAccessible.cpp
accessible/generic/FormControlAccessible.h
accessible/generic/HyperTextAccessible.cpp
accessible/generic/HyperTextAccessible.h
accessible/generic/ImageAccessible.cpp
accessible/generic/ImageAccessible.h
accessible/generic/RootAccessible.cpp
accessible/html/HTMLElementAccessibles.cpp
accessible/html/HTMLFormControlAccessible.cpp
accessible/html/HTMLImageMapAccessible.cpp
accessible/html/HTMLLinkAccessible.cpp
accessible/html/HTMLSelectAccessible.cpp
accessible/html/HTMLSelectAccessible.h
accessible/html/HTMLTableAccessible.cpp
accessible/html/HTMLTableAccessible.h
accessible/interfaces/nsIAccessibilityService.h
accessible/interfaces/nsIAccessible.idl
accessible/interfaces/nsIAccessibleDocument.idl
accessible/interfaces/nsIAccessibleEditableText.idl
accessible/interfaces/nsIAccessibleSelectable.idl
accessible/interfaces/nsIAccessibleText.idl
accessible/mac/AccessibleWrap.h
accessible/mac/AccessibleWrap.mm
accessible/mac/mozAccessible.h
accessible/mac/mozAccessible.mm
accessible/mac/mozActionElements.mm
accessible/mac/mozTextAccessible.h
accessible/mac/mozTextAccessible.mm
accessible/tests/mochitest/common.js
accessible/windows/ia2/ia2AccessibleAction.cpp
accessible/windows/ia2/ia2AccessibleEditableText.h
accessible/windows/ia2/ia2AccessibleImage.cpp
accessible/windows/ia2/ia2AccessibleRelation.cpp
accessible/windows/ia2/ia2AccessibleRelation.h
accessible/windows/ia2/ia2AccessibleTable.cpp
accessible/windows/ia2/ia2AccessibleText.h
accessible/windows/msaa/AccessibleWrap.cpp
accessible/windows/msaa/AccessibleWrap.h
accessible/windows/msaa/HTMLWin32ObjectAccessible.cpp
accessible/windows/msaa/HTMLWin32ObjectAccessible.h
accessible/windows/msaa/XULMenuAccessibleWrap.cpp
accessible/windows/sdn/sdnDocAccessible.cpp
accessible/xpcom/moz.build
accessible/xpcom/nsAccessibleRelation.cpp
accessible/xpcom/xpcAccessible.cpp
accessible/xpcom/xpcAccessible.h
accessible/xpcom/xpcAccessibleApplication.cpp
accessible/xpcom/xpcAccessibleApplication.h
accessible/xpcom/xpcAccessibleDocument.cpp
accessible/xpcom/xpcAccessibleDocument.h
accessible/xpcom/xpcAccessibleGeneric.cpp
accessible/xpcom/xpcAccessibleGeneric.h
accessible/xpcom/xpcAccessibleHyperLink.cpp
accessible/xpcom/xpcAccessibleHyperLink.h
accessible/xpcom/xpcAccessibleHyperText.cpp
accessible/xpcom/xpcAccessibleHyperText.h
accessible/xpcom/xpcAccessibleImage.cpp
accessible/xpcom/xpcAccessibleImage.h
accessible/xpcom/xpcAccessibleSelectable.cpp
accessible/xpcom/xpcAccessibleSelectable.h
accessible/xpcom/xpcAccessibleTable.cpp
accessible/xpcom/xpcAccessibleTable.h
accessible/xpcom/xpcAccessibleTableCell.cpp
accessible/xpcom/xpcAccessibleTableCell.h
accessible/xpcom/xpcAccessibleTextRange.cpp
accessible/xpcom/xpcAccessibleValue.cpp
accessible/xpcom/xpcAccessibleValue.h
accessible/xul/XULColorPickerAccessible.cpp
accessible/xul/XULElementAccessibles.cpp
accessible/xul/XULElementAccessibles.h
accessible/xul/XULListboxAccessible.cpp
accessible/xul/XULListboxAccessible.h
accessible/xul/XULSelectControlAccessible.cpp
accessible/xul/XULSelectControlAccessible.h
accessible/xul/XULSliderAccessible.cpp
accessible/xul/XULTabAccessible.cpp
accessible/xul/XULTreeAccessible.cpp
accessible/xul/XULTreeAccessible.h
accessible/xul/XULTreeGridAccessible.cpp
accessible/xul/XULTreeGridAccessible.h
layout/inspector/inDOMView.cpp
widget/cocoa/nsChildView.mm
widget/windows/winrt/UIAAccessibilityBridge.cpp
widget/windows/winrt/UIABridge.cpp
widget/windows/winrt/UIABridgePrivate.h
--- a/accessible/atk/AccessibleWrap.cpp
+++ b/accessible/atk/AccessibleWrap.cpp
@@ -5,21 +5,18 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "AccessibleWrap.h"
 
 #include "Accessible-inl.h"
 #include "ApplicationAccessibleWrap.h"
 #include "InterfaceInitFuncs.h"
 #include "nsAccUtils.h"
-#include "nsIAccessibleRelation.h"
-#include "nsIAccessibleTable.h"
 #include "ProxyAccessible.h"
 #include "RootAccessible.h"
-#include "nsIAccessibleValue.h"
 #include "nsMai.h"
 #include "nsMaiHyperlink.h"
 #include "nsString.h"
 #include "nsAutoPtr.h"
 #include "prprf.h"
 #include "nsStateMap.h"
 #include "mozilla/a11y/Platform.h"
 #include "Relation.h"
@@ -300,68 +297,68 @@ AccessibleWrap::SetMaiHyperlink(MaiHyper
             return; // Never set and we're shutting down
         }
         delete maiHyperlink;
         g_object_set_qdata(G_OBJECT(mAtkObject), quark_mai_hyperlink,
                            aMaiHyperlink);
     }
 }
 
-NS_IMETHODIMP
+void
 AccessibleWrap::GetNativeInterface(void** aOutAccessible)
 {
-    *aOutAccessible = nullptr;
-
-    if (!mAtkObject) {
-        if (IsDefunct() || !nsAccUtils::IsEmbeddedObject(this)) {
-            // We don't create ATK objects for node which has been shutdown, or
-            // nsIAccessible plain text leaves
-            return NS_ERROR_FAILURE;
-        }
+  *aOutAccessible = nullptr;
 
-        GType type = GetMaiAtkType(CreateMaiInterfaces());
-        NS_ENSURE_TRUE(type, NS_ERROR_FAILURE);
-        mAtkObject =
-            reinterpret_cast<AtkObject *>
-                            (g_object_new(type, nullptr));
-        NS_ENSURE_TRUE(mAtkObject, NS_ERROR_OUT_OF_MEMORY);
-
-        atk_object_initialize(mAtkObject, this);
-        mAtkObject->role = ATK_ROLE_INVALID;
-        mAtkObject->layer = ATK_LAYER_INVALID;
+  if (!mAtkObject) {
+    if (IsDefunct() || !nsAccUtils::IsEmbeddedObject(this)) {
+      // We don't create ATK objects for node which has been shutdown or
+      // plain text leaves
+      return;
     }
 
-    *aOutAccessible = mAtkObject;
-    return NS_OK;
+    GType type = GetMaiAtkType(CreateMaiInterfaces());
+    if (!type)
+      return;
+
+    mAtkObject = reinterpret_cast<AtkObject*>(g_object_new(type, nullptr));
+    if (!mAtkObject)
+      return;
+
+    atk_object_initialize(mAtkObject, this);
+    mAtkObject->role = ATK_ROLE_INVALID;
+    mAtkObject->layer = ATK_LAYER_INVALID;
+  }
+
+  *aOutAccessible = mAtkObject;
 }
 
 AtkObject *
 AccessibleWrap::GetAtkObject(void)
 {
     void *atkObj = nullptr;
     GetNativeInterface(&atkObj);
     return static_cast<AtkObject *>(atkObj);
 }
 
-// Get AtkObject from nsIAccessible interface
+// Get AtkObject from Accessible interface
 /* static */
 AtkObject *
-AccessibleWrap::GetAtkObject(nsIAccessible* acc)
+AccessibleWrap::GetAtkObject(Accessible* acc)
 {
     void *atkObjPtr = nullptr;
     acc->GetNativeInterface(&atkObjPtr);
     return atkObjPtr ? ATK_OBJECT(atkObjPtr) : nullptr;    
 }
 
 /* private */
 uint16_t
 AccessibleWrap::CreateMaiInterfaces(void)
 {
   uint16_t interfacesBits = 0;
-    
+
   // The Component interface is supported by all accessibles.
   interfacesBits |= 1 << MAI_INTERFACE_COMPONENT;
 
   // Add Action interface if the action count is more than zero.
   if (ActionCount() > 0)
     interfacesBits |= 1 << MAI_INTERFACE_ACTION;
 
   // Text, Editabletext, and Hypertext interface.
@@ -369,22 +366,18 @@ AccessibleWrap::CreateMaiInterfaces(void
   if (hyperText && hyperText->IsTextRole()) {
     interfacesBits |= 1 << MAI_INTERFACE_TEXT;
     interfacesBits |= 1 << MAI_INTERFACE_EDITABLE_TEXT;
     if (!nsAccUtils::MustPrune(this))
       interfacesBits |= 1 << MAI_INTERFACE_HYPERTEXT;
   }
 
   // Value interface.
-  nsCOMPtr<nsIAccessibleValue> accessInterfaceValue;
-  QueryInterface(NS_GET_IID(nsIAccessibleValue),
-                 getter_AddRefs(accessInterfaceValue));
-  if (accessInterfaceValue) {
-    interfacesBits |= 1 << MAI_INTERFACE_VALUE; 
-  }
+  if (HasNumericValue())
+    interfacesBits |= 1 << MAI_INTERFACE_VALUE;
 
   // Document interface.
   if (IsDoc())
     interfacesBits |= 1 << MAI_INTERFACE_DOCUMENT;
 
   if (IsImage())
     interfacesBits |= 1 << MAI_INTERFACE_IMAGE;
 
@@ -677,17 +670,17 @@ getRoleCB(AtkObject *aAtkObj)
     ProxyAccessible* proxy = GetProxy(aAtkObj);
     if (!proxy)
       return ATK_ROLE_INVALID;
 
     role = proxy->Role();
   } else {
 #ifdef DEBUG
     NS_ASSERTION(nsAccUtils::IsTextInterfaceSupportCorrect(accWrap),
-                 "Does not support nsIAccessibleText when it should");
+                 "Does not support Text interface when it should");
 #endif
 
     role = accWrap->Role();
   }
 
 #define ROLE(geckoRole, stringRole, atkRole, macRole, \
              msaaRole, ia2Role, nameRule) \
   case roles::geckoRole: \
@@ -842,20 +835,20 @@ refChildCB(AtkObject *aAtkObj, gint aChi
 
   if (aAtkObj != childAtkObj->accessible_parent)
     atk_object_set_parent(childAtkObj, aAtkObj);
 
   return childAtkObj;
 }
 
 gint
-getIndexInParentCB(AtkObject *aAtkObj)
+getIndexInParentCB(AtkObject* aAtkObj)
 {
-    // We don't use nsIAccessible::GetIndexInParent() because
-    // for ATK we don't want to include text leaf nodes as children
+  // We don't use Accessible::IndexInParent() because we don't include text
+  // leaf nodes as children in ATK.
     AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
     if (!accWrap) {
         return -1;
     }
 
     Accessible* parent = accWrap->Parent();
     if (!parent)
         return -1; // No parent
@@ -1036,18 +1029,18 @@ AccessibleWrap::HandleAccEvent(AccEvent*
     // which decides it would be fun to change the DOM and flush layout.
     if (accessible->IsDefunct())
         return NS_OK;
 
     uint32_t type = aEvent->GetEventType();
 
     AtkObject* atkObj = AccessibleWrap::GetAtkObject(accessible);
 
-    // We don't create ATK objects for nsIAccessible plain text leaves,
-    // just return NS_OK in such case
+  // We don't create ATK objects for plain text leaves, just return NS_OK in
+  // such case.
     if (!atkObj) {
         NS_ASSERTION(type == nsIAccessibleEvent::EVENT_SHOW ||
                      type == nsIAccessibleEvent::EVENT_HIDE,
                      "Event other than SHOW and HIDE fired for plain text leaves");
         return NS_OK;
     }
 
     AccessibleWrap* accWrap = GetAccessibleWrap(atkObj);
@@ -1078,25 +1071,24 @@ AccessibleWrap::HandleAccEvent(AccEvent*
       {
         nsAutoString newName;
         accessible->Name(newName);
 
         MaybeFireNameChange(atkObj, newName);
 
         break;
       }
-    case nsIAccessibleEvent::EVENT_VALUE_CHANGE:
-      {
-        nsCOMPtr<nsIAccessibleValue> value(do_QueryObject(accessible));
-        if (value) {    // Make sure this is a numeric value
-            // Don't fire for MSAA string value changes (e.g. text editing)
-            // ATK values are always numeric
-            g_object_notify( (GObject*)atkObj, "accessible-value" );
-        }
-      } break;
+
+  case nsIAccessibleEvent::EVENT_VALUE_CHANGE:
+    if (accessible->HasNumericValue()) {
+      // Make sure this is a numeric value. Don't fire for string value changes
+      // (e.g. text editing) ATK values are always numeric.
+      g_object_notify((GObject*)atkObj, "accessible-value");
+    }
+    break;
 
     case nsIAccessibleEvent::EVENT_SELECTION:
     case nsIAccessibleEvent::EVENT_SELECTION_ADD:
     case nsIAccessibleEvent::EVENT_SELECTION_REMOVE:
     {
       // XXX: dupe events may be fired
       AccSelChangeEvent* selChangeEvent = downcast_accEvent(aEvent);
       g_signal_emit_by_name(AccessibleWrap::GetAtkObject(selChangeEvent->Widget()),
--- a/accessible/atk/AccessibleWrap.h
+++ b/accessible/atk/AccessibleWrap.h
@@ -50,24 +50,24 @@ class AccessibleWrap : public Accessible
 public:
   AccessibleWrap(nsIContent* aContent, DocAccessible* aDoc);
   virtual ~AccessibleWrap();
   void ShutdownAtkObject();
 
   virtual void Shutdown();
 
   // return the atk object for this AccessibleWrap
-  NS_IMETHOD GetNativeInterface(void **aOutAccessible);
+  virtual void GetNativeInterface(void** aOutAccessible) MOZ_OVERRIDE;
   virtual nsresult HandleAccEvent(AccEvent* aEvent);
 
   AtkObject * GetAtkObject(void);
-  static AtkObject * GetAtkObject(nsIAccessible * acc);
+  static AtkObject* GetAtkObject(Accessible* aAccessible);
 
   bool IsValidObject();
-    
+
   // get/set the MaiHyperlink object for this AccessibleWrap
   MaiHyperlink* GetMaiHyperlink(bool aCreate = true);
   void SetMaiHyperlink(MaiHyperlink* aMaiHyperlink);
 
   static const char * ReturnString(nsAString &aString) {
     static nsCString returnedString;
     returnedString = NS_ConvertUTF16toUTF8(aString);
     return returnedString.get();
--- a/accessible/atk/ApplicationAccessibleWrap.cpp
+++ b/accessible/atk/ApplicationAccessibleWrap.cpp
@@ -84,34 +84,33 @@ ApplicationAccessibleWrap::Name(nsString
   // ATK doesn't provide a way to obtain an application name (for example,
   // Firefox or Thunderbird) like IA2 does. Thus let's return an application
   // name as accessible name that was used to get a branding name (for example,
   // Minefield aka nightly Firefox or Daily aka nightly Thunderbird).
   AppName(aName);
   return eNameOK;
 }
 
-NS_IMETHODIMP
+void
 ApplicationAccessibleWrap::GetNativeInterface(void** aOutAccessible)
 {
-    *aOutAccessible = nullptr;
-
-    if (!mAtkObject) {
-        mAtkObject =
-            reinterpret_cast<AtkObject *>
-                            (g_object_new(MAI_TYPE_ATK_OBJECT, nullptr));
-        NS_ENSURE_TRUE(mAtkObject, NS_ERROR_OUT_OF_MEMORY);
+  *aOutAccessible = nullptr;
 
-        atk_object_initialize(mAtkObject, this);
-        mAtkObject->role = ATK_ROLE_INVALID;
-        mAtkObject->layer = ATK_LAYER_INVALID;
-    }
+  if (!mAtkObject) {
+    mAtkObject =
+      reinterpret_cast<AtkObject*>(g_object_new(MAI_TYPE_ATK_OBJECT, nullptr));
+    if (!mAtkObject)
+      return;
 
-    *aOutAccessible = mAtkObject;
-    return NS_OK;
+    atk_object_initialize(mAtkObject, this);
+    mAtkObject->role = ATK_ROLE_INVALID;
+    mAtkObject->layer = ATK_LAYER_INVALID;
+  }
+
+  *aOutAccessible = mAtkObject;
 }
 
 struct AtkRootAccessibleAddedEvent {
   AtkObject *app_accessible;
   AtkObject *root_accessible;
   uint32_t index;
 };
 
--- a/accessible/atk/ApplicationAccessibleWrap.h
+++ b/accessible/atk/ApplicationAccessibleWrap.h
@@ -21,15 +21,15 @@ public:
   // Accessible
   virtual mozilla::a11y::ENameValueFlag Name(nsString& aName);
   virtual bool InsertChildAt(uint32_t aIdx, Accessible* aChild) MOZ_OVERRIDE;
   virtual bool RemoveChild(Accessible* aChild);
 
   /**
    * Return the atk object for app root accessible.
    */
-  NS_IMETHOD GetNativeInterface(void** aOutAccessible);
+  virtual void GetNativeInterface(void** aOutAccessible) MOZ_OVERRIDE;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif   /* __NS_APP_ROOT_ACCESSIBLE_H__ */
--- a/accessible/atk/AtkSocketAccessible.cpp
+++ b/accessible/atk/AtkSocketAccessible.cpp
@@ -131,21 +131,20 @@ AtkSocketAccessible::AtkSocketAccessible
   if (gCanEmbed && G_TYPE_CHECK_INSTANCE_TYPE(mAtkObject, g_atk_socket_type) &&
       !aPlugId.IsVoid()) {
     AtkSocket* accSocket =
       G_TYPE_CHECK_INSTANCE_CAST(mAtkObject, g_atk_socket_type, AtkSocket);
     g_atk_socket_embed(accSocket, (gchar*)aPlugId.get());
   }
 }
 
-NS_IMETHODIMP
+void
 AtkSocketAccessible::GetNativeInterface(void** aOutAccessible)
 {
   *aOutAccessible = mAtkObject;
-  return NS_OK;
 }
 
 void
 AtkSocketAccessible::Shutdown()
 {
   if (mAtkObject) {
     if (MAI_IS_ATK_SOCKET(mAtkObject))
       MAI_ATK_SOCKET(mAtkObject)->accWrap = nullptr;
--- a/accessible/atk/AtkSocketAccessible.h
+++ b/accessible/atk/AtkSocketAccessible.h
@@ -42,16 +42,15 @@ public:
    */
   static bool gCanEmbed;
 
   AtkSocketAccessible(nsIContent* aContent, DocAccessible* aDoc,
                       const nsCString& aPlugId);
 
   virtual void Shutdown();
 
-  // nsIAccessible
-  NS_IMETHODIMP GetNativeInterface(void** aOutAccessible);
+  virtual void GetNativeInterface(void** aOutAccessible) MOZ_OVERRIDE;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
--- a/accessible/atk/nsMaiInterfaceAction.cpp
+++ b/accessible/atk/nsMaiInterfaceAction.cpp
@@ -34,18 +34,17 @@ getActionCountCB(AtkAction *aAction)
 static const gchar*
 getActionDescriptionCB(AtkAction *aAction, gint aActionIndex)
 {
   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aAction));
   if (!accWrap)
     return nullptr;
 
   nsAutoString description;
-  nsresult rv = accWrap->GetActionDescription(aActionIndex, description);
-  NS_ENSURE_SUCCESS(rv, nullptr);
+  accWrap->ActionDescriptionAt(aActionIndex, description);
   return AccessibleWrap::ReturnString(description);
 }
 
 static const gchar*
 getActionNameCB(AtkAction *aAction, gint aActionIndex)
 {
   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aAction));
   if (!accWrap)
--- a/accessible/atk/nsMaiInterfaceDocument.cpp
+++ b/accessible/atk/nsMaiInterfaceDocument.cpp
@@ -78,17 +78,17 @@ getDocumentAttributesCB(AtkDocument *aDo
   // according to atkobject.h, AtkAttributeSet is a GSList
   GSList* attributes = nullptr;
   DocAccessible* document = accWrap->AsDoc();
   nsAutoString aURL;
   document->URL(aURL);
   attributes = prependToList(attributes, kDocUrlName, aURL);
 
   nsAutoString aW3CDocType;
-  document->GetDocType(aW3CDocType);
+  document->DocType(aW3CDocType);
   attributes = prependToList(attributes, kDocTypeName, aW3CDocType);
 
   nsAutoString aMimeType;
   document->MimeType(aMimeType);
   attributes = prependToList(attributes, kMimeTypeName, aMimeType);
 
   return attributes;
 }
@@ -97,23 +97,21 @@ const gchar *
 getDocumentAttributeValueCB(AtkDocument *aDocument,
                             const gchar *aAttrName)
 {
   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aDocument));
   if (!accWrap || !accWrap->IsDoc())
     return nullptr;
 
   DocAccessible* document = accWrap->AsDoc();
-  nsresult rv;
   nsAutoString attrValue;
   if (!strcasecmp(aAttrName, kDocTypeName))
-    rv = document->GetDocType(attrValue);
+    document->DocType(attrValue);
   else if (!strcasecmp(aAttrName, kDocUrlName))
     document->URL(attrValue);
   else if (!strcasecmp(aAttrName, kMimeTypeName))
     document->MimeType(attrValue);
   else
     return nullptr;
 
-  NS_ENSURE_SUCCESS(rv, nullptr);
   return attrValue.IsEmpty() ? nullptr : AccessibleWrap::ReturnString(attrValue);
 }
 }
--- a/accessible/atk/nsMaiInterfaceImage.cpp
+++ b/accessible/atk/nsMaiInterfaceImage.cpp
@@ -26,36 +26,40 @@ getImagePositionCB(AtkImage* aImage, gin
   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aImage));
   if (!accWrap || !accWrap->IsImage())
     return;
 
   ImageAccessible* image = accWrap->AsImage();
   uint32_t geckoCoordType = (aCoordType == ATK_XY_WINDOW) ?
     nsIAccessibleCoordinateType::COORDTYPE_WINDOW_RELATIVE :
     nsIAccessibleCoordinateType::COORDTYPE_SCREEN_RELATIVE;
-  // Returned in screen coordinates
-  image->GetImagePosition(geckoCoordType, aAccX, aAccY);
+  nsIntPoint pos = image->Position(geckoCoordType);
+  *aAccX = pos.x;
+  *aAccY = pos.y;
 }
 
 static const gchar*
 getImageDescriptionCB(AtkImage* aImage)
 {
   return getDescriptionCB(ATK_OBJECT(aImage));
 }
 
 static void
 getImageSizeCB(AtkImage* aImage, gint* aAccWidth, gint* aAccHeight)
 {
   AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aImage));
   if (!accWrap || !accWrap->IsImage())
     return;
 
-  accWrap->AsImage()->GetImageSize(aAccWidth, aAccHeight);
+  nsIntSize size = accWrap->AsImage()->Size();
+  *aAccWidth = size.width;
+  *aAccHeight = size.height;
 }
-}
+
+} // extern "C"
 
 void
 imageInterfaceInitCB(AtkImageIface* aIface)
 {
   NS_ASSERTION(aIface, "no interface!");
   if (MOZ_UNLIKELY(!aIface))
     return;
 
--- a/accessible/atk/nsStateMap.h
+++ b/accessible/atk/nsStateMap.h
@@ -3,35 +3,37 @@
 /* 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 <atk/atk.h>
 #include "AccessibleWrap.h"
 
 /******************************************************************************
-The following nsIAccessible states aren't translated, just ignored:
+The following accessible states aren't translated, just ignored:
   STATE_READONLY:        Supported indirectly via EXT_STATE_EDITABLE
   STATE_HOTTRACKED:      No ATK equivalent.  No known use case.
                          The nsIAccessible state is not currently supported.
   STATE_FLOATING:        No ATK equivalent.  No known use case.
                          The nsIAccessible state is not currently supported.
   STATE_MOVEABLE:        No ATK equivalent.  No known use case.
                          The nsIAccessible state is not currently supported.
   STATE_SELFVOICING:     No ATK equivalent -- the object has self-TTS.
                          The nsIAccessible state is not currently supported.
   STATE_LINKED:          The object is formatted as a hyperlink. Supported via ATK_ROLE_LINK.
   STATE_EXTSELECTABLE:   Indicates that an object extends its selection.
                          This is supported via STATE_MULTISELECTABLE.
   STATE_PROTECTED:       The object is a password-protected edit control.
                          Supported via ATK_ROLE_PASSWORD_TEXT
   STATE_HASPOPUP:        Object displays a pop-up menu or window when invoked.
-                         No ATK equivalent.  The nsIAccessible state is not currently supported.
-  STATE_PINNED:          The object is pinned, usually indicating it is fixed in place and has permanence.
-                         No ATK equivalent.  The nsIAccessible state is not currently supported.
+                         No ATK equivalent. The accessible state is not
+                         currently supported.
+  STATE_PINNED:          The object is pinned, usually indicating it is fixed in
+                         place and has permanence. No ATK equivalent. The
+                         accessible state is not currently supported.
 
 The following ATK states are not supported:
   ATK_STATE_ARMED:       No clear use case, used briefly when button is activated
   ATK_STATE_HAS_TOOLTIP: No clear use case, no IA2 equivalent
   ATK_STATE_ICONIFIED:   Mozilla does not have elements which are collapsable into icons
   ATK_STATE_TRUNCATED:   No clear use case. Indicates that an object's onscreen content is truncated, 
                          e.g. a text value in a spreadsheet cell. No IA2 state.
 ******************************************************************************/
--- a/accessible/base/ARIAMap.cpp
+++ b/accessible/base/ARIAMap.cpp
@@ -25,22 +25,22 @@ static const uint32_t kGenericAccType = 
 
 /**
  *  This list of WAI-defined roles are currently hardcoded.
  *  Eventually we will most likely be loading an RDF resource that contains this information
  *  Using RDF will also allow for role extensibility. See bug 280138.
  *
  *  Definition of nsRoleMapEntry contains comments explaining this table.
  *
- *  When no nsIAccessibleRole enum mapping exists for an ARIA role, the
- *  role will be exposed via the object attribute "xml-roles".
- *  In addition, in MSAA, the unmapped role will also be exposed as a BSTR string role.
+ *  When no Role enum mapping exists for an ARIA role, the role will be exposed
+ *  via the object attribute "xml-roles".
  *
- *  There are no nsIAccessibleRole enums for the following landmark roles:
- *    banner, contentinfo, main, navigation, note, search, secondary, seealso, breadcrumbs
+ *  There are no Role enums for the following landmark roles:
+ *    banner, contentinfo, main, navigation, note, search, secondary,
+ *    seealso, breadcrumbs.
  */
 
 static nsRoleMapEntry sWAIRoleMaps[] =
 {
   { // alert
     &nsGkAtoms::alert,
     roles::ALERT,
     kUseMapRole,
--- a/accessible/base/ARIAMap.h
+++ b/accessible/base/ARIAMap.h
@@ -16,27 +16,27 @@
 #include "nsIContent.h"
 
 class nsINode;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Value constants
 
 /**
- * Used to define if role requires to expose nsIAccessibleValue.
+ * Used to define if role requires to expose Value interface.
  */
 enum EValueRule
 {
   /**
-   * nsIAccessibleValue isn't exposed.
+   * Value interface isn't exposed.
    */
   eNoValue,
 
   /**
-   * nsIAccessibleValue is implemented, supports value, min and max from
+   * Value interface is implemented, supports value, min and max from
    * aria-valuenow, aria-valuemin and aria-valuemax.
    */
   eHasValueMinMax
 };
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Action constants
@@ -145,40 +145,40 @@ struct nsRoleMapEntry
    * Return ARIA role.
    */
   const nsDependentAtomString ARIARoleString() const
     { return nsDependentAtomString(*roleAtom); }
 
   // ARIA role: string representation such as "button"
   nsIAtom** roleAtom;
 
-  // Role mapping rule: maps to this nsIAccessibleRole
+  // Role mapping rule: maps to enum Role
   mozilla::a11y::role role;
-  
+
   // Role rule: whether to use mapped role or native semantics
   bool roleRule;
-  
-  // Value mapping rule: how to compute nsIAccessible value
+
+  // Value mapping rule: how to compute accessible value
   EValueRule valueRule;
 
-  // Action mapping rule, how to expose nsIAccessible action
+  // 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.
   uint32_t accTypes;
 
-  // Automatic state mapping rule: always include in nsIAccessibleStates
-  uint64_t state;   // or kNoReqStates if no nsIAccessibleStates are automatic for this role.
+  // 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 nsIAccessibleStates mapping rules)
+  // 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 variable sized array would not allow the use of
   // C++'s struct initialization feature.
   mozilla::a11y::aria::EStateRule attributeMap1;
   mozilla::a11y::aria::EStateRule attributeMap2;
   mozilla::a11y::aria::EStateRule attributeMap3;
   mozilla::a11y::aria::EStateRule attributeMap4;
 };
--- a/accessible/base/AccEvent.cpp
+++ b/accessible/base/AccEvent.cpp
@@ -5,16 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "AccEvent.h"
 
 #include "nsAccUtils.h"
 #include "DocAccessible.h"
 #include "xpcAccEvents.h"
 #include "States.h"
+#include "xpcAccessibleDocument.h"
 
 #include "mozilla/EventStateManager.h"
 #include "mozilla/dom/Selection.h"
 
 using namespace mozilla;
 using namespace mozilla::a11y;
 
 static_assert(static_cast<bool>(eNoUserInput) == false &&
@@ -179,17 +180,17 @@ AccTableChangeEvent::
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccVCChangeEvent
 ////////////////////////////////////////////////////////////////////////////////
 
 AccVCChangeEvent::
   AccVCChangeEvent(Accessible* aAccessible,
-                   nsIAccessible* aOldAccessible,
+                   Accessible* aOldAccessible,
                    int32_t aOldStart, int32_t aOldEnd,
                    int16_t aReason, EIsFromUserInput aIsFromUserInput) :
     AccEvent(::nsIAccessibleEvent::EVENT_VIRTUALCURSOR_CHANGED, aAccessible,
              aIsFromUserInput),
     mOldAccessible(aOldAccessible), mOldStart(aOldStart), mOldEnd(aOldEnd),
     mReason(aReason)
 {
 }
@@ -205,60 +206,68 @@ a11y::MakeXPCEvent(AccEvent* aEvent)
   uint32_t type = aEvent->GetEventType();
   uint32_t eventGroup = aEvent->GetEventGroups();
   nsCOMPtr<nsIAccessibleEvent> xpEvent;
 
   if (eventGroup & (1 << AccEvent::eStateChangeEvent)) {
     AccStateChangeEvent* sc = downcast_accEvent(aEvent);
     bool extra = false;
     uint32_t state = nsAccUtils::To32States(sc->GetState(), &extra);
-    xpEvent = new xpcAccStateChangeEvent(type, acc, doc, domNode, fromUser,
+    xpEvent = new xpcAccStateChangeEvent(type, ToXPC(acc), ToXPCDocument(doc),
+                                         domNode, fromUser,
                                          state, extra, sc->IsStateEnabled());
     return xpEvent.forget();
   }
 
   if (eventGroup & (1 << AccEvent::eTextChangeEvent)) {
     AccTextChangeEvent* tc = downcast_accEvent(aEvent);
     nsString text;
     tc->GetModifiedText(text);
-    xpEvent = new xpcAccTextChangeEvent(type, acc, doc, domNode, fromUser,
+    xpEvent = new xpcAccTextChangeEvent(type, ToXPC(acc), ToXPCDocument(doc),
+                                        domNode, fromUser,
                                         tc->GetStartOffset(), tc->GetLength(),
                                         tc->IsTextInserted(), text);
     return xpEvent.forget();
   }
 
   if (eventGroup & (1 << AccEvent::eHideEvent)) {
     AccHideEvent* hideEvent = downcast_accEvent(aEvent);
-    xpEvent = new xpcAccHideEvent(type, acc, doc, domNode, fromUser,
-                                  hideEvent->TargetParent(),
-                                  hideEvent->TargetNextSibling(),
-                                  hideEvent->TargetPrevSibling());
+    xpEvent = new xpcAccHideEvent(type, ToXPC(acc), ToXPCDocument(doc),
+                                  domNode, fromUser,
+                                  ToXPC(hideEvent->TargetParent()),
+                                  ToXPC(hideEvent->TargetNextSibling()),
+                                  ToXPC(hideEvent->TargetPrevSibling()));
     return xpEvent.forget();
   }
 
   if (eventGroup & (1 << AccEvent::eCaretMoveEvent)) {
     AccCaretMoveEvent* cm = downcast_accEvent(aEvent);
-    xpEvent = new xpcAccCaretMoveEvent(type, acc, doc, domNode, fromUser,
+    xpEvent = new xpcAccCaretMoveEvent(type, ToXPC(acc), ToXPCDocument(doc),
+                                       domNode, fromUser,
                                        cm->GetCaretOffset());
     return xpEvent.forget();
   }
 
   if (eventGroup & (1 << AccEvent::eVirtualCursorChangeEvent)) {
     AccVCChangeEvent* vcc = downcast_accEvent(aEvent);
-    xpEvent = new xpcAccVirtualCursorChangeEvent(type, acc, doc, domNode, fromUser,
-                                                 vcc->OldAccessible(),
+    xpEvent = new xpcAccVirtualCursorChangeEvent(type,
+                                                 ToXPC(acc), ToXPCDocument(doc),
+                                                 domNode, fromUser,
+                                                 ToXPC(vcc->OldAccessible()),
                                                  vcc->OldStartOffset(),
                                                  vcc->OldEndOffset(),
                                                  vcc->Reason());
     return xpEvent.forget();
   }
 
   if (eventGroup & (1 << AccEvent::eObjectAttrChangedEvent)) {
     AccObjectAttrChangedEvent* oac = downcast_accEvent(aEvent);
-    xpEvent = new xpcAccObjectAttributeChangedEvent(type, acc, doc, domNode,
+    xpEvent = new xpcAccObjectAttributeChangedEvent(type,
+                                                    ToXPC(acc),
+                                                    ToXPCDocument(doc), domNode,
                                                     fromUser,
                                                     oac->GetAttribute());
     return xpEvent.forget();
   }
 
-  xpEvent = new xpcAccEvent(type, acc, doc, domNode, fromUser);
+  xpEvent = new xpcAccEvent(type, ToXPC(acc), ToXPCDocument(doc), domNode, fromUser);
   return xpEvent.forget();
   }
--- a/accessible/base/AccEvent.h
+++ b/accessible/base/AccEvent.h
@@ -70,17 +70,17 @@ public:
      // eRemoveDupes : For repeat events, only the newest event in queue
      //    will be emitted.
     eRemoveDupes,
 
      // eDoNotEmit : This event is confirmed as a duplicate, do not emit it.
     eDoNotEmit
   };
 
-  // Initialize with an nsIAccessible
+  // Initialize with an accessible.
   AccEvent(uint32_t aEventType, Accessible* aAccessible,
            EIsFromUserInput aIsFromUserInput = eAutoDetect,
            EEventRule aEventRule = eRemoveDupes);
 
   // AccEvent
   uint32_t GetEventType() const { return mEventType; }
   EEventRule GetEventRule() const { return mEventRule; }
   bool IsFromUserInput() const { return mIsFromUserInput; }
@@ -465,38 +465,38 @@ private:
 
 /**
  * Accessible virtual cursor change event.
  */
 class AccVCChangeEvent : public AccEvent
 {
 public:
   AccVCChangeEvent(Accessible* aAccessible,
-                   nsIAccessible* aOldAccessible,
+                   Accessible* aOldAccessible,
                    int32_t aOldStart, int32_t aOldEnd,
                    int16_t aReason,
                    EIsFromUserInput aIsFromUserInput = eFromUserInput);
 
   virtual ~AccVCChangeEvent() { }
 
   // AccEvent
   static const EventGroup kEventGroup = eVirtualCursorChangeEvent;
   virtual unsigned int GetEventGroups() const
   {
     return AccEvent::GetEventGroups() | (1U << eVirtualCursorChangeEvent);
   }
 
   // AccTableChangeEvent
-  nsIAccessible* OldAccessible() const { return mOldAccessible; }
+  Accessible* OldAccessible() const { return mOldAccessible; }
   int32_t OldStartOffset() const { return mOldStart; }
   int32_t OldEndOffset() const { return mOldEnd; }
   int32_t Reason() const { return mReason; }
 
 private:
-  nsRefPtr<nsIAccessible> mOldAccessible;
+  nsRefPtr<Accessible> mOldAccessible;
   int32_t mOldStart;
   int32_t mOldEnd;
   int16_t mReason;
 };
 
 /**
  * Accessible object attribute changed event.
  */
--- a/accessible/base/DocManager.cpp
+++ b/accessible/base/DocManager.cpp
@@ -6,16 +6,17 @@
 #include "DocManager.h"
 
 #include "ApplicationAccessible.h"
 #include "ARIAMap.h"
 #include "DocAccessible-inl.h"
 #include "DocAccessibleChild.h"
 #include "nsAccessibilityService.h"
 #include "RootAccessibleWrap.h"
+#include "xpcAccessibleDocument.h"
 
 #ifdef A11Y_LOG
 #include "Logging.h"
 #endif
 
 #include "mozilla/EventListenerManager.h"
 #include "mozilla/dom/Event.h" // for nsIDOMEvent::InternalDOMEvent()
 #include "nsCURILoader.h"
@@ -35,17 +36,17 @@ using namespace mozilla;
 using namespace mozilla::a11y;
 using namespace mozilla::dom;
 
 ////////////////////////////////////////////////////////////////////////////////
 // DocManager
 ////////////////////////////////////////////////////////////////////////////////
 
 DocManager::DocManager()
-  : mDocAccessibleCache(2)
+  : mDocAccessibleCache(2), mXPCDocumentCache(0)
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DocManager public
 
 DocAccessible*
 DocManager::GetDocAccessible(nsIDocument* aDocument)
@@ -70,16 +71,44 @@ DocManager::FindAccessibleInCache(nsINod
   arg.mNode = aNode;
 
   mDocAccessibleCache.EnumerateRead(SearchAccessibleInDocCache,
                                     static_cast<void*>(&arg));
 
   return arg.mAccessible;
 }
 
+void
+DocManager::NotifyOfDocumentShutdown(DocAccessible* aDocument,
+                                     nsIDocument* aDOMDocument)
+{
+  xpcAccessibleDocument* xpcDoc = mXPCDocumentCache.GetWeak(aDocument);
+  if (xpcDoc) {
+    xpcDoc->Shutdown();
+    mXPCDocumentCache.Remove(aDocument);
+  }
+
+  mDocAccessibleCache.Remove(aDOMDocument);
+  RemoveListeners(aDOMDocument);
+}
+
+xpcAccessibleDocument*
+DocManager::GetXPCDocument(DocAccessible* aDocument)
+{
+  if (!aDocument)
+    return nullptr;
+
+  xpcAccessibleDocument* xpcDoc = mXPCDocumentCache.GetWeak(aDocument);
+  if (!xpcDoc) {
+    xpcDoc = new xpcAccessibleDocument(aDocument);
+    mXPCDocumentCache.Put(aDocument, xpcDoc);
+  }
+  return xpcDoc;
+}
+
 #ifdef DEBUG
 bool
 DocManager::IsProcessingRefreshDriverNotification() const
 {
   bool isDocRefreshing = false;
   mDocAccessibleCache.EnumerateRead(SearchIfDocIsRefreshing,
                                     static_cast<void*>(&isDocRefreshing));
 
--- a/accessible/base/DocManager.h
+++ b/accessible/base/DocManager.h
@@ -12,16 +12,17 @@
 #include "nsWeakReference.h"
 #include "nsIPresShell.h"
 
 namespace mozilla {
 namespace a11y {
 
 class Accessible;
 class DocAccessible;
+class xpcAccessibleDocument;
 class DocAccessibleParent;
 
 /**
  * Manage the document accessible life cycle.
  */
 class DocManager : public nsIWebProgressListener,
                    public nsIDOMEventListener,
                    public nsSupportsWeakReference
@@ -55,21 +56,25 @@ public:
    * Search through all document accessibles for an accessible with the given
    * unique id.
    */
   Accessible* FindAccessibleInCache(nsINode* aNode) const;
 
   /**
    * Called by document accessible when it gets shutdown.
    */
-  inline void NotifyOfDocumentShutdown(nsIDocument* aDocument)
-  {
-    mDocAccessibleCache.Remove(aDocument);
-    RemoveListeners(aDocument);
-  }
+  void NotifyOfDocumentShutdown(DocAccessible* aDocument,
+                                nsIDocument* aDOMDocument);
+
+  /**
+   * Return XPCOM accessible document.
+   */
+  xpcAccessibleDocument* GetXPCDocument(DocAccessible* aDocument);
+  xpcAccessibleDocument* GetCachedXPCDocument(DocAccessible* aDocument) const
+    { return mXPCDocumentCache.GetWeak(aDocument); }
 
   /*
    * Notification that a top level document in a content process has gone away.
    */
   void RemoteDocShutdown(DocAccessibleParent* aDoc)
   {
     DebugOnly<bool> result = mRemoteDocuments.RemoveElement(aDoc);
     MOZ_ASSERT(result, "Why didn't we find the document!");
@@ -125,19 +130,16 @@ private:
   void AddListeners(nsIDocument *aDocument, bool aAddPageShowListener);
   void RemoveListeners(nsIDocument* aDocument);
 
   /**
    * Create document or root accessible.
    */
   DocAccessible* CreateDocOrRootAccessible(nsIDocument* aDocument);
 
-  typedef nsRefPtrHashtable<nsPtrHashKey<const nsIDocument>, DocAccessible>
-    DocAccessibleHashtable;
-
   /**
    * Get first entry of the document accessible from cache.
    */
   static PLDHashOperator
     GetFirstEntryInDocCache(const nsIDocument* aKey,
                             DocAccessible* aDocAccessible,
                             void* aUserArg);
 
@@ -158,18 +160,24 @@ private:
                                void* aUserArg);
 
 #ifdef DEBUG
   static PLDHashOperator
     SearchIfDocIsRefreshing(const nsIDocument* aKey,
                             DocAccessible* aDocAccessible, void* aUserArg);
 #endif
 
+  typedef nsRefPtrHashtable<nsPtrHashKey<const nsIDocument>, DocAccessible>
+    DocAccessibleHashtable;
   DocAccessibleHashtable mDocAccessibleCache;
 
+  typedef nsRefPtrHashtable<nsPtrHashKey<const DocAccessible>, xpcAccessibleDocument>
+    XPCDocumentHashtable;
+  XPCDocumentHashtable mXPCDocumentCache;
+
   /*
    * The list of remote top level documents.
    */
   nsTArray<DocAccessibleParent*> mRemoteDocuments;
 };
 
 /**
  * Return the existing document accessible for the document if any.
--- a/accessible/base/nsAccCache.h
+++ b/accessible/base/nsAccCache.h
@@ -1,19 +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/. */
 
 #ifndef _nsAccCache_H_
 #define _nsAccCache_H_
 
-#include "nsIAccessible.h"
-#include "nsRefPtrHashtable.h"
-#include "nsCycleCollectionParticipant.h"
+#include "xpcAccessibleDocument.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // Accessible cache utils
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
  * Shutdown and removes the accessible from cache.
  */
@@ -33,49 +31,9 @@ ClearCacheEntry(const void* aKey, nsRefP
  */
 
 static void
 ClearCache(mozilla::a11y::AccessibleHashtable& aCache)
 {
   aCache.Enumerate(ClearCacheEntry<mozilla::a11y::Accessible>, nullptr);
 }
 
-/**
- * Traverse the accessible cache entry for cycle collector.
- */
-template <class T>
-static PLDHashOperator
-CycleCollectorTraverseCacheEntry(const void *aKey, T *aAccessible,
-                                 void *aUserArg)
-{
-  nsCycleCollectionTraversalCallback *cb =
-    static_cast<nsCycleCollectionTraversalCallback*>(aUserArg);
-
-  NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(*cb, "accessible cache entry");
-
-  nsISupports *supports = static_cast<nsIAccessible*>(aAccessible);
-  cb->NoteXPCOMChild(supports);
-  return PL_DHASH_NEXT;
-}
-
-/**
- * Unlink the accessible cache for the cycle collector.
- */
-inline void
-ImplCycleCollectionUnlink(mozilla::a11y::AccessibleHashtable& aCache)
-{
-  ClearCache(aCache);
-}
-
-/**
- * Traverse the accessible cache for cycle collector.
- */
-inline void
-ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
-                            mozilla::a11y::AccessibleHashtable& aCache,
-                            const char* aName,
-                            uint32_t aFlags = 0)
-{
-  aCache.EnumerateRead(CycleCollectorTraverseCacheEntry<mozilla::a11y::Accessible>,
-                       &aCallback);
-}
-
 #endif
--- a/accessible/base/nsAccUtils.cpp
+++ b/accessible/base/nsAccUtils.cpp
@@ -363,24 +363,17 @@ nsAccUtils::IsTextInterfaceSupportCorrec
   for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {
     Accessible* child = aAccessible->GetChildAt(childIdx);
     if (!IsEmbeddedObject(child)) {
       foundText = true;
       break;
     }
   }
 
-  if (foundText) {
-    // found text child node
-    nsCOMPtr<nsIAccessibleText> text = do_QueryObject(aAccessible);
-    if (!text)
-      return false;
-  }
-
-  return true;
+  return !foundText || aAccessible->IsHyperText();
 }
 #endif
 
 uint32_t
 nsAccUtils::TextLength(Accessible* aAccessible)
 {
   if (IsEmbeddedObject(aAccessible))
     return 1;
--- a/accessible/base/nsAccessibilityService.cpp
+++ b/accessible/base/nsAccessibilityService.cpp
@@ -30,16 +30,18 @@
 #include "Role.h"
 #ifdef MOZ_ACCESSIBILITY_ATK
 #include "RootAccessibleWrap.h"
 #endif
 #include "States.h"
 #include "Statistics.h"
 #include "TextLeafAccessibleWrap.h"
 #include "TreeWalker.h"
+#include "xpcAccessibleApplication.h"
+#include "xpcAccessibleDocument.h"
 
 #ifdef MOZ_ACCESSIBILITY_ATK
 #include "AtkSocketAccessible.h"
 #endif
 
 #ifdef XP_WIN
 #include "mozilla/a11y/Compatibility.h"
 #include "HTMLWin32ObjectAccessible.h"
@@ -132,16 +134,17 @@ MustBeAccessible(nsIContent* aContent, D
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsAccessibilityService
 ////////////////////////////////////////////////////////////////////////////////
 
 nsAccessibilityService *nsAccessibilityService::gAccessibilityService = nullptr;
 ApplicationAccessible* nsAccessibilityService::gApplicationAccessible = nullptr;
+xpcAccessibleApplication* nsAccessibilityService::gXPCApplicationAccessible = nullptr;
 bool nsAccessibilityService::gIsShutdown = true;
 
 nsAccessibilityService::nsAccessibilityService() :
   DocManager(), FocusManager()
 {
 }
 
 nsAccessibilityService::~nsAccessibilityService()
@@ -551,18 +554,17 @@ nsAccessibilityService::RecreateAccessib
 ////////////////////////////////////////////////////////////////////////////////
 // nsIAccessibleRetrieval
 
 NS_IMETHODIMP
 nsAccessibilityService::GetApplicationAccessible(nsIAccessible** aAccessibleApplication)
 {
   NS_ENSURE_ARG_POINTER(aAccessibleApplication);
 
-  NS_IF_ADDREF(*aAccessibleApplication = ApplicationAcc());
-
+  NS_IF_ADDREF(*aAccessibleApplication = XPCApplicationAcc());
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAccessibilityService::GetAccessibleFor(nsIDOMNode *aNode,
                                          nsIAccessible **aAccessible)
 {
   NS_ENSURE_ARG_POINTER(aAccessible);
@@ -571,17 +573,17 @@ nsAccessibilityService::GetAccessibleFor
     return NS_OK;
 
   nsCOMPtr<nsINode> node(do_QueryInterface(aNode));
   if (!node)
     return NS_ERROR_INVALID_ARG;
 
   DocAccessible* document = GetDocAccessible(node->OwnerDoc());
   if (document)
-    NS_IF_ADDREF(*aAccessible = document->GetAccessible(node));
+    NS_IF_ADDREF(*aAccessible = ToXPC(document->GetAccessible(node)));
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAccessibilityService::GetStringRole(uint32_t aRole, nsAString& aString)
 {
 #define ROLE(geckoRole, stringRole, atkRole, \
@@ -775,29 +777,29 @@ nsAccessibilityService::GetAccessibleFro
   // exist in the document cache.
   Accessible* accessible = FindAccessibleInCache(node);
   if (!accessible) {
     nsCOMPtr<nsIDocument> document(do_QueryInterface(node));
     if (document)
       accessible = GetExistingDocAccessible(document);
   }
 
-  NS_IF_ADDREF(*aAccessible = accessible);
+  NS_IF_ADDREF(*aAccessible = ToXPC(accessible));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAccessibilityService::CreateAccessiblePivot(nsIAccessible* aRoot,
                                               nsIAccessiblePivot** aPivot)
 {
   NS_ENSURE_ARG_POINTER(aPivot);
   NS_ENSURE_ARG(aRoot);
   *aPivot = nullptr;
 
-  nsRefPtr<Accessible> accessibleRoot(do_QueryObject(aRoot));
+  Accessible* accessibleRoot = aRoot->ToInternalAccessible();
   NS_ENSURE_TRUE(accessibleRoot, NS_ERROR_INVALID_ARG);
 
   nsAccessiblePivot* pivot = new nsAccessiblePivot(accessibleRoot);
   NS_ADDREF(*aPivot = pivot);
 
   return NS_OK;
 }
 
@@ -1174,16 +1176,19 @@ nsAccessibilityService::Shutdown()
   NS_ASSERTION(!gIsShutdown, "Accessibility was shutdown already");
 
   gIsShutdown = true;
 
   PlatformShutdown();
   gApplicationAccessible->Shutdown();
   NS_RELEASE(gApplicationAccessible);
   gApplicationAccessible = nullptr;
+
+  NS_IF_RELEASE(gXPCApplicationAccessible);
+  gXPCApplicationAccessible = nullptr;
 }
 
 already_AddRefed<Accessible>
 nsAccessibilityService::CreateAccessibleByType(nsIContent* aContent,
                                                DocAccessible* aDoc)
 {
   nsAutoString role;
   for (const nsXBLBinding* binding = aContent->GetXBLBinding(); binding; binding = binding->GetBaseBinding()) {
@@ -1661,16 +1666,30 @@ nsAccessibilityService::RemoveNativeRoot
 #ifdef MOZ_ACCESSIBILITY_ATK
   ApplicationAccessible* applicationAcc = ApplicationAcc();
 
   if (applicationAcc)
     applicationAcc->RemoveChild(aAccessible);
 #endif
 }
 
+bool
+nsAccessibilityService::HasAccessible(nsIDOMNode* aDOMNode)
+{
+  nsCOMPtr<nsINode> node(do_QueryInterface(aDOMNode));
+  if (!node)
+    return false;
+
+  DocAccessible* document = GetDocAccessible(node->OwnerDoc());
+  if (!document)
+    return false;
+
+  return document->HasAccessible(node);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // NS_GetAccessibilityService
 ////////////////////////////////////////////////////////////////////////////////
 
 /**
  * Return accessibility service; creating one if necessary.
  */
 nsresult
@@ -1755,16 +1774,29 @@ SelectionMgr()
 }
 
 ApplicationAccessible*
 ApplicationAcc()
 {
   return nsAccessibilityService::gApplicationAccessible;
 }
 
+xpcAccessibleApplication*
+XPCApplicationAcc()
+{
+  if (!nsAccessibilityService::gXPCApplicationAccessible &&
+      nsAccessibilityService::gApplicationAccessible) {
+    nsAccessibilityService::gXPCApplicationAccessible =
+      new xpcAccessibleApplication(nsAccessibilityService::gApplicationAccessible);
+    NS_ADDREF(nsAccessibilityService::gXPCApplicationAccessible);
+  }
+
+  return nsAccessibilityService::gXPCApplicationAccessible;
+}
+
 EPlatformDisabledState
 PlatformDisabledState()
 {
   static int disabledState = 0xff;
 
   if (disabledState == 0xff) {
     disabledState = Preferences::GetInt("accessibility.force_disabled", 0);
     if (disabledState < ePlatformIsForceEnabled)
--- a/accessible/base/nsAccessibilityService.h
+++ b/accessible/base/nsAccessibilityService.h
@@ -17,31 +17,33 @@
 class nsImageFrame;
 class nsPluginFrame;
 class nsITreeView;
 
 namespace mozilla {
 namespace a11y {
 
 class ApplicationAccessible;
+class xpcAccessibleApplication;
 
 /**
  * Return focus manager.
  */
 FocusManager* FocusMgr();
 
 /**
  * Return selection manager.
  */
 SelectionManager* SelectionMgr();
 
 /**
  * Returns the application accessible.
  */
 ApplicationAccessible* ApplicationAcc();
+xpcAccessibleApplication* XPCApplicationAcc();
 
 } // namespace a11y
 } // namespace mozilla
 
 class nsAccessibilityService MOZ_FINAL : public mozilla::a11y::DocManager,
                                          public mozilla::a11y::FocusManager,
                                          public mozilla::a11y::SelectionManager,
                                          public nsIAccessibilityService,
@@ -68,16 +70,19 @@ public:
 
   /**
    * Adds/remove ATK root accessible for gtk+ native window to/from children
    * of the application accessible.
    */
   virtual Accessible* AddNativeRootAccessible(void* aAtkAccessible);
   virtual void RemoveNativeRootAccessible(Accessible* aRootAccessible);
 
+  virtual bool HasAccessible(nsIDOMNode* aDOMNode) MOZ_OVERRIDE;
+
+  // nsAccesibilityService
   /**
    * Notification used to update the accessible tree when deck panel is
    * switched.
    */
   void DeckPanelSwitched(nsIPresShell* aPresShell, nsIContent* aDeckNode,
                          nsIFrame* aPrevBoxFrame, nsIFrame* aCurrentBoxFrame);
 
   /**
@@ -210,26 +215,28 @@ private:
    * Reference for accessibility service instance.
    */
   static nsAccessibilityService* gAccessibilityService;
 
   /**
    * Reference for application accessible instance.
    */
   static mozilla::a11y::ApplicationAccessible* gApplicationAccessible;
+  static mozilla::a11y::xpcAccessibleApplication* gXPCApplicationAccessible;
 
   /**
    * Indicates whether accessibility service was shutdown.
    */
   static bool gIsShutdown;
 
   friend nsAccessibilityService* GetAccService();
   friend mozilla::a11y::FocusManager* mozilla::a11y::FocusMgr();
   friend mozilla::a11y::SelectionManager* mozilla::a11y::SelectionMgr();
   friend mozilla::a11y::ApplicationAccessible* mozilla::a11y::ApplicationAcc();
+  friend mozilla::a11y::xpcAccessibleApplication* mozilla::a11y::XPCApplicationAcc();
 
   friend nsresult NS_GetAccessibilityService(nsIAccessibilityService** aResult);
 };
 
 /**
  * Return the accessibility service instance. (Handy global function)
  */
 inline nsAccessibilityService*
--- a/accessible/base/nsAccessiblePivot.cpp
+++ b/accessible/base/nsAccessiblePivot.cpp
@@ -4,16 +4,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/. */
 
 #include "nsAccessiblePivot.h"
 
 #include "HyperTextAccessible.h"
 #include "nsAccUtils.h"
 #include "States.h"
+#include "xpcAccessibleDocument.h"
 
 using namespace mozilla::a11y;
 
 
 /**
  * An object that stores a given traversal rule during the pivot movement.
  */
 class RuleCache
@@ -65,75 +66,74 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(nsAcces
 ////////////////////////////////////////////////////////////////////////////////
 // nsIAccessiblePivot
 
 NS_IMETHODIMP
 nsAccessiblePivot::GetRoot(nsIAccessible** aRoot)
 {
   NS_ENSURE_ARG_POINTER(aRoot);
 
-  NS_IF_ADDREF(*aRoot = mRoot);
+  NS_IF_ADDREF(*aRoot = ToXPC(mRoot));
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAccessiblePivot::GetPosition(nsIAccessible** aPosition)
 {
   NS_ENSURE_ARG_POINTER(aPosition);
 
-  NS_IF_ADDREF(*aPosition = mPosition);
+  NS_IF_ADDREF(*aPosition = ToXPC(mPosition));
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAccessiblePivot::SetPosition(nsIAccessible* aPosition)
 {
-  nsRefPtr<Accessible> secondPosition;
+  nsRefPtr<Accessible> position = nullptr;
 
   if (aPosition) {
-    secondPosition = do_QueryObject(aPosition);
-    if (!secondPosition || !IsDescendantOf(secondPosition, GetActiveRoot()))
+    position = aPosition->ToInternalAccessible();
+    if (!position || !IsDescendantOf(position, GetActiveRoot()))
       return NS_ERROR_INVALID_ARG;
   }
 
   // Swap old position with new position, saves us an AddRef/Release.
-  mPosition.swap(secondPosition);
+  mPosition.swap(position);
   int32_t oldStart = mStartOffset, oldEnd = mEndOffset;
   mStartOffset = mEndOffset = -1;
-  NotifyOfPivotChange(secondPosition, oldStart, oldEnd,
+  NotifyOfPivotChange(position, oldStart, oldEnd,
                       nsIAccessiblePivot::REASON_NONE, false);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAccessiblePivot::GetModalRoot(nsIAccessible** aModalRoot)
 {
   NS_ENSURE_ARG_POINTER(aModalRoot);
 
-  NS_IF_ADDREF(*aModalRoot = mModalRoot);
+  NS_IF_ADDREF(*aModalRoot = ToXPC(mModalRoot));
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAccessiblePivot::SetModalRoot(nsIAccessible* aModalRoot)
 {
-  nsRefPtr<Accessible> modalRoot;
+  Accessible* modalRoot = nullptr;
 
   if (aModalRoot) {
-    modalRoot = do_QueryObject(aModalRoot);
+    modalRoot = aModalRoot->ToInternalAccessible();
     if (!modalRoot || !IsDescendantOf(modalRoot, mRoot))
       return NS_ERROR_INVALID_ARG;
   }
 
-  mModalRoot.swap(modalRoot);
-
+  mModalRoot = modalRoot;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAccessiblePivot::GetStartOffset(int32_t* aStartOffset)
 {
   NS_ENSURE_ARG_POINTER(aStartOffset);
 
@@ -160,60 +160,58 @@ nsAccessiblePivot::SetTextRange(nsIAcces
   NS_ENSURE_ARG(aTextAccessible);
 
   // Check that start offset is smaller than end offset, and that if a value is
   // smaller than 0, both should be -1.
   NS_ENSURE_TRUE(aStartOffset <= aEndOffset &&
                  (aStartOffset >= 0 || (aStartOffset != -1 && aEndOffset != -1)),
                  NS_ERROR_INVALID_ARG);
 
-  nsRefPtr<Accessible> acc(do_QueryObject(aTextAccessible));
-  if (!acc)
-    return NS_ERROR_INVALID_ARG;
+  nsCOMPtr<nsIAccessible> xpcAcc = do_QueryInterface(aTextAccessible);
+  NS_ENSURE_ARG(xpcAcc);
 
-  HyperTextAccessible* newPosition = acc->AsHyperText();
-  if (!newPosition || !IsDescendantOf(newPosition, GetActiveRoot()))
+  nsRefPtr<Accessible> acc = xpcAcc->ToInternalAccessible();
+  NS_ENSURE_ARG(acc);
+
+  HyperTextAccessible* position = acc->AsHyperText();
+  if (!position || !IsDescendantOf(position, GetActiveRoot()))
     return NS_ERROR_INVALID_ARG;
 
   // Make sure the given offsets don't exceed the character count.
-  int32_t charCount = newPosition->CharacterCount();
-
-  if (aEndOffset > charCount)
+  if (aEndOffset > static_cast<int32_t>(position->CharacterCount()))
     return NS_ERROR_FAILURE;
 
   int32_t oldStart = mStartOffset, oldEnd = mEndOffset;
   mStartOffset = aStartOffset;
   mEndOffset = aEndOffset;
 
-  nsRefPtr<Accessible> oldPosition = mPosition.forget();
-  mPosition = newPosition;
-
-  NotifyOfPivotChange(oldPosition, oldStart, oldEnd,
+  mPosition.swap(acc);
+  NotifyOfPivotChange(acc, oldStart, oldEnd,
                       nsIAccessiblePivot::REASON_TEXT,
                       (aArgc > 0) ? aIsFromUserInput : true);
 
   return NS_OK;
 }
 
 // Traversal functions
 
 NS_IMETHODIMP
 nsAccessiblePivot::MoveNext(nsIAccessibleTraversalRule* aRule,
                             nsIAccessible* aAnchor, bool aIncludeStart,
                             bool aIsFromUserInput, uint8_t aArgc, bool* aResult)
 {
   NS_ENSURE_ARG(aResult);
   NS_ENSURE_ARG(aRule);
-
   *aResult = false;
 
-  Accessible* root = GetActiveRoot();
-  nsRefPtr<Accessible> anchor =
-    (aArgc > 0) ? do_QueryObject(aAnchor) : mPosition;
-  if (anchor && (anchor->IsDefunct() || !IsDescendantOf(anchor, root)))
+  Accessible* anchor = mPosition;
+  if (aArgc > 0 && aAnchor)
+    anchor = aAnchor->ToInternalAccessible();
+
+  if (anchor && (anchor->IsDefunct() || !IsDescendantOf(anchor, GetActiveRoot())))
     return NS_ERROR_NOT_IN_TREE;
 
   nsresult rv = NS_OK;
   Accessible* accessible =
     SearchForward(anchor, aRule, (aArgc > 1) ? aIncludeStart : false, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (accessible)
@@ -226,23 +224,23 @@ nsAccessiblePivot::MoveNext(nsIAccessibl
 NS_IMETHODIMP
 nsAccessiblePivot::MovePrevious(nsIAccessibleTraversalRule* aRule,
                                 nsIAccessible* aAnchor,
                                 bool aIncludeStart, bool aIsFromUserInput,
                                 uint8_t aArgc, bool* aResult)
 {
   NS_ENSURE_ARG(aResult);
   NS_ENSURE_ARG(aRule);
-
   *aResult = false;
 
-  Accessible* root = GetActiveRoot();
-  nsRefPtr<Accessible> anchor =
-    (aArgc > 0) ? do_QueryObject(aAnchor) : mPosition;
-  if (anchor && (anchor->IsDefunct() || !IsDescendantOf(anchor, root)))
+  Accessible* anchor = mPosition;
+  if (aArgc > 0 && aAnchor)
+    anchor = aAnchor->ToInternalAccessible();
+
+  if (anchor && (anchor->IsDefunct() || !IsDescendantOf(anchor, GetActiveRoot())))
     return NS_ERROR_NOT_IN_TREE;
 
   nsresult rv = NS_OK;
   Accessible* accessible =
     SearchBackward(anchor, aRule, (aArgc > 1) ? aIncludeStart : false, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   if (accessible)
@@ -850,20 +848,21 @@ bool
 nsAccessiblePivot::NotifyOfPivotChange(Accessible* aOldPosition,
                                        int32_t aOldStart, int32_t aOldEnd,
                                        int16_t aReason, bool aIsFromUserInput)
 {
   if (aOldPosition == mPosition &&
       aOldStart == mStartOffset && aOldEnd == mEndOffset)
     return false;
 
+  nsCOMPtr<nsIAccessible> xpcOldPos = ToXPC(aOldPosition); // death grip
   nsTObserverArray<nsCOMPtr<nsIAccessiblePivotObserver> >::ForwardIterator iter(mObservers);
   while (iter.HasMore()) {
     nsIAccessiblePivotObserver* obs = iter.GetNext();
-    obs->OnPivotChanged(this, aOldPosition, aOldStart, aOldEnd, aReason,
+    obs->OnPivotChanged(this, xpcOldPos, aOldStart, aOldEnd, aReason,
                         aIsFromUserInput);
   }
 
   return true;
 }
 
 nsresult
 RuleCache::ApplyFilter(Accessible* aAccessible, uint16_t* aResult)
@@ -920,10 +919,10 @@ RuleCache::ApplyFilter(Accessible* aAcce
       matchesRole = mAcceptRoles[idx] == accessibleRole;
       if (matchesRole)
         break;
     }
     if (!matchesRole)
       return NS_OK;
   }
 
-  return mRule->Match(aAccessible, aResult);
+  return mRule->Match(ToXPC(aAccessible), aResult);
 }
--- a/accessible/generic/ARIAGridAccessible.cpp
+++ b/accessible/generic/ARIAGridAccessible.cpp
@@ -23,39 +23,24 @@ using namespace mozilla::a11y;
 ////////////////////////////////////////////////////////////////////////////////
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Constructor
 
 ARIAGridAccessible::
   ARIAGridAccessible(nsIContent* aContent, DocAccessible* aDoc) :
-  AccessibleWrap(aContent, aDoc), xpcAccessibleTable(this)
+  AccessibleWrap(aContent, aDoc)
 {
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// nsISupports
-
-NS_IMPL_ISUPPORTS_INHERITED(ARIAGridAccessible,
-                            Accessible,
-                            nsIAccessibleTable)
+NS_IMPL_ISUPPORTS_INHERITED0(ARIAGridAccessible, Accessible)
 
 ////////////////////////////////////////////////////////////////////////////////
-// Accessible
-
-void
-ARIAGridAccessible::Shutdown()
-{
-  mTable = nullptr;
-  AccessibleWrap::Shutdown();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// nsIAccessibleTable
+// Table
 
 uint32_t
 ARIAGridAccessible::ColCount()
 {
   AccIterator rowIter(this, filters::GetRow);
   Accessible* row = rowIter.Next();
   if (!row)
     return 0;
@@ -400,38 +385,16 @@ ARIAGridAccessible::UnselectCol(uint32_t
     if (cell)
       SetARIASelected(cell, false);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Protected
 
-bool
-ARIAGridAccessible::IsValidRow(int32_t aRow)
-{
-  if (aRow < 0)
-    return false;
-  
-  int32_t rowCount = 0;
-  GetRowCount(&rowCount);
-  return aRow < rowCount;
-}
-
-bool
-ARIAGridAccessible::IsValidColumn(int32_t aColumn)
-{
-  if (aColumn < 0)
-    return false;
-
-  int32_t colCount = 0;
-  GetColumnCount(&colCount);
-  return aColumn < colCount;
-}
-
 Accessible*
 ARIAGridAccessible::GetRowAt(int32_t aRow)
 {
   int32_t rowIdx = aRow;
 
   AccIterator rowIter(this, filters::GetRow);
 
   Accessible* row = rowIter.Next();
@@ -527,30 +490,25 @@ ARIAGridAccessible::SetARIASelected(Acce
 ////////////////////////////////////////////////////////////////////////////////
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Constructor
 
 ARIAGridCellAccessible::
   ARIAGridCellAccessible(nsIContent* aContent, DocAccessible* aDoc) :
-  HyperTextAccessibleWrap(aContent, aDoc), xpcAccessibleTableCell(this)
+  HyperTextAccessibleWrap(aContent, aDoc)
 {
   mGenericTypes |= eTableCell;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// nsISupports
-
-NS_IMPL_ISUPPORTS_INHERITED(ARIAGridCellAccessible,
-                            HyperTextAccessible,
-                            nsIAccessibleTableCell)
+NS_IMPL_ISUPPORTS_INHERITED0(ARIAGridCellAccessible, HyperTextAccessible)
 
 ////////////////////////////////////////////////////////////////////////////////
-// nsIAccessibleTableCell
+// TableCell
 
 TableAccessible*
 ARIAGridCellAccessible::Table() const
 {
   Accessible* table = TableFor(Row());
   return table ? table->AsTable() : nullptr;
 }
 
@@ -643,15 +601,8 @@ ARIAGridCellAccessible::NativeAttributes
   int32_t rowIdx = RowIndexFor(thisRow);
 
   nsAutoString stringIdx;
   stringIdx.AppendInt(rowIdx * colCount + colIdx);
   nsAccUtils::SetAccAttr(attributes, nsGkAtoms::tableCellIndex, stringIdx);
 
   return attributes.forget();
 }
-
-void
-ARIAGridCellAccessible::Shutdown()
-{
-  mTableCell = nullptr;
-  HyperTextAccessibleWrap::Shutdown();
-}
--- a/accessible/generic/ARIAGridAccessible.h
+++ b/accessible/generic/ARIAGridAccessible.h
@@ -1,47 +1,36 @@
 /* -*- 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_ARIAGridAccessible_h_
 #define MOZILLA_A11Y_ARIAGridAccessible_h_
 
-#include "nsIAccessibleTable.h"
-
 #include "HyperTextAccessibleWrap.h"
 #include "TableAccessible.h"
 #include "TableCellAccessible.h"
-#include "xpcAccessibleTable.h"
-#include "xpcAccessibleTableCell.h"
 
 namespace mozilla {
 namespace a11y {
 
 /**
  * Accessible for ARIA grid and treegrid.
  */
 class ARIAGridAccessible : public AccessibleWrap,
-                           public xpcAccessibleTable,
-                           public nsIAccessibleTable,
                            public TableAccessible
 {
 public:
   ARIAGridAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
-  // nsISupports
   NS_DECL_ISUPPORTS_INHERITED
 
-  // nsIAccessibleTable
-  NS_FORWARD_NSIACCESSIBLETABLE(xpcAccessibleTable::)
-
   // Accessible
   virtual TableAccessible* AsTable() { return this; }
-  virtual void Shutdown();
 
   // TableAccessible
   virtual uint32_t ColCount();
   virtual uint32_t RowCount();
   virtual Accessible* CellAt(uint32_t aRowIndex, uint32_t aColumnIndex);
   virtual bool IsColSelected(uint32_t aColIdx);
   virtual bool IsRowSelected(uint32_t aRowIdx);
   virtual bool IsCellSelected(uint32_t aRowIdx, uint32_t aColIdx);
@@ -57,26 +46,16 @@ public:
   virtual void UnselectCol(uint32_t aColIdx);
   virtual void UnselectRow(uint32_t aRowIdx);
   virtual Accessible* AsAccessible() { return this; }
 
 protected:
   virtual ~ARIAGridAccessible() {}
 
   /**
-   * Return true if the given row index is valid.
-   */
-  bool IsValidRow(int32_t aRow);
-
-  /**
-   * Retrn true if the given column index is valid.
-   */
-  bool IsValidColumn(int32_t aColumn);
-
-  /**
    * Return row accessible at the given row index.
    */
   Accessible* GetRowAt(int32_t aRow);
 
   /**
    * Return cell accessible at the given column index in the row.
    */
   Accessible* GetCellInRowAt(Accessible* aRow, int32_t aColumn);
@@ -93,32 +72,25 @@ protected:
                            bool aNotify = true);
 };
 
 
 /**
  * Accessible for ARIA gridcell and rowheader/columnheader.
  */
 class ARIAGridCellAccessible : public HyperTextAccessibleWrap,
-                               public nsIAccessibleTableCell,
-                               public TableCellAccessible,
-                               public xpcAccessibleTableCell
+                               public TableCellAccessible
 {
 public:
   ARIAGridCellAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
-  // nsISupports
   NS_DECL_ISUPPORTS_INHERITED
 
-  // nsIAccessibleTableCell
-  NS_FORWARD_NSIACCESSIBLETABLECELL(xpcAccessibleTableCell::)
-
   // Accessible
   virtual TableCellAccessible* AsTableCell() { return this; }
-  virtual void Shutdown();
   virtual void ApplyARIAState(uint64_t* aState) const;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() MOZ_OVERRIDE;
 
 protected:
   virtual ~ARIAGridCellAccessible() {}
 
   /**
    * Return a containing row.
--- a/accessible/generic/Accessible.cpp
+++ b/accessible/generic/Accessible.cpp
@@ -89,24 +89,20 @@ using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Accessible: nsISupports and cycle collection
 
 NS_IMPL_CYCLE_COLLECTION(Accessible,
                          mContent, mParent, mChildren)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Accessible)
-  NS_INTERFACE_MAP_ENTRY(nsIAccessible)
   if (aIID.Equals(NS_GET_IID(Accessible)))
-    foundInterface = static_cast<nsIAccessible*>(this);
+    foundInterface = this;
   else
-  NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleSelectable, IsSelect())
-  NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleValue, HasNumericValue())
-  NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleHyperLink, IsLink())
-  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIAccessible)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, Accessible)
 NS_INTERFACE_MAP_END
 
 NS_IMPL_CYCLE_COLLECTING_ADDREF(Accessible)
 NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_DESTROY(Accessible, LastRelease())
 
 Accessible::Accessible(nsIContent* aContent, DocAccessible* aDoc) :
   mContent(aContent), mDoc(aDoc),
   mParent(nullptr), mIndexInParent(-1), mChildrenFlags(eChildrenUninitialized),
@@ -920,17 +916,17 @@ Accessible::NativeAttributes()
   nsAutoString unused;
 
   // We support values, so expose the string value as well, via the valuetext
   // object attribute. We test for the value interface because we don't want
   // to expose traditional Value() information such as URL's on links and
   // documents, or text in an input.
   if (HasNumericValue()) {
     nsAutoString valuetext;
-    GetValue(valuetext);
+    Value(valuetext);
     attributes->SetStringProperty(NS_LITERAL_CSTRING("valuetext"), valuetext,
                                   unused);
   }
 
   // Expose checkable object attribute if the accessible has checkable state
   if (State() & states::CHECKABLE) {
     nsAccUtils::SetAccAttr(attributes, nsGkAtoms::checkable,
                            NS_LITERAL_STRING("true"));
@@ -1713,20 +1709,19 @@ Accessible::RelationByType(RelationType 
     case RelationType::CONTAINING_APPLICATION:
       return Relation(ApplicationAcc());
 
     default:
       return Relation();
   }
 }
 
-/* [noscript] void getNativeInterface(out voidPtr aOutAccessible); */
-NS_IMETHODIMP Accessible::GetNativeInterface(void **aOutAccessible)
+void
+Accessible::GetNativeInterface(void** aNativeAccessible)
 {
-  return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 void
 Accessible::DoCommand(nsIContent *aContent, uint32_t aActionIndex)
 {
   class Runnable MOZ_FINAL : public nsRunnable
   {
   public:
@@ -2199,29 +2194,23 @@ Accessible::AnchorURIAt(uint32_t aAnchor
   NS_PRECONDITION(IsLink(), "AnchorURIAt is called on not hyper link!");
   return nullptr;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // SelectAccessible
 
-already_AddRefed<nsIArray>
-Accessible::SelectedItems()
+void
+Accessible::SelectedItems(nsTArray<Accessible*>* aItems)
 {
-  nsCOMPtr<nsIMutableArray> selectedItems = do_CreateInstance(NS_ARRAY_CONTRACTID);
-  if (!selectedItems)
-    return nullptr;
-
   AccIterator iter(this, filters::GetSelected);
-  nsIAccessible* selected = nullptr;
+  Accessible* selected = nullptr;
   while ((selected = iter.Next()))
-    selectedItems->AppendElement(selected, false);
-
-  return selectedItems.forget();
+    aItems->AppendElement(selected);
 }
 
 uint32_t
 Accessible::SelectedItemCount()
 {
   uint32_t count = 0;
   AccIterator iter(this, filters::GetSelected);
   Accessible* selected = nullptr;
--- a/accessible/generic/Accessible.h
+++ b/accessible/generic/Accessible.h
@@ -6,41 +6,37 @@
 #ifndef _Accessible_H_
 #define _Accessible_H_
 
 #include "mozilla/a11y/AccTypes.h"
 #include "mozilla/a11y/RelationType.h"
 #include "mozilla/a11y/Role.h"
 #include "mozilla/a11y/States.h"
 
-#include "xpcAccessible.h"
-#include "xpcAccessibleHyperLink.h"
-#include "nsIAccessibleStates.h"
-#include "xpcAccessibleSelectable.h"
-#include "xpcAccessibleValue.h"
-
 #include "nsIContent.h"
 #include "nsString.h"
 #include "nsTArray.h"
 #include "nsRefPtrHashtable.h"
 
 struct nsRoleMapEntry;
 
 struct nsRect;
 class nsIFrame;
 class nsIAtom;
 struct nsIntRect;
+class nsIPersistentProperties;
 class nsView;
 
 namespace mozilla {
 namespace a11y {
 
 class Accessible;
 class AccEvent;
 class AccGroupInfo;
+class ApplicationAccessible;
 class DocAccessible;
 class EmbeddedObjCollector;
 class HTMLImageMapAccessible;
 class HTMLLIAccessible;
 class HyperTextAccessible;
 class ImageAccessible;
 class KeyBinding;
 class Relation;
@@ -118,32 +114,26 @@ typedef nsRefPtrHashtable<nsPtrHashKey<c
 #define NS_ACCESSIBLE_IMPL_IID                          \
 {  /* 133c8bf4-4913-4355-bd50-426bd1d6e1ad */           \
   0x133c8bf4,                                           \
   0x4913,                                               \
   0x4355,                                               \
   { 0xbd, 0x50, 0x42, 0x6b, 0xd1, 0xd6, 0xe1, 0xad }    \
 }
 
-class Accessible : public xpcAccessible,
-                   public xpcAccessibleHyperLink,
-                   public xpcAccessibleSelectable,
-                   public xpcAccessibleValue
+class Accessible : public nsISupports
 {
 public:
   Accessible(nsIContent* aContent, DocAccessible* aDoc);
 
   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(Accessible, nsIAccessible)
+  NS_DECL_CYCLE_COLLECTION_CLASS(Accessible)
 
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_ACCESSIBLE_IMPL_IID)
 
-  // nsIAccessible
-  NS_IMETHOD GetNativeInterface(void** aOutAccessible);
-
   //////////////////////////////////////////////////////////////////////////////
   // Public methods
 
   /**
    * Return the document accessible for this accessible.
    */
   DocAccessible* Document() const { return mDoc; }
 
@@ -190,16 +180,21 @@ public:
   virtual void Description(nsString& aDescription);
 
   /**
    * Get the value of this accessible.
    */
   virtual void Value(nsString& aValue);
 
   /**
+   * Get help string for the accessible.
+   */
+  void Help(nsString& aHelp) const { aHelp.Truncate(); }
+
+  /**
    * Get the name of this accessible.
    *
    * Note: aName.IsVoid() when name was left empty by the author on purpose.
    * aName.IsEmpty() when the author missed name, AT can try to repair a name.
    */
   virtual ENameValueFlag Name(nsString& aName);
 
   /**
@@ -529,16 +524,21 @@ public:
   virtual nsRect RelativeBounds(nsIFrame** aRelativeFrame) const;
 
   /**
    * Selects the accessible within its container if applicable.
    */
   virtual void SetSelected(bool aSelect);
 
   /**
+   * Extend selection to this accessible.
+   */
+  void ExtendSelection() { };
+
+  /**
    * Select the accessible within its container.
    */
   void TakeSelection();
 
   /**
    * Focus the accessible.
    */
   virtual void TakeFocus();
@@ -548,26 +548,33 @@ public:
    */
   void ScrollTo(uint32_t aHow) const;
 
   /**
    * Scroll the accessible to the given point.
    */
   void ScrollToPoint(uint32_t aCoordinateType, int32_t aX, int32_t aY);
 
+  /**
+   * Get a pointer to accessibility interface for this node, which is specific
+   * to the OS/accessibility toolkit we're running on.
+   */
+  virtual void GetNativeInterface(void** aNativeAccessible);
+
   //////////////////////////////////////////////////////////////////////////////
   // Downcasting and types
 
   inline bool IsAbbreviation() const
   {
     return mContent->IsHTML() &&
       (mContent->Tag() == nsGkAtoms::abbr || mContent->Tag() == nsGkAtoms::acronym);
   }
 
   bool IsApplication() const { return mType == eApplicationType; }
+  ApplicationAccessible* AsApplication();
 
   bool IsAutoComplete() const { return HasGenericType(eAutoComplete); }
 
   bool IsAutoCompletePopup() const
     { return HasGenericType(eAutoCompletePopup); }
 
   bool IsButton() const { return HasGenericType(eButton); }
 
@@ -729,17 +736,17 @@ public:
   virtual already_AddRefed<nsIURI> AnchorURIAt(uint32_t aAnchorIndex);
 
   //////////////////////////////////////////////////////////////////////////////
   // SelectAccessible
 
   /**
    * Return an array of selected items.
    */
-  virtual already_AddRefed<nsIArray> SelectedItems();
+  virtual void SelectedItems(nsTArray<Accessible*>* aItems);
 
   /**
    * Return the number of selected items.
    */
   virtual uint32_t SelectedItemCount();
 
   /**
    * Return selected item at the given index.
--- a/accessible/generic/ApplicationAccessible.cpp
+++ b/accessible/generic/ApplicationAccessible.cpp
@@ -25,21 +25,17 @@ using namespace mozilla::a11y;
 
 ApplicationAccessible::ApplicationAccessible() :
   AccessibleWrap(nullptr, nullptr)
 {
   mType = eApplicationType;
   mAppInfo = do_GetService("@mozilla.org/xre/app-info;1");
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// nsISupports
-
-NS_IMPL_ISUPPORTS_INHERITED(ApplicationAccessible, Accessible,
-                            nsIAccessibleApplication)
+NS_IMPL_ISUPPORTS_INHERITED0(ApplicationAccessible, Accessible)
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIAccessible
 
 ENameValueFlag
 ApplicationAccessible::Name(nsString& aName)
 {
   aName.Truncate();
--- a/accessible/generic/ApplicationAccessible.h
+++ b/accessible/generic/ApplicationAccessible.h
@@ -4,17 +4,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 mozilla_a11y_ApplicationAccessible_h__
 #define mozilla_a11y_ApplicationAccessible_h__
 
 #include "AccessibleWrap.h"
-#include "xpcAccessibleApplication.h"
 
 #include "nsIMutableArray.h"
 #include "nsIXULAppInfo.h"
 
 namespace mozilla {
 namespace a11y {
 
 /**
@@ -22,24 +21,22 @@ namespace a11y {
  * Only one instance of ApplicationAccessible exists for one Mozilla instance.
  * And this one should be created when Mozilla Startup (if accessibility
  * feature has been enabled) and destroyed when Mozilla Shutdown.
  *
  * All the accessibility objects for toplevel windows are direct children of
  * the ApplicationAccessible instance.
  */
 
-class ApplicationAccessible : public AccessibleWrap,
-                              public xpcAccessibleApplication
+class ApplicationAccessible : public AccessibleWrap
 {
 public:
 
   ApplicationAccessible();
 
-  // nsISupports
   NS_DECL_ISUPPORTS_INHERITED
 
   // Accessible
   virtual void Shutdown();
   virtual nsIntRect Bounds() const MOZ_OVERRIDE;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() MOZ_OVERRIDE;
   virtual GroupPos GroupPosition();
   virtual ENameValueFlag Name(nsString& aName);
@@ -94,13 +91,19 @@ protected:
   virtual void CacheChildren();
   virtual Accessible* GetSiblingAtOffset(int32_t aOffset,
                                          nsresult *aError = nullptr) const;
 
 private:
   nsCOMPtr<nsIXULAppInfo> mAppInfo;
 };
 
+inline ApplicationAccessible*
+Accessible::AsApplication()
+{
+  return IsApplication() ? static_cast<ApplicationAccessible*>(this) : nullptr;
+}
+
 } // namespace a11y
 } // namespace mozilla
 
 #endif
 
--- a/accessible/generic/BaseAccessibles.cpp
+++ b/accessible/generic/BaseAccessibles.cpp
@@ -164,18 +164,17 @@ LinkableAccessible::Shutdown()
 
 ////////////////////////////////////////////////////////////////////////////////
 // LinkableAccessible: HyperLinkAccessible
 
 already_AddRefed<nsIURI>
 LinkableAccessible::AnchorURIAt(uint32_t aAnchorIndex)
 {
   if (mIsLink) {
-    NS_ASSERTION(mActionAcc->IsLink(),
-                 "nsIAccessibleHyperLink isn't implemented.");
+    NS_ASSERTION(mActionAcc->IsLink(), "HyperLink isn't implemented.");
 
     if (mActionAcc->IsLink())
       return mActionAcc->AnchorURIAt(aAnchorIndex);
   }
 
   return nullptr;
 }
 
--- a/accessible/generic/BaseAccessibles.h
+++ b/accessible/generic/BaseAccessibles.h
@@ -113,22 +113,25 @@ protected:
 
 /**
  * A wrapper accessible around native accessible to connect it with
  * crossplatform accessible tree.
  */
 class DummyAccessible : public AccessibleWrap
 {
 public:
-  DummyAccessible() : AccessibleWrap(nullptr, nullptr) { }
-  virtual ~DummyAccessible() { }
+  DummyAccessible(DocAccessible* aDocument = nullptr) :
+    AccessibleWrap(nullptr, aDocument) { }
 
   virtual uint64_t NativeState() MOZ_OVERRIDE MOZ_FINAL;
   virtual uint64_t NativeInteractiveState() const MOZ_OVERRIDE MOZ_FINAL;
   virtual uint64_t NativeLinkState() const MOZ_OVERRIDE MOZ_FINAL;
   virtual bool NativelyUnavailable() const MOZ_OVERRIDE MOZ_FINAL;
   virtual void ApplyARIAState(uint64_t* aState) const MOZ_OVERRIDE MOZ_FINAL;
+
+protected:
+  virtual ~DummyAccessible() { }
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
--- a/accessible/generic/DocAccessible.cpp
+++ b/accessible/generic/DocAccessible.cpp
@@ -11,16 +11,17 @@
 #include "nsAccCache.h"
 #include "nsAccessiblePivot.h"
 #include "nsAccUtils.h"
 #include "nsEventShell.h"
 #include "nsTextEquivUtils.h"
 #include "Role.h"
 #include "RootAccessible.h"
 #include "TreeWalker.h"
+#include "xpcAccessibleDocument.h"
 
 #include "nsIMutableArray.h"
 #include "nsICommandManager.h"
 #include "nsIDocShell.h"
 #include "nsIDocument.h"
 #include "nsIDOMAttr.h"
 #include "nsIDOMCharacterData.h"
 #include "nsIDOMDocument.h"
@@ -71,17 +72,17 @@ static nsIAtom** kRelationAttrs[] =
 static const uint32_t kRelationAttrsLen = ArrayLength(kRelationAttrs);
 
 ////////////////////////////////////////////////////////////////////////////////
 // Constructor/desctructor
 
 DocAccessible::
   DocAccessible(nsIDocument* aDocument, nsIContent* aRootContent,
                   nsIPresShell* aPresShell) :
-  HyperTextAccessibleWrap(aRootContent, this), xpcAccessibleDocument(),
+  HyperTextAccessibleWrap(aRootContent, this),
   // XXX aaronl should we use an algorithm for the initial cache size?
   mAccessibleCache(kDefaultCacheLength),
   mNodeToAccessibleMap(kDefaultCacheLength),
   mDocumentNode(aDocument),
   mScrollPositionChangedTicks(0),
   mLoadState(eTreeConstructionPending), mDocFlags(0), mLoadEventType(0),
   mVirtualCursor(nullptr),
   mPresShell(aPresShell), mIPCDoc(nullptr)
@@ -123,43 +124,22 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_IN
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mChildDocuments)
   tmp->mDependentIDsHash.Clear();
   tmp->mNodeToAccessibleMap.Clear();
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mAccessibleCache)
   NS_IMPL_CYCLE_COLLECTION_UNLINK(mAnchorJumpElm)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(DocAccessible)
-  NS_INTERFACE_MAP_ENTRY(nsIAccessibleDocument)
   NS_INTERFACE_MAP_ENTRY(nsIDocumentObserver)
   NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
   NS_INTERFACE_MAP_ENTRY(nsIObserver)
   NS_INTERFACE_MAP_ENTRY(nsIAccessiblePivotObserver)
-  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIAccessibleDocument)
-    foundInterface = 0;
-
-  nsresult status;
-  if (!foundInterface) {
-    // HTML document accessible must inherit from HyperTextAccessible to get
-    // support text interfaces. XUL document accessible doesn't need this.
-    // However at some point we may push <body> to implement the interfaces and
-    // return DocAccessible to inherit from AccessibleWrap.
-
-    status = IsHyperText() ? 
-      HyperTextAccessible::QueryInterface(aIID, (void**)&foundInterface) :
-      Accessible::QueryInterface(aIID, (void**)&foundInterface);
-  } else {
-    NS_ADDREF(foundInterface);
-    status = NS_OK;
-  }
-
-  *aInstancePtr = foundInterface;
-  return status;
-}
+NS_INTERFACE_MAP_END_INHERITING(HyperTextAccessible)
 
 NS_IMPL_ADDREF_INHERITED(DocAccessible, HyperTextAccessible)
 NS_IMPL_RELEASE_INHERITED(DocAccessible, HyperTextAccessible)
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIAccessible
 
 ENameValueFlag
@@ -495,17 +475,17 @@ DocAccessible::Shutdown()
     // We're about to get rid of all of our children so there won't be anything
     // to invalidate.
     AutoTreeMutation mut(this, false);
     ClearCache(mAccessibleCache);
   }
 
   HyperTextAccessibleWrap::Shutdown();
 
-  GetAccService()->NotifyOfDocumentShutdown(kungFuDeathGripDoc);
+  GetAccService()->NotifyOfDocumentShutdown(this, kungFuDeathGripDoc);
 }
 
 nsIFrame*
 DocAccessible::GetFrame() const
 {
   nsIFrame* root = nullptr;
   if (mPresShell)
     root = mPresShell->GetRootFrame();
@@ -685,19 +665,21 @@ DocAccessible::Observe(nsISupports* aSub
 
 NS_IMETHODIMP
 DocAccessible::OnPivotChanged(nsIAccessiblePivot* aPivot,
                               nsIAccessible* aOldAccessible,
                               int32_t aOldStart, int32_t aOldEnd,
                               PivotMoveReason aReason,
                               bool aIsFromUserInput)
 {
-  nsRefPtr<AccEvent> event = new AccVCChangeEvent(
-    this, aOldAccessible, aOldStart, aOldEnd, aReason,
-    aIsFromUserInput ? eFromUserInput : eNoUserInput);
+  nsRefPtr<AccEvent> event =
+    new AccVCChangeEvent(
+      this, (aOldAccessible ? aOldAccessible->ToInternalAccessible() : nullptr),
+      aOldStart, aOldEnd, aReason,
+      aIsFromUserInput ? eFromUserInput : eNoUserInput);
   nsEventShell::FireEvent(event);
 
   return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIDocumentObserver
 
@@ -1260,16 +1242,21 @@ DocAccessible::UnbindFromDocument(Access
 #endif
   }
 
   // Remove an accessible from node-to-accessible map if it exists there.
   if (aAccessible->IsNodeMapEntry() &&
       mNodeToAccessibleMap.Get(aAccessible->GetNode()) == aAccessible)
     mNodeToAccessibleMap.Remove(aAccessible->GetNode());
 
+  // Update XPCOM part.
+  xpcAccessibleDocument* xpcDoc = GetAccService()->GetCachedXPCDocument(this);
+  if (xpcDoc)
+    xpcDoc->NotifyOfShutdown(aAccessible);
+
   void* uniqueID = aAccessible->UniqueID();
 
   NS_ASSERTION(!aAccessible->IsDefunct(), "Shutdown the shutdown accessible!");
   aAccessible->Shutdown();
 
   mAccessibleCache.Remove(uniqueID);
 }
 
--- a/accessible/generic/DocAccessible.h
+++ b/accessible/generic/DocAccessible.h
@@ -1,17 +1,16 @@
 /* -*- 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_DocAccessible_h__
 #define mozilla_a11y_DocAccessible_h__
 
-#include "xpcAccessibleDocument.h"
 #include "nsIAccessiblePivot.h"
 
 #include "AccEvent.h"
 #include "HyperTextAccessibleWrap.h"
 
 #include "nsClassHashtable.h"
 #include "nsDataHashtable.h"
 #include "nsIDocument.h"
@@ -34,28 +33,26 @@ namespace a11y {
 class DocManager;
 class NotificationController;
 class DocAccessibleChild;
 class RelatedAccIterator;
 template<class Class, class Arg>
 class TNotification;
 
 class DocAccessible : public HyperTextAccessibleWrap,
-                      public xpcAccessibleDocument,
                       public nsIDocumentObserver,
                       public nsIObserver,
                       public nsIScrollPositionListener,
                       public nsSupportsWeakReference,
                       public nsIAccessiblePivotObserver
 {
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(DocAccessible, Accessible)
 
   NS_DECL_NSIOBSERVER
-
   NS_DECL_NSIACCESSIBLEPIVOTOBSERVER
 
 public:
 
   DocAccessible(nsIDocument* aDocument, nsIContent* aRootContent,
                 nsIPresShell* aPresShell);
 
   // nsIScrollPositionListener
--- a/accessible/generic/FormControlAccessible.cpp
+++ b/accessible/generic/FormControlAccessible.cpp
@@ -18,30 +18,16 @@ using namespace mozilla::a11y;
 ////////////////////////////////////////////////////////////////////////////////
 // ProgressMeterAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 template class mozilla::a11y::ProgressMeterAccessible<1>;
 template class mozilla::a11y::ProgressMeterAccessible<100>;
 
 ////////////////////////////////////////////////////////////////////////////////
-// nsISupports
-
-template<int Max>
-NS_IMPL_ADDREF_INHERITED(ProgressMeterAccessible<Max>, LeafAccessible)
-
-template<int Max>
-NS_IMPL_RELEASE_INHERITED(ProgressMeterAccessible<Max>, LeafAccessible)
-
-template<int Max>
-NS_IMPL_QUERY_INTERFACE_INHERITED(ProgressMeterAccessible<Max>,
-                                  LeafAccessible,
-                                  nsIAccessibleValue)
-
-////////////////////////////////////////////////////////////////////////////////
 // Accessible
 
 template<int Max>
 role
 ProgressMeterAccessible<Max>::NativeRole()
 {
   return roles::PROGRESSBAR;
 }
@@ -68,17 +54,17 @@ ProgressMeterAccessible<Max>::NativeStat
 template<int Max>
 bool
 ProgressMeterAccessible<Max>::IsWidget() const
 {
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// nsIAccessibleValue
+// ProgressMeterAccessible<Max>: Value
 
 template<int Max>
 void
 ProgressMeterAccessible<Max>::Value(nsString& aValue)
 {
   LeafAccessible::Value(aValue);
   if (!aValue.IsEmpty())
     return;
--- a/accessible/generic/FormControlAccessible.h
+++ b/accessible/generic/FormControlAccessible.h
@@ -22,18 +22,16 @@ public:
     LeafAccessible(aContent, aDoc)
   {
     // Ignore 'ValueChange' DOM event in lieu of @value attribute change
     // notifications.
     mStateFlags |= eHasNumericValue | eIgnoreDOMUIEvent;
     mType = eProgressType;
   }
 
-  NS_DECL_ISUPPORTS_INHERITED
-
   // Accessible
   virtual void Value(nsString& aValue);
   virtual mozilla::a11y::role NativeRole() MOZ_OVERRIDE;
   virtual uint64_t NativeState() MOZ_OVERRIDE;
 
   // Value
   virtual double MaxValue() const MOZ_OVERRIDE;
   virtual double MinValue() const MOZ_OVERRIDE;
--- a/accessible/generic/HyperTextAccessible.cpp
+++ b/accessible/generic/HyperTextAccessible.cpp
@@ -43,29 +43,22 @@ using namespace mozilla;
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // HyperTextAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 HyperTextAccessible::
   HyperTextAccessible(nsIContent* aNode, DocAccessible* aDoc) :
-  AccessibleWrap(aNode, aDoc), xpcAccessibleHyperText()
+  AccessibleWrap(aNode, aDoc)
 {
   mGenericTypes |= eHyperText;
 }
 
-nsresult
-HyperTextAccessible::QueryInterface(REFNSIID aIID, void** aInstancePtr)
-{
-  xpcAccessibleHyperText::QueryInterface(aIID, aInstancePtr);
-  return *aInstancePtr ? NS_OK : Accessible::QueryInterface(aIID, aInstancePtr);
-}
-NS_IMPL_ADDREF_INHERITED(HyperTextAccessible, AccessibleWrap)
-NS_IMPL_RELEASE_INHERITED(HyperTextAccessible, AccessibleWrap)
+NS_IMPL_ISUPPORTS_INHERITED0(HyperTextAccessible, Accessible)
 
 role
 HyperTextAccessible::NativeRole()
 {
   nsIAtom *tag = mContent->Tag();
 
   if (tag == nsGkAtoms::dd)
     return roles::DEFINITION;
@@ -644,22 +637,22 @@ HyperTextAccessible::TextBeforeOffset(in
     return;
   }
 
   uint32_t adjustedOffset = convertedOffset;
   if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET)
     adjustedOffset = AdjustCaretOffset(adjustedOffset);
 
   switch (aBoundaryType) {
-    case BOUNDARY_CHAR:
+    case nsIAccessibleText::BOUNDARY_CHAR:
       if (convertedOffset != 0)
         CharAt(convertedOffset - 1, aText, aStartOffset, aEndOffset);
       break;
 
-    case BOUNDARY_WORD_START: {
+    case nsIAccessibleText::BOUNDARY_WORD_START: {
       // If the offset is a word start (except text length offset) then move
       // backward to find a start offset (end offset is the given offset).
       // Otherwise move backward twice to find both start and end offsets.
       if (adjustedOffset == CharacterCount()) {
         *aEndOffset = FindWordBoundary(adjustedOffset, eDirPrevious, eStartWord);
         *aStartOffset = FindWordBoundary(*aEndOffset, eDirPrevious, eStartWord);
       } else {
         *aStartOffset = FindWordBoundary(adjustedOffset, eDirPrevious, eStartWord);
@@ -668,31 +661,31 @@ HyperTextAccessible::TextBeforeOffset(in
           *aEndOffset = *aStartOffset;
           *aStartOffset = FindWordBoundary(*aEndOffset, eDirPrevious, eStartWord);
         }
       }
       TextSubstring(*aStartOffset, *aEndOffset, aText);
       break;
     }
 
-    case BOUNDARY_WORD_END: {
+    case nsIAccessibleText::BOUNDARY_WORD_END: {
       // Move word backward twice to find start and end offsets.
       *aEndOffset = FindWordBoundary(convertedOffset, eDirPrevious, eEndWord);
       *aStartOffset = FindWordBoundary(*aEndOffset, eDirPrevious, eEndWord);
       TextSubstring(*aStartOffset, *aEndOffset, aText);
       break;
     }
 
-    case BOUNDARY_LINE_START:
+    case nsIAccessibleText::BOUNDARY_LINE_START:
       *aStartOffset = FindLineBoundary(adjustedOffset, ePrevLineBegin);
       *aEndOffset = FindLineBoundary(adjustedOffset, eThisLineBegin);
       TextSubstring(*aStartOffset, *aEndOffset, aText);
       break;
 
-    case BOUNDARY_LINE_END: {
+    case nsIAccessibleText::BOUNDARY_LINE_END: {
       *aEndOffset = FindLineBoundary(adjustedOffset, ePrevLineEnd);
       int32_t tmpOffset = *aEndOffset;
       // Adjust offset if line is wrapped.
       if (*aEndOffset != 0 && !IsLineEndCharAt(*aEndOffset))
         tmpOffset--;
 
       *aStartOffset = FindLineBoundary(tmpOffset, ePrevLineEnd);
       TextSubstring(*aStartOffset, *aEndOffset, aText);
@@ -712,53 +705,53 @@ HyperTextAccessible::TextAtOffset(int32_
 
   uint32_t adjustedOffset = ConvertMagicOffset(aOffset);
   if (adjustedOffset == std::numeric_limits<uint32_t>::max()) {
     NS_ERROR("Wrong given offset!");
     return;
   }
 
   switch (aBoundaryType) {
-    case BOUNDARY_CHAR:
+    case nsIAccessibleText::BOUNDARY_CHAR:
       // Return no char if caret is at the end of wrapped line (case of no line
       // end character). Returning a next line char is confusing for AT.
       if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET && IsCaretAtEndOfLine())
         *aStartOffset = *aEndOffset = adjustedOffset;
       else
         CharAt(adjustedOffset, aText, aStartOffset, aEndOffset);
       break;
 
-    case BOUNDARY_WORD_START:
+    case nsIAccessibleText::BOUNDARY_WORD_START:
       if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET)
         adjustedOffset = AdjustCaretOffset(adjustedOffset);
 
       *aEndOffset = FindWordBoundary(adjustedOffset, eDirNext, eStartWord);
       *aStartOffset = FindWordBoundary(*aEndOffset, eDirPrevious, eStartWord);
       TextSubstring(*aStartOffset, *aEndOffset, aText);
       break;
 
-    case BOUNDARY_WORD_END:
+    case nsIAccessibleText::BOUNDARY_WORD_END:
       // Ignore the spec and follow what WebKitGtk does because Orca expects it,
       // i.e. return a next word at word end offset of the current word
       // (WebKitGtk behavior) instead the current word (AKT spec).
       *aEndOffset = FindWordBoundary(adjustedOffset, eDirNext, eEndWord);
       *aStartOffset = FindWordBoundary(*aEndOffset, eDirPrevious, eEndWord);
       TextSubstring(*aStartOffset, *aEndOffset, aText);
       break;
 
-    case BOUNDARY_LINE_START:
+    case nsIAccessibleText::BOUNDARY_LINE_START:
       if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET)
         adjustedOffset = AdjustCaretOffset(adjustedOffset);
 
       *aStartOffset = FindLineBoundary(adjustedOffset, eThisLineBegin);
       *aEndOffset = FindLineBoundary(adjustedOffset, eNextLineBegin);
       TextSubstring(*aStartOffset, *aEndOffset, aText);
       break;
 
-    case BOUNDARY_LINE_END:
+    case nsIAccessibleText::BOUNDARY_LINE_END:
       if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET)
         adjustedOffset = AdjustCaretOffset(adjustedOffset);
 
       // In contrast to word end boundary we follow the spec here.
       *aStartOffset = FindLineBoundary(adjustedOffset, ePrevLineEnd);
       *aEndOffset = FindLineBoundary(adjustedOffset, eThisLineEnd);
       TextSubstring(*aStartOffset, *aEndOffset, aText);
       break;
@@ -780,33 +773,33 @@ HyperTextAccessible::TextAfterOffset(int
     return;
   }
 
   uint32_t adjustedOffset = convertedOffset;
   if (aOffset == nsIAccessibleText::TEXT_OFFSET_CARET)
     adjustedOffset = AdjustCaretOffset(adjustedOffset);
 
   switch (aBoundaryType) {
-    case BOUNDARY_CHAR:
+    case nsIAccessibleText::BOUNDARY_CHAR:
       // If caret is at the end of wrapped line (case of no line end character)
       // then char after the offset is a first char at next line.
       if (adjustedOffset >= CharacterCount())
         *aStartOffset = *aEndOffset = CharacterCount();
       else
         CharAt(adjustedOffset + 1, aText, aStartOffset, aEndOffset);
       break;
 
-    case BOUNDARY_WORD_START:
+    case nsIAccessibleText::BOUNDARY_WORD_START:
       // Move word forward twice to find start and end offsets.
       *aStartOffset = FindWordBoundary(adjustedOffset, eDirNext, eStartWord);
       *aEndOffset = FindWordBoundary(*aStartOffset, eDirNext, eStartWord);
       TextSubstring(*aStartOffset, *aEndOffset, aText);
       break;
 
-    case BOUNDARY_WORD_END:
+    case nsIAccessibleText::BOUNDARY_WORD_END:
       // If the offset is a word end (except 0 offset) then move forward to find
       // end offset (start offset is the given offset). Otherwise move forward
       // twice to find both start and end offsets.
       if (convertedOffset == 0) {
         *aStartOffset = FindWordBoundary(convertedOffset, eDirNext, eEndWord);
         *aEndOffset = FindWordBoundary(*aStartOffset, eDirNext, eEndWord);
       } else {
         *aEndOffset = FindWordBoundary(convertedOffset, eDirNext, eEndWord);
@@ -814,23 +807,23 @@ HyperTextAccessible::TextAfterOffset(int
         if (*aStartOffset != static_cast<int32_t>(convertedOffset)) {
           *aStartOffset = *aEndOffset;
           *aEndOffset = FindWordBoundary(*aStartOffset, eDirNext, eEndWord);
         }
       }
       TextSubstring(*aStartOffset, *aEndOffset, aText);
       break;
 
-    case BOUNDARY_LINE_START:
+    case nsIAccessibleText::BOUNDARY_LINE_START:
       *aStartOffset = FindLineBoundary(adjustedOffset, eNextLineBegin);
       *aEndOffset = FindLineBoundary(*aStartOffset, eNextLineBegin);
       TextSubstring(*aStartOffset, *aEndOffset, aText);
       break;
 
-    case BOUNDARY_LINE_END:
+    case nsIAccessibleText::BOUNDARY_LINE_END:
       *aStartOffset = FindLineBoundary(adjustedOffset, eThisLineEnd);
       *aEndOffset = FindLineBoundary(adjustedOffset, eNextLineEnd);
       TextSubstring(*aStartOffset, *aEndOffset, aText);
       break;
   }
 }
 
 already_AddRefed<nsIPersistentProperties>
--- a/accessible/generic/HyperTextAccessible.h
+++ b/accessible/generic/HyperTextAccessible.h
@@ -2,18 +2,18 @@
 /* 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_HyperTextAccessible_h__
 #define mozilla_a11y_HyperTextAccessible_h__
 
 #include "AccessibleWrap.h"
+#include "nsIAccessibleText.h"
 #include "nsIAccessibleTypes.h"
-#include "xpcAccessibleHyperText.h"
 #include "nsDirection.h"
 #include "WordMovementType.h"
 #include "nsIFrame.h"
 
 #include "nsISelectionController.h"
 
 class nsFrameSelection;
 class nsRange;
@@ -32,27 +32,26 @@ class TextRange;
 struct DOMPoint {
   DOMPoint() : node(nullptr), idx(0) { }
   DOMPoint(nsINode* aNode, int32_t aIdx) : node(aNode), idx(aIdx) { }
 
   nsINode* node;
   int32_t idx;
 };
 
-// This character marks where in the text returned via nsIAccessibleText(),
+// This character marks where in the text returned via Text interface,
 // that embedded object characters exist
 const char16_t kEmbeddedObjectChar = 0xfffc;
 const char16_t kImaginaryEmbeddedObjectChar = ' ';
 const char16_t kForcedNewLineChar = '\n';
 
 /**
   * Special Accessible that knows how contain both text and embedded objects
   */
-class HyperTextAccessible : public AccessibleWrap,
-                            public xpcAccessibleHyperText
+class HyperTextAccessible : public AccessibleWrap
 {
 public:
   HyperTextAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   NS_DECL_ISUPPORTS_INHERITED
 
   // Accessible
   virtual int32_t GetLevelInternal();
--- a/accessible/generic/ImageAccessible.cpp
+++ b/accessible/generic/ImageAccessible.cpp
@@ -34,19 +34,16 @@ ImageAccessible::
 {
   mType = eImageType;
 }
 
 ImageAccessible::~ImageAccessible()
 {
 }
 
-NS_IMPL_ISUPPORTS_INHERITED(ImageAccessible, Accessible,
-                            nsIAccessibleImage)
-
 ////////////////////////////////////////////////////////////////////////////////
 // Accessible public
 
 uint64_t
 ImageAccessible::NativeState()
 {
   // The state is a bitfield, get our inherited state, then logically OR it with
   // states::ANIMATED if this is an animated image.
@@ -95,17 +92,17 @@ ImageAccessible::NativeName(nsString& aN
 
 role
 ImageAccessible::NativeRole()
 {
   return roles::GRAPHIC;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// nsIAccessible
+// Accessible
 
 uint8_t
 ImageAccessible::ActionCount()
 {
   uint8_t actionCount = LinkableAccessible::ActionCount();
   return HasLongDesc() ? actionCount + 1 : actionCount;
 }
 
--- a/accessible/generic/ImageAccessible.h
+++ b/accessible/generic/ImageAccessible.h
@@ -2,37 +2,32 @@
 /* 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_ImageAccessible_h__
 #define mozilla_a11y_ImageAccessible_h__
 
 #include "BaseAccessibles.h"
-#include "xpcAccessibleImage.h"
 
 class nsGenericHTMLElement;
 
 namespace mozilla {
 namespace a11y {
 
 /* Accessible for supporting images
  * supports:
  * - gets name, role
  * - support basic state
  */
-class ImageAccessible : public LinkableAccessible,
-                        public xpcAccessibleImage
+class ImageAccessible : public LinkableAccessible
 {
 public:
   ImageAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
-  // nsISupports
-  NS_DECL_ISUPPORTS_INHERITED
-
   // Accessible
   virtual a11y::role NativeRole() MOZ_OVERRIDE;
   virtual uint64_t NativeState() MOZ_OVERRIDE;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() MOZ_OVERRIDE;
 
   // ActionAccessible
   virtual uint8_t ActionCount() MOZ_OVERRIDE;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) MOZ_OVERRIDE;
--- a/accessible/generic/RootAccessible.cpp
+++ b/accessible/generic/RootAccessible.cpp
@@ -20,17 +20,16 @@
 #include "Role.h"
 #include "States.h"
 #ifdef MOZ_XUL
 #include "XULTreeAccessible.h"
 #endif
 
 #include "mozilla/dom/Element.h"
 
-#include "nsIAccessibleRelation.h"
 #include "nsIDocShellTreeItem.h"
 #include "nsIDocShellTreeOwner.h"
 #include "mozilla/dom/Event.h"
 #include "mozilla/dom/EventTarget.h"
 #include "nsIDOMCustomEvent.h"
 #include "nsIDOMXULMultSelectCntrlEl.h"
 #include "nsIDocument.h"
 #include "nsIInterfaceRequestorUtils.h"
@@ -48,17 +47,17 @@
 
 using namespace mozilla;
 using namespace mozilla::a11y;
 using namespace mozilla::dom;
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsISupports
 
-NS_IMPL_ISUPPORTS_INHERITED(RootAccessible, DocAccessible, nsIAccessibleDocument)
+NS_IMPL_ISUPPORTS_INHERITED0(RootAccessible, DocAccessible)
 
 ////////////////////////////////////////////////////////////////////////////////
 // Constructor/destructor
 
 RootAccessible::
   RootAccessible(nsIDocument* aDocument, nsIContent* aRootContent,
                  nsIPresShell* aPresShell) :
   DocAccessibleWrap(aDocument, aRootContent, aPresShell)
@@ -472,17 +471,16 @@ RootAccessible::Shutdown()
 {
   // Called manually or by Accessible::LastRelease()
   if (!PresShell())
     return;  // Already shutdown
 
   DocAccessibleWrap::Shutdown();
 }
 
-// nsIAccessible method
 Relation
 RootAccessible::RelationByType(RelationType aType)
 {
   if (!mDocumentNode || aType != RelationType::EMBEDS)
     return DocAccessibleWrap::RelationByType(aType);
 
   nsIDOMWindow* rootWindow = mDocumentNode->GetWindow();
   if (rootWindow) {
--- a/accessible/html/HTMLElementAccessibles.cpp
+++ b/accessible/html/HTMLElementAccessibles.cpp
@@ -2,17 +2,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/. */
 
 #include "HTMLElementAccessibles.h"
 
 #include "DocAccessible.h"
 #include "nsAccUtils.h"
-#include "nsIAccessibleRelation.h"
 #include "nsIPersistentProperties2.h"
 #include "nsTextEquivUtils.h"
 #include "Relation.h"
 #include "Role.h"
 #include "States.h"
 
 #include "mozilla/dom/HTMLLabelElement.h"
 
--- a/accessible/html/HTMLFormControlAccessible.cpp
+++ b/accessible/html/HTMLFormControlAccessible.cpp
@@ -10,17 +10,16 @@
 #include "nsEventShell.h"
 #include "nsTextEquivUtils.h"
 #include "Relation.h"
 #include "Role.h"
 #include "States.h"
 
 #include "nsContentList.h"
 #include "mozilla/dom/HTMLInputElement.h"
-#include "nsIAccessibleRelation.h"
 #include "nsIDOMNSEditableElement.h"
 #include "nsIDOMHTMLTextAreaElement.h"
 #include "nsIEditor.h"
 #include "nsIFormControl.h"
 #include "nsIPersistentProperties2.h"
 #include "nsISelectionController.h"
 #include "nsIServiceManager.h"
 #include "nsITextControlFrame.h"
@@ -279,20 +278,18 @@ HTMLButtonAccessible::IsWidget() const
 
 HTMLTextFieldAccessible::
   HTMLTextFieldAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   HyperTextAccessibleWrap(aContent, aDoc)
 {
   mType = eHTMLTextFieldType;
 }
 
-NS_IMPL_ISUPPORTS_INHERITED(HTMLTextFieldAccessible,
-                            Accessible,
-                            nsIAccessibleText,
-                            nsIAccessibleEditableText)
+NS_IMPL_ISUPPORTS_INHERITED0(HTMLTextFieldAccessible,
+                             HyperTextAccessible)
 
 role
 HTMLTextFieldAccessible::NativeRole()
 {
   if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
                             nsGkAtoms::password, eIgnoreCase)) {
     return roles::PASSWORD_TEXT;
   }
--- a/accessible/html/HTMLImageMapAccessible.cpp
+++ b/accessible/html/HTMLImageMapAccessible.cpp
@@ -170,27 +170,27 @@ HTMLAreaAccessible::
   HTMLLinkAccessible(aContent, aDoc)
 {
   // Make HTML area DOM element not accessible. HTML image map accessible
   // manages its tree itself.
   mStateFlags |= eNotNodeMapEntry;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// HTMLAreaAccessible: nsIAccessible
+// HTMLAreaAccessible: Accessible
 
 ENameValueFlag
 HTMLAreaAccessible::NativeName(nsString& aName)
 {
   ENameValueFlag nameFlag = Accessible::NativeName(aName);
   if (!aName.IsEmpty())
     return nameFlag;
 
   if (!mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::alt, aName))
-    GetValue(aName);
+    Value(aName);
 
   return eNameOK;
 }
 
 void
 HTMLAreaAccessible::Description(nsString& aDescription)
 {
   aDescription.Truncate();
--- a/accessible/html/HTMLLinkAccessible.cpp
+++ b/accessible/html/HTMLLinkAccessible.cpp
@@ -22,19 +22,17 @@ using namespace mozilla::a11y;
 ////////////////////////////////////////////////////////////////////////////////
 
 HTMLLinkAccessible::
   HTMLLinkAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   HyperTextAccessibleWrap(aContent, aDoc)
 {
 }
 
-// Expose nsIAccessibleHyperLink unconditionally
-NS_IMPL_ISUPPORTS_INHERITED(HTMLLinkAccessible, HyperTextAccessibleWrap,
-                            nsIAccessibleHyperLink)
+NS_IMPL_ISUPPORTS_INHERITED0(HTMLLinkAccessible, HyperTextAccessible)
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIAccessible
 
 role
 HTMLLinkAccessible::NativeRole()
 {
   return roles::LINK;
--- a/accessible/html/HTMLSelectAccessible.cpp
+++ b/accessible/html/HTMLSelectAccessible.cpp
@@ -5,17 +5,16 @@
 
 #include "HTMLSelectAccessible.h"
 
 #include "Accessible-inl.h"
 #include "nsAccessibilityService.h"
 #include "nsAccUtils.h"
 #include "DocAccessible.h"
 #include "nsEventShell.h"
-#include "nsIAccessibleEvent.h"
 #include "nsTextEquivUtils.h"
 #include "Role.h"
 #include "States.h"
 
 #include "nsCOMPtr.h"
 #include "mozilla/dom/HTMLOptionElement.h"
 #include "nsIComboboxControlFrame.h"
 #include "nsContainerFrame.h"
@@ -388,18 +387,17 @@ HTMLComboboxAccessible::CacheChildren()
   if (!comboFrame)
     return;
 
   nsIFrame* listFrame = comboFrame->GetDropDown();
   if (!listFrame)
     return;
 
   if (!mListAccessible) {
-    mListAccessible = 
-      new HTMLComboboxListAccessible(mParent, mContent, mDoc);
+    mListAccessible = new HTMLComboboxListAccessible(mParent, mContent, mDoc);
 
     // Initialize and put into cache.
     Document()->BindToDocument(mListAccessible, nullptr);
   }
 
   if (AppendChild(mListAccessible)) {
     // Cache combobox option accessibles so that we build complete accessible
     // tree for combobox.
@@ -554,17 +552,17 @@ HTMLComboboxAccessible::SelectedOption()
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLComboboxListAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 HTMLComboboxListAccessible::
-  HTMLComboboxListAccessible(nsIAccessible* aParent, nsIContent* aContent,
+  HTMLComboboxListAccessible(Accessible* aParent, nsIContent* aContent,
                              DocAccessible* aDoc) :
   HTMLSelectListAccessible(aContent, aDoc)
 {
   mStateFlags |= eSharedNode;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLComboboxAccessible: Accessible
--- a/accessible/html/HTMLSelectAccessible.h
+++ b/accessible/html/HTMLSelectAccessible.h
@@ -204,17 +204,17 @@ private:
  * A class that represents the window that lives to the right
  * of the drop down button inside the Select. This is the window
  * that is made visible when the button is pressed.
  */
 class HTMLComboboxListAccessible : public HTMLSelectListAccessible
 {
 public:
 
-  HTMLComboboxListAccessible(nsIAccessible* aParent, nsIContent* aContent,
+  HTMLComboboxListAccessible(Accessible* aParent, nsIContent* aContent,
                              DocAccessible* aDoc);
   virtual ~HTMLComboboxListAccessible() {}
 
   // Accessible
   virtual nsIFrame* GetFrame() const;
   virtual a11y::role NativeRole() MOZ_OVERRIDE;
   virtual uint64_t NativeState() MOZ_OVERRIDE;
   virtual nsRect RelativeBounds(nsIFrame** aBoundingFrame) const MOZ_OVERRIDE;
--- a/accessible/html/HTMLTableAccessible.cpp
+++ b/accessible/html/HTMLTableAccessible.cpp
@@ -6,17 +6,16 @@
 #include "HTMLTableAccessible.h"
 
 #include "mozilla/DebugOnly.h"
 
 #include "Accessible-inl.h"
 #include "nsAccessibilityService.h"
 #include "nsAccUtils.h"
 #include "DocAccessible.h"
-#include "nsIAccessibleRelation.h"
 #include "nsTextEquivUtils.h"
 #include "Relation.h"
 #include "Role.h"
 #include "States.h"
 #include "TreeWalker.h"
 
 #include "mozilla/dom/HTMLTableElement.h"
 #include "nsIDOMElement.h"
@@ -42,38 +41,26 @@ using namespace mozilla::dom;
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLTableCellAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 HTMLTableCellAccessible::
   HTMLTableCellAccessible(nsIContent* aContent, DocAccessible* aDoc) :
-  HyperTextAccessibleWrap(aContent, aDoc), xpcAccessibleTableCell(this)
+  HyperTextAccessibleWrap(aContent, aDoc)
 {
   mGenericTypes |= eTableCell;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// HTMLTableCellAccessible: nsISupports implementation
-
-NS_IMPL_ISUPPORTS_INHERITED(HTMLTableCellAccessible,
-                            HyperTextAccessible,
-                            nsIAccessibleTableCell)
+NS_IMPL_ISUPPORTS_INHERITED0(HTMLTableCellAccessible, HyperTextAccessible)
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLTableCellAccessible: Accessible implementation
 
-void
-HTMLTableCellAccessible::Shutdown()
-{
-  mTableCell = nullptr;
-  HyperTextAccessibleWrap::Shutdown();
-}
-
 role
 HTMLTableCellAccessible::NativeRole()
 {
   return roles::CELL;
 }
 
 uint64_t
 HTMLTableCellAccessible::NativeState()
@@ -141,17 +128,17 @@ HTMLTableCellAccessible::NativeAttribute
   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::axis, axisText);
   if (!axisText.IsEmpty())
     nsAccUtils::SetAccAttr(attributes, nsGkAtoms::axis, axisText);
 
   return attributes.forget();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// HTMLTableCellAccessible: nsIAccessibleTableCell implementation
+// HTMLTableCellAccessible: TableCellAccessible implementation
 
 TableAccessible*
 HTMLTableCellAccessible::Table() const
 {
   Accessible* parent = const_cast<HTMLTableCellAccessible*>(this);
   while ((parent = parent->Parent())) {
     roles::Role role = parent->Role();
     if (role == roles::TABLE || role == roles::TREE_TABLE)
@@ -356,30 +343,22 @@ HTMLTableRowAccessible::NativeRole()
 {
   return roles::ROW;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLTableAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
-NS_IMPL_ISUPPORTS_INHERITED(HTMLTableAccessible, Accessible,
-                            nsIAccessibleTable)
+NS_IMPL_ISUPPORTS_INHERITED0(HTMLTableAccessible, Accessible)
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLTableAccessible: Accessible
 
 void
-HTMLTableAccessible::Shutdown()
-{
-  mTable = nullptr;
-  AccessibleWrap::Shutdown();
-}
-
-void
 HTMLTableAccessible::CacheChildren()
 {
   // Move caption accessible so that it's the first child. Check for the first
   // caption only, because nsAccessibilityService ensures we don't create
   // accessibles for the other captions, since only the first is actually
   // visible.
   TreeWalker walker(this, mContent);
 
@@ -439,30 +418,30 @@ HTMLTableAccessible::NativeAttributes()
     attributes->SetStringProperty(NS_LITERAL_CSTRING("layout-guess"),
                                   NS_LITERAL_STRING("true"), unused);
   }
 
   return attributes.forget();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// HTMLTableAccessible: nsIAccessible implementation
+// HTMLTableAccessible: Accessible
 
 Relation
 HTMLTableAccessible::RelationByType(RelationType aType)
 {
   Relation rel = AccessibleWrap::RelationByType(aType);
   if (aType == RelationType::LABELLED_BY)
     rel.AppendTarget(Caption());
 
   return rel;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// HTMLTableAccessible: nsIAccessibleTable implementation
+// HTMLTableAccessible: Table
 
 Accessible*
 HTMLTableAccessible::Caption() const
 {
   Accessible* child = mChildren.SafeElementAt(0, nullptr);
   return child && child->Role() == roles::CAPTION ? child : nullptr;
 }
 
@@ -1008,28 +987,27 @@ HTMLTableAccessible::IsProbablyLayoutTab
     }
   }
 
   if (HasDescendant(NS_LITERAL_STRING("table"))) {
     RETURN_LAYOUT_ANSWER(true, "Has a nested table within it");
   }
 
   // If only 1 column or only 1 row, it's for layout
-  int32_t columns, rows;
-  GetColumnCount(&columns);
-  if (columns <=1) {
+  uint32_t colCount = ColCount();
+  if (colCount <=1) {
     RETURN_LAYOUT_ANSWER(true, "Has only 1 column");
   }
-  GetRowCount(&rows);
-  if (rows <=1) {
+  uint32_t rowCount = RowCount();
+  if (rowCount <=1) {
     RETURN_LAYOUT_ANSWER(true, "Has only 1 row");
   }
 
   // Check for many columns
-  if (columns >= 5) {
+  if (colCount >= 5) {
     RETURN_LAYOUT_ANSWER(false, ">=5 columns");
   }
 
   // Now we know there are 2-4 columns and 2 or more rows
   // Check to see if there are visible borders on the cells
   // XXX currently, we just check the first cell -- do we really need to do more?
   nsTableOuterFrame* tableFrame = do_QueryFrame(mContent->GetPrimaryFrame());
   if (!tableFrame)
@@ -1062,18 +1040,18 @@ HTMLTableAccessible::IsProbablyLayoutTab
       rowColor = rowFrame->StyleBackground()->mBackgroundColor;
 
       if (childIdx > 0 && prevRowColor != rowColor)
         RETURN_LAYOUT_ANSWER(false, "2 styles of row background color, non-bordered");
     }
   }
 
   // Check for many rows
-  const int32_t kMaxLayoutRows = 20;
-  if (rows > kMaxLayoutRows) { // A ton of rows, this is probably for data
+  const uint32_t kMaxLayoutRows = 20;
+  if (rowCount > kMaxLayoutRows) { // A ton of rows, this is probably for data
     RETURN_LAYOUT_ANSWER(false, ">= kMaxLayoutRows (20) and non-bordered");
   }
 
   // Check for very wide table.
   nsIFrame* documentFrame = Document()->GetFrame();
   nsSize documentSize = documentFrame->GetSize();
   if (documentSize.width > 0) {
     nsSize tableSize = GetFrame()->GetSize();
@@ -1082,17 +1060,17 @@ HTMLTableAccessible::IsProbablyLayoutTab
       // 3-4 columns, no borders, not a lot of rows, and 95% of the doc's width
       // Probably for layout
       RETURN_LAYOUT_ANSWER(true,
                            "<= 4 columns, table width is 95% of document width");
     }
   }
 
   // Two column rules
-  if (rows * columns <= 10) {
+  if (rowCount * colCount <= 10) {
     RETURN_LAYOUT_ANSWER(true, "2-4 columns, 10 cells or less, non-bordered");
   }
 
   if (HasDescendant(NS_LITERAL_STRING("embed")) ||
       HasDescendant(NS_LITERAL_STRING("object")) ||
       HasDescendant(NS_LITERAL_STRING("applet")) ||
       HasDescendant(NS_LITERAL_STRING("iframe"))) {
     RETURN_LAYOUT_ANSWER(true, "Has no borders, and has iframe, object, applet or iframe, typical of advertisements");
--- a/accessible/html/HTMLTableAccessible.h
+++ b/accessible/html/HTMLTableAccessible.h
@@ -2,48 +2,39 @@
 /* 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_HTMLTableAccessible_h__
 #define mozilla_a11y_HTMLTableAccessible_h__
 
 #include "HyperTextAccessibleWrap.h"
-#include "nsIAccessibleTable.h"
 #include "TableAccessible.h"
 #include "TableCellAccessible.h"
-#include "xpcAccessibleTable.h"
-#include "xpcAccessibleTableCell.h"
 
 class nsITableLayout;
 class nsITableCellLayout;
 
 namespace mozilla {
 namespace a11y {
 
 /**
  * HTML table cell accessible (html:td).
  */
 class HTMLTableCellAccessible : public HyperTextAccessibleWrap,
-                                public nsIAccessibleTableCell,
-                                public TableCellAccessible,
-                                public xpcAccessibleTableCell
+                                public TableCellAccessible
 {
 public:
   HTMLTableCellAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // nsISupports
   NS_DECL_ISUPPORTS_INHERITED
 
-  // nsIAccessibleTableCell
-  NS_FORWARD_NSIACCESSIBLETABLECELL(xpcAccessibleTableCell::)
-
   // Accessible
   virtual TableCellAccessible* AsTableCell() { return this; }
-  virtual void Shutdown();
   virtual a11y::role NativeRole() MOZ_OVERRIDE;
   virtual uint64_t NativeState() MOZ_OVERRIDE;
   virtual uint64_t NativeInteractiveState() const MOZ_OVERRIDE;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() MOZ_OVERRIDE;
 
   // TableCellAccessible
   virtual TableAccessible* Table() const MOZ_OVERRIDE;
   virtual uint32_t ColIdx() const MOZ_OVERRIDE;
@@ -53,21 +44,16 @@ public:
   virtual void ColHeaderCells(nsTArray<Accessible*>* aCells) MOZ_OVERRIDE;
   virtual void RowHeaderCells(nsTArray<Accessible*>* aCells) MOZ_OVERRIDE;
   virtual bool Selected() MOZ_OVERRIDE;
 
 protected:
   virtual ~HTMLTableCellAccessible() {}
 
   /**
-   * Return host table accessible.
-   */
-  already_AddRefed<nsIAccessibleTable> GetTableAccessible();
-
-  /**
    * Return nsITableCellLayout of the table cell frame.
    */
   nsITableCellLayout* GetCellLayout() const;
 
   /**
    * Return row and column indices of the cell.
    */
   nsresult GetCellIndexes(int32_t& aRowIdx, int32_t& aColIdx) const;
@@ -115,33 +101,28 @@ protected:
  */
 
 // To turn on table debugging descriptions define SHOW_LAYOUT_HEURISTIC
 // This allow release trunk builds to be used by testers to refine the
 // data vs. layout heuristic
 // #define SHOW_LAYOUT_HEURISTIC
 
 class HTMLTableAccessible : public AccessibleWrap,
-                            public xpcAccessibleTable,
-                            public nsIAccessibleTable,
                             public TableAccessible
 {
 public:
   HTMLTableAccessible(nsIContent* aContent, DocAccessible* aDoc) :
-    AccessibleWrap(aContent, aDoc), xpcAccessibleTable(this)
+    AccessibleWrap(aContent, aDoc)
   {
     mType = eHTMLTableType;
     mGenericTypes |= eTable;
   }
 
   NS_DECL_ISUPPORTS_INHERITED
 
-  // nsIAccessible Table
-  NS_FORWARD_NSIACCESSIBLETABLE(xpcAccessibleTable::)
-
   // TableAccessible
   virtual Accessible* Caption() const;
   virtual void Summary(nsString& aSummary);
   virtual uint32_t ColCount();
   virtual uint32_t RowCount();
   virtual Accessible* CellAt(uint32_t aRowIndex, uint32_t aColumnIndex);
   virtual int32_t CellIndexAt(uint32_t aRowIdx, uint32_t aColIdx);
   virtual int32_t ColIndexAt(uint32_t aCellIdx);
@@ -163,17 +144,16 @@ public:
   virtual void SelectCol(uint32_t aColIdx);
   virtual void SelectRow(uint32_t aRowIdx);
   virtual void UnselectCol(uint32_t aColIdx);
   virtual void UnselectRow(uint32_t aRowIdx);
   virtual bool IsProbablyLayoutTable();
   virtual Accessible* AsAccessible() { return this; }
 
   // Accessible
-  virtual void Shutdown();
   virtual TableAccessible* AsTable() { return this; }
   virtual void Description(nsString& aDescription);
   virtual a11y::role NativeRole() MOZ_OVERRIDE;
   virtual uint64_t NativeState() MOZ_OVERRIDE;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() MOZ_OVERRIDE;
   virtual Relation RelationByType(RelationType aRelationType) MOZ_OVERRIDE;
 
 protected:
@@ -224,21 +204,21 @@ protected:
 /**
  * HTML caption accessible (html:caption).
  */
 class HTMLCaptionAccessible : public HyperTextAccessibleWrap
 {
 public:
   HTMLCaptionAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     HyperTextAccessibleWrap(aContent, aDoc) { }
-  virtual ~HTMLCaptionAccessible() { }
-
-  // nsIAccessible
 
   // Accessible
   virtual a11y::role NativeRole() MOZ_OVERRIDE;
   virtual Relation RelationByType(RelationType aRelationType) MOZ_OVERRIDE;
+
+protected:
+  virtual ~HTMLCaptionAccessible() { }
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
--- a/accessible/interfaces/nsIAccessibilityService.h
+++ b/accessible/interfaces/nsIAccessibilityService.h
@@ -21,20 +21,20 @@ class Accessible;
 } // namespace mozilla
 
 class nsINode;
 class nsIContent;
 class nsIFrame;
 class nsIPresShell;
 class nsPluginFrame;
 
-// 10ff6dca-b219-4b64-9a4c-67a62b86edce
+// 0e7e6879-854b-4260-bc6e-525b5fb5cf34
 #define NS_IACCESSIBILITYSERVICE_IID \
-{ 0x84dd9182, 0x6639, 0x4377, \
- { 0xa4, 0x13, 0xad, 0xe1, 0xae, 0x4e, 0x52, 0xdd } }
+{ 0x0e7e6879, 0x854b, 0x4260, \
+ { 0xbc, 0x6e, 0x52, 0x5b, 0x5f, 0xb5, 0xcf, 0x34 } }
 
 class nsIAccessibilityService : public nsIAccessibleRetrieval
 {
 public:
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_IACCESSIBILITYSERVICE_IID)
 
   /**
    * Return root document accessible that is or contains a document accessible
@@ -59,16 +59,21 @@ public:
   /**
    * Fire accessible event of the given type for the given target.
    *
    * @param aEvent   [in] accessible event type
    * @param aTarget  [in] target of accessible event
    */
   virtual void FireAccessibleEvent(uint32_t aEvent,
                                    mozilla::a11y::Accessible* aTarget) = 0;
+
+  /**
+   * Return true if the given DOM node has accessible object.
+   */
+  virtual bool HasAccessible(nsIDOMNode* aDOMNode) = 0;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsIAccessibilityService,
                               NS_IACCESSIBILITYSERVICE_IID)
 
 // for component registration
 // {DE401C37-9A7F-4278-A6F8-3DE2833989EF}
 #define NS_ACCESSIBILITY_SERVICE_CID \
--- a/accessible/interfaces/nsIAccessible.idl
+++ b/accessible/interfaces/nsIAccessible.idl
@@ -7,16 +7,24 @@
 #include "nsIArray.idl"
 
 interface nsIPersistentProperties;
 interface nsIDOMCSSPrimitiveValue;
 interface nsIDOMNode;
 interface nsIAccessibleDocument;
 interface nsIAccessibleRelation;
 
+%{C++
+namespace mozilla {
+namespace a11y {
+class Accessible;
+}
+}
+%}
+
 /**
  * A cross-platform interface that supports platform-specific 
  * accessibility APIs like MSAA and ATK. Contains the sum of what's needed
  * to support IAccessible as well as ATK's generic accessibility objects.
  * Can also be used by in-process accessibility clients to get information
  * about objects in the accessible tree. The accessible tree is a subset of 
  * nodes in the DOM tree -- such as documents, focusable elements and text.
  * Mozilla creates the implementations of nsIAccessible on demand.
@@ -161,17 +169,16 @@ interface nsIAccessible : nsISupports
    * Returns grouping information. Used for tree items, list items, tab panel
    * labels, radio buttons, etc. Also used for collectons of non-text objects.
    *
    * @param groupLevel - 1-based, similar to ARIA 'level' property
    * @param similarItemsInGroup - 1-based, similar to ARIA 'setsize' property,
    *                              inclusive of the current item
    * @param positionInGroup - 1-based, similar to ARIA 'posinset' property
    */
-  [binaryname(ScriptableGroupPosition)]
   void groupPosition(out long aGroupLevel, out long aSimilarItemsInGroup,
                      out long aPositionInGroup);
 
   /**
    * Accessible child which contains the coordinate at (x, y) in screen pixels.
    * If the point is in the current accessible but not in a child, the
    * current accessible will be returned.
    * If the point is in neither the current accessible or a child, then
@@ -193,17 +200,16 @@ interface nsIAccessible : nsISupports
    * @param y  screen's y coordinate
    * @return   the deepest accessible child containing the given point
    */
   nsIAccessible getDeepestChildAtPoint(in long x, in long y);
 
   /**
    * Nth accessible child using zero-based index or last child if index less than zero
    */
-  [binaryname(ScriptableGetChildAt)]
   nsIAccessible getChildAt(in long aChildIndex);
 
   /**
    * Return accessible relation by the given relation type (see.
    * constants defined in nsIAccessibleRelation).
    */
   nsIAccessibleRelation getRelationByType(in unsigned long aRelationType);
 
@@ -216,40 +222,37 @@ interface nsIAccessible : nsISupports
    * Return accessible's x and y coordinates relative to the screen and
    * accessible's width and height.
    */
   void getBounds(out long x, out long y, out long width, out long height);
 
   /**
    * Add or remove this accessible to the current selection
    */
-  [binaryname(ScriptableSetSelected)]
   void setSelected(in boolean isSelected);
 
   /**
    * Extend the current selection from its current accessible anchor node
    * to this accessible
    */
   void extendSelection();
 
   /**
    * Select this accessible node only
    */
-  [binaryname(ScriptableTakeSelection)]
   void takeSelection();
 
   /**
    * Focus this accessible node,
    * The state STATE_FOCUSABLE indicates whether this node is normally focusable.
    * It is the callers responsibility to determine whether this node is focusable.
    * accTakeFocus on a node that is not normally focusable (such as a table),
-   * will still set focus on that node, although normally that will not be visually 
+   * will still set focus on that node, although normally that will not be visually
    * indicated in most style sheets.
    */
-  [binaryname(ScriptableTakeFocus)]
   void takeFocus();
 
   /**
    * The number of accessible actions associated with this accessible
    */
   readonly attribute uint8_t actionCount;
 
   /**
@@ -261,40 +264,36 @@ interface nsIAccessible : nsISupports
    * The description of the accessible action at the given zero-based index
    */
   AString getActionDescription(in uint8_t aIndex);
 
   /**
    * Perform the accessible action at the given zero-based index
    * Action number 0 is the default action
    */
-  [binaryname(ScriptableDoAction)]
   void doAction(in uint8_t index);
 
   /**
    * Makes an object visible on screen.
    *
    * @param scrollType - defines where the object should be placed on
    *                     the screen (see nsIAccessibleScrollType for
    *                     available constants).
    */
-  [binaryname(ScriptableScrollTo)]
   void scrollTo(in unsigned long aScrollType);
 
   /**
    * Moves the top left of an object to a specified location.
    *
    * @param coordinateType [in] - specifies whether the coordinates are relative to
    *                         the screen or the parent object (for available
    *                         constants refer to nsIAccessibleCoordinateType)
    * @param x [in] - defines the x coordinate
    * @param y [in] - defines the y coordinate
   */
-  [binaryname(ScriptableScrollToPoint)]
   void scrollToPoint(in unsigned long coordinateType, in long x, in long y);
 
-  /**
-   * Get a pointer to accessibility interface for this node, which is specific 
-   * to the OS/accessibility toolkit we're running on.
-   */
-  [noscript] void getNativeInterface(out voidPtr aOutAccessible);
+  %{C++
+  virtual mozilla::a11y::Accessible* ToInternalAccessible() const = 0;
+  %}
+
 };
 
--- a/accessible/interfaces/nsIAccessibleDocument.idl
+++ b/accessible/interfaces/nsIAccessibleDocument.idl
@@ -14,17 +14,17 @@ interface nsIDOMWindow;
  * that wish to retrieve information about a document.
  * When accessibility is turned on in Gecko,
  * there is an nsIAccessibleDocument for each document
  * whether it is XUL, HTML or whatever.
  * You can QueryInterface to nsIAccessibleDocument from the nsIAccessible for
  * the root node of a document or you can get one from
  * nsIAccessible::GetDocument().
  */
-[scriptable, uuid(c80f6600-3210-4893-8f71-fde381ca39c9)]
+[scriptable, uuid(2be938df-0210-4609-9ece-26b197a517e5)]
 interface nsIAccessibleDocument : nsISupports
 {
   /**
    * The URL of the document
    */
   readonly attribute AString URL;
 
   /**
@@ -65,11 +65,10 @@ interface nsIAccessibleDocument : nsISup
   /**
    * The virtual cursor pivot this document manages.
    */
   readonly attribute nsIAccessiblePivot virtualCursor;
 
   /**
    * Return the child document accessible at the given index.
    */
-  [binaryname(ScriptableGetChildDocumentAt)]
   nsIAccessibleDocument getChildDocumentAt(in unsigned long index);
 };
--- a/accessible/interfaces/nsIAccessibleEditableText.idl
+++ b/accessible/interfaces/nsIAccessibleEditableText.idl
@@ -1,61 +1,56 @@
 /* -*- 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 "nsISupports.idl"
 
-[scriptable, uuid(93d0ba57-0d20-49d1-aede-8fde6699855d)]
+[scriptable, uuid(28915cca-3366-4034-ba1d-b7afb9b37639)]
 interface nsIAccessibleEditableText : nsISupports
 {
   /**
    * Replaces the text represented by this object by the given text.
    */
   void setTextContents (in AString text);
 
   /**
    * Inserts text at the specified position.
    *
    * @param text - text that is inserted.
    * @param position - index at which to insert the text.
    */
-  [binaryname(ScriptableInsertText)]
   void insertText(in AString text, in long position);
 
   /**
    * Copies the text range into the clipboard.
    *
    * @param startPos - start index of the text to moved into the clipboard.
    * @param endPos - end index of the text to moved into the clipboard.
    */
-  [binaryname(ScriptableCopyText)]
   void copyText(in long startPos, in long endPos);
 
   /**
    * Deletes a range of text and copies it to the clipboard.
    *
    * @param startPos - start index of the text to be deleted.
    * @param endOffset - end index of the text to be deleted.
    */
-  [binaryname(ScriptableCutText)]
   void cutText(in long startPos, in long endPos);
 
   /**
    * Deletes a range of text.
    *
    * @param startPos - start index of the text to be deleted.
    * @param endPos - end index of the text to be deleted.
    */
-  [binaryname(ScriptableDeleteText)]
   void deleteText(in long startPos, in long endPos);
 
   /**
    * Pastes text from the clipboard.
    *
    * @param position - index at which to insert the text from the system
    *                   clipboard into the text represented by this object.
    */
-  [binaryname(ScriptablePasteText)]
   void pasteText(in long position);
 };
--- a/accessible/interfaces/nsIAccessibleSelectable.idl
+++ b/accessible/interfaces/nsIAccessibleSelectable.idl
@@ -6,17 +6,17 @@
 #include "nsISupports.idl"
 
 interface nsIAccessible;
 interface nsIArray;
 
 /**
  * An accessibility interface for selectable widgets.
  */
-[scriptable, uuid(3e507fc4-4fcc-4223-a674-a095f591eba1)]
+[scriptable, uuid(8efb03d4-1354-4875-94cf-261336057626)]
 interface nsIAccessibleSelectable : nsISupports
 {
   /**
    * Return an nsIArray of selected items within the widget.
    */
   readonly attribute nsIArray selectedItems;
 
   /**
@@ -27,38 +27,33 @@ interface nsIAccessibleSelectable : nsIS
   /**
    * Return a nth selected item within the widget.
    */
   nsIAccessible getSelectedItemAt(in unsigned long index);
 
   /**
    * Return true if the given item is selected.
    */
-  [binaryname(ScriptableIsItemSelected)]
   boolean isItemSelected(in unsigned long index);
 
   /**
    * Adds the specified item to the widget's selection.
    */
-  [binaryname(ScriptableAddItemToSelection)]
   void addItemToSelection(in unsigned long index);
 
   /**
    * Removes the specified item from the widget's selection.
    */
-  [binaryname(ScriptableRemoveItemFromSelection)]
   void removeItemFromSelection(in unsigned long index);
 
   /**
    * Select all items.
    *
    * @return false if the object does not accept multiple selection,
    *         otherwise true.
    */
-  [binaryname(ScriptableSelectAll)]
   boolean selectAll();
 
   /**
    * Unselect all items.
    */
-  [binaryname(ScriptableUnselectAll)]
   void unselectAll();
 };
--- a/accessible/interfaces/nsIAccessibleText.idl
+++ b/accessible/interfaces/nsIAccessibleText.idl
@@ -8,17 +8,17 @@
 
 typedef long AccessibleTextBoundary;
 
 interface nsIAccessible;
 interface nsIArray;
 interface nsIPersistentProperties;
 interface nsIAccessibleTextRange;
 
-[scriptable, uuid(88789f40-54c9-494a-846d-3acaaf4cf46a)]
+[scriptable, uuid(93ad2ca1-f12b-4ab9-a793-95d9fa9d1774)]
 interface nsIAccessibleText : nsISupports
 {
   // In parameters for character offsets:
   //  -1 will be treated as the equal to the end of the text
   //  -2 will be treated as the caret position
   const int32_t TEXT_OFFSET_END_OF_TEXT = -1;
   const int32_t TEXT_OFFSET_CARET       = -2;
 
@@ -29,17 +29,16 @@ interface nsIAccessibleText : nsISupport
   const AccessibleTextBoundary BOUNDARY_SENTENCE_END = 4;  // don't use, deprecated
   const AccessibleTextBoundary BOUNDARY_LINE_START = 5;
   const AccessibleTextBoundary BOUNDARY_LINE_END = 6;
 
   /**
    * The current current caret offset.
    * If set < 0 then caret will be placed  at the end of the text
    */
-  [binaryname(ScriptableCaretOffset)]
   attribute long caretOffset;
 
   readonly attribute long characterCount;
   readonly attribute long selectionCount;
 
     /**
       * String methods may need to return multibyte-encoded strings,
       * since some locales can't be encoded using 16-bit chars.
@@ -166,33 +165,31 @@ interface nsIAccessibleText : nsISupport
    *
    * @param startIndex  0-based character offset
    * @param endIndex    0-based character offset - the offset of the
    *                    character just past the last character of the
    *                    string
    * @param scrollType  defines how to scroll (see nsIAccessibleScrollType for
    *                    available constants)
    */
-  [binaryname(ScriptableScrollSubstringTo)]
   void scrollSubstringTo(in long startIndex, in long endIndex,
                          in unsigned long scrollType);
 
   /**
    * Moves the top left of a substring to a specified location.
    *
    * @param startIndex      0-based character offset
    * @param endIndex        0-based character offset - the offset of the
    *                        character just past the last character of
    *                        the string
    * @param coordinateType  specifies the coordinates origin (for available
    *                        constants refer to nsIAccessibleCoordinateType)
    * @param x               defines the x coordinate
    * @param y               defines the y coordinate
    */
-  [binaryname(ScriptableScrollSubstringToPoint)]
   void scrollSubstringToPoint(in long startIndex, in long endIndex,
                               in unsigned long coordinateType,
                               in long x, in long y);
 
   /**
    * Return a range that encloses this text control or otherwise the document
    * this text accessible belongs to.
    */
--- a/accessible/mac/AccessibleWrap.h
+++ b/accessible/mac/AccessibleWrap.h
@@ -27,22 +27,22 @@
 namespace mozilla {
 namespace a11y {
 
 class AccessibleWrap : public Accessible
 {
 public: // construction, destruction
   AccessibleWrap(nsIContent* aContent, DocAccessible* aDoc);
   virtual ~AccessibleWrap();
-    
+
   /**
    * Get the native Obj-C object (mozAccessible).
    */
-  NS_IMETHOD GetNativeInterface (void** aOutAccessible);
-  
+  virtual void GetNativeInterface(void** aOutAccessible) MOZ_OVERRIDE;
+
   /**
    * The objective-c |Class| type that this accessible's native object
    * should be instantied with.   used on runtime to determine the
    * right type for this accessible's associated native object.
    */
   virtual Class GetNativeType ();
 
   virtual void Shutdown ();
--- a/accessible/mac/AccessibleWrap.mm
+++ b/accessible/mac/AccessibleWrap.mm
@@ -38,24 +38,20 @@ AccessibleWrap::GetNativeObject()
   
   mNativeInited = true;
   
   return mNativeObject;
   
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 
-NS_IMETHODIMP
-AccessibleWrap::GetNativeInterface (void **aOutInterface) 
+void
+AccessibleWrap::GetNativeInterface(void** aOutInterface)
 {
-  NS_ENSURE_ARG_POINTER(aOutInterface);
-
   *aOutInterface = static_cast<void*>(GetNativeObject());
-    
-  return *aOutInterface ? NS_OK : NS_ERROR_FAILURE;
 }
 
 // overridden in subclasses to create the right kind of object. by default we create a generic
 // 'mozAccessible' node.
 Class
 AccessibleWrap::GetNativeType () 
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
--- a/accessible/mac/mozAccessible.h
+++ b/accessible/mac/mozAccessible.h
@@ -19,17 +19,17 @@
  */
 inline id <mozAccessible>
 GetObjectOrRepresentedView(id <mozAccessible> aObject)
 {
   return [aObject hasRepresentedView] ? [aObject representedView] : aObject;
 }
 
 inline mozAccessible*
-GetNativeFromGeckoAccessible(nsIAccessible* aAccessible)
+GetNativeFromGeckoAccessible(mozilla::a11y::Accessible* aAccessible)
 {
   mozAccessible* native = nil;
   aAccessible->GetNativeInterface((void**)&native);
   return native;
 }
 
 @interface mozAccessible : NSObject <mozAccessible>
 {
@@ -44,17 +44,17 @@ GetNativeFromGeckoAccessible(nsIAccessib
   NSMutableArray* mChildren;
   
   /** 
    * Weak reference to the parent
    */
   mozAccessible* mParent;
 
   /**
-   * The nsIAccessible role of our gecko accessible.
+   * The role of our gecko accessible.
    */
   mozilla::a11y::role        mRole;
 }
 
 // inits with the gecko owner.
 - (id)initWithAccessible:(mozilla::a11y::AccessibleWrap*)geckoParent;
 
 // our accessible parent (AXParent)
--- a/accessible/mac/mozAccessible.mm
+++ b/accessible/mac/mozAccessible.mm
@@ -6,17 +6,16 @@
 #import "mozAccessible.h"
 
 #import "MacUtils.h"
 #import "mozView.h"
 
 #include "Accessible-inl.h"
 #include "nsAccUtils.h"
 #include "nsIAccessibleRelation.h"
-#include "nsIAccessibleText.h"
 #include "nsIAccessibleEditableText.h"
 #include "nsIPersistentProperties2.h"
 #include "Relation.h"
 #include "Role.h"
 #include "RootAccessible.h"
 
 #include "mozilla/Services.h"
 #include "nsRect.h"
@@ -298,20 +297,20 @@ GetClosestInterestingAccessible(id anObj
       return GetClosestInterestingAccessible(nativeParent);
   }
   
   // GetUnignoredParent() returns null when there is no unignored accessible all the way up to
   // the root accessible. so we'll have to return whatever native accessible is above our root accessible 
   // (which might be the owning NSWindow in the application, for example).
   //
   // get the native root accessible, and tell it to return its first parent unignored accessible.
-  RootAccessible* root = mGeckoAccessible->RootAccessible();
-  id nativeParent = GetNativeFromGeckoAccessible(static_cast<nsIAccessible*>(root));
+  id nativeParent =
+    GetNativeFromGeckoAccessible(mGeckoAccessible->RootAccessible());
   NSAssert1 (nativeParent, @"!!! we can't find a parent for %@", self);
-  
+
   return GetClosestInterestingAccessible(nativeParent);
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 
 - (BOOL)hasRepresentedView
 {
   return NO;
@@ -388,34 +387,33 @@ GetClosestInterestingAccessible(id anObj
 
 - (NSValue*)size
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
 
   if (!mGeckoAccessible)
     return nil;
 
-  int32_t x = 0, y = 0, width = 0, height = 0;
-  mGeckoAccessible->GetBounds (&x, &y, &width, &height);
+  nsIntRect rect = mGeckoAccessible->Bounds();
   CGFloat scaleFactor =
     nsCocoaUtils::GetBackingScaleFactor([[NSScreen screens] objectAtIndex:0]);
-  return [NSValue valueWithSize:NSMakeSize(static_cast<CGFloat>(width) / scaleFactor,
-                                           static_cast<CGFloat>(height) / scaleFactor)];
+  return [NSValue valueWithSize:NSMakeSize(static_cast<CGFloat>(rect.width) / scaleFactor,
+                                           static_cast<CGFloat>(rect.height) / scaleFactor)];
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 
 - (NSString*)role
 {
   if (!mGeckoAccessible)
     return nil;
 
 #ifdef DEBUG_A11Y
   NS_ASSERTION(nsAccUtils::IsTextInterfaceSupportCorrect(mGeckoAccessible),
-               "Does not support nsIAccessibleText when it should");
+               "Does not support Text when it should");
 #endif
 
 #define ROLE(geckoRole, stringRole, atkRole, macRole, msaaRole, ia2Role, nameRule) \
   case roles::geckoRole: \
     return macRole;
 
   switch (mRole) {
 #include "RoleMap.h"
@@ -528,17 +526,17 @@ GetClosestInterestingAccessible(id anObj
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 
 - (id)value
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
 
   nsAutoString value;
-  mGeckoAccessible->GetValue (value);
+  mGeckoAccessible->Value(value);
   return value.IsEmpty() ? nil : [NSString stringWithCharacters:reinterpret_cast<const unichar*>(value.BeginReading())
                                                          length:value.Length()];
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 
 - (void)valueDidChange
 {
@@ -573,17 +571,17 @@ GetClosestInterestingAccessible(id anObj
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 
 - (NSString*)help
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
 
   nsAutoString helpText;
-  mGeckoAccessible->GetHelp (helpText);
+  mGeckoAccessible->Help(helpText);
   return helpText.IsEmpty() ? nil : [NSString stringWithCharacters:reinterpret_cast<const unichar*>(helpText.BeginReading())
                                                             length:helpText.Length()];
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 
 // objc-style description (from NSObject); not to be confused with the accessible description above.
 - (NSString*)description
--- a/accessible/mac/mozActionElements.mm
+++ b/accessible/mac/mozActionElements.mm
@@ -289,25 +289,24 @@ enum CheckboxValue {
 
 /**
  * Returns the selected tab (the mozAccessible)
  */
 - (id)value
 {
   if (!mGeckoAccessible)
     return nil;
-    
+
   Accessible* accessible = mGeckoAccessible->GetSelectedItem(0);
   if (!accessible)
     return nil;
 
   mozAccessible* nativeAcc = nil;
-  nsresult rv = accessible->GetNativeInterface((void**)&nativeAcc);
-  NS_ENSURE_SUCCESS(rv, nil);
-  
+  accessible->GetNativeInterface((void**)&nativeAcc);
+
   return nativeAcc;
 }
 
 /**
  * Return the mozAccessibles that are the tabs.
  */
 - (id)tabs
 {
--- a/accessible/mac/mozTextAccessible.h
+++ b/accessible/mac/mozTextAccessible.h
@@ -6,16 +6,15 @@
 
 #import "HyperTextAccessible.h"
 
 @interface mozTextAccessible : mozAccessible
 {
   // both of these are the same old mGeckoAccessible, but already
   // QI'd for us, to the right type, for convenience.
   mozilla::a11y::HyperTextAccessible* mGeckoTextAccessible; // strong
-  nsIAccessibleEditableText *mGeckoEditableTextAccessible; // strong
 }
 @end
 
 @interface mozTextLeafAccessible : mozAccessible
 {
 }
 @end
--- a/accessible/mac/mozTextAccessible.mm
+++ b/accessible/mac/mozTextAccessible.mm
@@ -54,17 +54,16 @@ ToNSString(id aValue)
 @implementation mozTextAccessible
 
 - (id)initWithAccessible:(AccessibleWrap*)accessible
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
 
   if ((self = [super initWithAccessible:accessible])) {
     mGeckoTextAccessible = accessible->AsHyperText();
-    CallQueryInterface(accessible, &mGeckoEditableTextAccessible);
   }
   return self;
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 
 - (BOOL)accessibilityIsIgnored
 {
@@ -304,32 +303,31 @@ ToNSString(id aValue)
   return nil;
 }
 
 - (void)expire
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
 
   mGeckoTextAccessible = nullptr;
-  NS_IF_RELEASE(mGeckoEditableTextAccessible);
   [super expire];
 
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 
 #pragma mark -
 
 - (BOOL)isReadOnly
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
 
   if ([[self role] isEqualToString:NSAccessibilityStaticTextRole])
     return YES;
-    
-  if (mGeckoEditableTextAccessible)
+
+  if (mGeckoTextAccessible)
     return (mGeckoAccessible->State() & states::READONLY) == 0;
 
   return NO;
 
   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NO);
 }
 
 - (NSNumber*)caretLineNumber
@@ -339,20 +337,20 @@ ToNSString(id aValue)
 
   return (lineNumber >= 0) ? [NSNumber numberWithInt:lineNumber] : nil;
 }
 
 - (void)setText:(NSString*)aNewString
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
 
-  if (mGeckoEditableTextAccessible) {
+  if (mGeckoTextAccessible) {
     nsString text;
     nsCocoaUtils::GetStringForNSString(aNewString, text);
-    mGeckoEditableTextAccessible->SetTextContents(text);
+    mGeckoTextAccessible->ReplaceText(text);
   }
 
   NS_OBJC_END_TRY_ABORT_BLOCK;
 }
 
 - (NSString*)text
 {
   if (!mGeckoAccessible || !mGeckoTextAccessible)
--- a/accessible/tests/mochitest/common.js
+++ b/accessible/tests/mochitest/common.js
@@ -29,17 +29,16 @@ const nsIAccessibleDocument = Components
 const nsIAccessibleApplication = Components.interfaces.nsIAccessibleApplication;
 
 const nsIAccessibleText = Components.interfaces.nsIAccessibleText;
 const nsIAccessibleEditableText = Components.interfaces.nsIAccessibleEditableText;
 
 const nsIAccessibleHyperLink = Components.interfaces.nsIAccessibleHyperLink;
 const nsIAccessibleHyperText = Components.interfaces.nsIAccessibleHyperText;
 
-const nsIAccessibleCursorable = Components.interfaces.nsIAccessibleCursorable;
 const nsIAccessibleImage = Components.interfaces.nsIAccessibleImage;
 const nsIAccessiblePivot = Components.interfaces.nsIAccessiblePivot;
 const nsIAccessibleSelectable = Components.interfaces.nsIAccessibleSelectable;
 const nsIAccessibleTable = Components.interfaces.nsIAccessibleTable;
 const nsIAccessibleTableCell = Components.interfaces.nsIAccessibleTableCell;
 const nsIAccessibleTraversalRule = Components.interfaces.nsIAccessibleTraversalRule;
 const nsIAccessibleValue = Components.interfaces.nsIAccessibleValue;
 
@@ -168,17 +167,17 @@ function getNode(aAccOrNodeOrID, aDocume
     return null;
 
   if (aAccOrNodeOrID instanceof nsIDOMNode)
     return aAccOrNodeOrID;
 
   if (aAccOrNodeOrID instanceof nsIAccessible)
     return aAccOrNodeOrID.DOMNode;
 
-  node = (aDocument || document).getElementById(aAccOrNodeOrID);
+  var node = (aDocument || document).getElementById(aAccOrNodeOrID);
   if (!node) {
     ok(false, "Can't get DOM element for " + aAccOrNodeOrID);
     return null;
   }
 
   return node;
 }
 
--- a/accessible/windows/ia2/ia2AccessibleAction.cpp
+++ b/accessible/windows/ia2/ia2AccessibleAction.cpp
@@ -72,29 +72,25 @@ ia2AccessibleAction::doAction(long aActi
 
 STDMETHODIMP
 ia2AccessibleAction::get_description(long aActionIndex, BSTR *aDescription)
 {
   A11Y_TRYBLOCK_BEGIN
 
   if (!aDescription)
     return E_INVALIDARG;
-
   *aDescription = nullptr;
 
   AccessibleWrap* acc = static_cast<AccessibleWrap*>(this);
   if (acc->IsDefunct())
     return CO_E_OBJNOTCONNECTED;
 
   nsAutoString description;
   uint8_t index = static_cast<uint8_t>(aActionIndex);
-  nsresult rv = acc->GetActionDescription(index, description);
-  if (NS_FAILED(rv))
-    return GetHRESULT(rv);
-
+  acc->ActionDescriptionAt(index, description);
   if (description.IsEmpty())
     return S_FALSE;
 
   *aDescription = ::SysAllocStringLen(description.get(),
                                       description.Length());
   return *aDescription ? S_OK : E_OUTOFMEMORY;
 
   A11Y_TRYBLOCK_END
--- a/accessible/windows/ia2/ia2AccessibleEditableText.h
+++ b/accessible/windows/ia2/ia2AccessibleEditableText.h
@@ -4,17 +4,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 _ACCESSIBLE_EDITABLETEXT_H
 #define _ACCESSIBLE_EDITABLETEXT_H
 
 #include "nsISupports.h"
-#include "nsIAccessibleEditableText.h"
 
 #include "AccessibleEditableText.h"
 
 namespace mozilla {
 namespace a11y {
 
 class ia2AccessibleEditableText: public IAccessibleEditableText
 {
--- a/accessible/windows/ia2/ia2AccessibleImage.cpp
+++ b/accessible/windows/ia2/ia2AccessibleImage.cpp
@@ -50,20 +50,17 @@ ia2AccessibleImage::get_description(BSTR
 
   *aDescription = nullptr;
 
   ImageAccessibleWrap* acc = static_cast<ImageAccessibleWrap*>(this);
   if (acc->IsDefunct())
     return CO_E_OBJNOTCONNECTED;
 
   nsAutoString description;
-  nsresult rv = acc->GetName(description);
-  if (NS_FAILED(rv))
-    return GetHRESULT(rv);
-
+  acc->Name(description);
   if (description.IsEmpty())
     return S_FALSE;
 
   *aDescription = ::SysAllocStringLen(description.get(), description.Length());
   return *aDescription ? S_OK : E_OUTOFMEMORY;
 
   A11Y_TRYBLOCK_END
 }
@@ -83,24 +80,20 @@ ia2AccessibleImage::get_imagePosition(en
 
   ImageAccessibleWrap* imageAcc = static_cast<ImageAccessibleWrap*>(this);
   if (imageAcc->IsDefunct())
     return CO_E_OBJNOTCONNECTED;
 
   uint32_t geckoCoordType = (aCoordType == IA2_COORDTYPE_SCREEN_RELATIVE) ?
     nsIAccessibleCoordinateType::COORDTYPE_SCREEN_RELATIVE :
     nsIAccessibleCoordinateType::COORDTYPE_PARENT_RELATIVE;
-  int32_t x = 0, y = 0;
 
-  nsresult rv = imageAcc->GetImagePosition(geckoCoordType, &x, &y);
-  if (NS_FAILED(rv))
-    return GetHRESULT(rv);
-
-  *aX = x;
-  *aY = y;
+  nsIntPoint pos = imageAcc->Position(geckoCoordType);
+  *aX = pos.x;
+  *aY = pos.y;
   return S_OK;
 
   A11Y_TRYBLOCK_END
 }
 
 STDMETHODIMP
 ia2AccessibleImage::get_imageSize(long* aHeight, long* aWidth)
 {
@@ -111,20 +104,16 @@ ia2AccessibleImage::get_imageSize(long* 
 
   *aHeight = 0;
   *aWidth = 0;
 
   ImageAccessibleWrap* imageAcc = static_cast<ImageAccessibleWrap*>(this);
   if (imageAcc->IsDefunct())
     return CO_E_OBJNOTCONNECTED;
 
-  int32_t width = 0, height = 0;
-  nsresult rv = imageAcc->GetImageSize(&width, &height);
-  if (NS_FAILED(rv))
-    return GetHRESULT(rv);
-
-  *aHeight = width;
-  *aWidth = height;
+  nsIntSize size = imageAcc->Size();
+  *aHeight = size.width;
+  *aWidth = size.height;
   return S_OK;
 
   A11Y_TRYBLOCK_END
 }
 
--- a/accessible/windows/ia2/ia2AccessibleRelation.cpp
+++ b/accessible/windows/ia2/ia2AccessibleRelation.cpp
@@ -3,17 +3,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/. */
 
 #include "ia2AccessibleRelation.h"
 
 #include "Relation.h"
-#include "nsIAccessibleRelation.h"
 #include "nsID.h"
 
 #include "AccessibleRelation_i.c"
 
 using namespace mozilla::a11y;
 
 ia2AccessibleRelation::ia2AccessibleRelation(RelationType aType, Relation* aRel) :
   mType(aType)
--- a/accessible/windows/ia2/ia2AccessibleRelation.h
+++ b/accessible/windows/ia2/ia2AccessibleRelation.h
@@ -5,17 +5,16 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef _NS_ACCESSIBLE_RELATION_WRAP_H
 #define _NS_ACCESSIBLE_RELATION_WRAP_H
 
 #include "Accessible.h"
 #include "IUnknownImpl.h"
-#include "nsIAccessibleRelation.h"
 
 #include <utility>
 #include "nsTArray.h"
 
 #include "AccessibleRelation.h"
 
 namespace mozilla {
 namespace a11y {
--- a/accessible/windows/ia2/ia2AccessibleTable.cpp
+++ b/accessible/windows/ia2/ia2AccessibleTable.cpp
@@ -414,18 +414,18 @@ ia2AccessibleTable::get_summary(IUnknown
 {
   A11Y_TRYBLOCK_BEGIN
 
   if (!aAccessible)
     return E_INVALIDARG;
 
   // Neither html:table nor xul:tree nor ARIA grid/tree have an ability to
   // link an accessible object to specify a summary. There is closes method
-  // in nsIAccessibleTable::summary to get a summary as a string which is not
-  // mapped directly to IAccessible2.
+  // in Table::summary to get a summary as a string which is not mapped
+  // directly to IAccessible2.
 
   *aAccessible = nullptr;
   return S_FALSE;
 
   A11Y_TRYBLOCK_END
 }
 
 STDMETHODIMP
--- a/accessible/windows/ia2/ia2AccessibleText.h
+++ b/accessible/windows/ia2/ia2AccessibleText.h
@@ -4,17 +4,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 _ACCESSIBLE_TEXT_H
 #define _ACCESSIBLE_TEXT_H
 
 #include "nsISupports.h"
-#include "nsIAccessibleText.h"
 
 #include "AccessibleText.h"
 
 namespace mozilla {
 namespace a11y {
 
 class ia2AccessibleText: public IAccessibleText
 {
--- a/accessible/windows/msaa/AccessibleWrap.cpp
+++ b/accessible/windows/msaa/AccessibleWrap.cpp
@@ -8,17 +8,16 @@
 #include "Accessible-inl.h"
 
 #include "Compatibility.h"
 #include "DocAccessible-inl.h"
 #include "EnumVariant.h"
 #include "nsAccUtils.h"
 #include "nsCoreUtils.h"
 #include "nsIAccessibleEvent.h"
-#include "nsIAccessibleRelation.h"
 #include "nsWinUtils.h"
 #include "ServiceProvider.h"
 #include "Relation.h"
 #include "Role.h"
 #include "RootAccessible.h"
 #include "sdnAccessible.h"
 #include "States.h"
 
@@ -360,17 +359,17 @@ AccessibleWrap::get_accRole(
   if (!xpAccessible)
     return E_INVALIDARG;
 
   if (xpAccessible->IsDefunct())
     return CO_E_OBJNOTCONNECTED;
 
 #ifdef DEBUG
   NS_ASSERTION(nsAccUtils::IsTextInterfaceSupportCorrect(xpAccessible),
-               "Does not support nsIAccessibleText when it should");
+               "Does not support Text when it should");
 #endif
 
   a11y::role geckoRole = xpAccessible->Role();
   uint32_t msaaRole = 0;
 
 #define ROLE(_geckoRole, stringRole, atkRole, macRole, \
              _msaaRole, ia2Role, nameRule) \
   case roles::_geckoRole: \
@@ -583,22 +582,25 @@ AccessibleWrap::get_accFocus(
     pvarChild->vt = VT_EMPTY;   // No focus or focus is not a child
   }
 
   return S_OK;
 
   A11Y_TRYBLOCK_END
 }
 
-// This helper class implements IEnumVARIANT for a nsIArray containing nsIAccessible objects.
-
+/**
+ * This helper class implements IEnumVARIANT for a nsTArray containing
+ * accessible objects.
+ */
 class AccessibleEnumerator MOZ_FINAL : public IEnumVARIANT
 {
 public:
-  AccessibleEnumerator(nsIArray* aArray) : mArray(aArray), mCurIndex(0) { }
+  AccessibleEnumerator(const nsTArray<Accessible*>& aArray) :
+    mArray(aArray), mCurIndex(0) { }
   AccessibleEnumerator(const AccessibleEnumerator& toCopy) :
     mArray(toCopy.mArray), mCurIndex(toCopy.mCurIndex) { }
   ~AccessibleEnumerator() { }
 
   // IUnknown
   DECL_IUNKNOWN
 
   // IEnumVARIANT
@@ -607,17 +609,17 @@ public:
   STDMETHODIMP Reset()
   {
     mCurIndex = 0;
     return S_OK;
   }
   STDMETHODIMP Clone(IEnumVARIANT FAR* FAR* ppenum);
 
 private:
-  nsCOMPtr<nsIArray> mArray;
+  nsTArray<Accessible*> mArray;
   uint32_t mCurIndex;
 };
 
 STDMETHODIMP
 AccessibleEnumerator::QueryInterface(REFIID iid, void ** ppvObject)
 {
   A11Y_TRYBLOCK_BEGIN
 
@@ -638,36 +640,29 @@ AccessibleEnumerator::QueryInterface(REF
   A11Y_TRYBLOCK_END
 }
 
 STDMETHODIMP
 AccessibleEnumerator::Next(unsigned long celt, VARIANT FAR* rgvar, unsigned long FAR* pceltFetched)
 {
   A11Y_TRYBLOCK_BEGIN
 
-  uint32_t length = 0;
-  mArray->GetLength(&length);
-
+  uint32_t length = mArray.Length();
   HRESULT hr = S_OK;
 
   // Can't get more elements than there are...
   if (celt > length - mCurIndex) {
     hr = S_FALSE;
     celt = length - mCurIndex;
   }
 
+  // Copy the elements of the array into rgvar.
   for (uint32_t i = 0; i < celt; ++i, ++mCurIndex) {
-    // Copy the elements of the array into rgvar
-    nsCOMPtr<nsIAccessible> accel(do_QueryElementAt(mArray, mCurIndex));
-    NS_ASSERTION(accel, "Invalid pointer in mArray");
-
-    if (accel) {
-      rgvar[i].vt = VT_DISPATCH;
-      rgvar[i].pdispVal = AccessibleWrap::NativeAccessible(accel);
-    }
+    rgvar[i].vt = VT_DISPATCH;
+    rgvar[i].pdispVal = AccessibleWrap::NativeAccessible(mArray[mCurIndex]);
   }
 
   if (pceltFetched)
     *pceltFetched = celt;
 
   return hr;
 
   A11Y_TRYBLOCK_END
@@ -687,33 +682,32 @@ AccessibleEnumerator::Clone(IEnumVARIANT
   A11Y_TRYBLOCK_END
 }
 
 STDMETHODIMP
 AccessibleEnumerator::Skip(unsigned long celt)
 {
   A11Y_TRYBLOCK_BEGIN
 
-  uint32_t length = 0;
-  mArray->GetLength(&length);
+  uint32_t length = mArray.Length();
   // Check if we can skip the requested number of elements
   if (celt > length - mCurIndex) {
     mCurIndex = length;
     return S_FALSE;
   }
   mCurIndex += celt;
   return S_OK;
 
   A11Y_TRYBLOCK_END
 }
 
 /**
   * This method is called when a client wants to know which children of a node
   *  are selected. Note that this method can only find selected children for
-  *  nsIAccessible object which implement SelectAccessible.
+  *  accessible object which implement SelectAccessible.
   *
   * The VARIANT return value arguement is expected to either contain a single IAccessible
   *  or an IEnumVARIANT of IAccessibles. We return the IEnumVARIANT regardless of the number
   *  of children selected, unless there are none selected in which case we return an empty
   *  VARIANT.
   *
   * We get the selected options from the select's accessible object and wrap
   *  those in an AccessibleEnumerator which we then put in the return VARIANT.
@@ -732,28 +726,23 @@ AccessibleWrap::get_accSelection(VARIANT
 
   VariantInit(pvarChildren);
   pvarChildren->vt = VT_EMPTY;
 
   if (IsDefunct())
     return CO_E_OBJNOTCONNECTED;
 
   if (IsSelect()) {
-    nsCOMPtr<nsIArray> selectedItems = SelectedItems();
-    if (selectedItems) {
-      // 1) Create and initialize the enumeration
-      nsRefPtr<AccessibleEnumerator> pEnum =
-        new AccessibleEnumerator(selectedItems);
+    nsAutoTArray<Accessible*, 10> selectedItems;
+    SelectedItems(&selectedItems);
 
-      // 2) Put the enumerator in the VARIANT
-      if (!pEnum)
-        return E_OUTOFMEMORY;
-      pvarChildren->vt = VT_UNKNOWN;    // this must be VT_UNKNOWN for an IEnumVARIANT
-      NS_ADDREF(pvarChildren->punkVal = pEnum);
-    }
+    // 1) Create and initialize the enumeration
+    nsRefPtr<AccessibleEnumerator> pEnum = new AccessibleEnumerator(selectedItems);
+    pvarChildren->vt = VT_UNKNOWN;    // this must be VT_UNKNOWN for an IEnumVARIANT
+    NS_ADDREF(pvarChildren->punkVal = pEnum);
   }
   return S_OK;
 
   A11Y_TRYBLOCK_END
 }
 
 STDMETHODIMP
 AccessibleWrap::get_accDefaultAction(
@@ -1076,24 +1065,21 @@ AccessibleWrap::Invoke(DISPID dispIdMemb
   if (!typeInfo)
     return E_FAIL;
 
   return typeInfo->Invoke(static_cast<IAccessible*>(this), dispIdMember,
                           wFlags, pDispParams, pVarResult, pExcepInfo,
                           puArgErr);
 }
 
-
-// nsIAccessible method
-NS_IMETHODIMP
-AccessibleWrap::GetNativeInterface(void **aOutAccessible)
+void
+AccessibleWrap::GetNativeInterface(void** aOutAccessible)
 {
   *aOutAccessible = static_cast<IAccessible*>(this);
   NS_ADDREF_THIS();
-  return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Accessible
 
 nsresult
 AccessibleWrap::HandleAccEvent(AccEvent* aEvent)
 {
@@ -1217,21 +1203,21 @@ AccessibleWrap::GetHWNDFor(Accessible* a
     }
 
     return static_cast<HWND>(document->GetNativeWindow());
   }
   return nullptr;
 }
 
 IDispatch*
-AccessibleWrap::NativeAccessible(nsIAccessible* aAccessible)
+AccessibleWrap::NativeAccessible(Accessible* aAccessible)
 {
   if (!aAccessible) {
-   NS_WARNING("Not passing in an aAccessible");
-   return nullptr;
+    NS_WARNING("Not passing in an aAccessible");
+    return nullptr;
   }
 
   IAccessible* msaaAccessible = nullptr;
   aAccessible->GetNativeInterface(reinterpret_cast<void**>(&msaaAccessible));
   return static_cast<IDispatch*>(msaaAccessible);
 }
 
 Accessible*
--- a/accessible/windows/msaa/AccessibleWrap.h
+++ b/accessible/windows/msaa/AccessibleWrap.h
@@ -165,19 +165,19 @@ public: // construction, destruction
    */
   void UpdateSystemCaretFor(Accessible* aAccessible);
 
   /**
    * Find an accessible by the given child ID in cached documents.
    */
   Accessible* GetXPAccessibleFor(const VARIANT& aVarChild);
 
-  NS_IMETHOD GetNativeInterface(void **aOutAccessible);
+  virtual void GetNativeInterface(void **aOutAccessible) MOZ_OVERRIDE;
 
-  static IDispatch *NativeAccessible(nsIAccessible *aXPAccessible);
+  static IDispatch* NativeAccessible(Accessible* aAccessible);
 
 protected:
   virtual ~AccessibleWrap() { }
 
   /**
    * Creates ITypeInfo for LIBID_Accessibility if it's needed and returns it.
    */
   static ITypeInfo* GetTI(LCID lcid);
--- a/accessible/windows/msaa/HTMLWin32ObjectAccessible.cpp
+++ b/accessible/windows/msaa/HTMLWin32ObjectAccessible.cpp
@@ -16,17 +16,17 @@ using namespace mozilla::a11y;
 
 HTMLWin32ObjectOwnerAccessible::
   HTMLWin32ObjectOwnerAccessible(nsIContent* aContent,
                                  DocAccessible* aDoc, void* aHwnd) :
   AccessibleWrap(aContent, aDoc), mHwnd(aHwnd)
 {
   // Our only child is a HTMLWin32ObjectAccessible object.
   if (mHwnd)
-    mNativeAccessible = new HTMLWin32ObjectAccessible(mHwnd);
+    mNativeAccessible = new HTMLWin32ObjectAccessible(mHwnd, aDoc);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLWin32ObjectOwnerAccessible: Accessible implementation
 
 void
 HTMLWin32ObjectOwnerAccessible::Shutdown()
 {
@@ -58,35 +58,35 @@ HTMLWin32ObjectOwnerAccessible::CacheChi
     AppendChild(mNativeAccessible);
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLWin32ObjectAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
-HTMLWin32ObjectAccessible::HTMLWin32ObjectAccessible(void* aHwnd) :
-  DummyAccessible()
+HTMLWin32ObjectAccessible::HTMLWin32ObjectAccessible(void* aHwnd,
+                                                     DocAccessible* aDoc) :
+  DummyAccessible(aDoc)
 {
   mHwnd = aHwnd;
   if (mHwnd) {
     // The plugin is not windowless. In this situation we use 
     // use its inner child owned by the plugin so that we don't get
     // in an infinite loop, where the WM_GETOBJECT's get forwarded
     // back to us and create another HTMLWin32ObjectAccessible
     HWND childWnd = ::GetWindow((HWND)aHwnd, GW_CHILD);
     if (childWnd) {
       mHwnd = childWnd;
     }
   }
 }
 
-NS_IMETHODIMP 
+void
 HTMLWin32ObjectAccessible::GetNativeInterface(void** aNativeAccessible)
 {
   if (mHwnd) {
     ::AccessibleObjectFromWindow(static_cast<HWND>(mHwnd),
                                  OBJID_WINDOW, IID_IAccessible,
                                  aNativeAccessible);
   }
-  return NS_OK;
 }
 
--- a/accessible/windows/msaa/HTMLWin32ObjectAccessible.h
+++ b/accessible/windows/msaa/HTMLWin32ObjectAccessible.h
@@ -18,17 +18,17 @@ class HTMLWin32ObjectOwnerAccessible : p
 public:
   // This will own the HTMLWin32ObjectAccessible. We create this where the
   // <object> or <embed> exists in the tree, so that get_accNextSibling() etc.
   // will still point to Gecko accessible sibling content. This is necessary
   // because the native plugin accessible doesn't know where it exists in the
   // Mozilla tree, and returns null for previous and next sibling. This would
   // have the effect of cutting off all content after the plugin.
   HTMLWin32ObjectOwnerAccessible(nsIContent* aContent,
-                                   DocAccessible* aDoc, void* aHwnd);
+                                 DocAccessible* aDoc, void* aHwnd);
   virtual ~HTMLWin32ObjectOwnerAccessible() {}
 
   // Accessible
   virtual void Shutdown();
   virtual mozilla::a11y::role NativeRole();
   virtual bool NativelyUnavailable() const;
 
 protected:
@@ -39,28 +39,28 @@ protected:
   void* mHwnd;
   nsRefPtr<Accessible> mNativeAccessible;
 };
 
 /**
   * This class is used only internally, we never! send out an IAccessible linked
   *   back to this object. This class is used to represent a plugin object when
   *   referenced as a child or sibling of another Accessible node. We need only
-  *   a limited portion of the nsIAccessible interface implemented here. The
+  *   a limited portion of the Accessible interface implemented here. The
   *   in depth accessible information will be returned by the actual IAccessible
   *   object returned by us in Accessible::NewAccessible() that gets the IAccessible
   *   from the windows system from the window handle.
   */
 class HTMLWin32ObjectAccessible : public DummyAccessible
 {
 public:
-  HTMLWin32ObjectAccessible(void* aHwnd);
+  HTMLWin32ObjectAccessible(void* aHwnd, DocAccessible* aDoc);
   virtual ~HTMLWin32ObjectAccessible() {}
 
-  NS_IMETHOD GetNativeInterface(void** aNativeAccessible) MOZ_OVERRIDE;
+  virtual void GetNativeInterface(void** aNativeAccessible) MOZ_OVERRIDE;
 
 protected:
   void* mHwnd;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
--- a/accessible/windows/msaa/XULMenuAccessibleWrap.cpp
+++ b/accessible/windows/msaa/XULMenuAccessibleWrap.cpp
@@ -16,21 +16,21 @@ XULMenuitemAccessibleWrap::
   XULMenuitemAccessibleWrap(nsIContent* aContent, DocAccessible* aDoc) :
   XULMenuitemAccessible(aContent, aDoc)
 {
 }
 
 ENameValueFlag
 XULMenuitemAccessibleWrap::Name(nsString& aName)
 {
-  // XXX This should be done in get_accName() so that nsIAccessible::GetName()]
+  // XXX This should be done in MSAA's get_accName() so that Accessible::Name()]
   // provides the same results on all platforms
   XULMenuitemAccessible::Name(aName);
   if (aName.IsEmpty())
     return eNameOK;
-  
+
   nsAutoString accel;
   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::acceltext, accel);
   if (!accel.IsEmpty())
     aName += NS_LITERAL_STRING("\t") + accel;
 
   return eNameOK;
 }
--- a/accessible/windows/sdn/sdnDocAccessible.cpp
+++ b/accessible/windows/sdn/sdnDocAccessible.cpp
@@ -72,20 +72,17 @@ sdnDocAccessible::get_mimeType(BSTR __RP
   if (!aMimeType)
     return E_INVALIDARG;
   *aMimeType = nullptr;
 
   if (mAccessible->IsDefunct())
     return CO_E_OBJNOTCONNECTED;
 
   nsAutoString mimeType;
-  nsresult rv = mAccessible->GetMimeType(mimeType);
-  if (NS_FAILED(rv))
-    return E_FAIL;
-
+  mAccessible->MimeType(mimeType);
   if (mimeType.IsEmpty())
     return S_FALSE;
 
   *aMimeType = ::SysAllocStringLen(mimeType.get(), mimeType.Length());
   return *aMimeType ? S_OK : E_OUTOFMEMORY;
 
   A11Y_TRYBLOCK_END
 }
@@ -98,20 +95,17 @@ sdnDocAccessible::get_docType(BSTR __RPC
   if (!aDocType)
     return E_INVALIDARG;
   *aDocType = nullptr;
 
   if (mAccessible->IsDefunct())
     return CO_E_OBJNOTCONNECTED;
 
   nsAutoString docType;
-  nsresult rv = mAccessible->GetDocType(docType);
-  if (NS_FAILED(rv))
-    return E_FAIL;
-
+  mAccessible->DocType(docType);
   if (docType.IsEmpty())
     return S_FALSE;
 
   *aDocType = ::SysAllocStringLen(docType.get(), docType.Length());
   return *aDocType ? S_OK : E_OUTOFMEMORY;
 
   A11Y_TRYBLOCK_END
 }
--- a/accessible/xpcom/moz.build
+++ b/accessible/xpcom/moz.build
@@ -1,28 +1,20 @@
 # -*- Mode: python; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # 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/.
 
-EXPORTS += [
-    'xpcAccessible.h',
-    'xpcAccessibleDocument.h',
-    'xpcAccessibleHyperLink.h',
-    'xpcAccessibleHyperText.h',
-    'xpcAccessibleSelectable.h',
-    'xpcAccessibleValue.h',
-]
-
 UNIFIED_SOURCES += [
     'nsAccessibleRelation.cpp',
     'xpcAccessible.cpp',
     'xpcAccessibleApplication.cpp',
     'xpcAccessibleDocument.cpp',
+    'xpcAccessibleGeneric.cpp',
     'xpcAccessibleHyperLink.cpp',
     'xpcAccessibleHyperText.cpp',
     'xpcAccessibleImage.cpp',
     'xpcAccessibleSelectable.cpp',
     'xpcAccessibleTable.cpp',
     'xpcAccessibleTableCell.cpp',
     'xpcAccessibleTextRange.cpp',
     'xpcAccessibleValue.cpp',
--- a/accessible/xpcom/nsAccessibleRelation.cpp
+++ b/accessible/xpcom/nsAccessibleRelation.cpp
@@ -2,30 +2,31 @@
 /* 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 "nsAccessibleRelation.h"
 
 #include "Relation.h"
 #include "Accessible.h"
+#include "xpcAccessibleDocument.h"
 
 #include "nsArrayUtils.h"
 #include "nsComponentManagerUtils.h"
 
 using namespace mozilla::a11y;
 
 nsAccessibleRelation::nsAccessibleRelation(uint32_t aType,
                                            Relation* aRel) :
   mType(aType)
 {
   mTargets = do_CreateInstance(NS_ARRAY_CONTRACTID);
-  nsIAccessible* targetAcc = nullptr;
+  Accessible* targetAcc = nullptr;
   while ((targetAcc = aRel->Next()))
-    mTargets->AppendElement(targetAcc, false);
+    mTargets->AppendElement(static_cast<nsIAccessible*>(ToXPC(targetAcc)), false);
 }
 
 nsAccessibleRelation::~nsAccessibleRelation()
 {
 }
 
 // nsISupports
 NS_IMPL_ISUPPORTS(nsAccessibleRelation, nsIAccessibleRelation)
--- a/accessible/xpcom/xpcAccessible.cpp
+++ b/accessible/xpcom/xpcAccessible.cpp
@@ -1,307 +1,311 @@
 /* -*- 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 "xpcAccessible.h"
-
 #include "Accessible-inl.h"
 #include "nsAccUtils.h"
 #include "nsIAccessibleRelation.h"
 #include "nsIAccessibleRole.h"
 #include "nsAccessibleRelation.h"
 #include "Relation.h"
 #include "Role.h"
 #include "RootAccessible.h"
+#include "xpcAccessibleDocument.h"
 
 #include "nsIMutableArray.h"
 #include "nsIPersistentProperties2.h"
 
 using namespace mozilla::a11y;
 
 NS_IMETHODIMP
 xpcAccessible::GetParent(nsIAccessible** aParent)
 {
   NS_ENSURE_ARG_POINTER(aParent);
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  NS_IF_ADDREF(*aParent = static_cast<Accessible*>(this)->Parent());
+  NS_IF_ADDREF(*aParent = ToXPC(Intl()->Parent()));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetNextSibling(nsIAccessible** aNextSibling)
 {
   NS_ENSURE_ARG_POINTER(aNextSibling);
   *aNextSibling = nullptr;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsresult rv = NS_OK;
-  NS_IF_ADDREF(*aNextSibling = static_cast<Accessible*>(this)->GetSiblingAtOffset(1, &rv));
+  NS_IF_ADDREF(*aNextSibling = ToXPC(Intl()->GetSiblingAtOffset(1, &rv)));
   return rv;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetPreviousSibling(nsIAccessible** aPreviousSibling)
 {
   NS_ENSURE_ARG_POINTER(aPreviousSibling);
   *aPreviousSibling = nullptr;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsresult rv = NS_OK;
-  NS_IF_ADDREF(*aPreviousSibling = static_cast<Accessible*>(this)->GetSiblingAtOffset(-1, &rv));
+  NS_IF_ADDREF(*aPreviousSibling = ToXPC(Intl()->GetSiblingAtOffset(-1, &rv)));
   return rv;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetFirstChild(nsIAccessible** aFirstChild)
 {
   NS_ENSURE_ARG_POINTER(aFirstChild);
   *aFirstChild = nullptr;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  NS_IF_ADDREF(*aFirstChild = static_cast<Accessible*>(this)->FirstChild());
+  NS_IF_ADDREF(*aFirstChild = ToXPC(Intl()->FirstChild()));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetLastChild(nsIAccessible** aLastChild)
 {
   NS_ENSURE_ARG_POINTER(aLastChild);
   *aLastChild = nullptr;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  NS_IF_ADDREF(*aLastChild = static_cast<Accessible*>(this)->LastChild());
+  NS_IF_ADDREF(*aLastChild = ToXPC(Intl()->LastChild()));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetChildCount(int32_t* aChildCount)
 {
   NS_ENSURE_ARG_POINTER(aChildCount);
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aChildCount = static_cast<Accessible*>(this)->ChildCount();
+  *aChildCount = Intl()->ChildCount();
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessible::ScriptableGetChildAt(int32_t aChildIndex, nsIAccessible** aChild)
+xpcAccessible::GetChildAt(int32_t aChildIndex, nsIAccessible** aChild)
 {
   NS_ENSURE_ARG_POINTER(aChild);
   *aChild = nullptr;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   // If child index is negative, then return last child.
   // XXX: do we really need this?
   if (aChildIndex < 0)
-    aChildIndex = static_cast<Accessible*>(this)->ChildCount() - 1;
+    aChildIndex = Intl()->ChildCount() - 1;
 
-  Accessible* child = static_cast<Accessible*>(this)->GetChildAt(aChildIndex);
+  Accessible* child = Intl()->GetChildAt(aChildIndex);
   if (!child)
     return NS_ERROR_INVALID_ARG;
 
-  NS_ADDREF(*aChild = child);
+  NS_ADDREF(*aChild = ToXPC(child));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetChildren(nsIArray** aChildren)
 {
   NS_ENSURE_ARG_POINTER(aChildren);
   *aChildren = nullptr;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsresult rv = NS_OK;
   nsCOMPtr<nsIMutableArray> children =
     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  uint32_t childCount = static_cast<Accessible*>(this)->ChildCount();
+  uint32_t childCount = Intl()->ChildCount();
   for (uint32_t childIdx = 0; childIdx < childCount; childIdx++) {
-    nsIAccessible* child = static_cast<Accessible*>(this)->GetChildAt(childIdx);
-    children->AppendElement(child, false);
+    Accessible* child = Intl()->GetChildAt(childIdx);
+    children->AppendElement(static_cast<nsIAccessible*>(ToXPC(child)), false);
   }
 
   NS_ADDREF(*aChildren = children);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetIndexInParent(int32_t* aIndexInParent)
 {
   NS_ENSURE_ARG_POINTER(aIndexInParent);
 
-  *aIndexInParent = static_cast<Accessible*>(this)->IndexInParent();
+  *aIndexInParent = Intl()->IndexInParent();
   return *aIndexInParent != -1 ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetDOMNode(nsIDOMNode** aDOMNode)
 {
   NS_ENSURE_ARG_POINTER(aDOMNode);
   *aDOMNode = nullptr;
 
-  nsINode *node = static_cast<Accessible*>(this)->GetNode();
+  nsINode* node = Intl()->GetNode();
   if (node)
     CallQueryInterface(node, aDOMNode);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetDocument(nsIAccessibleDocument** aDocument)
 {
   NS_ENSURE_ARG_POINTER(aDocument);
 
-  NS_IF_ADDREF(*aDocument = static_cast<Accessible*>(this)->Document());
+  NS_IF_ADDREF(*aDocument = ToXPCDocument(Intl()->Document()));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetRootDocument(nsIAccessibleDocument** aRootDocument)
 {
   NS_ENSURE_ARG_POINTER(aRootDocument);
 
-  NS_IF_ADDREF(*aRootDocument = static_cast<Accessible*>(this)->RootAccessible());
+  NS_IF_ADDREF(*aRootDocument = ToXPCDocument(Intl()->RootAccessible()));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetRole(uint32_t* aRole)
 {
   NS_ENSURE_ARG_POINTER(aRole);
   *aRole = nsIAccessibleRole::ROLE_NOTHING;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aRole = static_cast<Accessible*>(this)->Role();
+  *aRole = Intl()->Role();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetState(uint32_t* aState, uint32_t* aExtraState)
 {
   NS_ENSURE_ARG_POINTER(aState);
 
-  nsAccUtils::To32States(static_cast<Accessible*>(this)->State(),
-                         aState, aExtraState);
+  nsAccUtils::To32States(Intl()->State(), aState, aExtraState);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetName(nsAString& aName)
 {
   aName.Truncate();
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsAutoString name;
-  static_cast<Accessible*>(this)->Name(name);
+  Intl()->Name(name);
   aName.Assign(name);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetDescription(nsAString& aDescription)
 {
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsAutoString desc;
-  static_cast<Accessible*>(this)->Description(desc);
+  Intl()->Description(desc);
   aDescription.Assign(desc);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetLanguage(nsAString& aLanguage)
 {
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<Accessible*>(this)->Language(aLanguage);
+  Intl()->Language(aLanguage);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetValue(nsAString& aValue)
 {
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsAutoString value;
-  static_cast<Accessible*>(this)->Value(value);
+  Intl()->Value(value);
   aValue.Assign(value);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetHelp(nsAString& aHelp)
 {
-  return NS_ERROR_NOT_IMPLEMENTED;
+  if (!Intl())
+    return NS_ERROR_FAILURE;
+
+  nsAutoString help;
+  Intl()->Help(help);
+  aHelp.Assign(help);
+
+  return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetAccessKey(nsAString& aAccessKey)
 {
   aAccessKey.Truncate();
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<Accessible*>(this)->AccessKey().ToString(aAccessKey);
+  Intl()->AccessKey().ToString(aAccessKey);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetKeyboardShortcut(nsAString& aKeyBinding)
 {
   aKeyBinding.Truncate();
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<Accessible*>(this)->KeyboardShortcut().ToString(aKeyBinding);
+  Intl()->KeyboardShortcut().ToString(aKeyBinding);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetAttributes(nsIPersistentProperties** aAttributes)
 {
   NS_ENSURE_ARG_POINTER(aAttributes);
   *aAttributes = nullptr;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  nsCOMPtr<nsIPersistentProperties> attributes =
-    static_cast<Accessible*>(this)->Attributes();
+  nsCOMPtr<nsIPersistentProperties> attributes = Intl()->Attributes();
   attributes.swap(*aAttributes);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetBounds(int32_t* aX, int32_t* aY,
                          int32_t* aWidth, int32_t* aHeight)
@@ -310,46 +314,46 @@ xpcAccessible::GetBounds(int32_t* aX, in
   *aX = 0;
   NS_ENSURE_ARG_POINTER(aY);
   *aY = 0;
   NS_ENSURE_ARG_POINTER(aWidth);
   *aWidth = 0;
   NS_ENSURE_ARG_POINTER(aHeight);
   *aHeight = 0;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  nsIntRect rect = static_cast<Accessible*>(this)->Bounds();
+  nsIntRect rect = Intl()->Bounds();
   *aX = rect.x;
   *aY = rect.y;
   *aWidth = rect.width;
   *aHeight = rect.height;;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessible::ScriptableGroupPosition(int32_t* aGroupLevel,
-                                       int32_t* aSimilarItemsInGroup,
-                                       int32_t* aPositionInGroup)
+xpcAccessible::GroupPosition(int32_t* aGroupLevel,
+                             int32_t* aSimilarItemsInGroup,
+                             int32_t* aPositionInGroup)
 {
   NS_ENSURE_ARG_POINTER(aGroupLevel);
   *aGroupLevel = 0;
 
   NS_ENSURE_ARG_POINTER(aSimilarItemsInGroup);
   *aSimilarItemsInGroup = 0;
 
   NS_ENSURE_ARG_POINTER(aPositionInGroup);
   *aPositionInGroup = 0;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  GroupPos groupPos = static_cast<Accessible*>(this)->GroupPosition();
+  GroupPos groupPos = Intl()->GroupPosition();
 
   *aGroupLevel = groupPos.level;
   *aSimilarItemsInGroup = groupPos.setSize;
   *aPositionInGroup = groupPos.posInSet;
 
   return NS_OK;
 }
 
@@ -357,31 +361,31 @@ NS_IMETHODIMP
 xpcAccessible::GetRelationByType(uint32_t aType,
                                  nsIAccessibleRelation** aRelation)
 {
   NS_ENSURE_ARG_POINTER(aRelation);
   *aRelation = nullptr;
 
   NS_ENSURE_ARG(aType <= static_cast<uint32_t>(RelationType::LAST));
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  Relation rel = static_cast<Accessible*>(this)->RelationByType(static_cast<RelationType>(aType));
+  Relation rel = Intl()->RelationByType(static_cast<RelationType>(aType));
   NS_ADDREF(*aRelation = new nsAccessibleRelation(aType, &rel));
   return *aRelation ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetRelations(nsIArray** aRelations)
 {
   NS_ENSURE_ARG_POINTER(aRelations);
   *aRelations = nullptr;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsCOMPtr<nsIMutableArray> relations = do_CreateInstance(NS_ARRAY_CONTRACTID);
   NS_ENSURE_TRUE(relations, NS_ERROR_OUT_OF_MEMORY);
 
   static const uint32_t relationTypes[] = {
     nsIAccessibleRelation::RELATION_LABELLED_BY,
     nsIAccessibleRelation::RELATION_LABEL_FOR,
@@ -422,151 +426,152 @@ xpcAccessible::GetRelations(nsIArray** a
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetFocusedChild(nsIAccessible** aChild)
 {
   NS_ENSURE_ARG_POINTER(aChild);
   *aChild = nullptr;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  NS_IF_ADDREF(*aChild = static_cast<Accessible*>(this)->FocusedChild());
+  NS_IF_ADDREF(*aChild = ToXPC(Intl()->FocusedChild()));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetChildAtPoint(int32_t aX, int32_t aY,
                                nsIAccessible** aAccessible)
 {
   NS_ENSURE_ARG_POINTER(aAccessible);
   *aAccessible = nullptr;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   NS_IF_ADDREF(*aAccessible =
-               static_cast<Accessible*>(this)->ChildAtPoint(aX, aY,
-                                                            Accessible::eDirectChild));
+               ToXPC(Intl()->ChildAtPoint(aX, aY, Accessible::eDirectChild)));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetDeepestChildAtPoint(int32_t aX, int32_t aY,
                                       nsIAccessible** aAccessible)
 {
   NS_ENSURE_ARG_POINTER(aAccessible);
   *aAccessible = nullptr;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   NS_IF_ADDREF(*aAccessible =
-               static_cast<Accessible*>(this)->ChildAtPoint(aX, aY,
-                                                            Accessible::eDeepestChild));
+               ToXPC(Intl()->ChildAtPoint(aX, aY, Accessible::eDeepestChild)));
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessible::ScriptableSetSelected(bool aSelect)
+xpcAccessible::SetSelected(bool aSelect)
 {
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<Accessible*>(this)->SetSelected(aSelect);
+  Intl()->SetSelected(aSelect);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::ExtendSelection()
 {
-  return NS_ERROR_NOT_IMPLEMENTED;
-}
-
-NS_IMETHODIMP
-xpcAccessible::ScriptableTakeSelection()
-{
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<Accessible*>(this)->TakeSelection();
+  Intl()->ExtendSelection();
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessible::ScriptableTakeFocus()
+xpcAccessible::TakeSelection()
 {
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<Accessible*>(this)->TakeFocus();
+  Intl()->TakeSelection();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+xpcAccessible::TakeFocus()
+{
+  if (!Intl())
+    return NS_ERROR_FAILURE;
+
+  Intl()->TakeFocus();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetActionCount(uint8_t* aActionCount)
 {
   NS_ENSURE_ARG_POINTER(aActionCount);
   *aActionCount = 0;
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aActionCount = static_cast<Accessible*>(this)->ActionCount();
+  *aActionCount = Intl()->ActionCount();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetActionName(uint8_t aIndex, nsAString& aName)
 {
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aIndex >= static_cast<Accessible*>(this)->ActionCount())
+  if (aIndex >= Intl()->ActionCount())
     return NS_ERROR_INVALID_ARG;
 
-  static_cast<Accessible*>(this)->ActionNameAt(aIndex, aName);
+  Intl()->ActionNameAt(aIndex, aName);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessible::GetActionDescription(uint8_t aIndex, nsAString& aDescription)
 {
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aIndex >= static_cast<Accessible*>(this)->ActionCount())
+  if (aIndex >= Intl()->ActionCount())
     return NS_ERROR_INVALID_ARG;
 
-  static_cast<Accessible*>(this)->ActionDescriptionAt(aIndex, aDescription);
+  Intl()->ActionDescriptionAt(aIndex, aDescription);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessible::ScriptableDoAction(uint8_t aIndex)
+xpcAccessible::DoAction(uint8_t aIndex)
 {
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  return static_cast<Accessible*>(this)->DoAction(aIndex) ?
+  return Intl()->DoAction(aIndex) ?
     NS_OK : NS_ERROR_INVALID_ARG;
 }
 
 NS_IMETHODIMP
-xpcAccessible::ScriptableScrollTo(uint32_t aHow)
+xpcAccessible::ScrollTo(uint32_t aHow)
 {
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<Accessible*>(this)->ScrollTo(aHow);
+  Intl()->ScrollTo(aHow);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessible::ScriptableScrollToPoint(uint32_t aCoordinateType,
-                                       int32_t aX, int32_t aY)
+xpcAccessible::ScrollToPoint(uint32_t aCoordinateType, int32_t aX, int32_t aY)
 {
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<Accessible*>(this)->ScrollToPoint(aCoordinateType, aX, aY);
+  Intl()->ScrollToPoint(aCoordinateType, aX, aY);
   return NS_OK;
-}
\ No newline at end of file
+}
--- a/accessible/xpcom/xpcAccessible.h
+++ b/accessible/xpcom/xpcAccessible.h
@@ -9,27 +9,33 @@
 
 #include "nsIAccessible.h"
 
 class nsIAccessible;
 
 namespace mozilla {
 namespace a11y {
 
+class Accessible;
+
+/**
+ * XPCOM nsIAccessible interface implementation, used by xpcAccessibleGeneric
+ * class.
+ */
 class xpcAccessible : public nsIAccessible
 {
 public:
+  // nsIAccessible
   NS_IMETHOD GetParent(nsIAccessible** aParent) MOZ_FINAL;
   NS_IMETHOD GetNextSibling(nsIAccessible** aNextSibling) MOZ_FINAL;
   NS_IMETHOD GetPreviousSibling(nsIAccessible** aPreviousSibling) MOZ_FINAL;
   NS_IMETHOD GetFirstChild(nsIAccessible** aFirstChild) MOZ_FINAL;
   NS_IMETHOD GetLastChild(nsIAccessible** aLastChild) MOZ_FINAL;
   NS_IMETHOD GetChildCount(int32_t* aChildCount) MOZ_FINAL;
-  NS_IMETHOD ScriptableGetChildAt(int32_t aChildIndex,
-                                  nsIAccessible** aChild) MOZ_FINAL;
+  NS_IMETHOD GetChildAt(int32_t aChildIndex, nsIAccessible** aChild) MOZ_FINAL;
   NS_IMETHOD GetChildren(nsIArray** aChildren) MOZ_FINAL;
   NS_IMETHOD GetIndexInParent(int32_t* aIndexInParent) MOZ_FINAL;
 
   NS_IMETHOD GetDOMNode(nsIDOMNode** aDOMNode) MOZ_FINAL;
   NS_IMETHOD GetDocument(nsIAccessibleDocument** aDocument) MOZ_FINAL;
   NS_IMETHOD GetRootDocument(nsIAccessibleDocument** aRootDocument) MOZ_FINAL;
 
   NS_IMETHOD GetRole(uint32_t* aRole) MOZ_FINAL;
@@ -42,46 +48,48 @@ public:
   NS_IMETHOD GetHelp(nsAString& aHelp) MOZ_FINAL;
 
   NS_IMETHOD GetAccessKey(nsAString& aAccessKey) MOZ_FINAL;
   NS_IMETHOD GetKeyboardShortcut(nsAString& aKeyBinding) MOZ_FINAL;
 
   NS_IMETHOD GetAttributes(nsIPersistentProperties** aAttributes) MOZ_FINAL;
   NS_IMETHOD GetBounds(int32_t* aX, int32_t* aY,
                        int32_t* aWidth, int32_t* aHeight) MOZ_FINAL;
-  NS_IMETHOD ScriptableGroupPosition(int32_t* aGroupLevel,
-                                     int32_t* aSimilarItemsInGroup,
-                                     int32_t* aPositionInGroup) MOZ_FINAL;
+  NS_IMETHOD GroupPosition(int32_t* aGroupLevel, int32_t* aSimilarItemsInGroup,
+                           int32_t* aPositionInGroup) MOZ_FINAL;
   NS_IMETHOD GetRelationByType(uint32_t aType,
                                nsIAccessibleRelation** aRelation) MOZ_FINAL;
   NS_IMETHOD GetRelations(nsIArray** aRelations) MOZ_FINAL;
 
   NS_IMETHOD GetFocusedChild(nsIAccessible** aChild) MOZ_FINAL;
   NS_IMETHOD GetChildAtPoint(int32_t aX, int32_t aY,
                              nsIAccessible** aAccessible) MOZ_FINAL;
   NS_IMETHOD GetDeepestChildAtPoint(int32_t aX, int32_t aY,
                                     nsIAccessible** aAccessible) MOZ_FINAL;
 
-  NS_IMETHOD ScriptableSetSelected(bool aSelect) MOZ_FINAL;
+  NS_IMETHOD SetSelected(bool aSelect) MOZ_FINAL;
   NS_IMETHOD ExtendSelection() MOZ_FINAL;
-  NS_IMETHOD ScriptableTakeSelection() MOZ_FINAL;
-  NS_IMETHOD ScriptableTakeFocus() MOZ_FINAL;
+  NS_IMETHOD TakeSelection() MOZ_FINAL;
+  NS_IMETHOD TakeFocus() MOZ_FINAL;
 
   NS_IMETHOD GetActionCount(uint8_t* aActionCount) MOZ_FINAL;
   NS_IMETHOD GetActionName(uint8_t aIndex, nsAString& aName) MOZ_FINAL;
   NS_IMETHOD GetActionDescription(uint8_t aIndex, nsAString& aDescription) MOZ_FINAL;
-  NS_IMETHOD ScriptableDoAction(uint8_t aIndex) MOZ_FINAL;
+  NS_IMETHOD DoAction(uint8_t aIndex) MOZ_FINAL;
 
-  NS_IMETHOD ScriptableScrollTo(uint32_t aHow) MOZ_FINAL;
-  NS_IMETHOD ScriptableScrollToPoint(uint32_t aCoordinateType,
-                                     int32_t aX, int32_t aY) MOZ_FINAL;
+  NS_IMETHOD ScrollTo(uint32_t aHow) MOZ_FINAL;
+  NS_IMETHOD ScrollToPoint(uint32_t aCoordinateType,
+                           int32_t aX, int32_t aY) MOZ_FINAL;
+
+protected:
+  xpcAccessible() { }
+  virtual ~xpcAccessible() {}
 
 private:
-  xpcAccessible() { }
-  friend class Accessible;
+  Accessible* Intl();
 
   xpcAccessible(const xpcAccessible&) MOZ_DELETE;
   xpcAccessible& operator =(const xpcAccessible&) MOZ_DELETE;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
--- a/accessible/xpcom/xpcAccessibleApplication.cpp
+++ b/accessible/xpcom/xpcAccessibleApplication.cpp
@@ -5,55 +5,65 @@
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "xpcAccessibleApplication.h"
 
 #include "ApplicationAccessible.h"
 
 using namespace mozilla::a11y;
 
+////////////////////////////////////////////////////////////////////////////////
+// nsISupports
+
+NS_IMPL_ISUPPORTS_INHERITED(xpcAccessibleApplication,
+                            xpcAccessibleGeneric,
+                            nsIAccessibleApplication)
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIAccessibleApplication
+
 NS_IMETHODIMP
 xpcAccessibleApplication::GetAppName(nsAString& aName)
 {
   aName.Truncate();
 
-  if (static_cast<ApplicationAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<ApplicationAccessible*>(this)->AppName(aName);
+  Intl()->AppName(aName);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleApplication::GetAppVersion(nsAString& aVersion)
 {
   aVersion.Truncate();
 
-  if (static_cast<ApplicationAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<ApplicationAccessible*>(this)->AppVersion(aVersion);
+  Intl()->AppVersion(aVersion);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleApplication::GetPlatformName(nsAString& aName)
 {
   aName.Truncate();
 
-  if (static_cast<ApplicationAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<ApplicationAccessible*>(this)->PlatformName(aName);
+  Intl()->PlatformName(aName);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleApplication::GetPlatformVersion(nsAString& aVersion)
 {
   aVersion.Truncate();
 
-  if (static_cast<ApplicationAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<ApplicationAccessible*>(this)->PlatformVersion(aVersion);
+  Intl()->PlatformVersion(aVersion);
   return NS_OK;
 }
--- a/accessible/xpcom/xpcAccessibleApplication.h
+++ b/accessible/xpcom/xpcAccessibleApplication.h
@@ -3,33 +3,44 @@
 /* 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_xpcAccessibleApplication_h_
 #define mozilla_a11y_xpcAccessibleApplication_h_
 
 #include "nsIAccessibleApplication.h"
-
-class nsIAccessible;
+#include "ApplicationAccessible.h"
+#include "xpcAccessibleGeneric.h"
 
 namespace mozilla {
 namespace a11y {
 
-class xpcAccessibleApplication : public nsIAccessibleApplication
+/**
+ * XPCOM wrapper around ApplicationAccessible class.
+ */
+class xpcAccessibleApplication : public xpcAccessibleGeneric,
+                                 public nsIAccessibleApplication
 {
 public:
+  xpcAccessibleApplication(Accessible* aIntl) : xpcAccessibleGeneric(aIntl) { }
+
+  NS_DECL_ISUPPORTS_INHERITED
+
+  // nsIAccessibleApplication
   NS_IMETHOD GetAppName(nsAString& aName) MOZ_FINAL;
   NS_IMETHOD GetAppVersion(nsAString& aVersion) MOZ_FINAL;
   NS_IMETHOD GetPlatformName(nsAString& aName) MOZ_FINAL;
   NS_IMETHOD GetPlatformVersion(nsAString& aVersion) MOZ_FINAL;
 
+protected:
+  virtual ~xpcAccessibleApplication() {}
+
 private:
-  xpcAccessibleApplication() { }
-  friend class ApplicationAccessible;
+  ApplicationAccessible* Intl() { return mIntl->AsApplication(); }
 
   xpcAccessibleApplication(const xpcAccessibleApplication&) MOZ_DELETE;
   xpcAccessibleApplication& operator =(const xpcAccessibleApplication&) MOZ_DELETE;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
--- a/accessible/xpcom/xpcAccessibleDocument.cpp
+++ b/accessible/xpcom/xpcAccessibleDocument.cpp
@@ -1,135 +1,203 @@
 /* -*- 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 "xpcAccessibleDocument.h"
+#include "xpcAccessibleImage.h"
+#include "xpcAccessibleTable.h"
+#include "xpcAccessibleTableCell.h"
 
 #include "DocAccessible-inl.h"
 #include "nsIDOMDocument.h"
 
 using namespace mozilla::a11y;
 
+////////////////////////////////////////////////////////////////////////////////
+// nsISupports and cycle collection
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(xpcAccessibleDocument)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(xpcAccessibleDocument,
+                                                  xpcAccessibleGeneric)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCache)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(xpcAccessibleDocument,
+                                                xpcAccessibleGeneric)
+  tmp->mCache.Clear();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(xpcAccessibleDocument)
+  NS_INTERFACE_MAP_ENTRY(nsIAccessibleDocument)
+NS_INTERFACE_MAP_END_INHERITING(xpcAccessibleHyperText)
+
+NS_IMPL_ADDREF_INHERITED(xpcAccessibleDocument, xpcAccessibleHyperText)
+NS_IMPL_RELEASE_INHERITED(xpcAccessibleDocument, xpcAccessibleHyperText)
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIAccessibleDocument
+
 NS_IMETHODIMP
 xpcAccessibleDocument::GetURL(nsAString& aURL)
 {
-  if (static_cast<DocAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<DocAccessible*>(this)->URL(aURL);
+  Intl()->URL(aURL);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleDocument::GetTitle(nsAString& aTitle)
 {
-  if (static_cast<DocAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsAutoString title;
-  static_cast<DocAccessible*>(this)->Title(title);
+  Intl()->Title(title);
   aTitle = title;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleDocument::GetMimeType(nsAString& aType)
 {
-  if (static_cast<DocAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<DocAccessible*>(this)->MimeType(aType);
+  Intl()->MimeType(aType);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleDocument::GetDocType(nsAString& aType)
 {
-  if (static_cast<DocAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  static_cast<DocAccessible*>(this)->DocType(aType);
+  Intl()->DocType(aType);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleDocument::GetDOMDocument(nsIDOMDocument** aDOMDocument)
 {
   NS_ENSURE_ARG_POINTER(aDOMDocument);
   *aDOMDocument = nullptr;
 
-  if (static_cast<DocAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (static_cast<DocAccessible*>(this)->DocumentNode())
-    CallQueryInterface(static_cast<DocAccessible*>(this)->DocumentNode(), aDOMDocument);
+  if (Intl()->DocumentNode())
+    CallQueryInterface(Intl()->DocumentNode(), aDOMDocument);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleDocument::GetWindow(nsIDOMWindow** aDOMWindow)
 {
   NS_ENSURE_ARG_POINTER(aDOMWindow);
   *aDOMWindow = nullptr;
 
-  if (static_cast<DocAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  NS_IF_ADDREF(*aDOMWindow = static_cast<DocAccessible*>(this)->DocumentNode()->GetWindow());
+  NS_IF_ADDREF(*aDOMWindow = Intl()->DocumentNode()->GetWindow());
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleDocument::GetParentDocument(nsIAccessibleDocument** aDocument)
 {
   NS_ENSURE_ARG_POINTER(aDocument);
   *aDocument = nullptr;
 
-  if (static_cast<DocAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  NS_IF_ADDREF(*aDocument = static_cast<DocAccessible*>(this)->ParentDocument());
+  NS_IF_ADDREF(*aDocument = ToXPCDocument(Intl()->ParentDocument()));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleDocument::GetChildDocumentCount(uint32_t* aCount)
 {
   NS_ENSURE_ARG_POINTER(aCount);
   *aCount = 0;
 
-  if (static_cast<DocAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aCount = static_cast<DocAccessible*>(this)->ChildDocumentCount();
+  *aCount = Intl()->ChildDocumentCount();
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleDocument::ScriptableGetChildDocumentAt(uint32_t aIndex,
-                                                    nsIAccessibleDocument** aDocument)
+xpcAccessibleDocument::GetChildDocumentAt(uint32_t aIndex,
+                                          nsIAccessibleDocument** aDocument)
 {
   NS_ENSURE_ARG_POINTER(aDocument);
   *aDocument = nullptr;
 
-  if (static_cast<DocAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  NS_IF_ADDREF(*aDocument = static_cast<DocAccessible*>(this)->GetChildDocumentAt(aIndex));
+  NS_IF_ADDREF(*aDocument = ToXPCDocument(Intl()->GetChildDocumentAt(aIndex)));
   return *aDocument ? NS_OK : NS_ERROR_INVALID_ARG;
 }
 
 NS_IMETHODIMP
 xpcAccessibleDocument::GetVirtualCursor(nsIAccessiblePivot** aVirtualCursor)
 {
   NS_ENSURE_ARG_POINTER(aVirtualCursor);
   *aVirtualCursor = nullptr;
 
-  if (static_cast<DocAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  NS_ADDREF(*aVirtualCursor = static_cast<DocAccessible*>(this)->VirtualCursor());
+  NS_ADDREF(*aVirtualCursor = Intl()->VirtualCursor());
   return NS_OK;
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// xpcAccessibleDocument
+
+xpcAccessibleGeneric*
+xpcAccessibleDocument::GetAccessible(Accessible* aAccessible)
+{
+  if (ToXPCDocument(aAccessible->Document()) != this) {
+    NS_ERROR("This XPCOM document is not related with given internal accessible!");
+    return nullptr;
+  }
+
+  if (aAccessible->IsDoc())
+    return this;
+
+  xpcAccessibleGeneric* xpcAcc = mCache.GetWeak(aAccessible);
+  if (xpcAcc)
+    return xpcAcc;
+
+  if (aAccessible->IsImage())
+    xpcAcc = new xpcAccessibleImage(aAccessible);
+  else if (aAccessible->IsTable())
+    xpcAcc = new xpcAccessibleTable(aAccessible);
+  else if (aAccessible->IsTableCell())
+    xpcAcc = new xpcAccessibleTableCell(aAccessible);
+  else if (aAccessible->IsHyperText())
+    xpcAcc = new xpcAccessibleHyperText(aAccessible);
+  else
+    xpcAcc = new xpcAccessibleGeneric(aAccessible);
+
+  mCache.Put(aAccessible, xpcAcc);
+  return xpcAcc;
+}
+
+void
+xpcAccessibleDocument::Shutdown()
+{
+  mCache.Clear();
+  xpcAccessibleGeneric::Shutdown();
+}
--- a/accessible/xpcom/xpcAccessibleDocument.h
+++ b/accessible/xpcom/xpcAccessibleDocument.h
@@ -4,39 +4,109 @@
  * 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_xpcAccessibleDocument_h_
 #define mozilla_a11y_xpcAccessibleDocument_h_
 
 #include "nsIAccessibleDocument.h"
 
+#include "DocAccessible.h"
+#include "nsAccessibilityService.h"
+#include "xpcAccessibleApplication.h"
+#include "xpcAccessibleHyperText.h"
+
 namespace mozilla {
 namespace a11y {
 
-class xpcAccessibleDocument : public nsIAccessibleDocument
+/**
+ * XPCOM wrapper around DocAccessible class.
+ */
+class xpcAccessibleDocument : public xpcAccessibleHyperText,
+                              public nsIAccessibleDocument
 {
 public:
+  xpcAccessibleDocument(DocAccessible* aIntl) :
+    xpcAccessibleHyperText(aIntl), mCache(kDefaultCacheLength) { }
+
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(xpcAccessibleDocument,
+                                           xpcAccessibleGeneric)
+
+  // nsIAccessibleDocument
   NS_IMETHOD GetURL(nsAString& aURL) MOZ_FINAL;
   NS_IMETHOD GetTitle(nsAString& aTitle) MOZ_FINAL;
   NS_IMETHOD GetMimeType(nsAString& aType) MOZ_FINAL;
   NS_IMETHOD GetDocType(nsAString& aType) MOZ_FINAL;
   NS_IMETHOD GetDOMDocument(nsIDOMDocument** aDOMDocument) MOZ_FINAL;
   NS_IMETHOD GetWindow(nsIDOMWindow** aDOMWindow) MOZ_FINAL;
   NS_IMETHOD GetParentDocument(nsIAccessibleDocument** aDocument) MOZ_FINAL;
   NS_IMETHOD GetChildDocumentCount(uint32_t* aCount) MOZ_FINAL;
-  NS_IMETHOD ScriptableGetChildDocumentAt(uint32_t aIndex,
-                                          nsIAccessibleDocument** aDocument) MOZ_FINAL;
+  NS_IMETHOD GetChildDocumentAt(uint32_t aIndex,
+                                nsIAccessibleDocument** aDocument) MOZ_FINAL;
   NS_IMETHOD GetVirtualCursor(nsIAccessiblePivot** aVirtualCursor) MOZ_FINAL;
 
+  /**
+   * Return XPCOM wrapper for the internal accessible.
+   */
+  xpcAccessibleGeneric* GetAccessible(Accessible* aAccessible);
+
+  virtual void Shutdown() MOZ_OVERRIDE;
+
+protected:
+  virtual ~xpcAccessibleDocument() {}
+
 private:
+  DocAccessible* Intl() { return mIntl->AsDoc(); }
+
+  void NotifyOfShutdown(Accessible* aAccessible)
+  {
+    xpcAccessibleGeneric* xpcAcc = mCache.GetWeak(aAccessible);
+    if (xpcAcc)
+      xpcAcc->Shutdown();
+
+    mCache.Remove(aAccessible);
+  }
+
+  friend class DocManager;
   friend class DocAccessible;
 
-  xpcAccessibleDocument() { }
-
   xpcAccessibleDocument(const xpcAccessibleDocument&) MOZ_DELETE;
   xpcAccessibleDocument& operator =(const xpcAccessibleDocument&) MOZ_DELETE;
+
+  nsRefPtrHashtable<nsPtrHashKey<const Accessible>, xpcAccessibleGeneric> mCache;
 };
 
+inline xpcAccessibleGeneric*
+ToXPC(Accessible* aAccessible)
+{
+  if (!aAccessible)
+    return nullptr;
+
+  if (aAccessible->IsApplication())
+    return XPCApplicationAcc();
+
+  xpcAccessibleDocument* xpcDoc =
+    GetAccService()->GetXPCDocument(aAccessible->Document());
+  return xpcDoc ? xpcDoc->GetAccessible(aAccessible) : nullptr;
+}
+
+inline xpcAccessibleHyperText*
+ToXPCText(HyperTextAccessible* aAccessible)
+{
+  if (!aAccessible)
+    return nullptr;
+
+  xpcAccessibleDocument* xpcDoc =
+    GetAccService()->GetXPCDocument(aAccessible->Document());
+  return static_cast<xpcAccessibleHyperText*>(xpcDoc->GetAccessible(aAccessible));
+}
+
+inline xpcAccessibleDocument*
+ToXPCDocument(DocAccessible* aAccessible)
+{
+  return GetAccService()->GetXPCDocument(aAccessible);
+}
+
 } // namespace a11y
 } // namespace mozilla
 
 #endif
new file mode 100644
--- /dev/null
+++ b/accessible/xpcom/xpcAccessibleGeneric.cpp
@@ -0,0 +1,46 @@
+/* -*- 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 "xpcAccessibleGeneric.h"
+
+using namespace mozilla::a11y;
+
+////////////////////////////////////////////////////////////////////////////////
+// nsISupports and cycle collection
+
+NS_IMPL_CYCLE_COLLECTION_0(xpcAccessibleGeneric)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(xpcAccessibleGeneric)
+  NS_INTERFACE_MAP_ENTRY(nsIAccessible)
+  NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleSelectable,
+                                     mSupportedIfaces & eSelectable)
+  NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleValue,
+                                     mSupportedIfaces & eValue)
+  NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleHyperLink,
+                                     mSupportedIfaces & eHyperLink)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIAccessible)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(xpcAccessibleGeneric)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(xpcAccessibleGeneric)
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIAccessible
+
+Accessible*
+xpcAccessibleGeneric::ToInternalAccessible() const
+{
+  return mIntl;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// xpcAccessibleGeneric
+
+void
+xpcAccessibleGeneric::Shutdown()
+{
+  mIntl = nullptr;
+}
new file mode 100644
--- /dev/null
+++ b/accessible/xpcom/xpcAccessibleGeneric.h
@@ -0,0 +1,100 @@
+/* -*- 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/. */
+
+#ifndef mozilla_a11y_xpcAccessibleGeneric_h_
+#define mozilla_a11y_xpcAccessibleGeneric_h_
+
+#include "xpcAccessible.h"
+#include "xpcAccessibleHyperLink.h"
+#include "xpcAccessibleSelectable.h"
+#include "xpcAccessibleValue.h"
+
+#include "Accessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+/**
+ * XPCOM wrapper around Accessible class.
+ */
+class xpcAccessibleGeneric : public xpcAccessible,
+                             public xpcAccessibleHyperLink,
+                             public xpcAccessibleSelectable,
+                             public xpcAccessibleValue
+{
+public:
+  xpcAccessibleGeneric(Accessible* aInternal) :
+    mIntl(aInternal), mSupportedIfaces(0)
+  {
+    if (mIntl->IsSelect())
+      mSupportedIfaces |= eSelectable;
+    if (mIntl->HasNumericValue())
+      mSupportedIfaces |= eValue;
+    if (mIntl->IsLink())
+      mSupportedIfaces |= eHyperLink;
+  }
+
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(xpcAccessibleGeneric, nsIAccessible)
+
+  // nsIAccessible
+  virtual Accessible* ToInternalAccessible() const MOZ_FINAL;
+
+  // xpcAccessibleGeneric
+  virtual void Shutdown();
+
+protected:
+  virtual ~xpcAccessibleGeneric() {}
+
+  Accessible* mIntl;
+
+  enum {
+    eSelectable = 1 << 0,
+    eValue = 1 << 1,
+    eHyperLink = 1 << 2,
+    eText = 1 << 3
+  };
+  uint8_t mSupportedIfaces;
+
+private:
+  friend class Accessible;
+  friend class xpcAccessible;
+  friend class xpcAccessibleHyperLink;
+  friend class xpcAccessibleSelectable;
+  friend class xpcAccessibleValue;
+
+  xpcAccessibleGeneric(const xpcAccessibleGeneric&) MOZ_DELETE;
+  xpcAccessibleGeneric& operator =(const xpcAccessibleGeneric&) MOZ_DELETE;
+};
+
+inline Accessible*
+xpcAccessible::Intl()
+{
+  return static_cast<xpcAccessibleGeneric*>(this)->mIntl;
+}
+
+inline Accessible*
+xpcAccessibleHyperLink::Intl()
+{
+  return static_cast<xpcAccessibleGeneric*>(this)->mIntl;
+}
+
+inline Accessible*
+xpcAccessibleSelectable::Intl()
+{
+  return static_cast<xpcAccessibleGeneric*>(this)->mIntl;
+}
+
+inline Accessible*
+xpcAccessibleValue::Intl()
+{
+  return static_cast<xpcAccessibleGeneric*>(this)->mIntl;
+}
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif
--- a/accessible/xpcom/xpcAccessibleHyperLink.cpp
+++ b/accessible/xpcom/xpcAccessibleHyperLink.cpp
@@ -1,97 +1,94 @@
 /* -*- 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 "xpcAccessibleHyperLink.h"
-
 #include "Accessible-inl.h"
+#include "xpcAccessibleDocument.h"
 
 using namespace mozilla::a11y;
 
 NS_IMETHODIMP
 xpcAccessibleHyperLink::GetStartIndex(int32_t* aStartIndex)
 {
   NS_ENSURE_ARG_POINTER(aStartIndex);
   *aStartIndex = 0;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aStartIndex = static_cast<Accessible*>(this)->StartOffset();
+  *aStartIndex = Intl()->StartOffset();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperLink::GetEndIndex(int32_t* aEndIndex)
 {
   NS_ENSURE_ARG_POINTER(aEndIndex);
   *aEndIndex = 0;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aEndIndex = static_cast<Accessible*>(this)->EndOffset();
+  *aEndIndex = Intl()->EndOffset();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperLink::GetAnchorCount(int32_t* aAnchorCount)
 {
   NS_ENSURE_ARG_POINTER(aAnchorCount);
   *aAnchorCount = 0;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aAnchorCount = static_cast<Accessible*>(this)->AnchorCount();
+  *aAnchorCount = Intl()->AnchorCount();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperLink::GetURI(int32_t aIndex, nsIURI** aURI)
 {
   NS_ENSURE_ARG_POINTER(aURI);
 
-  Accessible* thisAcc = static_cast<Accessible*>(this);
-  if (thisAcc->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aIndex < 0 || aIndex >= static_cast<int32_t>(thisAcc->AnchorCount()))
+  if (aIndex < 0 || aIndex >= static_cast<int32_t>(Intl()->AnchorCount()))
     return NS_ERROR_INVALID_ARG;
 
-  nsRefPtr<nsIURI>(thisAcc->AnchorURIAt(aIndex)).forget(aURI);
+  nsRefPtr<nsIURI>(Intl()->AnchorURIAt(aIndex)).forget(aURI);
   return NS_OK;
 }
 
 
 NS_IMETHODIMP
 xpcAccessibleHyperLink::GetAnchor(int32_t aIndex, nsIAccessible** aAccessible)
 {
   NS_ENSURE_ARG_POINTER(aAccessible);
   *aAccessible = nullptr;
 
-  Accessible* thisAcc = static_cast<Accessible*>(this);
-  if (thisAcc->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aIndex < 0 || aIndex >= static_cast<int32_t>(thisAcc->AnchorCount()))
+  if (aIndex < 0 || aIndex >= static_cast<int32_t>(Intl()->AnchorCount()))
     return NS_ERROR_INVALID_ARG;
 
-  NS_IF_ADDREF(*aAccessible = thisAcc->AnchorAt(aIndex));
+  NS_IF_ADDREF(*aAccessible = ToXPC(Intl()->AnchorAt(aIndex)));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperLink::GetValid(bool* aValid)
 {
   NS_ENSURE_ARG_POINTER(aValid);
   *aValid = false;
 
-  if (static_cast<Accessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aValid = static_cast<Accessible*>(this)->IsLinkValid();
+  *aValid = Intl()->IsLinkValid();
   return NS_OK;
 }
--- a/accessible/xpcom/xpcAccessibleHyperLink.h
+++ b/accessible/xpcom/xpcAccessibleHyperLink.h
@@ -9,30 +9,39 @@
 
 #include "nsIAccessibleHyperLink.h"
 
 class nsIAccessible;
 
 namespace mozilla {
 namespace a11y {
 
+class Accessible;
+
+/**
+ * XPCOM nsIAccessibleHyperLink implementation, used by xpcAccessibleGeneric
+ * class.
+ */
 class xpcAccessibleHyperLink : public nsIAccessibleHyperLink
 {
 public:
   NS_IMETHOD GetAnchorCount(int32_t* aAnchorCount) MOZ_FINAL;
   NS_IMETHOD GetStartIndex(int32_t* aStartIndex) MOZ_FINAL;
   NS_IMETHOD GetEndIndex(int32_t* aEndIndex) MOZ_FINAL;
   NS_IMETHOD GetURI(int32_t aIndex, nsIURI** aURI) MOZ_FINAL;
   NS_IMETHOD GetAnchor(int32_t aIndex, nsIAccessible** aAccessible) MOZ_FINAL;
   NS_IMETHOD GetValid(bool* aValid) MOZ_FINAL;
 
-private:
+protected:
   xpcAccessibleHyperLink() { }
-  friend class Accessible;
+  virtual ~xpcAccessibleHyperLink() {}
 
+private:
   xpcAccessibleHyperLink(const xpcAccessibleHyperLink&) MOZ_DELETE;
   xpcAccessibleHyperLink& operator =(const xpcAccessibleHyperLink&) MOZ_DELETE;
+
+  Accessible* Intl();
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
--- a/accessible/xpcom/xpcAccessibleHyperText.cpp
+++ b/accessible/xpcom/xpcAccessibleHyperText.cpp
@@ -1,210 +1,193 @@
 /* -*- 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 "xpcAccessibleHyperText.h"
 
+#include "Accessible-inl.h"
 #include "HyperTextAccessible-inl.h"
 #include "TextRange.h"
+#include "xpcAccessibleDocument.h"
 #include "xpcAccessibleTextRange.h"
 
 #include "nsIPersistentProperties2.h"
 #include "nsIMutableArray.h"
 
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsISupports
 
-nsresult
-xpcAccessibleHyperText::QueryInterface(REFNSIID aIID, void** aInstancePtr)
-{
-  *aInstancePtr = nullptr;
-
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (!text->IsTextRole())
-    return NS_ERROR_NO_INTERFACE;
+NS_INTERFACE_MAP_BEGIN(xpcAccessibleHyperText)
+  NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleText,
+                                     mSupportedIfaces & eText)
+  NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleEditableText,
+                                     mSupportedIfaces & eText)
+  NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsIAccessibleHyperText,
+                                     mSupportedIfaces & eText)
+NS_INTERFACE_MAP_END_INHERITING(xpcAccessibleGeneric)
 
-  if (aIID.Equals(NS_GET_IID(nsIAccessibleText)))
-    *aInstancePtr = static_cast<nsIAccessibleText*>(text);
-  else if (aIID.Equals(NS_GET_IID(nsIAccessibleEditableText)))
-    *aInstancePtr = static_cast<nsIAccessibleEditableText*>(text);
-  else if (aIID.Equals(NS_GET_IID(nsIAccessibleHyperText)))
-    *aInstancePtr = static_cast<nsIAccessibleHyperText*>(text);
-  else
-    return NS_ERROR_NO_INTERFACE;
-
-  NS_ADDREF(text);
-  return NS_OK;
-}
+NS_IMPL_ADDREF_INHERITED(xpcAccessibleHyperText, xpcAccessibleGeneric)
+NS_IMPL_RELEASE_INHERITED(xpcAccessibleHyperText, xpcAccessibleGeneric)
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIAccessibleText
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetCharacterCount(int32_t* aCharacterCount)
 {
   NS_ENSURE_ARG_POINTER(aCharacterCount);
   *aCharacterCount = 0;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aCharacterCount = text->CharacterCount();
+  *aCharacterCount = Intl()->CharacterCount();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetText(int32_t aStartOffset, int32_t aEndOffset,
                                 nsAString& aText)
 {
   aText.Truncate();
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->TextSubstring(aStartOffset, aEndOffset, aText);
+  Intl()->TextSubstring(aStartOffset, aEndOffset, aText);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetTextBeforeOffset(int32_t aOffset,
                                             AccessibleTextBoundary aBoundaryType,
                                             int32_t* aStartOffset,
                                             int32_t* aEndOffset,
                                             nsAString& aText)
 {
   NS_ENSURE_ARG_POINTER(aStartOffset);
   NS_ENSURE_ARG_POINTER(aEndOffset);
   *aStartOffset = *aEndOffset = 0;
   aText.Truncate();
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->TextBeforeOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);
+  Intl()->TextBeforeOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetTextAtOffset(int32_t aOffset,
                                         AccessibleTextBoundary aBoundaryType,
                                         int32_t* aStartOffset,
                                         int32_t* aEndOffset, nsAString& aText)
 {
   NS_ENSURE_ARG_POINTER(aStartOffset);
   NS_ENSURE_ARG_POINTER(aEndOffset);
   *aStartOffset = *aEndOffset = 0;
   aText.Truncate();
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->TextAtOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);
+  Intl()->TextAtOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetTextAfterOffset(int32_t aOffset,
                                            AccessibleTextBoundary aBoundaryType,
                                            int32_t* aStartOffset,
                                            int32_t* aEndOffset, nsAString& aText)
 {
   NS_ENSURE_ARG_POINTER(aStartOffset);
   NS_ENSURE_ARG_POINTER(aEndOffset);
   *aStartOffset = *aEndOffset = 0;
   aText.Truncate();
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->TextAfterOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);
+  Intl()->TextAfterOffset(aOffset, aBoundaryType, aStartOffset, aEndOffset, aText);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetCharacterAtOffset(int32_t aOffset,
                                              char16_t* aCharacter)
 {
   NS_ENSURE_ARG_POINTER(aCharacter);
   *aCharacter = L'\0';
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aCharacter = text->CharAt(aOffset);
+  *aCharacter = Intl()->CharAt(aOffset);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetTextAttributes(bool aIncludeDefAttrs,
                                           int32_t aOffset,
                                           int32_t* aStartOffset,
                                           int32_t* aEndOffset,
                                           nsIPersistentProperties** aAttributes)
 {
   NS_ENSURE_ARG_POINTER(aStartOffset);
   NS_ENSURE_ARG_POINTER(aEndOffset);
   NS_ENSURE_ARG_POINTER(aAttributes);
   *aStartOffset = *aEndOffset = 0;
   *aAttributes = nullptr;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsCOMPtr<nsIPersistentProperties> attrs =
-   text->TextAttributes(aIncludeDefAttrs, aOffset, aStartOffset, aEndOffset);
+   Intl()->TextAttributes(aIncludeDefAttrs, aOffset, aStartOffset, aEndOffset);
   attrs.swap(*aAttributes);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetDefaultTextAttributes(nsIPersistentProperties** aAttributes)
 {
   NS_ENSURE_ARG_POINTER(aAttributes);
   *aAttributes = nullptr;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  nsCOMPtr<nsIPersistentProperties> attrs = text->DefaultTextAttributes();
+  nsCOMPtr<nsIPersistentProperties> attrs = Intl()->DefaultTextAttributes();
   attrs.swap(*aAttributes);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetCharacterExtents(int32_t aOffset,
                                             int32_t* aX, int32_t* aY,
                                             int32_t* aWidth, int32_t* aHeight,
                                             uint32_t aCoordType)
 {
   NS_ENSURE_ARG_POINTER(aX);
   NS_ENSURE_ARG_POINTER(aY);
   NS_ENSURE_ARG_POINTER(aWidth);
   NS_ENSURE_ARG_POINTER(aHeight);
   *aX = *aY = *aWidth = *aHeight;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  nsIntRect rect = text->CharBounds(aOffset, aCoordType);
+  nsIntRect rect = Intl()->CharBounds(aOffset, aCoordType);
   *aX = rect.x; *aY = rect.y;
   *aWidth = rect.width; *aHeight = rect.height;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetRangeExtents(int32_t aStartOffset, int32_t aEndOffset,
                                         int32_t* aX, int32_t* aY,
@@ -212,407 +195,378 @@ xpcAccessibleHyperText::GetRangeExtents(
                                         uint32_t aCoordType)
 {
   NS_ENSURE_ARG_POINTER(aX);
   NS_ENSURE_ARG_POINTER(aY);
   NS_ENSURE_ARG_POINTER(aWidth);
   NS_ENSURE_ARG_POINTER(aHeight);
   *aX = *aY = *aWidth = *aHeight = 0;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  nsIntRect rect = text->TextBounds(aStartOffset, aEndOffset, aCoordType);
+  nsIntRect rect = Intl()->TextBounds(aStartOffset, aEndOffset, aCoordType);
   *aX = rect.x; *aY = rect.y;
   *aWidth = rect.width; *aHeight = rect.height;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetOffsetAtPoint(int32_t aX, int32_t aY,
                                          uint32_t aCoordType, int32_t* aOffset)
 {
   NS_ENSURE_ARG_POINTER(aOffset);
   *aOffset = -1;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aOffset = text->OffsetAtPoint(aX, aY, aCoordType);
+  *aOffset = Intl()->OffsetAtPoint(aX, aY, aCoordType);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleHyperText::GetScriptableCaretOffset(int32_t* aCaretOffset)
+xpcAccessibleHyperText::GetCaretOffset(int32_t* aCaretOffset)
 {
   NS_ENSURE_ARG_POINTER(aCaretOffset);
   *aCaretOffset = -1;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aCaretOffset = text->CaretOffset();
+  *aCaretOffset = Intl()->CaretOffset();
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleHyperText::SetScriptableCaretOffset(int32_t aCaretOffset)
+xpcAccessibleHyperText::SetCaretOffset(int32_t aCaretOffset)
 {
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->SetCaretOffset(aCaretOffset);
+  Intl()->SetCaretOffset(aCaretOffset);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetSelectionCount(int32_t* aSelectionCount)
 {
   NS_ENSURE_ARG_POINTER(aSelectionCount);
   *aSelectionCount = 0;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aSelectionCount = text->SelectionCount();
+  *aSelectionCount = Intl()->SelectionCount();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetSelectionBounds(int32_t aSelectionNum,
                                            int32_t* aStartOffset,
                                            int32_t* aEndOffset)
 {
   NS_ENSURE_ARG_POINTER(aStartOffset);
   NS_ENSURE_ARG_POINTER(aEndOffset);
   *aStartOffset = *aEndOffset = 0;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aSelectionNum < 0 || aSelectionNum >= text->SelectionCount())
+  if (aSelectionNum < 0 || aSelectionNum >= Intl()->SelectionCount())
     return NS_ERROR_INVALID_ARG;
 
-  text->SelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset);
+  Intl()->SelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::SetSelectionBounds(int32_t aSelectionNum,
                                            int32_t aStartOffset,
                                            int32_t aEndOffset)
 {
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   if (aSelectionNum < 0 ||
-      !text->SetSelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset))
+      !Intl()->SetSelectionBoundsAt(aSelectionNum, aStartOffset, aEndOffset))
     return NS_ERROR_INVALID_ARG;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::AddSelection(int32_t aStartOffset, int32_t aEndOffset)
 {
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->AddToSelection(aStartOffset, aEndOffset);
+  Intl()->AddToSelection(aStartOffset, aEndOffset);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::RemoveSelection(int32_t aSelectionNum)
 {
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->RemoveFromSelection(aSelectionNum);
+  Intl()->RemoveFromSelection(aSelectionNum);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleHyperText::ScriptableScrollSubstringTo(int32_t aStartOffset,
-                                                    int32_t aEndOffset,
-                                                    uint32_t aScrollType)
+xpcAccessibleHyperText::ScrollSubstringTo(int32_t aStartOffset,
+                                          int32_t aEndOffset,
+                                          uint32_t aScrollType)
 {
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->ScrollSubstringTo(aStartOffset, aEndOffset, aScrollType);
+  Intl()->ScrollSubstringTo(aStartOffset, aEndOffset, aScrollType);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleHyperText::ScriptableScrollSubstringToPoint(int32_t aStartOffset,
-                                                         int32_t aEndOffset,
-                                                         uint32_t aCoordinateType,
-                                                         int32_t aX, int32_t aY)
+xpcAccessibleHyperText::ScrollSubstringToPoint(int32_t aStartOffset,
+                                               int32_t aEndOffset,
+                                               uint32_t aCoordinateType,
+                                               int32_t aX, int32_t aY)
 {
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->ScrollSubstringToPoint(aStartOffset, aEndOffset, aCoordinateType, aX, aY);
+  Intl()->ScrollSubstringToPoint(aStartOffset, aEndOffset, aCoordinateType, aX, aY);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetEnclosingRange(nsIAccessibleTextRange** aRange)
 {
   NS_ENSURE_ARG_POINTER(aRange);
   *aRange = nullptr;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsRefPtr<xpcAccessibleTextRange> range = new xpcAccessibleTextRange;
-  text->EnclosingRange(range->mRange);
+  Intl()->EnclosingRange(range->mRange);
   NS_ASSERTION(range->mRange.IsValid(),
                "Should always have an enclosing range!");
 
   range.forget(aRange);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetSelectionRanges(nsIArray** aRanges)
 {
   NS_ENSURE_ARG_POINTER(aRanges);
   *aRanges = nullptr;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsresult rv = NS_OK;
   nsCOMPtr<nsIMutableArray> xpcRanges =
     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsAutoTArray<TextRange, 1> ranges;
-  text->SelectionRanges(&ranges);
+  Intl()->SelectionRanges(&ranges);
   uint32_t len = ranges.Length();
   for (uint32_t idx = 0; idx < len; idx++)
     xpcRanges->AppendElement(new xpcAccessibleTextRange(Move(ranges[idx])),
                              false);
 
   xpcRanges.forget(aRanges);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetVisibleRanges(nsIArray** aRanges)
 {
   NS_ENSURE_ARG_POINTER(aRanges);
   *aRanges = nullptr;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsresult rv = NS_OK;
   nsCOMPtr<nsIMutableArray> xpcRanges =
     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsTArray<TextRange> ranges;
-  text->VisibleRanges(&ranges);
+  Intl()->VisibleRanges(&ranges);
   uint32_t len = ranges.Length();
   for (uint32_t idx = 0; idx < len; idx++)
     xpcRanges->AppendElement(new xpcAccessibleTextRange(Move(ranges[idx])),
                              false);
 
   xpcRanges.forget(aRanges);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetRangeByChild(nsIAccessible* aChild,
                                         nsIAccessibleTextRange** aRange)
 {
   NS_ENSURE_ARG_POINTER(aRange);
   *aRange = nullptr;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  nsRefPtr<Accessible> child = do_QueryObject(aChild);
+  Accessible* child = aChild->ToInternalAccessible();
   if (child) {
     nsRefPtr<xpcAccessibleTextRange> range = new xpcAccessibleTextRange;
-    text->RangeByChild(child, range->mRange);
+    Intl()->RangeByChild(child, range->mRange);
     if (range->mRange.IsValid())
       range.forget(aRange);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetRangeAtPoint(int32_t aX, int32_t aY,
                                         nsIAccessibleTextRange** aRange)
 {
   NS_ENSURE_ARG_POINTER(aRange);
   *aRange = nullptr;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsRefPtr<xpcAccessibleTextRange> range = new xpcAccessibleTextRange;
-  text->RangeAtPoint(aX, aY, range->mRange);
+  Intl()->RangeAtPoint(aX, aY, range->mRange);
   if (range->mRange.IsValid())
     range.forget(aRange);
 
   return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIAccessibleEditableText
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::SetTextContents(const nsAString& aText)
 {
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->ReplaceText(aText);
+  Intl()->ReplaceText(aText);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleHyperText::ScriptableInsertText(const nsAString& aText,
-                                             int32_t aOffset)
+xpcAccessibleHyperText::InsertText(const nsAString& aText, int32_t aOffset)
 {
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->InsertText(aText, aOffset);
+  Intl()->InsertText(aText, aOffset);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleHyperText::ScriptableCopyText(int32_t aStartOffset,
-                                           int32_t aEndOffset)
+xpcAccessibleHyperText::CopyText(int32_t aStartOffset, int32_t aEndOffset)
 {
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->CopyText(aStartOffset, aEndOffset);
+  Intl()->CopyText(aStartOffset, aEndOffset);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleHyperText::ScriptableCutText(int32_t aStartOffset,
-                                          int32_t aEndOffset)
+xpcAccessibleHyperText::CutText(int32_t aStartOffset, int32_t aEndOffset)
 {
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->CutText(aStartOffset, aEndOffset);
+  Intl()->CutText(aStartOffset, aEndOffset);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleHyperText::ScriptableDeleteText(int32_t aStartOffset,
-                                             int32_t aEndOffset)
+xpcAccessibleHyperText::DeleteText(int32_t aStartOffset, int32_t aEndOffset)
 {
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->DeleteText(aStartOffset, aEndOffset);
+  Intl()->DeleteText(aStartOffset, aEndOffset);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleHyperText::ScriptablePasteText(int32_t aOffset)
+xpcAccessibleHyperText::PasteText(int32_t aOffset)
 {
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  text->PasteText(aOffset);
+  Intl()->PasteText(aOffset);
   return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIAccessibleHyperText
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetLinkCount(int32_t* aLinkCount)
 {
   NS_ENSURE_ARG_POINTER(aLinkCount);
   *aLinkCount = 0;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aLinkCount = text->LinkCount();
+  *aLinkCount = Intl()->LinkCount();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetLinkAt(int32_t aIndex, nsIAccessibleHyperLink** aLink)
 {
   NS_ENSURE_ARG_POINTER(aLink);
   *aLink = nullptr;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  nsCOMPtr<nsIAccessibleHyperLink> link = text->LinkAt(aIndex);
-  link.forget(aLink);
-
+  NS_IF_ADDREF(*aLink = ToXPC(Intl()->LinkAt(aIndex)));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetLinkIndex(nsIAccessibleHyperLink* aLink,
                                      int32_t* aIndex)
 {
   NS_ENSURE_ARG_POINTER(aLink);
   NS_ENSURE_ARG_POINTER(aIndex);
   *aIndex = -1;
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  nsRefPtr<Accessible> link(do_QueryObject(aLink));
-  *aIndex = text->LinkIndexOf(link);
+  nsCOMPtr<nsIAccessible> xpcLink(do_QueryInterface(aLink));
+  Accessible* link = xpcLink->ToInternalAccessible();
+  if (link)
+    *aIndex = Intl()->LinkIndexOf(link);
+
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleHyperText::GetLinkIndexAtOffset(int32_t aOffset,
                                              int32_t* aLinkIndex)
 {
   NS_ENSURE_ARG_POINTER(aLinkIndex);
   *aLinkIndex = -1; // API says this magic value means 'not found'
 
-  HyperTextAccessible* text = static_cast<HyperTextAccessible*>(this);
-  if (text->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aLinkIndex = text->LinkIndexAtOffset(aOffset);
+  *aLinkIndex = Intl()->LinkIndexAtOffset(aOffset);
   return NS_OK;
 }
--- a/accessible/xpcom/xpcAccessibleHyperText.h
+++ b/accessible/xpcom/xpcAccessibleHyperText.h
@@ -6,33 +6,45 @@
 
 #ifndef mozilla_a11y_xpcAccessibleHyperText_h_
 #define mozilla_a11y_xpcAccessibleHyperText_h_
 
 #include "nsIAccessibleText.h"
 #include "nsIAccessibleHyperText.h"
 #include "nsIAccessibleEditableText.h"
 
+#include "HyperTextAccessible.h"
+#include "xpcAccessibleGeneric.h"
+
 namespace mozilla {
 namespace a11y {
 
-class xpcAccessibleHyperText : public nsIAccessibleText,
+class xpcAccessibleHyperText : public xpcAccessibleGeneric,
+                               public nsIAccessibleText,
                                public nsIAccessibleEditableText,
                                public nsIAccessibleHyperText
 {
 public:
-  NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr);
+  xpcAccessibleHyperText(Accessible* aIntl) : xpcAccessibleGeneric(aIntl)
+  {
+    if (mIntl->IsHyperText() && mIntl->AsHyperText()->IsTextRole())
+      mSupportedIfaces |= eText;
+  }
+
+  NS_DECL_ISUPPORTS_INHERITED
 
   NS_DECL_NSIACCESSIBLETEXT
   NS_DECL_NSIACCESSIBLEHYPERTEXT
   NS_DECL_NSIACCESSIBLEEDITABLETEXT
 
+protected:
+  virtual ~xpcAccessibleHyperText() {}
+
 private:
-  xpcAccessibleHyperText() { }
-  friend class HyperTextAccessible;
+  HyperTextAccessible* Intl() { return mIntl->AsHyperText(); }
 
   xpcAccessibleHyperText(const xpcAccessibleHyperText&) MOZ_DELETE;
   xpcAccessibleHyperText& operator =(const xpcAccessibleHyperText&) MOZ_DELETE;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
--- a/accessible/xpcom/xpcAccessibleImage.cpp
+++ b/accessible/xpcom/xpcAccessibleImage.cpp
@@ -5,40 +5,51 @@
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "xpcAccessibleImage.h"
 
 #include "ImageAccessible.h"
 
 using namespace mozilla::a11y;
 
+////////////////////////////////////////////////////////////////////////////////
+// nsISupports
+
+NS_IMPL_ISUPPORTS_INHERITED(xpcAccessibleImage,
+                            xpcAccessibleGeneric,
+                            nsIAccessibleImage)
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIAccessibleImage
+
 NS_IMETHODIMP
-xpcAccessibleImage::GetImagePosition(uint32_t aCoordType, int32_t* aX, int32_t* aY)
+xpcAccessibleImage::GetImagePosition(uint32_t aCoordType,
+                                     int32_t* aX, int32_t* aY)
 {
   NS_ENSURE_ARG_POINTER(aX);
   *aX = 0;
   NS_ENSURE_ARG_POINTER(aY);
   *aY = 0;
 
-  if (static_cast<ImageAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  nsIntPoint point = static_cast<ImageAccessible*>(this)->Position(aCoordType);
+  nsIntPoint point = Intl()->Position(aCoordType);
   *aX = point.x; *aY = point.y;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleImage::GetImageSize(int32_t* aWidth, int32_t* aHeight)
 {
   NS_ENSURE_ARG_POINTER(aWidth);
   *aWidth = 0;
   NS_ENSURE_ARG_POINTER(aHeight);
   *aHeight = 0;
 
-  if (static_cast<ImageAccessible*>(this)->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  nsIntSize size = static_cast<ImageAccessible*>(this)->Size();
+  nsIntSize size = Intl()->Size();
   *aWidth = size.width;
   *aHeight = size.height;
   return NS_OK;
 }
--- a/accessible/xpcom/xpcAccessibleImage.h
+++ b/accessible/xpcom/xpcAccessibleImage.h
@@ -4,30 +4,38 @@
  * 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_xpcAccessibleImage_h_
 #define mozilla_a11y_xpcAccessibleImage_h_
 
 #include "nsIAccessibleImage.h"
 
+#include "xpcAccessibleGeneric.h"
+
 namespace mozilla {
 namespace a11y {
 
-class xpcAccessibleImage : public nsIAccessibleImage
+class xpcAccessibleImage : public xpcAccessibleGeneric,
+                           public nsIAccessibleImage
 {
 public:
+  xpcAccessibleImage(Accessible* aIntl) : xpcAccessibleGeneric(aIntl) { }
+
+  NS_DECL_ISUPPORTS_INHERITED
+
   NS_IMETHOD GetImagePosition(uint32_t aCoordType,
                               int32_t* aX, int32_t* aY) MOZ_FINAL;
   NS_IMETHOD GetImageSize(int32_t* aWidth, int32_t* aHeight) MOZ_FINAL;
 
+protected:
+  virtual ~xpcAccessibleImage() {}
+
 private:
-  friend class ImageAccessible;
-
-  xpcAccessibleImage() { }
+  ImageAccessible* Intl() { return mIntl->AsImage(); }
 
   xpcAccessibleImage(const xpcAccessibleImage&) MOZ_DELETE;
   xpcAccessibleImage& operator =(const xpcAccessibleImage&) MOZ_DELETE;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
--- a/accessible/xpcom/xpcAccessibleSelectable.cpp
+++ b/accessible/xpcom/xpcAccessibleSelectable.cpp
@@ -1,134 +1,134 @@
 /* -*- 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 "xpcAccessibleSelectable.h"
+#include "Accessible-inl.h"
+#include "xpcAccessibleDocument.h"
 
-#include "Accessible-inl.h"
+#include "nsIMutableArray.h"
 
 using namespace mozilla::a11y;
 
 NS_IMETHODIMP
 xpcAccessibleSelectable::GetSelectedItems(nsIArray** aSelectedItems)
 {
   NS_ENSURE_ARG_POINTER(aSelectedItems);
   *aSelectedItems = nullptr;
 
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
-  NS_PRECONDITION(acc->IsSelect(), "Called on non selectable widget!");
+  NS_PRECONDITION(Intl()->IsSelect(), "Called on non selectable widget!");
+
+  nsAutoTArray<Accessible*, 10> items;
+  Intl()->SelectedItems(&items);
 
-  nsCOMPtr<nsIArray> items = acc->SelectedItems();
-  if (items) {
-    uint32_t length = 0;
-    items->GetLength(&length);
-    if (length)
-      items.swap(*aSelectedItems);
-  }
+  uint32_t itemCount = items.Length();
+  if (itemCount == 0)
+    return NS_OK;
 
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIMutableArray> xpcItems =
+    do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  for (uint32_t idx = 0; idx < itemCount; idx++)
+    xpcItems->AppendElement(static_cast<nsIAccessible*>(ToXPC(items[idx])), false);
+
+  NS_ADDREF(*aSelectedItems = xpcItems);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleSelectable::GetSelectedItemCount(uint32_t* aSelectionCount)
 {
   NS_ENSURE_ARG_POINTER(aSelectionCount);
   *aSelectionCount = 0;
 
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
-  NS_PRECONDITION(acc->IsSelect(), "Called on non selectable widget!");
+  NS_PRECONDITION(Intl()->IsSelect(), "Called on non selectable widget!");
 
-  *aSelectionCount = acc->SelectedItemCount();
+  *aSelectionCount = Intl()->SelectedItemCount();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleSelectable::GetSelectedItemAt(uint32_t aIndex,
                                            nsIAccessible** aSelected)
 {
   NS_ENSURE_ARG_POINTER(aSelected);
   *aSelected = nullptr;
 
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
-  NS_PRECONDITION(acc->IsSelect(), "Called on non selectable widget!");
+  NS_PRECONDITION(Intl()->IsSelect(), "Called on non selectable widget!");
 
-  *aSelected = acc->GetSelectedItem(aIndex);
+  *aSelected = ToXPC(Intl()->GetSelectedItem(aIndex));
   if (*aSelected) {
     NS_ADDREF(*aSelected);
     return NS_OK;
   }
 
   return NS_ERROR_INVALID_ARG;
 }
 
 NS_IMETHODIMP
-xpcAccessibleSelectable::ScriptableIsItemSelected(uint32_t aIndex,
-                                                  bool* aIsSelected)
+xpcAccessibleSelectable::IsItemSelected(uint32_t aIndex, bool* aIsSelected)
 {
   NS_ENSURE_ARG_POINTER(aIsSelected);
   *aIsSelected = false;
 
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
-  NS_PRECONDITION(acc->IsSelect(), "Called on non selectable widget!");
+  NS_PRECONDITION(Intl()->IsSelect(), "Called on non selectable widget!");
 
-  *aIsSelected = acc->IsItemSelected(aIndex);
+  *aIsSelected = Intl()->IsItemSelected(aIndex);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleSelectable::ScriptableAddItemToSelection(uint32_t aIndex)
+xpcAccessibleSelectable::AddItemToSelection(uint32_t aIndex)
 {
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
-  NS_PRECONDITION(acc->IsSelect(), "Called on non selectable widget!");
+  NS_PRECONDITION(Intl()->IsSelect(), "Called on non selectable widget!");
 
-  return acc->AddItemToSelection(aIndex) ? NS_OK : NS_ERROR_INVALID_ARG;
+  return Intl()->AddItemToSelection(aIndex) ? NS_OK : NS_ERROR_INVALID_ARG;
 }
 
 NS_IMETHODIMP
-xpcAccessibleSelectable::ScriptableRemoveItemFromSelection(uint32_t aIndex)
+xpcAccessibleSelectable::RemoveItemFromSelection(uint32_t aIndex)
 {
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
-  NS_PRECONDITION(acc->IsSelect(), "Called on non selectable widget!");
+  NS_PRECONDITION(Intl()->IsSelect(), "Called on non selectable widget!");
 
-  return acc->RemoveItemFromSelection(aIndex) ? NS_OK : NS_ERROR_INVALID_ARG;
+  return Intl()->RemoveItemFromSelection(aIndex) ? NS_OK : NS_ERROR_INVALID_ARG;
 }
 
 NS_IMETHODIMP
-xpcAccessibleSelectable::ScriptableSelectAll(bool* aIsMultiSelect)
+xpcAccessibleSelectable::SelectAll(bool* aIsMultiSelect)
 {
   NS_ENSURE_ARG_POINTER(aIsMultiSelect);
   *aIsMultiSelect = false;
 
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
-  NS_PRECONDITION(acc->IsSelect(), "Called on non selectable widget!");
+  NS_PRECONDITION(Intl()->IsSelect(), "Called on non selectable widget!");
 
-  *aIsMultiSelect = acc->SelectAll();
+  *aIsMultiSelect = Intl()->SelectAll();
   return NS_OK;
 }
 
 NS_IMETHODIMP
-xpcAccessibleSelectable::ScriptableUnselectAll()
+xpcAccessibleSelectable::UnselectAll()
 {
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (!Intl())
     return NS_ERROR_FAILURE;
-  NS_PRECONDITION(acc->IsSelect(), "Called on non selectable widget!");
+  NS_PRECONDITION(Intl()->IsSelect(), "Called on non selectable widget!");
 
-  acc->UnselectAll();
+  Intl()->UnselectAll();
   return NS_OK;
 }
--- a/accessible/xpcom/xpcAccessibleSelectable.h
+++ b/accessible/xpcom/xpcAccessibleSelectable.h
@@ -10,32 +10,42 @@
 #include "nsIAccessibleSelectable.h"
 
 class nsIAccessible;
 class nsIArray;
 
 namespace mozilla {
 namespace a11y {
 
+class Accessible;
+
+/**
+ * XPCOM nsIAccessibleSelectable inteface implementation, used by
+ * xpcAccessibleGeneric class.
+ */
 class xpcAccessibleSelectable : public nsIAccessibleSelectable
 {
 public:
+  // nsIAccessibleSelectable
   NS_IMETHOD GetSelectedItems(nsIArray** aSelectedItems) MOZ_FINAL;
   NS_IMETHOD GetSelectedItemCount(uint32_t* aSelectedItemCount) MOZ_FINAL;
   NS_IMETHOD GetSelectedItemAt(uint32_t aIndex, nsIAccessible** aItem) MOZ_FINAL;
-  NS_IMETHOD ScriptableIsItemSelected(uint32_t aIndex, bool* aIsSelected) MOZ_FINAL;
-  NS_IMETHOD ScriptableAddItemToSelection(uint32_t aIndex) MOZ_FINAL;
-  NS_IMETHOD ScriptableRemoveItemFromSelection(uint32_t aIndex) MOZ_FINAL;
-  NS_IMETHOD ScriptableSelectAll(bool* aIsMultiSelect) MOZ_FINAL;
-  NS_IMETHOD ScriptableUnselectAll() MOZ_FINAL;
+  NS_IMETHOD IsItemSelected(uint32_t aIndex, bool* aIsSelected) MOZ_FINAL;
+  NS_IMETHOD AddItemToSelection(uint32_t aIndex) MOZ_FINAL;
+  NS_IMETHOD RemoveItemFromSelection(uint32_t aIndex) MOZ_FINAL;
+  NS_IMETHOD SelectAll(bool* aIsMultiSelect) MOZ_FINAL;
+  NS_IMETHOD UnselectAll() MOZ_FINAL;
+
+protected:
+  xpcAccessibleSelectable() { }
+  virtual ~xpcAccessibleSelectable() {}
 
 private:
-  xpcAccessibleSelectable() { }
-  friend class Accessible;
-
   xpcAccessibleSelectable(const xpcAccessibleSelectable&) MOZ_DELETE;
   xpcAccessibleSelectable& operator =(const xpcAccessibleSelectable&) MOZ_DELETE;
+
+  Accessible* Intl();
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
--- a/accessible/xpcom/xpcAccessibleTable.cpp
+++ b/accessible/xpcom/xpcAccessibleTable.cpp
@@ -3,485 +3,491 @@
 /* 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 "xpcAccessibleTable.h"
 
 #include "Accessible.h"
 #include "TableAccessible.h"
+#include "xpcAccessibleDocument.h"
 
 #include "nsIMutableArray.h"
 #include "nsComponentManagerUtils.h"
 
 using namespace mozilla::a11y;
 
 static const uint32_t XPC_TABLE_DEFAULT_SIZE = 40;
 
-nsresult
+////////////////////////////////////////////////////////////////////////////////
+// nsISupports
+
+NS_IMPL_ISUPPORTS_INHERITED(xpcAccessibleTable,
+                            xpcAccessibleGeneric,
+                            nsIAccessibleTable)
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIAccessibleTable
+
+NS_IMETHODIMP
 xpcAccessibleTable::GetCaption(nsIAccessible** aCaption)
 {
   NS_ENSURE_ARG_POINTER(aCaption);
   *aCaption = nullptr;
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  NS_IF_ADDREF(*aCaption = mTable->Caption());
+  NS_IF_ADDREF(*aCaption = ToXPC(Intl()->Caption()));
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetColumnCount(int32_t* aColumnCount)
 {
   NS_ENSURE_ARG_POINTER(aColumnCount);
   *aColumnCount = 0;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aColumnCount = mTable->ColCount();
+  *aColumnCount = Intl()->ColCount();
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetRowCount(int32_t* aRowCount)
 {
   NS_ENSURE_ARG_POINTER(aRowCount);
   *aRowCount = 0;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aRowCount = mTable->RowCount();
+  *aRowCount = Intl()->RowCount();
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetCellAt(int32_t aRowIdx, int32_t aColIdx,
                               nsIAccessible** aCell)
 {
   NS_ENSURE_ARG_POINTER(aCell);
   *aCell = nullptr;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount() ||
-      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())
+  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
+      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
-  NS_IF_ADDREF(*aCell = mTable->CellAt(aRowIdx, aColIdx));
+  NS_IF_ADDREF(*aCell = ToXPC(Intl()->CellAt(aRowIdx, aColIdx)));
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetCellIndexAt(int32_t aRowIdx, int32_t aColIdx,
                                    int32_t* aCellIdx)
 {
   NS_ENSURE_ARG_POINTER(aCellIdx);
   *aCellIdx = -1;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount() ||
-      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())
+  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
+      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
-  *aCellIdx = mTable->CellIndexAt(aRowIdx, aColIdx);
+  *aCellIdx = Intl()->CellIndexAt(aRowIdx, aColIdx);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetColumnExtentAt(int32_t aRowIdx, int32_t aColIdx,
                                       int32_t* aColumnExtent)
 {
   NS_ENSURE_ARG_POINTER(aColumnExtent);
   *aColumnExtent = -1;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount() ||
-      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())
+  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
+      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
-  *aColumnExtent = mTable->ColExtentAt(aRowIdx, aColIdx);
+  *aColumnExtent = Intl()->ColExtentAt(aRowIdx, aColIdx);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetRowExtentAt(int32_t aRowIdx, int32_t aColIdx,
                                    int32_t* aRowExtent)
 {
   NS_ENSURE_ARG_POINTER(aRowExtent);
   *aRowExtent = -1;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount() ||
-      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())
+  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
+      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
-  *aRowExtent = mTable->RowExtentAt(aRowIdx, aColIdx);
+  *aRowExtent = Intl()->RowExtentAt(aRowIdx, aColIdx);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetColumnDescription(int32_t aColIdx,
                                          nsAString& aDescription)
 {
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())
+  if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
   nsAutoString description;
-  mTable->ColDescription(aColIdx, description);
+  Intl()->ColDescription(aColIdx, description);
   aDescription.Assign(description);
 
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetRowDescription(int32_t aRowIdx, nsAString& aDescription)
 {
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->ColCount())
+  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
   nsAutoString description;
-  mTable->RowDescription(aRowIdx, description);
+  Intl()->RowDescription(aRowIdx, description);
   aDescription.Assign(description);
 
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::IsColumnSelected(int32_t aColIdx, bool* aIsSelected)
 {
   NS_ENSURE_ARG_POINTER(aIsSelected);
   *aIsSelected = false;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())
+  if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
-  *aIsSelected = mTable->IsColSelected(aColIdx);
+  *aIsSelected = Intl()->IsColSelected(aColIdx);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::IsRowSelected(int32_t aRowIdx, bool* aIsSelected)
 {
   NS_ENSURE_ARG_POINTER(aIsSelected);
   *aIsSelected = false;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount())
+  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount())
     return NS_ERROR_INVALID_ARG;
 
-  *aIsSelected = mTable->IsRowSelected(aRowIdx);
+  *aIsSelected = Intl()->IsRowSelected(aRowIdx);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::IsCellSelected(int32_t aRowIdx, int32_t aColIdx,
                                    bool* aIsSelected)
 {
   NS_ENSURE_ARG_POINTER(aIsSelected);
   *aIsSelected = false;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount() ||
-      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())
+  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount() ||
+      aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
-  *aIsSelected = mTable->IsCellSelected(aRowIdx, aColIdx);
+  *aIsSelected = Intl()->IsCellSelected(aRowIdx, aColIdx);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetSelectedCellCount(uint32_t* aSelectedCellCount)
 {
   NS_ENSURE_ARG_POINTER(aSelectedCellCount);
   *aSelectedCellCount = 0;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aSelectedCellCount = mTable->SelectedCellCount();
+  *aSelectedCellCount = Intl()->SelectedCellCount();
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetSelectedColumnCount(uint32_t* aSelectedColumnCount)
 {
   NS_ENSURE_ARG_POINTER(aSelectedColumnCount);
   *aSelectedColumnCount = 0;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aSelectedColumnCount = mTable->SelectedColCount();
+  *aSelectedColumnCount = Intl()->SelectedColCount();
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetSelectedRowCount(uint32_t* aSelectedRowCount)
 {
   NS_ENSURE_ARG_POINTER(aSelectedRowCount);
   *aSelectedRowCount = 0;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aSelectedRowCount = mTable->SelectedRowCount();
+  *aSelectedRowCount = Intl()->SelectedRowCount();
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetSelectedCells(nsIArray** aSelectedCells)
 {
   NS_ENSURE_ARG_POINTER(aSelectedCells);
   *aSelectedCells = nullptr;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  nsresult rv = NS_OK;
-  nsCOMPtr<nsIMutableArray> selCells = 
+  NS_IMETHODIMP rv = NS_OK;
+  nsCOMPtr<nsIMutableArray> selCells =
     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsAutoTArray<Accessible*, XPC_TABLE_DEFAULT_SIZE> cellsArray;
-  mTable->SelectedCells(&cellsArray);
+  Intl()->SelectedCells(&cellsArray);
 
   uint32_t totalCount = cellsArray.Length();
   for (uint32_t idx = 0; idx < totalCount; idx++) {
     Accessible* cell = cellsArray.ElementAt(idx);
-    selCells -> AppendElement(static_cast<nsIAccessible*>(cell), false);
+    selCells->AppendElement(static_cast<nsIAccessible*>(ToXPC(cell)), false);
   }
 
   NS_ADDREF(*aSelectedCells = selCells);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetSelectedCellIndices(uint32_t* aCellsArraySize,
                                            int32_t** aCellsArray)
 {
   NS_ENSURE_ARG_POINTER(aCellsArraySize);
   *aCellsArraySize = 0;
 
   NS_ENSURE_ARG_POINTER(aCellsArray);
   *aCellsArray = 0;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsAutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> cellsArray;
-  mTable->SelectedCellIndices(&cellsArray);
+  Intl()->SelectedCellIndices(&cellsArray);
 
   *aCellsArraySize = cellsArray.Length();
   *aCellsArray = static_cast<int32_t*>
     (moz_xmalloc(*aCellsArraySize * sizeof(int32_t)));
   memcpy(*aCellsArray, cellsArray.Elements(),
     *aCellsArraySize * sizeof(int32_t));
 
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetSelectedColumnIndices(uint32_t* aColsArraySize,
                                              int32_t** aColsArray)
 {
   NS_ENSURE_ARG_POINTER(aColsArraySize);
   *aColsArraySize = 0;
 
   NS_ENSURE_ARG_POINTER(aColsArray);
   *aColsArray = 0;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsAutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> colsArray;
-  mTable->SelectedColIndices(&colsArray);
+  Intl()->SelectedColIndices(&colsArray);
 
   *aColsArraySize = colsArray.Length();
   *aColsArray = static_cast<int32_t*>
     (moz_xmalloc(*aColsArraySize * sizeof(int32_t)));
   memcpy(*aColsArray, colsArray.Elements(),
     *aColsArraySize * sizeof(int32_t));
 
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetSelectedRowIndices(uint32_t* aRowsArraySize,
                                           int32_t** aRowsArray)
 {
   NS_ENSURE_ARG_POINTER(aRowsArraySize);
   *aRowsArraySize = 0;
 
   NS_ENSURE_ARG_POINTER(aRowsArray);
   *aRowsArray = 0;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsAutoTArray<uint32_t, XPC_TABLE_DEFAULT_SIZE> rowsArray;
-  mTable->SelectedRowIndices(&rowsArray);
+  Intl()->SelectedRowIndices(&rowsArray);
 
   *aRowsArraySize = rowsArray.Length();
   *aRowsArray = static_cast<int32_t*>
     (moz_xmalloc(*aRowsArraySize * sizeof(int32_t)));
   memcpy(*aRowsArray, rowsArray.Elements(),
     *aRowsArraySize * sizeof(int32_t));
 
   return NS_OK;
 }
 
-nsresult 
+NS_IMETHODIMP
 xpcAccessibleTable::GetColumnIndexAt(int32_t aCellIdx, int32_t* aColIdx)
 {
   NS_ENSURE_ARG_POINTER(aColIdx);
   *aColIdx = -1;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aCellIdx < 0 
-      || static_cast<uint32_t>(aCellIdx) 
-      >= mTable->RowCount() * mTable->ColCount())
+  if (aCellIdx < 0 ||
+      static_cast<uint32_t>(aCellIdx) >= Intl()->RowCount() * Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
-  *aColIdx = mTable->ColIndexAt(aCellIdx);
+  *aColIdx = Intl()->ColIndexAt(aCellIdx);
   return NS_OK;
 }
 
-nsresult 
+NS_IMETHODIMP
 xpcAccessibleTable::GetRowIndexAt(int32_t aCellIdx, int32_t* aRowIdx)
 {
   NS_ENSURE_ARG_POINTER(aRowIdx);
   *aRowIdx = -1;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aCellIdx < 0 
-      || static_cast<uint32_t>(aCellIdx) 
-      >= mTable->RowCount() * mTable->ColCount())
+  if (aCellIdx < 0 ||
+      static_cast<uint32_t>(aCellIdx) >= Intl()->RowCount() * Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
-  *aRowIdx = mTable->RowIndexAt(aCellIdx);
+  *aRowIdx = Intl()->RowIndexAt(aCellIdx);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetRowAndColumnIndicesAt(int32_t aCellIdx, int32_t* aRowIdx,
                                              int32_t* aColIdx)
 {
   NS_ENSURE_ARG_POINTER(aRowIdx);
   *aRowIdx = -1;
   NS_ENSURE_ARG_POINTER(aColIdx);
   *aColIdx = -1;
 
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aCellIdx < 0 
-      || static_cast<uint32_t>(aCellIdx) 
-      >= mTable->RowCount() * mTable->ColCount())
+  if (aCellIdx < 0 ||
+      static_cast<uint32_t>(aCellIdx) >= Intl()->RowCount() * Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
-  mTable->RowAndColIndicesAt(aCellIdx, aRowIdx, aColIdx);
-  return NS_OK;  
+  Intl()->RowAndColIndicesAt(aCellIdx, aRowIdx, aColIdx);
+  return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::GetSummary(nsAString& aSummary)
 {
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsAutoString summary;
-  mTable->Summary(summary);
+  Intl()->Summary(summary);
   aSummary.Assign(summary);
 
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::IsProbablyForLayout(bool* aResult)
 {
   NS_ENSURE_ARG_POINTER(aResult);
   *aResult = false;
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aResult = mTable->IsProbablyLayoutTable();
+  *aResult = Intl()->IsProbablyLayoutTable();
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::SelectColumn(int32_t aColIdx)
 {
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())
+  if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
-  mTable->SelectCol(aColIdx);
+  Intl()->SelectCol(aColIdx);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::SelectRow(int32_t aRowIdx)
 {
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount())
+  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount())
     return NS_ERROR_INVALID_ARG;
 
-  mTable->SelectRow(aRowIdx);
+  Intl()->SelectRow(aRowIdx);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::UnselectColumn(int32_t aColIdx)
 {
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= mTable->ColCount())
+  if (aColIdx < 0 || static_cast<uint32_t>(aColIdx) >= Intl()->ColCount())
     return NS_ERROR_INVALID_ARG;
 
-  mTable->UnselectCol(aColIdx);
+  Intl()->UnselectCol(aColIdx);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTable::UnselectRow(int32_t aRowIdx)
 {
-  if (!mTable)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= mTable->RowCount())
+  if (aRowIdx < 0 || static_cast<uint32_t>(aRowIdx) >= Intl()->RowCount())
     return NS_ERROR_INVALID_ARG;
 
-  mTable->UnselectRow(aRowIdx);
+  Intl()->UnselectRow(aRowIdx);
   return NS_OK;
 }
-
-
--- a/accessible/xpcom/xpcAccessibleTable.h
+++ b/accessible/xpcom/xpcAccessibleTable.h
@@ -1,73 +1,78 @@
-/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* -*- Mode: C++ MOZ_FINAL; tab-width: 2 MOZ_FINAL; indent-tabs-mode: nil MOZ_FINAL; 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/. */
 
-#ifndef MOZILLA_A11Y_XPCOM_XPACCESSIBLETABLE_H_
-#define MOZILLA_A11Y_XPCOM_XPACCESSIBLETABLE_H_
+#ifndef mozilla_a11y_xpcAccessibleTable_h_
+#define mozilla_a11y_xpcAccessibleTable_h_
 
-#include "nsAString.h"
-#include "nscore.h"
-
-class nsIAccessible;
-class nsIArray;
+#include "nsIAccessibleTable.h"
+#include "xpcAccessibleGeneric.h"
 
 namespace mozilla {
 namespace a11y {
 
-class TableAccessible;
-
-class xpcAccessibleTable
+/**
+ * XPCOM wrapper around TableAccessible class.
+ */
+class xpcAccessibleTable : public xpcAccessibleGeneric,
+                           public nsIAccessibleTable
 {
 public:
-  explicit xpcAccessibleTable(TableAccessible* aTable) :
-    mTable(aTable)
-  {
-  }
+  xpcAccessibleTable(Accessible* aIntl) : xpcAccessibleGeneric(aIntl) { }
+
+  NS_DECL_ISUPPORTS_INHERITED
 
-  nsresult GetCaption(nsIAccessible** aCaption);
-  nsresult GetSummary(nsAString& aSummary);
-  nsresult GetColumnCount(int32_t* aColumnCount);
-  nsresult GetRowCount(int32_t* aRowCount);
-  nsresult GetCellAt(int32_t aRowIndex, int32_t aColumnIndex,
-                     nsIAccessible** aCell);
-  nsresult GetCellIndexAt(int32_t aRowIndex, int32_t aColumnIndex,
-                          int32_t* aCellIndex);
-  nsresult GetColumnIndexAt(int32_t aCellIndex, int32_t* aColumnIndex);
-  nsresult GetRowIndexAt(int32_t aCellIndex, int32_t* aRowIndex);
-  nsresult GetRowAndColumnIndicesAt(int32_t aCellIndex, int32_t* aRowIndex,
-                                    int32_t* aColumnIndex);
-  nsresult GetColumnExtentAt(int32_t row, int32_t column,
-                             int32_t* aColumnExtent);
-  nsresult GetRowExtentAt(int32_t row, int32_t column,
-                          int32_t* aRowExtent);
-  nsresult GetColumnDescription(int32_t aColIdx, nsAString& aDescription);
-  nsresult GetRowDescription(int32_t aRowIdx, nsAString& aDescription);
-  nsresult IsColumnSelected(int32_t aColIdx, bool* _retval);
-  nsresult IsRowSelected(int32_t aRowIdx, bool* _retval);
-  nsresult IsCellSelected(int32_t aRowIdx, int32_t aColIdx, bool* _retval);
-  nsresult GetSelectedCellCount(uint32_t* aSelectedCellCount);
-  nsresult GetSelectedColumnCount(uint32_t* aSelectedColumnCount);
-  nsresult GetSelectedRowCount(uint32_t* aSelectedRowCount);
-  nsresult GetSelectedCells(nsIArray** aSelectedCell);
-  nsresult GetSelectedCellIndices(uint32_t* aCellsArraySize,
-                                  int32_t** aCellsArray);
-  nsresult GetSelectedColumnIndices(uint32_t* aColsArraySize,
-                                    int32_t** aColsArray);
-  nsresult GetSelectedRowIndices(uint32_t* aRowsArraySize,
-                                 int32_t** aRowsArray);
-  nsresult SelectColumn(int32_t aColIdx);
-  nsresult SelectRow(int32_t aRowIdx);
-  nsresult UnselectColumn(int32_t aColIdx);
-  nsresult UnselectRow(int32_t aRowIdx);
-  nsresult IsProbablyForLayout(bool* aIsForLayout);
+  // nsIAccessibleTable
+  NS_IMETHOD GetCaption(nsIAccessible** aCaption) MOZ_FINAL;
+  NS_IMETHOD GetSummary(nsAString& aSummary) MOZ_FINAL;
+  NS_IMETHOD GetColumnCount(int32_t* aColumnCount) MOZ_FINAL;
+  NS_IMETHOD GetRowCount(int32_t* aRowCount) MOZ_FINAL;
+  NS_IMETHOD GetCellAt(int32_t aRowIndex, int32_t aColumnIndex,
+                       nsIAccessible** aCell) MOZ_FINAL;
+  NS_IMETHOD GetCellIndexAt(int32_t aRowIndex, int32_t aColumnIndex,
+                            int32_t* aCellIndex) MOZ_FINAL;
+  NS_IMETHOD GetColumnIndexAt(int32_t aCellIndex, int32_t* aColumnIndex) MOZ_FINAL;
+  NS_IMETHOD GetRowIndexAt(int32_t aCellIndex, int32_t* aRowIndex) MOZ_FINAL;
+  NS_IMETHOD GetRowAndColumnIndicesAt(int32_t aCellIndex, int32_t* aRowIndex,
+                                      int32_t* aColumnIndex) MOZ_FINAL;
+  NS_IMETHOD GetColumnExtentAt(int32_t row, int32_t column,
+                               int32_t* aColumnExtent) MOZ_FINAL;
+  NS_IMETHOD GetRowExtentAt(int32_t row, int32_t column,
+                            int32_t* aRowExtent) MOZ_FINAL;
+  NS_IMETHOD GetColumnDescription(int32_t aColIdx, nsAString& aDescription) MOZ_FINAL;
+  NS_IMETHOD GetRowDescription(int32_t aRowIdx, nsAString& aDescription) MOZ_FINAL;
+  NS_IMETHOD IsColumnSelected(int32_t aColIdx, bool* _retval) MOZ_FINAL;
+  NS_IMETHOD IsRowSelected(int32_t aRowIdx, bool* _retval) MOZ_FINAL;
+  NS_IMETHOD IsCellSelected(int32_t aRowIdx, int32_t aColIdx, bool* _retval) MOZ_FINAL;
+  NS_IMETHOD GetSelectedCellCount(uint32_t* aSelectedCellCount) MOZ_FINAL;
+  NS_IMETHOD GetSelectedColumnCount(uint32_t* aSelectedColumnCount) MOZ_FINAL;
+  NS_IMETHOD GetSelectedRowCount(uint32_t* aSelectedRowCount) MOZ_FINAL;
+  NS_IMETHOD GetSelectedCells(nsIArray** aSelectedCell) MOZ_FINAL;
+  NS_IMETHOD GetSelectedCellIndices(uint32_t* aCellsArraySize,
+                                    int32_t** aCellsArray) MOZ_FINAL;
+  NS_IMETHOD GetSelectedColumnIndices(uint32_t* aColsArraySize,
+                                      int32_t** aColsArray) MOZ_FINAL;
+  NS_IMETHOD GetSelectedRowIndices(uint32_t* aRowsArraySize,
+                                   int32_t** aRowsArray) MOZ_FINAL;
+  NS_IMETHOD SelectColumn(int32_t aColIdx) MOZ_FINAL;
+  NS_IMETHOD SelectRow(int32_t aRowIdx) MOZ_FINAL;
+  NS_IMETHOD UnselectColumn(int32_t aColIdx) MOZ_FINAL;
+  NS_IMETHOD UnselectRow(int32_t aRowIdx) MOZ_FINAL;
+  NS_IMETHOD IsProbablyForLayout(bool* aIsForLayout) MOZ_FINAL;
 
 protected:
-  mozilla::a11y::TableAccessible* mTable;
+  virtual ~xpcAccessibleTable() {}
+
+private:
+  TableAccessible* Intl() { return mIntl->AsTable(); }
+
+  xpcAccessibleTable(const xpcAccessibleTable&) MOZ_DELETE;
+  xpcAccessibleTable& operator =(const xpcAccessibleTable&) MOZ_DELETE;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
-#endif // MOZILLA_A11Y_XPCOM_XPACCESSIBLETABLE_H_
+#endif // mozilla_a11y_xpcAccessibleTable_h_
--- a/accessible/xpcom/xpcAccessibleTableCell.cpp
+++ b/accessible/xpcom/xpcAccessibleTableCell.cpp
@@ -2,157 +2,160 @@
 /* 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 "xpcAccessibleTableCell.h"
 
 #include "Accessible.h"
+#include "nsIAccessibleTable.h"
 #include "TableAccessible.h"
 #include "TableCellAccessible.h"
-
-#include "nsIAccessibleTable.h"
+#include "xpcAccessibleDocument.h"
 
 #include "nsComponentManagerUtils.h"
 #include "nsIMutableArray.h"
 
 using namespace mozilla;
 using namespace mozilla::a11y;
 
-nsresult
+////////////////////////////////////////////////////////////////////////////////
+// nsISupports
+
+NS_IMPL_ISUPPORTS_INHERITED(xpcAccessibleTableCell,
+                            xpcAccessibleHyperText,
+                            nsIAccessibleTableCell)
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIAccessibleTableCell
+
+NS_IMETHODIMP
 xpcAccessibleTableCell::GetTable(nsIAccessibleTable** aTable)
 {
   NS_ENSURE_ARG_POINTER(aTable);
   *aTable = nullptr;
 
-  if (!mTableCell)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  TableAccessible* table = mTableCell->Table();
+  TableAccessible* table = Intl()->Table();
   if (!table)
     return NS_ERROR_FAILURE;
 
   nsCOMPtr<nsIAccessibleTable> xpcTable =
-    do_QueryInterface(static_cast<nsIAccessible*>(table->AsAccessible()));
+    do_QueryInterface(static_cast<nsIAccessible*>(ToXPC(table->AsAccessible())));
   xpcTable.forget(aTable);
-
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTableCell::GetColumnIndex(int32_t* aColIdx)
 {
   NS_ENSURE_ARG_POINTER(aColIdx);
   *aColIdx = -1;
 
-  if (!mTableCell)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aColIdx = mTableCell->ColIdx();
+  *aColIdx = Intl()->ColIdx();
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTableCell::GetRowIndex(int32_t* aRowIdx)
 {
   NS_ENSURE_ARG_POINTER(aRowIdx);
   *aRowIdx = -1;
 
-  if (!mTableCell)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aRowIdx = mTableCell->RowIdx();
-
+  *aRowIdx = Intl()->RowIdx();
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTableCell::GetColumnExtent(int32_t* aExtent)
 {
   NS_ENSURE_ARG_POINTER(aExtent);
   *aExtent = -1;
 
-  if (!mTableCell)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aExtent = mTableCell->ColExtent();
-
+  *aExtent = Intl()->ColExtent();
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTableCell::GetRowExtent(int32_t* aExtent)
 {
   NS_ENSURE_ARG_POINTER(aExtent);
   *aExtent = -1;
 
-  if (!mTableCell)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aExtent = mTableCell->RowExtent();
-
+  *aExtent = Intl()->RowExtent();
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTableCell::GetColumnHeaderCells(nsIArray** aHeaderCells)
 {
   NS_ENSURE_ARG_POINTER(aHeaderCells);
   *aHeaderCells = nullptr;
 
-  if (!mTableCell)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsAutoTArray<Accessible*, 10> headerCells;
-  mTableCell->ColHeaderCells(&headerCells);
+  Intl()->ColHeaderCells(&headerCells);
 
   nsCOMPtr<nsIMutableArray> cells = do_CreateInstance(NS_ARRAY_CONTRACTID);
   NS_ENSURE_TRUE(cells, NS_ERROR_FAILURE);
 
   for (uint32_t idx = 0; idx < headerCells.Length(); idx++) {
-    cells->
-      AppendElement(static_cast<nsIAccessible*>(headerCells.ElementAt(idx)),
-                    false);
+    cells->AppendElement(static_cast<nsIAccessible*>(ToXPC(headerCells[idx])),
+                         false);
   }
 
   NS_ADDREF(*aHeaderCells = cells);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTableCell::GetRowHeaderCells(nsIArray** aHeaderCells)
 {
   NS_ENSURE_ARG_POINTER(aHeaderCells);
   *aHeaderCells = nullptr;
 
-  if (!mTableCell)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
   nsAutoTArray<Accessible*, 10> headerCells;
-  mTableCell->RowHeaderCells(&headerCells);
+  Intl()->RowHeaderCells(&headerCells);
 
   nsCOMPtr<nsIMutableArray> cells = do_CreateInstance(NS_ARRAY_CONTRACTID);
   NS_ENSURE_TRUE(cells, NS_ERROR_FAILURE);
 
   for (uint32_t idx = 0; idx < headerCells.Length(); idx++) {
-    cells->
-      AppendElement(static_cast<nsIAccessible*>(headerCells.ElementAt(idx)),
-                    false);
+    cells->AppendElement(static_cast<nsIAccessible*>(ToXPC(headerCells[idx])),
+                         false);
   }
 
   NS_ADDREF(*aHeaderCells = cells);
   return NS_OK;
 }
 
-nsresult
+NS_IMETHODIMP
 xpcAccessibleTableCell::IsSelected(bool* aSelected)
 {
   NS_ENSURE_ARG_POINTER(aSelected);
   *aSelected = false;
 
-  if (!mTableCell)
+  if (!Intl())
     return NS_ERROR_FAILURE;
 
-  *aSelected = mTableCell->Selected();
-
+  *aSelected = Intl()->Selected();
   return NS_OK;
 }
--- a/accessible/xpcom/xpcAccessibleTableCell.h
+++ b/accessible/xpcom/xpcAccessibleTableCell.h
@@ -2,48 +2,50 @@
 /* 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/. */
 
 #ifndef mozilla_a11y_xpcom_xpcAccessibletableCell_h_
 #define mozilla_a11y_xpcom_xpcAccessibletableCell_h_
 
-#include "nscore.h"
+#include "nsIAccessibleTable.h"
 
-class nsIAccessibleTable;
-class nsIArray;
+#include "xpcAccessibleHyperText.h"
 
 namespace mozilla {
 namespace a11y {
 
-class TableAccessible;
-class TableCellAccessible;
-
 /**
- * This class provides an implementation of the nsIAccessibleTableCell
- * interface's methods.
+ * XPCOM wrapper around TableAccessibleCell class.
  */
-class xpcAccessibleTableCell
+class xpcAccessibleTableCell : public xpcAccessibleHyperText,
+                               public nsIAccessibleTableCell
 {
 public:
-  explicit xpcAccessibleTableCell(TableCellAccessible* aTableCell) :
-    mTableCell(aTableCell)
-  {
-  }
+  xpcAccessibleTableCell(Accessible* aIntl) : xpcAccessibleHyperText(aIntl) { }
+
+  NS_DECL_ISUPPORTS_INHERITED
 
-  nsresult GetTable(nsIAccessibleTable** aTable);
-  nsresult GetColumnIndex(int32_t* aColIdx);
-  nsresult GetRowIndex(int32_t* aRowIdx);
-  nsresult GetColumnExtent(int32_t* aExtent);
-  nsresult GetRowExtent(int32_t* aExtent);
-  nsresult GetColumnHeaderCells(nsIArray** aHeaderCells);
-  nsresult GetRowHeaderCells(nsIArray** aHeaderCells);
-  nsresult IsSelected(bool* aSelected);
+  // nsIAccessibleTableCell
+  NS_IMETHOD GetTable(nsIAccessibleTable** aTable) MOZ_FINAL;
+  NS_IMETHOD GetColumnIndex(int32_t* aColIdx) MOZ_FINAL;
+  NS_IMETHOD GetRowIndex(int32_t* aRowIdx) MOZ_FINAL;
+  NS_IMETHOD GetColumnExtent(int32_t* aExtent) MOZ_FINAL;
+  NS_IMETHOD GetRowExtent(int32_t* aExtent) MOZ_FINAL;
+  NS_IMETHOD GetColumnHeaderCells(nsIArray** aHeaderCells) MOZ_FINAL;
+  NS_IMETHOD GetRowHeaderCells(nsIArray** aHeaderCells) MOZ_FINAL;
+  NS_IMETHOD IsSelected(bool* aSelected) MOZ_FINAL;
 
 protected:
-  mozilla::a11y::TableCellAccessible* mTableCell;
+  virtual ~xpcAccessibleTableCell() {}
+
+private:
+  TableCellAccessible* Intl() { return mIntl->AsTableCell(); }
+
+  xpcAccessibleTableCell(const xpcAccessibleTableCell&) MOZ_DELETE;
+  xpcAccessibleTableCell& operator =(const xpcAccessibleTableCell&) MOZ_DELETE;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif // mozilla_a11y_xpcom_xpcAccessibletableCell_h_
--- a/accessible/xpcom/xpcAccessibleTextRange.cpp
+++ b/accessible/xpcom/xpcAccessibleTextRange.cpp
@@ -1,18 +1,19 @@
 /* -*- 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 "xpcAccessibleTextRange.h"
 
-#include "HyperTextAccessible.h"
 #include "TextRange.h"
+#include "xpcAccessibleDocument.h"
+
 #include "nsIMutableArray.h"
 #include "nsComponentManagerUtils.h"
 
 using namespace mozilla;
 using namespace mozilla::a11y;
 
 // nsISupports and cycle collection
 
@@ -31,66 +32,66 @@ NS_IMPL_CYCLE_COLLECTING_ADDREF(xpcAcces
 NS_IMPL_CYCLE_COLLECTING_RELEASE(xpcAccessibleTextRange)
 
 // nsIAccessibleTextRange
 
 NS_IMETHODIMP
 xpcAccessibleTextRange::GetStartContainer(nsIAccessibleText** aAnchor)
 {
   NS_ENSURE_ARG_POINTER(aAnchor);
-  NS_IF_ADDREF(*aAnchor = static_cast<nsIAccessibleText*>(mRange.StartContainer()));
+  NS_IF_ADDREF(*aAnchor = ToXPCText(mRange.StartContainer()));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleTextRange::GetStartOffset(int32_t* aOffset)
 {
   NS_ENSURE_ARG_POINTER(aOffset);
   *aOffset = mRange.StartOffset();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleTextRange::GetEndContainer(nsIAccessibleText** aAnchor)
 {
   NS_ENSURE_ARG_POINTER(aAnchor);
-  NS_IF_ADDREF(*aAnchor = static_cast<nsIAccessibleText*>(mRange.EndContainer()));
+  NS_IF_ADDREF(*aAnchor = ToXPCText(mRange.EndContainer()));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleTextRange::GetEndOffset(int32_t* aOffset)
 {
   NS_ENSURE_ARG_POINTER(aOffset);
   *aOffset = mRange.EndOffset();
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleTextRange::GetContainer(nsIAccessible** aContainer)
 {
   NS_ENSURE_ARG_POINTER(aContainer);
-  NS_IF_ADDREF(*aContainer = static_cast<nsIAccessible*>(mRange.Container()));
+  NS_IF_ADDREF(*aContainer = ToXPC(mRange.Container()));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleTextRange::GetEmbeddedChildren(nsIArray** aList)
 {
   nsresult rv = NS_OK;
   nsCOMPtr<nsIMutableArray> xpcList =
     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsTArray<Accessible*> objects;
   mRange.EmbeddedChildren(&objects);
 
   uint32_t len = objects.Length();
   for (uint32_t idx = 0; idx < len; idx++)
-    xpcList->AppendElement(static_cast<nsIAccessible*>(objects[idx]), false);
+    xpcList->AppendElement(static_cast<nsIAccessible*>(ToXPC(objects[idx])), false);
 
   xpcList.forget(aList);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleTextRange::Compare(nsIAccessibleTextRange* aOtherRange,
--- a/accessible/xpcom/xpcAccessibleValue.cpp
+++ b/accessible/xpcom/xpcAccessibleValue.cpp
@@ -1,90 +1,85 @@
 /* -*- 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 "xpcAccessibleValue.h"
+#include "xpcAccessibleGeneric.h"
 #include "Accessible.h"
 
 using namespace mozilla;
 using namespace mozilla::a11y;
 
 NS_IMETHODIMP
 xpcAccessibleValue::GetMaximumValue(double* aValue)
 {
   NS_ENSURE_ARG_POINTER(aValue);
   *aValue = 0;
 
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (Intl()->IsDefunct())
     return NS_ERROR_FAILURE;
 
-  double value = acc->MaxValue();
+  double value = Intl()->MaxValue();
   if (!IsNaN(value))
     *aValue = value;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleValue::GetMinimumValue(double* aValue)
 {
   NS_ENSURE_ARG_POINTER(aValue);
   *aValue = 0;
 
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (Intl()->IsDefunct())
     return NS_ERROR_FAILURE;
 
-  double value = acc->MinValue();
+  double value = Intl()->MinValue();
   if (!IsNaN(value))
     *aValue = value;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleValue::GetCurrentValue(double* aValue)
 {
   NS_ENSURE_ARG_POINTER(aValue);
   *aValue = 0;
 
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (Intl()->IsDefunct())
     return NS_ERROR_FAILURE;
 
-  double value = acc->CurValue();
+  double value = Intl()->CurValue();
   if (!IsNaN(value))
     *aValue = value;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleValue::SetCurrentValue(double aValue)
 {
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (Intl()->IsDefunct())
     return NS_ERROR_FAILURE;
 
-  acc->SetCurValue(aValue);
+  Intl()->SetCurValue(aValue);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 xpcAccessibleValue::GetMinimumIncrement(double* aValue)
 {
   NS_ENSURE_ARG_POINTER(aValue);
   *aValue = 0;
 
-  Accessible* acc = static_cast<Accessible*>(this);
-  if (acc->IsDefunct())
+  if (Intl()->IsDefunct())
     return NS_ERROR_FAILURE;
 
-  double value = acc->Step();
+  double value = Intl()->Step();
   if (!IsNaN(value))
     *aValue = value;
 
   return NS_OK;
 }
--- a/accessible/xpcom/xpcAccessibleValue.h
+++ b/accessible/xpcom/xpcAccessibleValue.h
@@ -7,28 +7,37 @@
 #ifndef mozilla_a11y_xpcAccessibleValue_h_
 #define mozilla_a11y_xpcAccessibleValue_h_
 
 #include "nsIAccessibleValue.h"
 
 namespace mozilla {
 namespace a11y {
 
+class Accessible;
+
+/**
+ * XPCOM nsIAccessibleValue interface implementation, used by
+ * xpcAccessibleGeneric class.
+ */
 class xpcAccessibleValue : public nsIAccessibleValue
 {
 public:
   NS_IMETHOD GetMaximumValue(double* aValue) MOZ_FINAL MOZ_OVERRIDE;
   NS_IMETHOD GetMinimumValue(double* aValue) MOZ_FINAL MOZ_OVERRIDE;
   NS_IMETHOD GetCurrentValue(double* aValue) MOZ_FINAL MOZ_OVERRIDE;
   NS_IMETHOD SetCurrentValue(double aValue) MOZ_FINAL MOZ_OVERRIDE;
   NS_IMETHOD GetMinimumIncrement(double* aMinIncrement) MOZ_FINAL MOZ_OVERRIDE;
 
-private:
+protected:
   xpcAccessibleValue() { }
-  friend class Accessible;
+  virtual ~xpcAccessibleValue() {}
+
+private:
+  Accessible* Intl();
 
   xpcAccessibleValue(const xpcAccessibleValue&) MOZ_DELETE;
   xpcAccessibleValue& operator =(const xpcAccessibleValue&) MOZ_DELETE;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
--- a/accessible/xul/XULColorPickerAccessible.cpp
+++ b/accessible/xul/XULColorPickerAccessible.cpp
@@ -23,29 +23,26 @@ using namespace mozilla::a11y;
 
 XULColorPickerTileAccessible::
   XULColorPickerTileAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   AccessibleWrap(aContent, aDoc)
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// XULColorPickerTileAccessible: nsIAccessible
+// XULColorPickerTileAccessible: Accessible
 
 void
 XULColorPickerTileAccessible::Value(nsString& aValue)
 {
   aValue.Truncate();
 
   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::color, aValue);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// XULColorPickerTileAccessible: Accessible
-
 role
 XULColorPickerTileAccessible::NativeRole()
 {
   return roles::PUSHBUTTON;
 }
 
 uint64_t
 XULColorPickerTileAccessible::NativeState()
--- a/accessible/xul/XULElementAccessibles.cpp
+++ b/accessible/xul/XULElementAccessibles.cpp
@@ -15,17 +15,16 @@
 #include "Role.h"
 #include "States.h"
 #include "TextUpdater.h"
 
 #ifdef A11Y_LOG
 #include "Logging.h"
 #endif
 
-#include "nsIAccessibleRelation.h"
 #include "nsIDOMXULDescriptionElement.h"
 #include "nsNameSpaceManager.h"
 #include "nsNetUtil.h"
 #include "nsString.h"
 #include "nsTextBoxFrame.h"
 
 using namespace mozilla::a11y;
 
@@ -183,22 +182,18 @@ XULLinkAccessible::
   XULLabelAccessible(aContent, aDoc)
 {
 }
 
 XULLinkAccessible::~XULLinkAccessible()
 {
 }
 
-// Expose nsIAccessibleHyperLink unconditionally
-NS_IMPL_ISUPPORTS_INHERITED(XULLinkAccessible, XULLabelAccessible,
-                            nsIAccessibleHyperLink)
-
 ////////////////////////////////////////////////////////////////////////////////
-// XULLinkAccessible. nsIAccessible
+// XULLinkAccessible: Accessible
 
 void
 XULLinkAccessible::Value(nsString& aValue)
 {
   aValue.Truncate();
 
   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::href, aValue);
 }
--- a/accessible/xul/XULElementAccessibles.h
+++ b/accessible/xul/XULElementAccessibles.h
@@ -80,18 +80,16 @@ public:
 };
 
 class XULLinkAccessible : public XULLabelAccessible
 {
 
 public:
   XULLinkAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
-  NS_DECL_ISUPPORTS_INHERITED
-
   // Accessible
   virtual void Value(nsString& aValue);
   virtual a11y::role NativeRole() MOZ_OVERRIDE;
   virtual uint64_t NativeLinkState() const MOZ_OVERRIDE;
 
   // ActionAccessible
   virtual uint8_t ActionCount() MOZ_OVERRIDE;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) MOZ_OVERRIDE;
--- a/accessible/xul/XULListboxAccessible.cpp
+++ b/accessible/xul/XULListboxAccessible.cpp
@@ -94,69 +94,32 @@ XULColumnItemAccessible::DoAction(uint8_
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULListboxAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 XULListboxAccessible::
   XULListboxAccessible(nsIContent* aContent, DocAccessible* aDoc) :
-  XULSelectControlAccessible(aContent, aDoc), xpcAccessibleTable(this)
+  XULSelectControlAccessible(aContent, aDoc)
 {
   nsIContent* parentContent = mContent->GetFlattenedTreeParent();
   if (parentContent) {
     nsCOMPtr<nsIAutoCompletePopup> autoCompletePopupElm =
       do_QueryInterface(parentContent);
     if (autoCompletePopupElm)
       mGenericTypes |= eAutoCompletePopup;
   }
-}
 
-NS_IMPL_ADDREF_INHERITED(XULListboxAccessible, XULSelectControlAccessible)
-NS_IMPL_RELEASE_INHERITED(XULListboxAccessible, XULSelectControlAccessible)
-
-nsresult
-XULListboxAccessible::QueryInterface(REFNSIID aIID, void** aInstancePtr)
-{
-  nsresult rv = XULSelectControlAccessible::QueryInterface(aIID, aInstancePtr);
-  if (*aInstancePtr)
-    return rv;
-
-  if (aIID.Equals(NS_GET_IID(nsIAccessibleTable)) && IsMulticolumn()) {
-    *aInstancePtr = static_cast<nsIAccessibleTable*>(this);
-    NS_ADDREF_THIS();
-    return NS_OK;
-  }
-
-  return NS_ERROR_NO_INTERFACE;
+  if (IsMulticolumn())
+    mGenericTypes |= eTable;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Accessible
-
-void
-XULListboxAccessible::Shutdown()
-{
-  mTable = nullptr;
-  XULSelectControlAccessible::Shutdown();
-}
-
-bool
-XULListboxAccessible::IsMulticolumn()
-{
-  int32_t numColumns = 0;
-  nsresult rv = GetColumnCount(&numColumns);
-  if (NS_FAILED(rv))
-    return false;
-
-  return numColumns > 1;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// XULListboxAccessible. nsIAccessible
+// XULListboxAccessible: Accessible
 
 uint64_t
 XULListboxAccessible::NativeState()
 {
   // As a XULListboxAccessible we can have the following states:
   //   FOCUSED, READONLY, FOCUSABLE
 
   // Get focus status from base class
@@ -198,17 +161,17 @@ XULListboxAccessible::NativeRole()
     do_QueryInterface(mContent->GetParent());
   if (xulPopup)
     return roles::COMBOBOX_LIST;
 
   return IsMulticolumn() ? roles::TABLE : roles::LISTBOX;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// XULListboxAccessible. nsIAccessibleTable
+// XULListboxAccessible: Table
 
 uint32_t
 XULListboxAccessible::ColCount()
 {
   nsIContent* headContent = nullptr;
   for (nsIContent* childContent = mContent->GetFirstChild(); childContent;
        childContent = childContent->GetNextSibling()) {
     if (childContent->NodeInfo()->Equals(nsGkAtoms::listcols,
@@ -615,17 +578,17 @@ XULListitemAccessible::GetListAccessible
 
 void
 XULListitemAccessible::Description(nsString& aDesc)
 {
   AccessibleWrap::Description(aDesc);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// XULListitemAccessible. nsIAccessible
+// XULListitemAccessible: Accessible
 
 /**
   * If there is a Listcell as a child ( not anonymous ) use it, otherwise
   *   default to getting the name from GetXULName
   */
 ENameValueFlag
 XULListitemAccessible::NativeName(nsString& aName)
 {
@@ -723,30 +686,29 @@ XULListitemAccessible::ContainerWidget()
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULListCellAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 XULListCellAccessible::
   XULListCellAccessible(nsIContent* aContent, DocAccessible* aDoc) :
-  HyperTextAccessibleWrap(aContent, aDoc), xpcAccessibleTableCell(this)
+  HyperTextAccessibleWrap(aContent, aDoc)
 {
   mGenericTypes |= eTableCell;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsISupports
 
-NS_IMPL_ISUPPORTS_INHERITED(XULListCellAccessible,
-                            HyperTextAccessible,
-                            nsIAccessibleTableCell)
+NS_IMPL_ISUPPORTS_INHERITED0(XULListCellAccessible,
+                             HyperTextAccessible)
 
 ////////////////////////////////////////////////////////////////////////////////
-// XULListCellAccessible: nsIAccessibleTableCell implementation
+// XULListCellAccessible: TableCell
 
 TableAccessible*
 XULListCellAccessible::Table() const
 {
   Accessible* thisRow = Parent();
   if (!thisRow || thisRow->Role() != roles::ROW)
     return nullptr;
 
@@ -839,23 +801,16 @@ XULListCellAccessible::Selected()
   NS_ENSURE_TRUE(table, false); // we expect to be in a listbox (table)
 
   return table->IsRowSelected(RowIdx());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULListCellAccessible. Accessible implementation
 
-void
-XULListCellAccessible::Shutdown()
-{
-  mTableCell = nullptr;
-  HyperTextAccessibleWrap::Shutdown();
-}
-
 role
 XULListCellAccessible::NativeRole()
 {
   return roles::CELL;
 }
 
 already_AddRefed<nsIPersistentProperties>
 XULListCellAccessible::NativeAttributes()
--- a/accessible/xul/XULListboxAccessible.h
+++ b/accessible/xul/XULListboxAccessible.h
@@ -2,17 +2,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 mozilla_a11y_XULListboxAccessible_h__
 #define mozilla_a11y_XULListboxAccessible_h__
 
 #include "BaseAccessibles.h"
-#include "nsIAccessibleTable.h"
 #include "TableAccessible.h"
 #include "TableCellAccessible.h"
 #include "xpcAccessibleTable.h"
 #include "xpcAccessibleTableCell.h"
 #include "XULMenuAccessible.h"
 #include "XULSelectControlAccessible.h"
 
 class nsIWeakReference;
@@ -54,28 +53,21 @@ public:
 
   enum { eAction_Click = 0 };
 };
 
 /*
  * A class the represents the XUL Listbox widget.
  */
 class XULListboxAccessible : public XULSelectControlAccessible,
-                             public xpcAccessibleTable,
-                             public nsIAccessibleTable,
                              public TableAccessible
 {
 public:
   XULListboxAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
-  NS_DECL_ISUPPORTS_INHERITED
-
-  // nsIAccessibleTable
-  NS_FORWARD_NSIACCESSIBLETABLE(xpcAccessibleTable::)
-
   // TableAccessible
   virtual uint32_t ColCount();
   virtual uint32_t RowCount();
   virtual Accessible* CellAt(uint32_t aRowIndex, uint32_t aColumnIndex);
   virtual bool IsColSelected(uint32_t aColIdx);
   virtual bool IsRowSelected(uint32_t aRowIdx);
   virtual bool IsCellSelected(uint32_t aRowIdx, uint32_t aColIdx);
   virtual uint32_t SelectedCellCount();
@@ -85,33 +77,32 @@ public:
   virtual void SelectedCellIndices(nsTArray<uint32_t>* aCells);
   virtual void SelectedColIndices(nsTArray<uint32_t>* aCols);
   virtual void SelectedRowIndices(nsTArray<uint32_t>* aRows);
   virtual void SelectRow(uint32_t aRowIdx);
   virtual void UnselectRow(uint32_t aRowIdx);
   virtual Accessible* AsAccessible() { return this; }
 
   // Accessible
-  virtual void Shutdown();
   virtual void Value(nsString& aValue);
   virtual TableAccessible* AsTable() { return this; }
   virtual a11y::role NativeRole() MOZ_OVERRIDE;
   virtual uint64_t NativeState() MOZ_OVERRIDE;
 
   // Widgets
   virtual bool IsWidget() const;
   virtual bool IsActiveWidget() const;
   virtual bool AreItemsOperable() const;
 
   virtual Accessible* ContainerWidget() const;
 
 protected:
   virtual ~XULListboxAccessible() {}
 
-  bool IsMulticolumn();
+  bool IsMulticolumn() { return ColCount() > 1; }
 };
 
 /**
   * Listitems -- used in listboxes
   */
 class XULListitemAccessible : public XULMenuitemAccessible
 {
 public:
@@ -150,32 +141,26 @@ protected:
 private:
   bool mIsCheckbox;
 };
 
 /**
  * Class represents xul:listcell.
  */
 class XULListCellAccessible : public HyperTextAccessibleWrap,
-                              public nsIAccessibleTableCell,
-                              public TableCellAccessible,
-                              public xpcAccessibleTableCell
+                              public TableCellAccessible
 {
 public:
   XULListCellAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // nsISupports
   NS_DECL_ISUPPORTS_INHERITED
 
-  // nsIAccessibleTableCell
-  NS_FORWARD_NSIACCESSIBLETABLECELL(xpcAccessibleTableCell::)
-
   // Accessible
   virtual TableCellAccessible* AsTableCell() { return this; }
-  virtual void Shutdown();
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() MOZ_OVERRIDE;
   virtual a11y::role NativeRole() MOZ_OVERRIDE;
 
   // TableCellAccessible
   virtual TableAccessible* Table() const MOZ_OVERRIDE;
   virtual uint32_t ColIdx() const MOZ_OVERRIDE;
   virtual uint32_t RowIdx() const MOZ_OVERRIDE;
   virtual void ColHeaderCells(nsTArray<Accessible*>* aHeaderCells) MOZ_OVERRIDE;
--- a/accessible/xul/XULSelectControlAccessible.cpp
+++ b/accessible/xul/XULSelectControlAccessible.cpp
@@ -43,52 +43,43 @@ XULSelectControlAccessible::Shutdown()
 {
   mSelectControl = nullptr;
   AccessibleWrap::Shutdown();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULSelectControlAccessible: SelectAccessible
 
-already_AddRefed<nsIArray>
-XULSelectControlAccessible::SelectedItems()
+void
+XULSelectControlAccessible::SelectedItems(nsTArray<Accessible*>* aItems)
 {
-  nsCOMPtr<nsIMutableArray> selectedItems =
-    do_CreateInstance(NS_ARRAY_CONTRACTID);
-  if (!selectedItems || !mDoc)
-    return nullptr;
-
   // For XUL multi-select control
   nsCOMPtr<nsIDOMXULMultiSelectControlElement> xulMultiSelect =
     do_QueryInterface(mSelectControl);
   if (xulMultiSelect) {
     int32_t length = 0;
     xulMultiSelect->GetSelectedCount(&length);
     for (int32_t index = 0; index < length; index++) {
       nsCOMPtr<nsIDOMXULSelectControlItemElement> itemElm;
       xulMultiSelect->MultiGetSelectedItem(index, getter_AddRefs(itemElm));
       nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemElm));
       Accessible* item = mDoc->GetAccessible(itemNode);
       if (item)
-        selectedItems->AppendElement(static_cast<nsIAccessible*>(item),
-                                     false);
+        aItems->AppendElement(item);
     }
   } else {  // Single select?
     nsCOMPtr<nsIDOMXULSelectControlItemElement> itemElm;
     mSelectControl->GetSelectedItem(getter_AddRefs(itemElm));
     nsCOMPtr<nsINode> itemNode(do_QueryInterface(itemElm));
     if (itemNode) {
       Accessible* item = mDoc->GetAccessible(itemNode);
       if (item)
-        selectedItems->AppendElement(static_cast<nsIAccessible*>(item),
-                                   false);
+        aItems->AppendElement(item);
     }
   }
-
-  return selectedItems.forget();
 }
 
 Accessible*
 XULSelectControlAccessible::GetSelectedItem(uint32_t aIndex)
 {
   nsCOMPtr<nsIDOMXULMultiSelectControlElement> multiSelectControl =
     do_QueryInterface(mSelectControl);
 
--- a/accessible/xul/XULSelectControlAccessible.h
+++ b/accessible/xul/XULSelectControlAccessible.h
@@ -21,17 +21,17 @@ class XULSelectControlAccessible : publi
 public:
   XULSelectControlAccessible(nsIContent* aContent, DocAccessible* aDoc);
   virtual ~XULSelectControlAccessible() {}
 
   // Accessible
   virtual void Shutdown();
 
   // SelectAccessible
-  virtual already_AddRefed<nsIArray> SelectedItems();
+  virtual void SelectedItems(nsTArray<Accessible*>* aItems) MOZ_OVERRIDE;
   virtual uint32_t SelectedItemCount();
   virtual Accessible* GetSelectedItem(uint32_t aIndex);
   virtual bool IsItemSelected(uint32_t aIndex);
   virtual bool AddItemToSelection(uint32_t aIndex);
   virtual bool RemoveItemFromSelection(uint32_t aIndex);
   virtual bool SelectAll();
   virtual bool UnselectAll();
 
--- a/accessible/xul/XULSliderAccessible.cpp
+++ b/accessible/xul/XULSliderAccessible.cpp
@@ -52,18 +52,16 @@ XULSliderAccessible::NativeInteractiveSt
 
 bool
 XULSliderAccessible::NativelyUnavailable() const
 {
   return mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
                                nsGkAtoms::_true, eCaseMatters);
 }
 
-// nsIAccessible
-
 void
 XULSliderAccessible::Value(nsString& aValue)
 {
   GetSliderAttr(nsGkAtoms::curpos, aValue);
 }
 
 uint8_t
 XULSliderAccessible::ActionCount()
--- a/accessible/xul/XULTabAccessible.cpp
+++ b/accessible/xul/XULTabAccessible.cpp
@@ -6,17 +6,16 @@
 #include "XULTabAccessible.h"
 
 #include "nsAccUtils.h"
 #include "Relation.h"
 #include "Role.h"
 #include "States.h"
 
 // NOTE: alphabetically ordered
-#include "nsIAccessibleRelation.h"
 #include "nsIDocument.h"
 #include "nsIDOMXULSelectCntrlEl.h"
 #include "nsIDOMXULSelectCntrlItemEl.h"
 #include "nsIDOMXULRelatedElement.h"
 
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -25,25 +24,24 @@ using namespace mozilla::a11y;
 
 XULTabAccessible::
   XULTabAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   AccessibleWrap(aContent, aDoc)
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// XULTabAccessible: nsIAccessible
+// XULTabAccessible: Accessible
 
 uint8_t
 XULTabAccessible::ActionCount()
 {
   return 1;
 }
 
-/** Return the name of our only action  */
 void
 XULTabAccessible::ActionNameAt(uint8_t aIndex, nsAString& aName)
 {
   if (aIndex == eAction_Switch)
     aName.AssignLiteral("switch");
 }
 
 bool
@@ -94,17 +92,16 @@ XULTabAccessible::NativeState()
 
 uint64_t
 XULTabAccessible::NativeInteractiveState() const
 {
   uint64_t state = Accessible::NativeInteractiveState();
   return (state & states::UNAVAILABLE) ? state : state | states::SELECTABLE;
 }
 
-// nsIAccessible
 Relation
 XULTabAccessible::RelationByType(RelationType aType)
 {
   Relation rel = AccessibleWrap::RelationByType(aType);
   if (aType != RelationType::LABEL_FOR)
     return rel;
 
   // Expose 'LABEL_FOR' relation on tab accessible for tabpanel accessible.
--- a/accessible/xul/XULTreeAccessible.cpp
+++ b/accessible/xul/XULTreeAccessible.cpp
@@ -243,45 +243,38 @@ XULTreeAccessible::CurrentItem()
 }
 
 void
 XULTreeAccessible::SetCurrentItem(Accessible* aItem)
 {
   NS_ERROR("XULTreeAccessible::SetCurrentItem not implemented");
 }
 
-already_AddRefed<nsIArray>
-XULTreeAccessible::SelectedItems()
+void
+XULTreeAccessible::SelectedItems(nsTArray<Accessible*>* aItems)
 {
   if (!mTreeView)
-    return nullptr;
+    return;
 
   nsCOMPtr<nsITreeSelection> selection;
   mTreeView->GetSelection(getter_AddRefs(selection));
   if (!selection)
-    return nullptr;
-
-  nsCOMPtr<nsIMutableArray> selectedItems =
-    do_CreateInstance(NS_ARRAY_CONTRACTID);
-  if (!selectedItems)
-    return nullptr;
+    return;
 
   int32_t rangeCount = 0;
   selection->GetRangeCount(&rangeCount);
   for (int32_t rangeIdx = 0; rangeIdx < rangeCount; rangeIdx++) {
     int32_t firstIdx = 0, lastIdx = -1;
     selection->GetRangeAt(rangeIdx, &firstIdx, &lastIdx);
     for (int32_t rowIdx = firstIdx; rowIdx <= lastIdx; rowIdx++) {
-      nsIAccessible* item = GetTreeItemAccessible(rowIdx);
+      Accessible* item = GetTreeItemAccessible(rowIdx);
       if (item)
-        selectedItems->AppendElement(item, false);
+        aItems->AppendElement(item);
     }
   }
-
-  return selectedItems.forget();
 }
 
 uint32_t
 XULTreeAccessible::SelectedItemCount()
 {
   if (!mTreeView)
     return 0;
 
@@ -720,17 +713,17 @@ NS_IMPL_CYCLE_COLLECTION_INHERITED(XULTr
 NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(XULTreeItemAccessibleBase)
   NS_INTERFACE_TABLE_INHERITED(XULTreeItemAccessibleBase,
                                XULTreeItemAccessibleBase)
 NS_INTERFACE_TABLE_TAIL_INHERITING(Accessible)
 NS_IMPL_ADDREF_INHERITED(XULTreeItemAccessibleBase, Accessible)
 NS_IMPL_RELEASE_INHERITED(XULTreeItemAccessibleBase, Accessible)
 
 ////////////////////////////////////////////////////////////////////////////////
-// XULTreeItemAccessibleBase: nsIAccessible implementation
+// XULTreeItemAccessibleBase: Accessible
 
 Accessible*
 XULTreeItemAccessibleBase::FocusedChild()
 {
   return FocusMgr()->FocusedAccessible() == this ? this : nullptr;
 }
 
 nsIntRect
--- a/accessible/xul/XULTreeAccessible.h
+++ b/accessible/xul/XULTreeAccessible.h
@@ -24,18 +24,16 @@ const uint32_t kDefaultTreeCacheLength =
 
 /**
  * Accessible class for XUL tree element.
  */
 
 class XULTreeAccessible : public AccessibleWrap
 {
 public:
-  using Accessible::GetChildAt;
-
   XULTreeAccessible(nsIContent* aContent, DocAccessible* aDoc,
                     nsTreeBodyFrame* aTreeframe);
 
   // nsISupports and cycle collection
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(XULTreeAccessible, Accessible)
 
   // Accessible
@@ -46,17 +44,17 @@ public:
   virtual Accessible* ChildAtPoint(int32_t aX, int32_t aY,
                                    EWhichChildAtPoint aWhichChild);
 
   virtual Accessible* GetChildAt(uint32_t aIndex) const MOZ_OVERRIDE;
   virtual uint32_t ChildCount() const MOZ_OVERRIDE;
   virtual Relation RelationByType(RelationType aType) MOZ_OVERRIDE;
 
   // SelectAccessible
-  virtual already_AddRefed<nsIArray> SelectedItems();
+  virtual void SelectedItems(nsTArray<Accessible*>* aItems) MOZ_OVERRIDE;
   virtual uint32_t SelectedItemCount();
   virtual Accessible* GetSelectedItem(uint32_t aIndex);
   virtual bool IsItemSelected(uint32_t aIndex);
   virtual bool AddItemToSelection(uint32_t aIndex);
   virtual bool RemoveItemFromSelection(uint32_t aIndex);
   virtual bool SelectAll();
   virtual bool UnselectAll();
 
@@ -130,18 +128,16 @@ protected:
   0x766a,                                             \
   0x443c,                                             \
   { 0x94, 0x0b, 0xb1, 0xe6, 0xb0, 0x83, 0x1d, 0xfc }  \
 }
 
 class XULTreeItemAccessibleBase : public AccessibleWrap
 {
 public:
-  using Accessible::GetParent;
-
   XULTreeItemAccessibleBase(nsIContent* aContent, DocAccessible* aDoc,
                             Accessible* aParent, nsITreeBoxObject* aTree,
                             nsITreeView* aTreeView, int32_t aRow);
 
   // nsISupports and cycle collection
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(XULTreeItemAccessibleBase,
                                            AccessibleWrap)
--- a/accessible/xul/XULTreeGridAccessible.cpp
+++ b/accessible/xul/XULTreeGridAccessible.cpp
@@ -22,24 +22,17 @@
 
 using namespace mozilla::a11y;
 
 XULTreeGridAccessible::~XULTreeGridAccessible()
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// XULTreeGridAccessible: nsISupports implementation
-
-NS_IMPL_ISUPPORTS_INHERITED(XULTreeGridAccessible,
-                            XULTreeAccessible,
-                            nsIAccessibleTable)
-
-////////////////////////////////////////////////////////////////////////////////
-// XULTreeGridAccessible: nsIAccessibleTable implementation
+// XULTreeGridAccessible: Table
 
 uint32_t
 XULTreeGridAccessible::ColCount()
 {
   return nsCoreUtils::GetSensibleColumnCount(mTree);
 }
 
 uint32_t
@@ -119,17 +112,17 @@ XULTreeGridAccessible::SelectedRowIndice
   uint32_t rowCount = RowCount();
   for (uint32_t rowIdx = 0; rowIdx < rowCount; rowIdx++)
     if (IsRowSelected(rowIdx))
       aRows->AppendElement(rowIdx);
 }
 
 Accessible*
 XULTreeGridAccessible::CellAt(uint32_t aRowIndex, uint32_t aColumnIndex)
-{ 
+{
   Accessible* row = GetTreeItemAccessible(aRowIndex);
   if (!row)
     return nullptr;
 
   nsCOMPtr<nsITreeColumn> column =
     nsCoreUtils::GetSensibleColumnAt(mTree, aColumnIndex);
   if (!column)
     return nullptr;
@@ -207,23 +200,16 @@ XULTreeGridAccessible::UnselectRow(uint3
 
   if (selection)
     selection->ClearRange(aRowIdx, aRowIdx);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULTreeGridAccessible: Accessible implementation
 
-void
-XULTreeGridAccessible::Shutdown()
-{
-  mTable = nullptr;
-  XULTreeAccessible::Shutdown();
-}
-
 role
 XULTreeGridAccessible::NativeRole()
 {
   nsCOMPtr<nsITreeColumns> treeColumns;
   mTree->GetColumns(getter_AddRefs(treeColumns));
   if (!treeColumns) {
     NS_ERROR("No treecolumns object for tree!");
     return roles::NOTHING;
@@ -434,17 +420,17 @@ XULTreeGridRowAccessible::CacheChildren(
 // XULTreeGridCellAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 XULTreeGridCellAccessible::
   XULTreeGridCellAccessible(nsIContent* aContent, DocAccessible* aDoc,
                             XULTreeGridRowAccessible* aRowAcc,
                             nsITreeBoxObject* aTree, nsITreeView* aTreeView,
                             int32_t aRow, nsITreeColumn* aColumn) :
-  LeafAccessible(aContent, aDoc), xpcAccessibleTableCell(this), mTree(aTree),
+  LeafAccessible(aContent, aDoc), mTree(aTree),
   mTreeView(aTreeView), mRow(aRow), mColumn(aColumn)
 {
   mParent = aRowAcc;
   mStateFlags |= eSharedNode;
   mGenericTypes |= eTableCell;
 
   NS_ASSERTION(mTreeView, "mTreeView is null");
 
@@ -463,31 +449,23 @@ XULTreeGridCellAccessible::~XULTreeGridC
 ////////////////////////////////////////////////////////////////////////////////
 // XULTreeGridCellAccessible: nsISupports implementation
 
 NS_IMPL_CYCLE_COLLECTION_INHERITED(XULTreeGridCellAccessible, LeafAccessible,
                                    mTree, mColumn)
 
 NS_INTERFACE_TABLE_HEAD_CYCLE_COLLECTION_INHERITED(XULTreeGridCellAccessible)
   NS_INTERFACE_TABLE_INHERITED(XULTreeGridCellAccessible,
-                               nsIAccessibleTableCell,
                                XULTreeGridCellAccessible)
 NS_INTERFACE_TABLE_TAIL_INHERITING(LeafAccessible)
 NS_IMPL_ADDREF_INHERITED(XULTreeGridCellAccessible, LeafAccessible)
 NS_IMPL_RELEASE_INHERITED(XULTreeGridCellAccessible, LeafAccessible)
 
 ////////////////////////////////////////////////////////////////////////////////
-// XULTreeGridCellAccessible: nsIAccessible implementation
-
-void
-XULTreeGridCellAccessible::Shutdown()
-{
-  mTableCell = nullptr;
-  LeafAccessible::Shutdown();
-}
+// XULTreeGridCellAccessible: Accessible
 
 Accessible*
 XULTreeGridCellAccessible::FocusedChild()
 {
   return nullptr;
 }
 
 ENameValueFlag
@@ -602,17 +580,17 @@ XULTreeGridCellAccessible::DoAction(uint
     DoCommand();
     return true;
   }
 
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// XULTreeGridCellAccessible: nsIAccessibleTableCell implementation
+// XULTreeGridCellAccessible: TableCell
 
 TableAccessible*
 XULTreeGridCellAccessible::Table() const
 {
   Accessible* grandParent = mParent->Parent();
   if (grandParent)
     return grandParent->AsTable();
 
--- a/accessible/xul/XULTreeGridAccessible.h
+++ b/accessible/xul/XULTreeGridAccessible.h
@@ -14,32 +14,24 @@
 
 namespace mozilla {
 namespace a11y {
 
 /**
  * Represents accessible for XUL tree in the case when it has multiple columns.
  */
 class XULTreeGridAccessible : public XULTreeAccessible,
-                              public xpcAccessibleTable,
-                              public nsIAccessibleTable,
                               public TableAccessible
 {
 public:
   XULTreeGridAccessible(nsIContent* aContent, DocAccessible* aDoc,
                         nsTreeBodyFrame* aTreeFrame) :
-    XULTreeAccessible(aContent, aDoc, aTreeFrame), xpcAccessibleTable(this)
+    XULTreeAccessible(aContent, aDoc, aTreeFrame)
     { mGenericTypes |= eTable; }
 
-  // nsISupports
-  NS_DECL_ISUPPORTS_INHERITED
-
-  // nsIAccessibleTable
-  NS_FORWARD_NSIACCESSIBLETABLE(xpcAccessibleTable::)
-
   // TableAccessible
   virtual uint32_t ColCount();
   virtual uint32_t RowCount();
   virtual Accessible* CellAt(uint32_t aRowIndex, uint32_t aColumnIndex);
   virtual void ColDescription(uint32_t aColIdx, nsString& aDescription);
   virtual bool IsColSelected(uint32_t aColIdx);
   virtual bool IsRowSelected(uint32_t aRowIdx);
   virtual bool IsCellSelected(uint32_t aRowIdx, uint32_t aColIdx);
@@ -50,17 +42,16 @@ public:
   virtual void SelectedCellIndices(nsTArray<uint32_t>* aCells);
   virtual void SelectedColIndices(nsTArray<uint32_t>* aCols);
   virtual void SelectedRowIndices(nsTArray<uint32_t>* aRows);
   virtual void SelectRow(uint32_t aRowIdx);
   virtual void UnselectRow(uint32_t aRowIdx);
   virtual Accessible* AsAccessible() { return this; }
 
   // Accessible
-  virtual void Shutdown();
   virtual TableAccessible* AsTable() { return this; }
   virtual a11y::role NativeRole() MOZ_OVERRIDE;
 
 protected:
   virtual ~XULTreeGridAccessible();
 
   // XULTreeAccessible
   virtual already_AddRefed<Accessible>
@@ -120,38 +111,32 @@ protected:
 {  /* 84588ad4-549c-4196-a932-4c5ca5de5dff */         \
   0x84588ad4,                                         \
   0x549c,                                             \
   0x4196,                                             \
   { 0xa9, 0x32, 0x4c, 0x5c, 0xa5, 0xde, 0x5d, 0xff }  \
 }
 
 class XULTreeGridCellAccessible : public LeafAccessible,
-                                  public nsIAccessibleTableCell,
-                                  public TableCellAccessible,
-                                  public xpcAccessibleTableCell
+                                  public TableCellAccessible
 {
 public:
 
   XULTreeGridCellAccessible(nsIContent* aContent, DocAccessible* aDoc,
                             XULTreeGridRowAccessible* aRowAcc,
                             nsITreeBoxObject* aTree, nsITreeView* aTreeView,
                             int32_t aRow, nsITreeColumn* aColumn);
 
   // nsISupports
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(XULTreeGridCellAccessible,
                                            LeafAccessible)
 
-  // nsIAccessibleTableCell
-  NS_FORWARD_NSIACCESSIBLETABLECELL(xpcAccessibleTableCell::)
-
   // Accessible
   virtual TableCellAccessible* AsTableCell() { return this; }
-  virtual void Shutdown();
   virtual nsIntRect Bounds() const MOZ_OVERRIDE;
   virtual ENameValueFlag Name(nsString& aName);
   virtual Accessible* FocusedChild();
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() MOZ_OVERRIDE;
   virtual int32_t IndexInParent() const;
   virtual Relation RelationByType(RelationType aType) MOZ_OVERRIDE;
   virtual a11y::role NativeRole() MOZ_OVERRIDE;
   virtual uint64_t NativeState() MOZ_OVERRIDE;
--- a/layout/inspector/inDOMView.cpp
+++ b/layout/inspector/inDOMView.cpp
@@ -22,17 +22,16 @@
 #include "nsIDocument.h"
 #include "nsIServiceManager.h"
 #include "nsITreeColumns.h"
 #include "nsITreeBoxObject.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/Services.h"
 
 #ifdef ACCESSIBILITY
-#include "nsIAccessible.h"
 #include "nsIAccessibilityService.h"
 #endif
 
 using namespace mozilla;
 
 ////////////////////////////////////////////////////////////////////////
 // inDOMViewNode
 
@@ -329,20 +328,17 @@ inDOMView::GetCellProperties(int32_t row
   }
 
 #ifdef ACCESSIBILITY
   if (mShowAccessibleNodes) {
 	  nsCOMPtr<nsIAccessibilityService> accService =
         services::GetAccessibilityService();
     NS_ENSURE_TRUE(accService, NS_ERROR_FAILURE);
 
-    nsCOMPtr<nsIAccessible> accessible;
-    nsresult rv =
-      accService->GetAccessibleFor(node->node, getter_AddRefs(accessible));
-    if (NS_SUCCEEDED(rv) && accessible)
+    if (accService->HasAccessible(node->node))
       aProps.AppendLiteral(" ACCESSIBLE_NODE");
   }
 #endif
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
--- a/widget/cocoa/nsChildView.mm
+++ b/widget/cocoa/nsChildView.mm
@@ -2762,17 +2762,17 @@ nsChildView::GetDocumentAccessible()
     CallQueryReferent(mAccessible.get(),
                       static_cast<a11y::Accessible**>(getter_AddRefs(ret)));
     return ret.forget();
   }
 
   // need to fetch the accessible anew, because it has gone away.
   // cache the accessible in our weak ptr
   nsRefPtr<a11y::Accessible> acc = GetRootAccessible();
-  mAccessible = do_GetWeakReference(static_cast<nsIAccessible *>(acc.get()));
+  mAccessible = do_GetWeakReference(acc.get());
 
   return acc.forget();
 }
 #endif
 
 // RectTextureImage implementation
 
 RectTextureImage::~RectTextureImage()
--- a/widget/windows/winrt/UIAAccessibilityBridge.cpp
+++ b/widget/windows/winrt/UIAAccessibilityBridge.cpp
@@ -6,17 +6,16 @@
 #if defined(ACCESSIBILITY)
 
 #include "UIAAccessibilityBridge.h"
 #include "MetroUtils.h"
 
 #include <OAIdl.h>
 
 #include "nsIAccessibleEvent.h"
-#include "nsIAccessibleEditableText.h"
 #include "nsIPersistentProperties2.h"
 
 // generated
 #include "UIABridge.h"
 
 #include <wrl/implements.h>
 
 using namespace mozilla::a11y;
--- a/widget/windows/winrt/UIABridge.cpp
+++ b/widget/windows/winrt/UIABridge.cpp
@@ -138,52 +138,50 @@ UIABridge::SetFocusInternal(LONG_PTR aAc
 HRESULT
 UIABridge::ClearFocus()
 {
   LogFunction();
   return S_OK;
 }
 
 static void
-DumpChildInfo(nsCOMPtr<nsIAccessible>& aChild)
+DumpChildInfo(nsRefPtr<Accessible>& aChild)
 {
 #ifdef DEBUG
   if (!aChild) {
     return;
   }
   nsString str;
   aChild->GetName(str);
   BridgeLog("name: %ls", str.BeginReading());
   aChild->GetDescription(str);
   BridgeLog("description: %ls", str.BeginReading());
 #endif
 }
 
 static bool
-ChildHasFocus(nsCOMPtr<nsIAccessible>& aChild)
+ChildHasFocus(nsRefPtr<Accessible>& aChild)
 {
-  Accessible* access = (Accessible*)aChild.get();
   BridgeLog("Focus element flags: editable:%d focusable:%d readonly:%d",
-    ((access->NativeState() & mozilla::a11y::states::EDITABLE) > 0),
-    ((access->NativeState() & mozilla::a11y::states::FOCUSABLE) > 0),
-    ((access->NativeState() & mozilla::a11y::states::READONLY) > 0));
-  return (((access->NativeState() & mozilla::a11y::states::EDITABLE) > 0) &&
-           ((access->NativeState() & mozilla::a11y::states::READONLY) == 0));
+    ((aChild->NativeState() & mozilla::a11y::states::EDITABLE) > 0),
+    ((aChild->NativeState() & mozilla::a11y::states::FOCUSABLE) > 0),
+    ((aChild->NativeState() & mozilla::a11y::states::READONLY) > 0));
+  return (((aChild->NativeState() & mozilla::a11y::states::EDITABLE) > 0) &&
+           ((aChild->NativeState() & mozilla::a11y::states::READONLY) == 0));
 }
 
 HRESULT
 UIABridge::FocusChangeEvent()
 {
   LogFunction();
   if (!Connected()) {
     return UIA_E_ELEMENTNOTAVAILABLE;
   }
 
-  nsCOMPtr<nsIAccessible> child;
-  mAccessible->GetFocusedChild(getter_AddRefs(child));
+  nsRefPtr<Accessible> child = mAccessible->FocusedChild();
   if (!child) {
     return S_OK;
   }
 
   if (!ChildHasFocus(child)) {
     ComPtr<IUIAElement> element;
     gElement.As(&element);
     if (!element) {
@@ -216,18 +214,17 @@ UIABridge::ElementProviderFromPoint(doub
 HRESULT
 UIABridge::GetFocus(IRawElementProviderFragment ** retVal)
 {
   LogFunction();
   if (!Connected()) {
     return UIA_E_ELEMENTNOTAVAILABLE;
   }
 
-  nsCOMPtr<nsIAccessible> child;
-  nsresult rv = mAccessible->GetFocusedChild(getter_AddRefs(child));
+  nsRefPtr<Accessible> child = mAccessible->FocusedChild();
   if (!child) {
     BridgeLog("mAccessible->GetFocusedChild failed.");
     return S_OK;
   }
 
   DumpChildInfo(child);
 
   ComPtr<IUIAElement> element;
@@ -488,20 +485,20 @@ UIABridge::get_HostRawElementProvider(IR
 // Element
 
 HRESULT
 UIATextElement::SetFocusInternal(LONG_PTR aAccessible)
 {
   LogFunction();
 #if defined(ACCESSIBILITY)
   NS_ASSERTION(mAccessItem, "Bad accessible pointer");
-  if (mAccessItem == (nsIAccessible*)aAccessible) {
+  if (mAccessItem == (Accessible*)aAccessible) {
     return E_UNEXPECTED;
   }
-  mAccessItem = (nsIAccessible*)aAccessible;
+  mAccessItem = (Accessible*)aAccessible;
   return S_OK;
 #endif
   return E_FAIL;
 }
 
 HRESULT
 UIATextElement::ClearFocus()
 {
@@ -691,22 +688,21 @@ UIATextElement::GetPropertyValue(PROPERT
       pRetVal->boolVal = VARIANT_TRUE;
       pRetVal->vt = VT_BOOL;
       break;
 
     case UIA_LocalizedControlTypePropertyId:
     case UIA_LabeledByPropertyId:
       break;
 
-    case UIA_HasKeyboardFocusPropertyId: 
+    case UIA_HasKeyboardFocusPropertyId:
     {
       if (mAccessItem) {
         uint32_t state, extraState;
-        if (NS_SUCCEEDED(mAccessItem->GetState(&state, &extraState)) &&
-            (state & nsIAccessibleStates::STATE_FOCUSED)) {
+        if (mAccessItem->NativeState() & mozilla::a11y::states::FOCUSED) {
           pRetVal->vt = VT_BOOL;
           pRetVal->boolVal = VARIANT_TRUE;
           return S_OK;
         }
       }
       pRetVal->vt = VT_BOOL;
       pRetVal->boolVal = VARIANT_FALSE;
       break;
--- a/widget/windows/winrt/UIABridgePrivate.h
+++ b/widget/windows/winrt/UIABridgePrivate.h
@@ -128,12 +128,12 @@ public:
   IFACEMETHODIMP get_IsReadOnly(BOOL *pRetVal);
 
   void SetIndexID(int id) {
     mIndexID = id;
   }
 
 private:
   int mIndexID;
-  nsCOMPtr<nsIAccessible> mAccessItem;
+  nsRefPtr<Accessible> mAccessItem;
 };
 
 } } }