--- 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");