--- a/accessible/public/nsIAccessibilityService.h
+++ b/accessible/public/nsIAccessibilityService.h
@@ -7,17 +7,17 @@
 #ifndef _nsIAccessibilityService_h_
 #define _nsIAccessibilityService_h_
 
 #include "nsIAccessibleRetrieval.h"
 #include "nsIAccessibleEvent.h"
 
 #include "nsAutoPtr.h"
 
-class nsAccessible;
+class Accessible;
 class nsINode;
 class nsIContent;
 class nsIDocument;
 class nsIFrame;
 class nsIPresShell;
 class nsObjectFrame;
 
 // 10ff6dca-b219-4b64-9a4c-67a62b86edce
@@ -32,36 +32,36 @@ public:
 
   /**
    * Return an accessible object for a DOM node in the given pres shell.
    *
    * @param  aNode      [in] the DOM node to get an accessible for
    * @param  aPresShell [in] the presentation shell which contains layout info
    *                         for the DOM node
    */
-  virtual nsAccessible* GetAccessible(nsINode* aNode,
-                                      nsIPresShell* aPresShell) = 0;
+  virtual Accessible* GetAccessible(nsINode* aNode,
+                                    nsIPresShell* aPresShell) = 0;
 
   /**
    * Return root document accessible that is or contains a document accessible
    * for the given presshell.
    *
    * @param aPresShell  [in] the presshell
    * @param aCanCreate  [in] points whether the root document accessible
    *                        should be returned from the cache or can be created
    */
-  virtual nsAccessible* GetRootDocumentAccessible(nsIPresShell* aPresShell,
-                                                  bool aCanCreate) = 0;
+  virtual Accessible* GetRootDocumentAccessible(nsIPresShell* aPresShell,
+                                                bool aCanCreate) = 0;
 
    /**
    * Adds/remove ATK root accessible for gtk+ native window to/from children
    * of the application accessible.
    */
-  virtual nsAccessible* AddNativeRootAccessible(void* aAtkAccessible) = 0;
-  virtual void RemoveNativeRootAccessible(nsAccessible* aRootAccessible) = 0;
+  virtual Accessible* AddNativeRootAccessible(void* aAtkAccessible) = 0;
+  virtual void RemoveNativeRootAccessible(Accessible* aRootAccessible) = 0;
 
   /**
    * Notification used to update the accessible tree when new content is
    * inserted.
    */
   virtual void ContentRangeInserted(nsIPresShell* aPresShell,
                                     nsIContent* aContainer,
                                     nsIContent* aStartChild,
@@ -86,17 +86,17 @@ public:
   virtual void PresShellDestroyed(nsIPresShell *aPresShell) = 0;
 
   /**
    * Fire accessible event of the given type for the given target.
    *
    * @param aEvent   [in] accessible event type
    * @param aTarget  [in] target of accessible event
    */
-  virtual void FireAccessibleEvent(PRUint32 aEvent, nsAccessible* aTarget) = 0;
+  virtual void FireAccessibleEvent(PRUint32 aEvent, Accessible* aTarget) = 0;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(nsIAccessibilityService,
                               NS_IACCESSIBILITYSERVICE_IID)
 
 // for component registration
 // {DE401C37-9A7F-4278-A6F8-3DE2833989EF}
 #define NS_ACCESSIBILITY_SERVICE_CID \

--- a/accessible/public/nsIAccessibleText.idl
+++ b/accessible/public/nsIAccessibleText.idl
@@ -1,38 +1,38 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "nsISupports.idl"
 
-typedef long nsAccessibleTextBoundary;
+typedef long AccessibleTextBoundary;
 
 interface nsIAccessible;
 interface nsIPersistentProperties;
 
 [scriptable, uuid(0f4633b1-550c-4b50-8c04-0eb1005eef2f)]
 interface nsIAccessibleText : nsISupports
 {
   // In parameters for character offsets:
   //  -1 will be treated as the equal to the end of the text
   //  -2 will be treated as the caret position
   const PRInt32 TEXT_OFFSET_END_OF_TEXT = -1;
   const PRInt32 TEXT_OFFSET_CARET       = -2;
 
-  const nsAccessibleTextBoundary BOUNDARY_CHAR = 0;
-  const nsAccessibleTextBoundary BOUNDARY_WORD_START = 1;
-  const nsAccessibleTextBoundary BOUNDARY_WORD_END = 2;
-  const nsAccessibleTextBoundary BOUNDARY_SENTENCE_START = 3; // don't use, deprecated
-  const nsAccessibleTextBoundary BOUNDARY_SENTENCE_END = 4;  // don't use, deprecated
-  const nsAccessibleTextBoundary BOUNDARY_LINE_START = 5;
-  const nsAccessibleTextBoundary BOUNDARY_LINE_END = 6;
-  const nsAccessibleTextBoundary BOUNDARY_ATTRIBUTE_RANGE = 7;
+  const AccessibleTextBoundary BOUNDARY_CHAR = 0;
+  const AccessibleTextBoundary BOUNDARY_WORD_START = 1;
+  const AccessibleTextBoundary BOUNDARY_WORD_END = 2;
+  const AccessibleTextBoundary BOUNDARY_SENTENCE_START = 3; // don't use, deprecated
+  const AccessibleTextBoundary BOUNDARY_SENTENCE_END = 4;  // don't use, deprecated
+  const AccessibleTextBoundary BOUNDARY_LINE_START = 5;
+  const AccessibleTextBoundary BOUNDARY_LINE_END = 6;
+  const AccessibleTextBoundary BOUNDARY_ATTRIBUTE_RANGE = 7;
 
   /**
    * The current current caret offset.
    * If set < 0 then caret will be placed  at the end of the text
    */
   attribute long caretOffset;
 
   readonly attribute long characterCount;
@@ -42,27 +42,27 @@ interface nsIAccessibleText : nsISupport
       * String methods may need to return multibyte-encoded strings,
       * since some locales can't be encoded using 16-bit chars.
       * So the methods below might return UTF-16 strings, or they could
       * return "string" values which are UTF-8.
       */
   AString getText (in long startOffset, in long endOffset);
 
   AString getTextAfterOffset (in long offset,
-                              in nsAccessibleTextBoundary boundaryType,
+                              in AccessibleTextBoundary boundaryType,
                               out long startOffset,
                               out long endOffset);
 
   AString getTextAtOffset (in long offset,
-                           in nsAccessibleTextBoundary boundaryType,
+                           in AccessibleTextBoundary boundaryType,
                            out long startOffset,
                            out long endOffset);
 
   AString getTextBeforeOffset (in long offset,
-                               in nsAccessibleTextBoundary boundaryType,
+                               in AccessibleTextBoundary boundaryType,
                                out long startOffset,
                                out long endOffset);
 
     /**
       * It would be better to return an unsigned long here,
       * to allow unicode chars > 16 bits
       */
   wchar getCharacterAtOffset (in long offset);

rename from accessible/src/atk/nsAccessibleWrap.cpp
rename to accessible/src/atk/AccessibleWrap.cpp
--- a/accessible/src/atk/nsAccessibleWrap.cpp
+++ b/accessible/src/atk/AccessibleWrap.cpp
@@ -1,15 +1,15 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "nsAccessibleWrap.h"
+#include "AccessibleWrap.h"
 
 #include "Accessible-inl.h"
 #include "ApplicationAccessibleWrap.h"
 #include "InterfaceInitFuncs.h"
 #include "nsAccUtils.h"
 #include "nsIAccessibleRelation.h"
 #include "RootAccessible.h"
 #include "nsIAccessibleValue.h"
@@ -25,17 +25,17 @@
 
 #include "mozilla/Util.h"
 #include "nsXPCOMStrings.h"
 #include "nsComponentManagerUtils.h"
 
 using namespace mozilla;
 using namespace mozilla::a11y;
 
-nsAccessibleWrap::EAvailableAtkSignals nsAccessibleWrap::gAvailableAtkSignals =
+AccessibleWrap::EAvailableAtkSignals AccessibleWrap::gAvailableAtkSignals =
   eUnknown;
 
 //defined in ApplicationAccessibleWrap.cpp
 extern "C" GType g_atk_hyperlink_impl_type;
 
 /* MaiAtkObject */
 
 enum {
@@ -120,22 +120,22 @@ static const GInterfaceInfo atk_if_infos
      (GInterfaceFinalizeFunc) NULL, NULL}
 };
 
 /**
  * This MaiAtkObject is a thin wrapper, in the MAI namespace, for AtkObject
  */
 struct MaiAtkObject
 {
-    AtkObject parent;
-    /*
-     * The nsAccessibleWrap whose properties and features are exported
-     * via this object instance.
-     */
-    nsAccessibleWrap *accWrap;
+  AtkObject parent;
+  /*
+   * The AccessibleWrap whose properties and features are exported
+   * via this object instance.
+   */
+  AccessibleWrap* accWrap;
 };
 
 struct MaiAtkObjectClass
 {
     AtkObjectClass parent_class;
 };
 
 static guint mai_atk_object_signals [LAST_SIGNAL] = { 0, };
@@ -227,64 +227,66 @@ mai_atk_object_get_type(void)
         type = g_type_register_static(ATK_TYPE_OBJECT,
                                       "MaiAtkObject", &tinfo, GTypeFlags(0));
         quark_mai_hyperlink = g_quark_from_static_string("MaiHyperlink");
     }
     return type;
 }
 
 #ifdef MAI_LOGGING
-PRInt32 nsAccessibleWrap::mAccWrapCreated = 0;
-PRInt32 nsAccessibleWrap::mAccWrapDeleted = 0;
+PRInt32 AccessibleWrap::mAccWrapCreated = 0;
+PRInt32 AccessibleWrap::mAccWrapDeleted = 0;
 #endif
 
-nsAccessibleWrap::
-  nsAccessibleWrap(nsIContent* aContent, DocAccessible* aDoc) :
-  nsAccessible(aContent, aDoc), mAtkObject(nsnull)
+AccessibleWrap::
+  AccessibleWrap(nsIContent* aContent, DocAccessible* aDoc) :
+  Accessible(aContent, aDoc), mAtkObject(nsnull)
 {
 #ifdef MAI_LOGGING
-    ++mAccWrapCreated;
+  ++mAccWrapCreated;
 #endif
-    MAI_LOG_DEBUG(("==nsAccessibleWrap creating: this=%p,total=%d left=%d\n",
-                   (void*)this, mAccWrapCreated,
-                  (mAccWrapCreated-mAccWrapDeleted)));
+  MAI_LOG_DEBUG(("==AccessibleWrap creating: this=%p,total=%d left=%d\n",
+                 (void*)this, mAccWrapCreated,
+                 (mAccWrapCreated-mAccWrapDeleted)));
 }
 
-nsAccessibleWrap::~nsAccessibleWrap()
+AccessibleWrap::~AccessibleWrap()
 {
     NS_ASSERTION(!mAtkObject, "ShutdownAtkObject() is not called");
 
 #ifdef MAI_LOGGING
     ++mAccWrapDeleted;
 #endif
-    MAI_LOG_DEBUG(("==nsAccessibleWrap deleting: this=%p,total=%d left=%d\n",
+    MAI_LOG_DEBUG(("==AccessibleWrap deleting: this=%p,total=%d left=%d\n",
                    (void*)this, mAccWrapDeleted,
                    (mAccWrapCreated-mAccWrapDeleted)));
 }
 
-void nsAccessibleWrap::ShutdownAtkObject()
+void
+AccessibleWrap::ShutdownAtkObject()
 {
     if (mAtkObject) {
         if (IS_MAI_OBJECT(mAtkObject)) {
             MAI_ATK_OBJECT(mAtkObject)->accWrap = nsnull;
         }
         SetMaiHyperlink(nsnull);
         g_object_unref(mAtkObject);
         mAtkObject = nsnull;
     }
 }
 
 void
-nsAccessibleWrap::Shutdown()
+AccessibleWrap::Shutdown()
 {
-    ShutdownAtkObject();
-    nsAccessible::Shutdown();
+  ShutdownAtkObject();
+  Accessible::Shutdown();
 }
 
-MaiHyperlink* nsAccessibleWrap::GetMaiHyperlink(bool aCreate /* = true */)
+MaiHyperlink*
+AccessibleWrap::GetMaiHyperlink(bool aCreate /* = true */)
 {
     // make sure mAtkObject is created
     GetAtkObject();
 
     NS_ASSERTION(quark_mai_hyperlink, "quark_mai_hyperlink not initialized");
     NS_ASSERTION(IS_MAI_OBJECT(mAtkObject), "Invalid AtkObject");
     MaiHyperlink* maiHyperlink = nsnull;
     if (quark_mai_hyperlink && IS_MAI_OBJECT(mAtkObject)) {
@@ -293,32 +295,34 @@ MaiHyperlink* nsAccessibleWrap::GetMaiHy
         if (!maiHyperlink && aCreate) {
             maiHyperlink = new MaiHyperlink(this);
             SetMaiHyperlink(maiHyperlink);
         }
     }
     return maiHyperlink;
 }
 
-void nsAccessibleWrap::SetMaiHyperlink(MaiHyperlink* aMaiHyperlink)
+void
+AccessibleWrap::SetMaiHyperlink(MaiHyperlink* aMaiHyperlink)
 {
     NS_ASSERTION(quark_mai_hyperlink, "quark_mai_hyperlink not initialized");
     NS_ASSERTION(IS_MAI_OBJECT(mAtkObject), "Invalid AtkObject");
     if (quark_mai_hyperlink && IS_MAI_OBJECT(mAtkObject)) {
         MaiHyperlink* maiHyperlink = GetMaiHyperlink(false);
         if (!maiHyperlink && !aMaiHyperlink) {
             return; // Never set and we're shutting down
         }
         delete maiHyperlink;
         g_object_set_qdata(G_OBJECT(mAtkObject), quark_mai_hyperlink,
                            aMaiHyperlink);
     }
 }
 
-NS_IMETHODIMP nsAccessibleWrap::GetNativeInterface(void **aOutAccessible)
+NS_IMETHODIMP
+AccessibleWrap::GetNativeInterface(void** aOutAccessible)
 {
     *aOutAccessible = nsnull;
 
     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;
@@ -336,36 +340,36 @@ NS_IMETHODIMP nsAccessibleWrap::GetNativ
         mAtkObject->layer = ATK_LAYER_INVALID;
     }
 
     *aOutAccessible = mAtkObject;
     return NS_OK;
 }
 
 AtkObject *
-nsAccessibleWrap::GetAtkObject(void)
+AccessibleWrap::GetAtkObject(void)
 {
     void *atkObj = nsnull;
     GetNativeInterface(&atkObj);
     return static_cast<AtkObject *>(atkObj);
 }
 
 // Get AtkObject from nsIAccessible interface
 /* static */
 AtkObject *
-nsAccessibleWrap::GetAtkObject(nsIAccessible * acc)
+AccessibleWrap::GetAtkObject(nsIAccessible* acc)
 {
     void *atkObjPtr = nsnull;
     acc->GetNativeInterface(&atkObjPtr);
     return atkObjPtr ? ATK_OBJECT(atkObjPtr) : nsnull;    
 }
 
 /* private */
 PRUint16
-nsAccessibleWrap::CreateMaiInterfaces(void)
+AccessibleWrap::CreateMaiInterfaces(void)
 {
   PRUint16 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)
@@ -464,34 +468,35 @@ GetMaiAtkType(PRUint16 interfacesBits)
                                     GetAtkTypeForMai((MaiInterfaceType)index),
                                     &atk_if_infos[index]);
       }
     }
 
     return type;
 }
 
-static const char *
+static const char*
 GetUniqueMaiAtkTypeName(PRUint16 interfacesBits)
 {
 #define MAI_ATK_TYPE_NAME_LEN (30)     /* 10+sizeof(PRUint16)*8/4+1 < 30 */
 
     static gchar namePrefix[] = "MaiAtkType";   /* size = 10 */
     static gchar name[MAI_ATK_TYPE_NAME_LEN + 1];
 
     PR_snprintf(name, MAI_ATK_TYPE_NAME_LEN, "%s%x", namePrefix,
                 interfacesBits);
     name[MAI_ATK_TYPE_NAME_LEN] = '\0';
 
     MAI_LOG_DEBUG(("MaiWidget::LastedTypeName=%s\n", name));
 
     return name;
 }
 
-bool nsAccessibleWrap::IsValidObject()
+bool
+AccessibleWrap::IsValidObject()
 {
     // to ensure we are not shut down
     return !IsDefunct();
 }
 
 /* static functions for ATK callbacks */
 void
 classInitCB(AtkObjectClass *aClass)
@@ -593,19 +598,19 @@ initializeCB(AtkObject *aAtkObj, gpointe
     /* call parent init function */
     /* AtkObjectClass has not a "initialize" function now,
      * maybe it has later
      */
 
     if (ATK_OBJECT_CLASS(parent_class)->initialize)
         ATK_OBJECT_CLASS(parent_class)->initialize(aAtkObj, aData);
 
-    /* initialize object */
-    MAI_ATK_OBJECT(aAtkObj)->accWrap =
-        static_cast<nsAccessibleWrap*>(aData);
+  /* initialize object */
+  MAI_ATK_OBJECT(aAtkObj)->accWrap =
+    static_cast<AccessibleWrap*>(aData);
 
 #ifdef MAI_LOGGING
     ++sMaiAtkObjCreated;
 #endif
     MAI_LOG_DEBUG(("MaiAtkObj Create obj=%p for AccWrap=%p, all=%d, left=%d\n",
                    (void*)aAtkObj, (void*)aData, sMaiAtkObjCreated,
                    (sMaiAtkObjCreated-sMaiAtkObjDeleted)));
 }
@@ -628,34 +633,34 @@ finalizeCB(GObject *aObj)
     // finalize of GObjectClass will unref the accessible parent if has
     if (G_OBJECT_CLASS (parent_class)->finalize)
         G_OBJECT_CLASS (parent_class)->finalize(aObj);
 }
 
 const gchar*
 getNameCB(AtkObject* aAtkObj)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
+  AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
   if (!accWrap)
     return nsnull;
 
   nsAutoString uniName;
   accWrap->Name(uniName);
 
   NS_ConvertUTF8toUTF16 objName(aAtkObj->name);
   if (!uniName.Equals(objName))
     atk_object_set_name(aAtkObj, NS_ConvertUTF16toUTF8(uniName).get());
 
   return aAtkObj->name;
 }
 
 const gchar *
 getDescriptionCB(AtkObject *aAtkObj)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(aAtkObj);
+    AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
     if (!accWrap || accWrap->IsDefunct())
         return nsnull;
 
     /* nsIAccessible is responsible for the non-NULL description */
     nsAutoString uniDesc;
     accWrap->Description(uniDesc);
 
     NS_ConvertUTF8toUTF16 objDesc(aAtkObj->description);
@@ -664,17 +669,17 @@ getDescriptionCB(AtkObject *aAtkObj)
                                    NS_ConvertUTF16toUTF8(uniDesc).get());
 
     return aAtkObj->description;
 }
 
 AtkRole
 getRoleCB(AtkObject *aAtkObj)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
+  AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
   if (!accWrap)
     return ATK_ROLE_INVALID;
 
 #ifdef DEBUG
   NS_ASSERTION(nsAccUtils::IsTextInterfaceSupportCorrect(accWrap),
       "Does not support nsIAccessibleText when it should");
 #endif
 
@@ -732,17 +737,17 @@ ConvertToAtkAttributeSet(nsIPersistentPr
         objAttributeSet = g_slist_prepend(objAttributeSet, objAttr);
     }
 
     //libspi will free it
     return objAttributeSet;
 }
 
 AtkAttributeSet*
-GetAttributeSet(nsAccessible* aAccessible)
+GetAttributeSet(Accessible* aAccessible)
 {
     nsCOMPtr<nsIPersistentProperties> attributes;
     aAccessible->GetAttributes(getter_AddRefs(attributes));
 
     if (attributes) {
         // Deal with attributes that we only need to expose in ATK
         if (aAccessible->State() & states::HASPOPUP) {
           // There is no ATK state for haspopup, must use object attribute to expose the same info
@@ -755,69 +760,68 @@ GetAttributeSet(nsAccessible* aAccessibl
     }
 
     return nsnull;
 }
 
 AtkAttributeSet *
 getAttributesCB(AtkObject *aAtkObj)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(aAtkObj);
-
-    return accWrap ? GetAttributeSet(accWrap) : nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
+  return accWrap ? GetAttributeSet(accWrap) : nsnull;
 }
 
 AtkObject *
 getParentCB(AtkObject *aAtkObj)
 {
   if (!aAtkObj->accessible_parent) {
-    nsAccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
+    AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
     if (!accWrap)
       return nsnull;
 
-    nsAccessible* accParent = accWrap->Parent();
+    Accessible* accParent = accWrap->Parent();
     if (!accParent)
       return nsnull;
 
-    AtkObject* parent = nsAccessibleWrap::GetAtkObject(accParent);
+    AtkObject* parent = AccessibleWrap::GetAtkObject(accParent);
     if (parent)
       atk_object_set_parent(aAtkObj, parent);
   }
   return aAtkObj->accessible_parent;
 }
 
 gint
 getChildCountCB(AtkObject *aAtkObj)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(aAtkObj);
+    AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
     if (!accWrap || nsAccUtils::MustPrune(accWrap)) {
         return 0;
     }
 
     return static_cast<gint>(accWrap->EmbeddedChildCount());
 }
 
 AtkObject *
 refChildCB(AtkObject *aAtkObj, gint aChildIndex)
 {
     // aChildIndex should not be less than zero
     if (aChildIndex < 0) {
       return nsnull;
     }
 
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(aAtkObj);
+    AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
     if (!accWrap || nsAccUtils::MustPrune(accWrap)) {
         return nsnull;
     }
 
-    nsAccessible* accChild = accWrap->GetEmbeddedChildAt(aChildIndex);
+    Accessible* accChild = accWrap->GetEmbeddedChildAt(aChildIndex);
     if (!accChild)
         return nsnull;
 
-    AtkObject* childAtkObj = nsAccessibleWrap::GetAtkObject(accChild);
+    AtkObject* childAtkObj = AccessibleWrap::GetAtkObject(accChild);
 
     NS_ASSERTION(childAtkObj, "Fail to get AtkObj");
     if (!childAtkObj)
         return nsnull;
     g_object_ref(childAtkObj);
 
   if (aAtkObj != childAtkObj->accessible_parent)
     atk_object_set_parent(childAtkObj, aAtkObj);
@@ -825,22 +829,22 @@ refChildCB(AtkObject *aAtkObj, gint aChi
   return childAtkObj;
 }
 
 gint
 getIndexInParentCB(AtkObject *aAtkObj)
 {
     // We don't use nsIAccessible::GetIndexInParent() because
     // for ATK we don't want to include text leaf nodes as children
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(aAtkObj);
+    AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
     if (!accWrap) {
         return -1;
     }
 
-    nsAccessible* parent = accWrap->Parent();
+    Accessible* parent = accWrap->Parent();
     if (!parent)
         return -1; // No parent
 
     return parent->GetIndexOfEmbeddedChild(accWrap);
 }
 
 static void
 TranslateStates(PRUint64 aState, AtkStateSet* aStateSet)
@@ -865,17 +869,17 @@ TranslateStates(PRUint64 aState, AtkStat
 }
 
 AtkStateSet *
 refStateSetCB(AtkObject *aAtkObj)
 {
     AtkStateSet *state_set = nsnull;
     state_set = ATK_OBJECT_CLASS(parent_class)->ref_state_set(aAtkObj);
 
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(aAtkObj);
+    AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
     if (!accWrap) {
         TranslateStates(states::DEFUNCT, state_set);
         return state_set;
     }
 
     // Map states
     TranslateStates(accWrap->State(), state_set);
 
@@ -883,17 +887,17 @@ refStateSetCB(AtkObject *aAtkObj)
 }
 
 AtkRelationSet *
 refRelationSetCB(AtkObject *aAtkObj)
 {
   AtkRelationSet* relation_set =
     ATK_OBJECT_CLASS(parent_class)->ref_relation_set(aAtkObj);
 
-  nsAccessibleWrap *accWrap = GetAccessibleWrap(aAtkObj);
+  AccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
   if (!accWrap)
     return relation_set;
 
   PRUint32 relationTypes[] = {
     nsIAccessibleRelation::RELATION_LABELLED_BY,
     nsIAccessibleRelation::RELATION_LABEL_FOR,
     nsIAccessibleRelation::RELATION_NODE_CHILD_OF,
     nsIAccessibleRelation::RELATION_CONTROLLED_BY,
@@ -909,79 +913,80 @@ refRelationSetCB(AtkObject *aAtkObj)
     AtkRelationType atkType = static_cast<AtkRelationType>(relationTypes[i]);
     AtkRelation* atkRelation =
       atk_relation_set_get_relation_by_type(relation_set, atkType);
     if (atkRelation)
       atk_relation_set_remove(relation_set, atkRelation);
 
     Relation rel(accWrap->RelationByType(relationTypes[i]));
     nsTArray<AtkObject*> targets;
-    nsAccessible* tempAcc = nsnull;
+    Accessible* tempAcc = nsnull;
     while ((tempAcc = rel.Next()))
-      targets.AppendElement(nsAccessibleWrap::GetAtkObject(tempAcc));
+      targets.AppendElement(AccessibleWrap::GetAtkObject(tempAcc));
 
     if (targets.Length()) {
       atkRelation = atk_relation_new(targets.Elements(), targets.Length(), atkType);
       atk_relation_set_add(relation_set, atkRelation);
       g_object_unref(atkRelation);
     }
   }
 
   return relation_set;
 }
 
-// Check if aAtkObj is a valid MaiAtkObject, and return the nsAccessibleWrap
+// Check if aAtkObj is a valid MaiAtkObject, and return the AccessibleWrap
 // for it.
-nsAccessibleWrap *GetAccessibleWrap(AtkObject *aAtkObj)
+AccessibleWrap*
+GetAccessibleWrap(AtkObject* aAtkObj)
 {
   NS_ENSURE_TRUE(IS_MAI_OBJECT(aAtkObj), nsnull);
-  nsAccessibleWrap* accWrap = MAI_ATK_OBJECT(aAtkObj)->accWrap;
+  AccessibleWrap* accWrap = MAI_ATK_OBJECT(aAtkObj)->accWrap;
 
   // Check if the accessible was deconstructed.
   if (!accWrap)
     return nsnull;
 
   NS_ENSURE_TRUE(accWrap->GetAtkObject() == aAtkObj, nsnull);
 
-  nsAccessibleWrap* appAccWrap = nsAccessNode::GetApplicationAccessible();
+  AccessibleWrap* appAccWrap = nsAccessNode::GetApplicationAccessible();
   if (appAccWrap != accWrap && !accWrap->IsValidObject())
     return nsnull;
 
   return accWrap;
 }
 
 nsresult
-nsAccessibleWrap::HandleAccEvent(AccEvent* aEvent)
+AccessibleWrap::HandleAccEvent(AccEvent* aEvent)
 {
-    nsresult rv = nsAccessible::HandleAccEvent(aEvent);
-    NS_ENSURE_SUCCESS(rv, rv);
+  nsresult rv = Accessible::HandleAccEvent(aEvent);
+  NS_ENSURE_SUCCESS(rv, rv);
 
-    return FirePlatformEvent(aEvent);
+  return FirePlatformEvent(aEvent);
 }
 
 nsresult
-nsAccessibleWrap::FirePlatformEvent(AccEvent* aEvent)
+AccessibleWrap::FirePlatformEvent(AccEvent* aEvent)
 {
-    nsAccessible *accessible = aEvent->GetAccessible();
+    Accessible* accessible = aEvent->GetAccessible();
     NS_ENSURE_TRUE(accessible, NS_ERROR_FAILURE);
 
     PRUint32 type = aEvent->GetEventType();
 
-    AtkObject *atkObj = nsAccessibleWrap::GetAtkObject(accessible);
+    AtkObject* atkObj = AccessibleWrap::GetAtkObject(accessible);
 
     // We don't create ATK objects for nsIAccessible 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;
     }
 
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(atkObj);
+    AccessibleWrap* accWrap = GetAccessibleWrap(atkObj);
     if (!accWrap) {
         return NS_OK; // Node is shut down
     }
 
     switch (type) {
     case nsIAccessibleEvent::EVENT_STATE_CHANGE:
         return FireAtkStateChangeEvent(aEvent, atkObj);
 
@@ -1025,17 +1030,17 @@ nsAccessibleWrap::FirePlatformEvent(AccE
 
     case nsIAccessibleEvent::EVENT_SELECTION:
     case nsIAccessibleEvent::EVENT_SELECTION_ADD:
     case nsIAccessibleEvent::EVENT_SELECTION_REMOVE:
     {
       // XXX: dupe events may be fired
       MAI_LOG_DEBUG(("\n\nReceived: EVENT_SELECTION_CHANGED\n"));
       AccSelChangeEvent* selChangeEvent = downcast_accEvent(aEvent);
-      g_signal_emit_by_name(nsAccessibleWrap::GetAtkObject(selChangeEvent->Widget()),
+      g_signal_emit_by_name(AccessibleWrap::GetAtkObject(selChangeEvent->Widget()),
                             "selection_changed");
       break;
     }
 
     case nsIAccessibleEvent::EVENT_SELECTION_WITHIN:
     {
       MAI_LOG_DEBUG(("\n\nReceived: EVENT_SELECTION_CHANGED\n"));
       g_signal_emit_by_name(atkObj, "selection_changed");
@@ -1253,18 +1258,18 @@ nsAccessibleWrap::FirePlatformEvent(AccE
         atk_object_notify_state_change(atkObj, ATK_STATE_SHOWING, false);
         break;
     }
 
     return NS_OK;
 }
 
 nsresult
-nsAccessibleWrap::FireAtkStateChangeEvent(AccEvent* aEvent,
-                                          AtkObject *aObject)
+AccessibleWrap::FireAtkStateChangeEvent(AccEvent* aEvent,
+                                        AtkObject* aObject)
 {
     MAI_LOG_DEBUG(("\n\nReceived: EVENT_STATE_CHANGE\n"));
 
     AccStateChangeEvent* event = downcast_accEvent(aEvent);
     NS_ENSURE_TRUE(event, NS_ERROR_FAILURE);
 
     bool isEnabled = event->IsStateEnabled();
     PRInt32 stateIndex = AtkStateMap::GetStateIndexFor(event->GetState());
@@ -1285,18 +1290,18 @@ nsAccessibleWrap::FireAtkStateChangeEven
                                            isEnabled);
         }
     }
 
     return NS_OK;
 }
 
 nsresult
-nsAccessibleWrap::FireAtkTextChangedEvent(AccEvent* aEvent,
-                                          AtkObject *aObject)
+AccessibleWrap::FireAtkTextChangedEvent(AccEvent* aEvent,
+                                        AtkObject* aObject)
 {
     MAI_LOG_DEBUG(("\n\nReceived: EVENT_TEXT_REMOVED/INSERTED\n"));
 
     AccTextChangeEvent* event = downcast_accEvent(aEvent);
     NS_ENSURE_TRUE(event, NS_ERROR_FAILURE);
 
     PRInt32 start = event->GetStartOffset();
     PRUint32 length = event->GetLength();
@@ -1326,18 +1331,18 @@ nsAccessibleWrap::FireAtkTextChangedEven
                           NS_ConvertUTF16toUTF8(text).get());
   }
 
   g_free(signal_name);
   return NS_OK;
 }
 
 nsresult
-nsAccessibleWrap::FireAtkShowHideEvent(AccEvent* aEvent,
-                                       AtkObject *aObject, bool aIsAdded)
+AccessibleWrap::FireAtkShowHideEvent(AccEvent* aEvent,
+                                     AtkObject* aObject, bool aIsAdded)
 {
     if (aIsAdded) {
         MAI_LOG_DEBUG(("\n\nReceived: Show event\n"));
     } else {
         MAI_LOG_DEBUG(("\n\nReceived: Hide event\n"));
     }
 
     PRInt32 indexInParent = getIndexInParentCB(aObject);

rename from accessible/src/atk/nsAccessibleWrap.h
rename to accessible/src/atk/AccessibleWrap.h
--- a/accessible/src/atk/nsAccessibleWrap.h
+++ b/accessible/src/atk/AccessibleWrap.h
@@ -3,17 +3,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef __NS_ACCESSIBLE_WRAP_H__
 #define __NS_ACCESSIBLE_WRAP_H__
 
 #include "nsCOMPtr.h"
-#include "nsAccessible.h"
+#include "Accessible.h"
 #include "prlog.h"
 
 #ifdef PR_LOGGING
 #define MAI_LOGGING
 #endif /* #ifdef PR_LOGGING */
 
 struct _AtkObject;
 typedef struct _AtkObject AtkObject;
@@ -39,75 +39,75 @@ struct AtkPropertyChange {
   PRInt32 type;     // property type as listed above
   void *oldvalue;
   void *newvalue;
 };
 
 class MaiHyperlink;
 
 /**
- * nsAccessibleWrap, and its descendents in atk directory provide the
+ * AccessibleWrap, and its descendents in atk directory provide the
  * implementation of AtkObject.
  */
-class nsAccessibleWrap: public nsAccessible
+class AccessibleWrap : public Accessible
 {
 public:
-  nsAccessibleWrap(nsIContent* aContent, DocAccessible* aDoc);
-    virtual ~nsAccessibleWrap();
-    void ShutdownAtkObject();
+  AccessibleWrap(nsIContent* aContent, DocAccessible* aDoc);
+  virtual ~AccessibleWrap();
+  void ShutdownAtkObject();
 
-    // nsAccessNode
-    virtual void Shutdown();
+  // nsAccessNode
+  virtual void Shutdown();
 
 #ifdef MAI_LOGGING
-    virtual void DumpnsAccessibleWrapInfo(int aDepth) {}
-    static PRInt32 mAccWrapCreated;
-    static PRInt32 mAccWrapDeleted;
+  virtual void DumpAccessibleWrapInfo(int aDepth) {}
+  static PRInt32 mAccWrapCreated;
+  static PRInt32 mAccWrapDeleted;
 #endif
 
-    // return the atk object for this nsAccessibleWrap
-    NS_IMETHOD GetNativeInterface(void **aOutAccessible);
-    virtual nsresult HandleAccEvent(AccEvent* aEvent);
+  // return the atk object for this AccessibleWrap
+  NS_IMETHOD GetNativeInterface(void **aOutAccessible);
+  virtual nsresult HandleAccEvent(AccEvent* aEvent);
 
-    AtkObject * GetAtkObject(void);
-    static AtkObject * GetAtkObject(nsIAccessible * acc);
+  AtkObject * GetAtkObject(void);
+  static AtkObject * GetAtkObject(nsIAccessible * acc);
 
-    bool IsValidObject();
+  bool IsValidObject();
     
-    // get/set the MaiHyperlink object for this nsAccessibleWrap
-    MaiHyperlink* GetMaiHyperlink(bool aCreate = true);
-    void SetMaiHyperlink(MaiHyperlink* aMaiHyperlink);
+  // 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();
-    }
+  static const char * ReturnString(nsAString &aString) {
+    static nsCString returnedString;
+    returnedString = NS_ConvertUTF16toUTF8(aString);
+    return returnedString.get();
+  }
 
 protected:
-    virtual nsresult FirePlatformEvent(AccEvent* aEvent);
+  virtual nsresult FirePlatformEvent(AccEvent* aEvent);
 
-    nsresult FireAtkStateChangeEvent(AccEvent* aEvent, AtkObject *aObject);
-    nsresult FireAtkTextChangedEvent(AccEvent* aEvent, AtkObject *aObject);
-    nsresult FireAtkShowHideEvent(AccEvent* aEvent, AtkObject *aObject,
-                                  bool aIsAdded);
+  nsresult FireAtkStateChangeEvent(AccEvent* aEvent, AtkObject *aObject);
+  nsresult FireAtkTextChangedEvent(AccEvent* aEvent, AtkObject *aObject);
+  nsresult FireAtkShowHideEvent(AccEvent* aEvent, AtkObject *aObject,
+                                bool aIsAdded);
 
-    AtkObject *mAtkObject;
+  AtkObject *mAtkObject;
 
 private:
 
   /*
    * do we have text-remove and text-insert signals if not we need to use
-   * text-changed see nsAccessibleWrap::FireAtkTextChangedEvent() and
+   * text-changed see AccessibleWrap::FireAtkTextChangedEvent() and
    * bug 619002
    */
   enum EAvailableAtkSignals {
     eUnknown,
     eHaveNewAtkTextSignals,
     eNoNewAtkSignals
   };
 
   static EAvailableAtkSignals gAvailableAtkSignals;
 
-    PRUint16 CreateMaiInterfaces(void);
+  PRUint16 CreateMaiInterfaces(void);
 };
 
 #endif /* __NS_ACCESSIBLE_WRAP_H__ */

--- a/accessible/src/atk/ApplicationAccessibleWrap.cpp
+++ b/accessible/src/atk/ApplicationAccessibleWrap.cpp
@@ -515,18 +515,18 @@ static nsresult LoadGtkModule(GnomeAcces
 ApplicationAccessibleWrap::ApplicationAccessibleWrap():
   ApplicationAccessible()
 {
   MAI_LOG_DEBUG(("======Create AppRootAcc=%p\n", (void*)this));
 }
 
 ApplicationAccessibleWrap::~ApplicationAccessibleWrap()
 {
-    MAI_LOG_DEBUG(("======Destory AppRootAcc=%p\n", (void*)this));
-    nsAccessibleWrap::ShutdownAtkObject();
+  MAI_LOG_DEBUG(("======Destory AppRootAcc=%p\n", (void*)this));
+  AccessibleWrap::ShutdownAtkObject();
 }
 
 static gboolean
 toplevel_event_watcher(GSignalInvocationHint* ihint,
                        guint                  n_param_values,
                        const GValue*          param_values,
                        gpointer               data)
 {
@@ -546,25 +546,25 @@ toplevel_event_watcher(GSignalInvocation
 
   // GTK native dialog
   if (!IS_MAI_OBJECT(child) &&
       (atk_object_get_role(child) == ATK_ROLE_DIALOG)) {
 
     if (data == reinterpret_cast<gpointer>(nsIAccessibleEvent::EVENT_SHOW)) {
 
       // Attach the dialog accessible to app accessible tree
-      nsAccessible* windowAcc = GetAccService()->AddNativeRootAccessible(child);
+      Accessible* windowAcc = GetAccService()->AddNativeRootAccessible(child);
       g_object_set_qdata(G_OBJECT(child), sQuark_gecko_acc_obj,
                          reinterpret_cast<gpointer>(windowAcc));
 
     } else {
 
       // Deattach the dialog accessible
-      nsAccessible* windowAcc =
-        reinterpret_cast<nsAccessible*>
+      Accessible* windowAcc =
+        reinterpret_cast<Accessible*>
                         (g_object_get_qdata(G_OBJECT(child), sQuark_gecko_acc_obj));
       if (windowAcc) {
         GetAccService()->RemoveNativeRootAccessible(windowAcc);
         g_object_set_qdata(G_OBJECT(child), sQuark_gecko_acc_obj, NULL);
       }
 
     }
   }
@@ -701,23 +701,23 @@ gboolean fireRootAccessibleAddedCB(gpoin
     g_object_unref(eventData->app_accessible);
     g_object_unref(eventData->root_accessible);
     free(data);
 
     return FALSE;
 }
 
 bool
-ApplicationAccessibleWrap::AppendChild(nsAccessible* aChild)
+ApplicationAccessibleWrap::AppendChild(Accessible* aChild)
 {
-    if (!ApplicationAccessible::AppendChild(aChild))
-      return false;
+  if (!ApplicationAccessible::AppendChild(aChild))
+    return false;
 
-    AtkObject *atkAccessible = nsAccessibleWrap::GetAtkObject(aChild);
-    atk_object_set_parent(atkAccessible, mAtkObject);
+  AtkObject* atkAccessible = AccessibleWrap::GetAtkObject(aChild);
+  atk_object_set_parent(atkAccessible, mAtkObject);
 
     PRUint32 count = mChildren.Length();
 
     // Emit children_changed::add in a timeout
     // to make sure aRootAccWrap is fully initialized.
     AtkRootAccessibleAddedEvent* eventData = (AtkRootAccessibleAddedEvent*)
       malloc(sizeof(AtkRootAccessibleAddedEvent));
     if (eventData) {
@@ -728,26 +728,26 @@ ApplicationAccessibleWrap::AppendChild(n
       g_object_ref(atkAccessible);
       g_timeout_add(0, fireRootAccessibleAddedCB, eventData);
     }
 
     return true;
 }
 
 bool
-ApplicationAccessibleWrap::RemoveChild(nsAccessible* aChild)
+ApplicationAccessibleWrap::RemoveChild(Accessible* aChild)
 {
-    PRInt32 index = aChild->IndexInParent();
+  PRInt32 index = aChild->IndexInParent();
 
-    AtkObject *atkAccessible = nsAccessibleWrap::GetAtkObject(aChild);
-    atk_object_set_parent(atkAccessible, NULL);
-    g_signal_emit_by_name(mAtkObject, "children_changed::remove", index,
-                          atkAccessible, NULL);
+  AtkObject* atkAccessible = AccessibleWrap::GetAtkObject(aChild);
+  atk_object_set_parent(atkAccessible, NULL);
+  g_signal_emit_by_name(mAtkObject, "children_changed::remove", index,
+                        atkAccessible, NULL);
 
-    return ApplicationAccessible::RemoveChild(aChild);
+  return ApplicationAccessible::RemoveChild(aChild);
 }
 
 void
 ApplicationAccessibleWrap::PreCreate()
 {
     if (!sATKChecked) {
         sATKLib = PR_LoadLibrary(sATKLibName);
         if (sATKLib) {

--- a/accessible/src/atk/ApplicationAccessibleWrap.h
+++ b/accessible/src/atk/ApplicationAccessibleWrap.h
@@ -20,20 +20,20 @@ public:
 
 public:
   ApplicationAccessibleWrap();
   virtual ~ApplicationAccessibleWrap();
 
   // nsAccessNode
   virtual bool Init();
 
-  // nsAccessible
+  // Accessible
   virtual mozilla::a11y::ENameValueFlag Name(nsString& aName);
-  virtual bool AppendChild(nsAccessible* aChild);
-  virtual bool RemoveChild(nsAccessible* aChild);
+  virtual bool AppendChild(Accessible* aChild);
+  virtual bool RemoveChild(Accessible* aChild);
 
   /**
    * Return the atk object for app root accessible.
    */
   NS_IMETHOD GetNativeInterface(void** aOutAccessible);
 };
 
 } // namespace a11y

--- a/accessible/src/atk/AtkSocketAccessible.cpp
+++ b/accessible/src/atk/AtkSocketAccessible.cpp
@@ -35,17 +35,17 @@ extern "C" GType mai_atk_socket_get_type
 #define MAI_ATK_SOCKET_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj),\
                                           MAI_TYPE_ATK_SOCKET,\
                                           MaiAtkSocketClass))
 
 typedef struct _MaiAtkSocket
 {
   AtkSocket parent;
 
-  nsAccessibleWrap* accWrap;
+  AccessibleWrap* accWrap;
 } MaiAtkSocket;
 
 typedef struct _MaiAtkSocketClass
 {
   AtkSocketClass parent_class;
 } MaiAtkSocketClass;
 
 G_DEFINE_TYPE_EXTENDED(MaiAtkSocket, mai_atk_socket,
@@ -59,17 +59,17 @@ mai_atk_socket_class_init(MaiAtkSocketCl
 }
 
 void
 mai_atk_socket_init(MaiAtkSocket* aAcc)
 {
 }
 
 static AtkObject*
-mai_atk_socket_new(nsAccessibleWrap* aAccWrap)
+mai_atk_socket_new(AccessibleWrap* aAccWrap)
 {
   NS_ENSURE_TRUE(aAccWrap, NULL);
 
   MaiAtkSocket* acc = nsnull;
   acc = static_cast<MaiAtkSocket*>(g_object_new(MAI_TYPE_ATK_SOCKET, NULL));
   NS_ENSURE_TRUE(acc, NULL);
 
   acc->accWrap = aAccWrap;
@@ -110,17 +110,17 @@ mai_atk_component_iface_init(AtkComponen
 
   aIface->ref_accessible_at_point = RefAccessibleAtPoint;
   aIface->get_extents = GetExtents;
 }
 
 AtkSocketAccessible::AtkSocketAccessible(nsIContent* aContent,
                                          DocAccessible* aDoc,
                                          const nsCString& aPlugId) :
-  nsAccessibleWrap(aContent, aDoc)
+  AccessibleWrap(aContent, aDoc)
 {
   mAtkObject = mai_atk_socket_new(this);
   if (!mAtkObject)
     return;
 
   // Embeds the children of an AtkPlug, specified by plugId, as the children of
   // this socket.
   // Using G_TYPE macros instead of ATK_SOCKET macros to avoid undefined
@@ -144,10 +144,10 @@ void
 AtkSocketAccessible::Shutdown()
 {
   if (mAtkObject) {
     if (MAI_IS_ATK_SOCKET(mAtkObject))
       MAI_ATK_SOCKET(mAtkObject)->accWrap = nsnull;
     g_object_unref(mAtkObject);
     mAtkObject = nsnull;
   }
-  nsAccessibleWrap::Shutdown();
+  AccessibleWrap::Shutdown();
 }

--- a/accessible/src/atk/AtkSocketAccessible.h
+++ b/accessible/src/atk/AtkSocketAccessible.h
@@ -2,31 +2,31 @@
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef _AtkSocketAccessible_H_
 #define _AtkSocketAccessible_H_
 
-#include "nsAccessibleWrap.h"
+#include "AccessibleWrap.h"
 
 // This file gets included by nsAccessibilityService.cpp, which can't include
 // atk.h (or glib.h), so we can't rely on it being included.
 #ifdef __ATK_H__
 extern "C" typedef void (*AtkSocketEmbedType) (AtkSocket*, gchar*);
 #else
 extern "C" typedef void (*AtkSocketEmbedType) (void*, void*);
 #endif
 
 /**
- * Provides a nsAccessibleWrap wrapper around AtkSocket for out-of-process
+ * Provides a AccessibleWrap wrapper around AtkSocket for out-of-process
  * accessibles.
  */
-class AtkSocketAccessible: public nsAccessibleWrap
+class AtkSocketAccessible : public AccessibleWrap
 {
 public:
 
   // Soft references to AtkSocket
   static AtkSocketEmbedType g_atk_socket_embed;
 #ifdef __ATK_H__
   static GType g_atk_socket_type;
 #endif

--- a/accessible/src/atk/InterfaceInitFuncs.h
+++ b/accessible/src/atk/InterfaceInitFuncs.h
@@ -4,17 +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/. */
 
 #ifndef ATK_INTERFACE_INIT_FUNCS_H_
 #define ATK_INTERFACE_INIT_FUNCS_H_
 
 #include <atk/atk.h>
 
-class nsAccessibleWrap;
+class AccessibleWrap;
 
 extern "C" {
 void actionInterfaceInitCB(AtkActionIface* aIface);
 void componentInterfaceInitCB(AtkComponentIface* aIface);
 void documentInterfaceInitCB(AtkDocumentIface *aIface);
 void editableTextInterfaceInitCB(AtkEditableTextIface* aIface);
 void hyperlinkImplInterfaceInitCB(AtkHyperlinkImplIface *aIface);
 void hypertextInterfaceInitCB(AtkHypertextIface* aIface);
@@ -23,15 +23,15 @@ void selectionInterfaceInitCB(AtkSelecti
 void tableInterfaceInitCB(AtkTableIface *aIface);
 void textInterfaceInitCB(AtkTextIface* aIface);
 void valueInterfaceInitCB(AtkValueIface *aIface);
 }
 
 /**
  * XXX these should live in a file of utils for atk.
  */
-AtkObject* refAccessibleAtPointHelper(nsAccessibleWrap* aAccWrap,
+AtkObject* refAccessibleAtPointHelper(AccessibleWrap* aAccWrap,
                                       gint aX, gint aY, AtkCoordType aCoordType);
-void getExtentsHelper(nsAccessibleWrap* aAccWrap,
+void getExtentsHelper(AccessibleWrap* aAccWrap,
                       gint* aX, gint* aY, gint* aWidth, gint* aHeight,
                       AtkCoordType aCoordType);
 
 #endif // ATK_INTERFACE_INIT_FUNCS_H_

--- a/accessible/src/atk/Makefile.in
+++ b/accessible/src/atk/Makefile.in
@@ -11,21 +11,21 @@ include $(DEPTH)/config/autoconf.mk
 
 MODULE = accessibility
 LIBRARY_NAME = accessibility_toolkit_s
 EXPORT_LIBRARY = ..
 LIBXUL_LIBRARY = 1
 
 
 CPPSRCS = \
+  AccessibleWrap.cpp \
+  ApplicationAccessibleWrap.cpp \
   AtkSocketAccessible.cpp \
   DocAccessibleWrap.cpp \
   nsAccessNodeWrap.cpp \
-  nsAccessibleWrap.cpp \
-  ApplicationAccessibleWrap.cpp \
   nsMaiInterfaceComponent.cpp \
   nsMaiInterfaceAction.cpp \
   nsMaiInterfaceText.cpp \
   nsMaiInterfaceEditableText.cpp \
   nsMaiInterfaceSelection.cpp \
   nsMaiInterfaceValue.cpp \
   nsMaiHyperlink.cpp \
   nsMaiInterfaceHypertext.cpp \

--- a/accessible/src/atk/nsMai.h
+++ b/accessible/src/atk/nsMai.h
@@ -6,17 +6,17 @@
 
 #ifndef __NS_MAI_H__
 #define __NS_MAI_H__
 
 #include <atk/atk.h>
 #include <glib.h>
 #include <glib-object.h>
 
-#include "nsAccessibleWrap.h"
+#include "AccessibleWrap.h"
 
 extern PRLogModuleInfo *gMaiLog;
 
 #ifdef MAI_LOGGING
 #define MAI_LOG(level, args) \
 PR_BEGIN_MACRO \
     if (!gMaiLog) { \
         gMaiLog = PR_NewLogModule("Mai"); \
@@ -41,11 +41,11 @@ PR_END_MACRO
 #define IS_MAI_OBJECT(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
                                          MAI_TYPE_ATK_OBJECT))
 #define IS_MAI_OBJECT_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), \
                                          MAI_TYPE_ATK_OBJECT))
 #define MAI_ATK_OBJECT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), \
                                          MAI_TYPE_ATK_OBJECT, \
                                          MaiAtkObjectClass))
 GType mai_atk_object_get_type(void);
-nsAccessibleWrap *GetAccessibleWrap(AtkObject *aAtkObj);
+AccessibleWrap* GetAccessibleWrap(AtkObject* aAtkObj);
 
 #endif /* __NS_MAI_H__ */

--- a/accessible/src/atk/nsMaiHyperlink.cpp
+++ b/accessible/src/atk/nsMaiHyperlink.cpp
@@ -54,17 +54,17 @@ static gchar *getUriCB(AtkHyperlink *aLi
 static AtkObject *getObjectCB(AtkHyperlink *aLink, gint aLinkIndex);
 static gint getEndIndexCB(AtkHyperlink *aLink);
 static gint getStartIndexCB(AtkHyperlink *aLink);
 static gboolean isValidCB(AtkHyperlink *aLink);
 static gint getAnchorCountCB(AtkHyperlink *aLink);
 G_END_DECLS
 
 static gpointer parent_class = NULL;
-static nsAccessible*
+static Accessible*
 get_accessible_hyperlink(AtkHyperlink *aHyperlink);
 
 GType
 mai_atk_hyperlink_get_type(void)
 {
     static GType type = 0;
 
     if (!type) {
@@ -83,17 +83,17 @@ mai_atk_hyperlink_get_type(void)
 
         type = g_type_register_static(ATK_TYPE_HYPERLINK,
                                       "MaiAtkHyperlink",
                                       &tinfo, GTypeFlags(0));
     }
     return type;
 }
 
-MaiHyperlink::MaiHyperlink(nsAccessible* aHyperLink) :
+MaiHyperlink::MaiHyperlink(Accessible* aHyperLink) :
     mHyperlink(aHyperLink),
     mMaiAtkHyperlink(nsnull)
 {
 }
 
 MaiHyperlink::~MaiHyperlink()
 {
     if (mMaiAtkHyperlink) {
@@ -174,83 +174,83 @@ finalizeCB(GObject *aObj)
     /* call parent finalize function */
     if (G_OBJECT_CLASS (parent_class)->finalize)
         G_OBJECT_CLASS (parent_class)->finalize(aObj);
 }
 
 gchar *
 getUriCB(AtkHyperlink *aLink, gint aLinkIndex)
 {
-    nsAccessible* hyperlink = get_accessible_hyperlink(aLink);
+    Accessible* hyperlink = get_accessible_hyperlink(aLink);
     NS_ENSURE_TRUE(hyperlink, nsnull);
 
     nsCOMPtr<nsIURI> uri = hyperlink->AnchorURIAt(aLinkIndex);
     if (!uri)
         return nsnull;
 
     nsCAutoString cautoStr;
     nsresult rv = uri->GetSpec(cautoStr);
     NS_ENSURE_SUCCESS(rv, nsnull);
 
     return g_strdup(cautoStr.get());
 }
 
 AtkObject *
 getObjectCB(AtkHyperlink *aLink, gint aLinkIndex)
 {
-    nsAccessible* hyperlink = get_accessible_hyperlink(aLink);
+    Accessible* hyperlink = get_accessible_hyperlink(aLink);
     NS_ENSURE_TRUE(hyperlink, nsnull);
 
-    nsAccessible* anchor = hyperlink->AnchorAt(aLinkIndex);
+    Accessible* anchor = hyperlink->AnchorAt(aLinkIndex);
     NS_ENSURE_TRUE(anchor, nsnull);
 
-    AtkObject *atkObj = nsAccessibleWrap::GetAtkObject(anchor);
+    AtkObject* atkObj = AccessibleWrap::GetAtkObject(anchor);
     //no need to add ref it, because it is "get" not "ref"
     return atkObj;
 }
 
 gint
 getEndIndexCB(AtkHyperlink *aLink)
 {
-    nsAccessible* hyperlink = get_accessible_hyperlink(aLink);
+    Accessible* hyperlink = get_accessible_hyperlink(aLink);
     NS_ENSURE_TRUE(hyperlink, -1);
 
     return static_cast<gint>(hyperlink->EndOffset());
 }
 
 gint
 getStartIndexCB(AtkHyperlink *aLink)
 {
-    nsAccessible* hyperlink = get_accessible_hyperlink(aLink);
+    Accessible* hyperlink = get_accessible_hyperlink(aLink);
     NS_ENSURE_TRUE(hyperlink, -1);
 
     return static_cast<gint>(hyperlink->StartOffset());
 }
 
 gboolean
 isValidCB(AtkHyperlink *aLink)
 {
-    nsAccessible* hyperlink = get_accessible_hyperlink(aLink);
+    Accessible* hyperlink = get_accessible_hyperlink(aLink);
     NS_ENSURE_TRUE(hyperlink, FALSE);
 
     return static_cast<gboolean>(hyperlink->IsLinkValid());
 }
 
 gint
 getAnchorCountCB(AtkHyperlink *aLink)
 {
-    nsAccessible* hyperlink = get_accessible_hyperlink(aLink);
+    Accessible* hyperlink = get_accessible_hyperlink(aLink);
     NS_ENSURE_TRUE(hyperlink, -1);
 
     return static_cast<gint>(hyperlink->AnchorCount());
 }
 
 // Check if aHyperlink is a valid MaiHyperlink, and return the
 // HyperLinkAccessible related.
-nsAccessible*
+Accessible*
 get_accessible_hyperlink(AtkHyperlink *aHyperlink)
 {
     NS_ENSURE_TRUE(MAI_IS_ATK_HYPERLINK(aHyperlink), nsnull);
     MaiHyperlink * maiHyperlink =
         MAI_ATK_HYPERLINK(aHyperlink)->maiHyperlink;
     NS_ENSURE_TRUE(maiHyperlink != nsnull, nsnull);
     NS_ENSURE_TRUE(maiHyperlink->GetAtkHyperlink() == aHyperlink, nsnull);
     return maiHyperlink->GetAccHyperlink();

--- a/accessible/src/atk/nsMaiHyperlink.h
+++ b/accessible/src/atk/nsMaiHyperlink.h
@@ -3,35 +3,35 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef __MAI_HYPERLINK_H__
 #define __MAI_HYPERLINK_H__
 
 #include "nsMai.h"
-#include "nsAccessible.h"
+#include "Accessible.h"
 
 struct _AtkHyperlink;
 typedef struct _AtkHyperlink                      AtkHyperlink;
 
 /*
  * MaiHyperlink is a auxiliary class for MaiInterfaceHyperText.
  */
 
 class MaiHyperlink
 {
 public:
-    MaiHyperlink(nsAccessible* aHyperLink);
-    ~MaiHyperlink();
+  MaiHyperlink(Accessible* aHyperLink);
+  ~MaiHyperlink();
 
 public:
-    AtkHyperlink *GetAtkHyperlink(void);
-  nsAccessible* GetAccHyperlink()
-  { return mHyperlink && mHyperlink->IsLink() ? mHyperlink : nsnull; }
+  AtkHyperlink *GetAtkHyperlink(void);
+  Accessible* GetAccHyperlink()
+    { return mHyperlink && mHyperlink->IsLink() ? mHyperlink : nsnull; }
 
 protected:
-    nsAccessible* mHyperlink;
-    AtkHyperlink *mMaiAtkHyperlink;
+  Accessible* mHyperlink;
+  AtkHyperlink* mMaiAtkHyperlink;
 public:
-    static nsresult Initialize(AtkHyperlink *aObj, MaiHyperlink *aClass);
+  static nsresult Initialize(AtkHyperlink *aObj, MaiHyperlink *aClass);
 };
 #endif /* __MAI_HYPERLINK_H__ */

--- a/accessible/src/atk/nsMaiInterfaceAction.cpp
+++ b/accessible/src/atk/nsMaiInterfaceAction.cpp
@@ -14,73 +14,73 @@
 
 using namespace mozilla::a11y;
 
 extern "C" {
 
 static gboolean
 doActionCB(AtkAction *aAction, gint aActionIndex)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aAction));
-    if (!accWrap)
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aAction));
+  if (!accWrap)
+    return FALSE;
  
-    nsresult rv = accWrap->DoAction(aActionIndex);
-    return (NS_FAILED(rv)) ? FALSE : TRUE;
+  nsresult rv = accWrap->DoAction(aActionIndex);
+  return (NS_FAILED(rv)) ? FALSE : TRUE;
 }
 
 static gint
 getActionCountCB(AtkAction *aAction)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aAction));
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aAction));
   return accWrap ? accWrap->ActionCount() : 0;
 }
 
 static const gchar*
 getActionDescriptionCB(AtkAction *aAction, gint aActionIndex)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aAction));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aAction));
+  if (!accWrap)
+    return nsnull;
 
-    nsAutoString description;
-    nsresult rv = accWrap->GetActionDescription(aActionIndex, description);
-    NS_ENSURE_SUCCESS(rv, nsnull);
-    return nsAccessibleWrap::ReturnString(description);
+  nsAutoString description;
+  nsresult rv = accWrap->GetActionDescription(aActionIndex, description);
+  NS_ENSURE_SUCCESS(rv, nsnull);
+  return AccessibleWrap::ReturnString(description);
 }
 
 static const gchar*
 getActionNameCB(AtkAction *aAction, gint aActionIndex)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aAction));
+    AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aAction));
     if (!accWrap)
         return nsnull;
 
     nsAutoString autoStr;
     nsresult rv = accWrap->GetActionName(aActionIndex, autoStr);
     NS_ENSURE_SUCCESS(rv, nsnull);
-    return nsAccessibleWrap::ReturnString(autoStr);
+    return AccessibleWrap::ReturnString(autoStr);
 }
 
 static const gchar*
 getKeyBindingCB(AtkAction *aAction, gint aActionIndex)
 {
-  nsAccessibleWrap* acc = GetAccessibleWrap(ATK_OBJECT(aAction));
+  AccessibleWrap* acc = GetAccessibleWrap(ATK_OBJECT(aAction));
   if (!acc)
     return nsnull;
 
   // Return all key bindings including access key and keyboard shortcut.
   nsAutoString keyBindingsStr;
 
   // Get access key.
   KeyBinding keyBinding = acc->AccessKey();
   if (!keyBinding.IsEmpty()) {
     keyBinding.AppendToString(keyBindingsStr, KeyBinding::eAtkFormat);
 
-    nsAccessible* parent = acc->Parent();
+    Accessible* parent = acc->Parent();
     roles::Role role = parent ? parent->Role() : roles::NOTHING;
     if (role == roles::PARENT_MENUITEM || role == roles::MENUITEM ||
         role == roles::RADIO_MENU_ITEM || role == roles::CHECK_MENU_ITEM) {
       // It is submenu, expose keyboard shortcuts from menu hierarchy like
       // "s;<Alt>f:s"
       nsAutoString keysInHierarchyStr = keyBindingsStr;
       do {
         KeyBinding parentKeyBinding = parent->AccessKey();
@@ -103,17 +103,17 @@ getKeyBindingCB(AtkAction *aAction, gint
 
   // Get keyboard shortcut.
   keyBindingsStr.Append(';');
   keyBinding = acc->KeyboardShortcut();
   if (!keyBinding.IsEmpty()) {
     keyBinding.AppendToString(keyBindingsStr, KeyBinding::eAtkFormat);
   }
 
-  return nsAccessibleWrap::ReturnString(keyBindingsStr);
+  return AccessibleWrap::ReturnString(keyBindingsStr);
 }
 }
 
 void
 actionInterfaceInitCB(AtkActionIface* aIface)
 {
   NS_ASSERTION(aIface, "Invalid aIface");
   if (NS_UNLIKELY(!aIface))

--- a/accessible/src/atk/nsMaiInterfaceComponent.cpp
+++ b/accessible/src/atk/nsMaiInterfaceComponent.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "nsAccessibleWrap.h"
+#include "AccessibleWrap.h"
 #include "nsAccUtils.h"
 #include "nsCoreUtils.h"
 #include "nsMai.h"
 
 extern "C" {
 
 static AtkObject*
 refAccessibleAtPointCB(AtkComponent* aComponent, gint aAccX, gint aAccY,
@@ -27,53 +27,53 @@ getExtentsCB(AtkComponent* aComponent, g
 {
   getExtentsHelper(GetAccessibleWrap(ATK_OBJECT(aComponent)),
                    aX, aY, aWidth, aHeight, aCoordType);
 }
 
 static gboolean
 grabFocusCB(AtkComponent* aComponent)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aComponent));
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aComponent));
   if (!accWrap)
     return FALSE;
 
   nsresult rv = accWrap->TakeFocus();
   return (NS_FAILED(rv)) ? FALSE : TRUE;
 }
 }
 
 AtkObject*
-refAccessibleAtPointHelper(nsAccessibleWrap* aAccWrap, gint aX, gint aY,
+refAccessibleAtPointHelper(AccessibleWrap* aAccWrap, gint aX, gint aY,
                            AtkCoordType aCoordType)
 {
   if (!aAccWrap || aAccWrap->IsDefunct() || nsAccUtils::MustPrune(aAccWrap))
     return nsnull;
 
-  // nsAccessible::ChildAtPoint(x,y) is in screen pixels.
+  // Accessible::ChildAtPoint(x,y) is in screen pixels.
   if (aCoordType == ATK_XY_WINDOW) {
     nsIntPoint winCoords =
       nsCoreUtils::GetScreenCoordsForWindow(aAccWrap->GetNode());
     aX += winCoords.x;
     aY += winCoords.y;
   }
 
-  nsAccessible* accAtPoint = aAccWrap->ChildAtPoint(aX, aY,
-                                                    nsAccessible::eDirectChild);
+  Accessible* accAtPoint = aAccWrap->ChildAtPoint(aX, aY,
+                                                  Accessible::eDirectChild);
   if (!accAtPoint)
     return nsnull;
 
-  AtkObject* atkObj = nsAccessibleWrap::GetAtkObject(accAtPoint);
+  AtkObject* atkObj = AccessibleWrap::GetAtkObject(accAtPoint);
   if (atkObj)
     g_object_ref(atkObj);
   return atkObj;
 }
 
 void
-getExtentsHelper(nsAccessibleWrap* aAccWrap,
+getExtentsHelper(AccessibleWrap* aAccWrap,
                  gint* aX, gint* aY, gint* aWidth, gint* aHeight,
                  AtkCoordType aCoordType)
 {
   *aX = *aY = *aWidth = *aHeight = 0;
 
   if (!aAccWrap || aAccWrap->IsDefunct())
     return;
 

--- a/accessible/src/atk/nsMaiInterfaceDocument.cpp
+++ b/accessible/src/atk/nsMaiInterfaceDocument.cpp
@@ -1,17 +1,17 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "nsAccessibleWrap.h"
+#include "AccessibleWrap.h"
 #include "DocAccessible.h"
 #include "nsMai.h"
 
 static const char* const kDocTypeName = "W3C-doctype";
 static const char* const kDocUrlName = "DocURL";
 static const char* const kMimeTypeName = "MimeType";
 
 // below functions are vfuncs on an ATK  interface so they need to be C call
@@ -37,23 +37,23 @@ documentInterfaceInitCB(AtkDocumentIface
     aIface->get_document_attributes = getDocumentAttributesCB;
     aIface->get_document_attribute_value = getDocumentAttributeValueCB;
     aIface->get_document_locale = getDocumentLocaleCB;
 }
 
 const gchar *
 getDocumentLocaleCB(AtkDocument *aDocument)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aDocument));
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aDocument));
   if (!accWrap)
     return nsnull;
 
   nsAutoString locale;
   accWrap->Language(locale);
-  return locale.IsEmpty() ? nsnull : nsAccessibleWrap::ReturnString(locale);
+  return locale.IsEmpty() ? nsnull : AccessibleWrap::ReturnString(locale);
 }
 
 static inline GSList *
 prependToList(GSList *aList, const char *const aName, const nsAutoString &aValue)
 {
   if (aValue.IsEmpty())
     return aList;
 
@@ -62,17 +62,17 @@ prependToList(GSList *aList, const char 
     atkAttr->name = g_strdup(aName);
     atkAttr->value = g_strdup(NS_ConvertUTF16toUTF8(aValue).get());
     return g_slist_prepend(aList, atkAttr);
 }
 
 AtkAttributeSet *
 getDocumentAttributesCB(AtkDocument *aDocument)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aDocument));
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aDocument));
   if (!accWrap || !accWrap->IsDoc())
     return nsnull;
 
   // according to atkobject.h, AtkAttributeSet is a GSList
   GSList* attributes = nsnull;
   DocAccessible* document = accWrap->AsDoc();
   nsAutoString aURL;
   nsresult rv = document->GetURL(aURL);
@@ -91,28 +91,28 @@ getDocumentAttributesCB(AtkDocument *aDo
 
   return attributes;
 }
 
 const gchar *
 getDocumentAttributeValueCB(AtkDocument *aDocument,
                             const gchar *aAttrName)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aDocument));
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aDocument));
   if (!accWrap || !accWrap->IsDoc())
     return nsnull;
 
   DocAccessible* document = accWrap->AsDoc();
   nsresult rv;
   nsAutoString attrValue;
   if (!strcasecmp(aAttrName, kDocTypeName))
     rv = document->GetDocType(attrValue);
   else if (!strcasecmp(aAttrName, kDocUrlName))
     rv = document->GetURL(attrValue);
   else if (!strcasecmp(aAttrName, kMimeTypeName))
     rv = document->GetMimeType(attrValue);
   else
     return nsnull;
 
   NS_ENSURE_SUCCESS(rv, nsnull);
-  return attrValue.IsEmpty() ? nsnull : nsAccessibleWrap::ReturnString(attrValue);
+  return attrValue.IsEmpty() ? nsnull : AccessibleWrap::ReturnString(attrValue);
 }
 }

--- a/accessible/src/atk/nsMaiInterfaceEditableText.cpp
+++ b/accessible/src/atk/nsMaiInterfaceEditableText.cpp
@@ -12,19 +12,19 @@
 #include "nsString.h"
 
 extern "C" {
 
 static gboolean
 setRunAttributesCB(AtkEditableText *aText, AtkAttributeSet *aAttribSet,
                    gint aStartOffset, gint aEndOffset)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return FALSE;
 
     nsCOMPtr<nsIAccessibleEditableText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleEditableText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, FALSE);
 
     nsCOMPtr<nsISupports> attrSet;
     /* how to insert attributes into nsISupports ??? */
@@ -32,19 +32,19 @@ setRunAttributesCB(AtkEditableText *aTex
     nsresult rv = accText->SetAttributes(aStartOffset, aEndOffset,
                                          attrSet);
     return NS_FAILED(rv) ? FALSE : TRUE;
 }
 
 static void
 setTextContentsCB(AtkEditableText *aText, const gchar *aString)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return;
 
     nsCOMPtr<nsIAccessibleEditableText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleEditableText),
                             getter_AddRefs(accText));
     if (!accText)
         return;
 
     MAI_LOG_DEBUG(("EditableText: setTextContentsCB, aString=%s", aString));
@@ -52,19 +52,19 @@ setTextContentsCB(AtkEditableText *aText
     NS_ConvertUTF8toUTF16 strContent(aString);
     accText->SetTextContents(strContent);
 }
 
 static void
 insertTextCB(AtkEditableText *aText,
              const gchar *aString, gint aLength, gint *aPosition)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return;
 
     nsCOMPtr<nsIAccessibleEditableText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleEditableText),
                             getter_AddRefs(accText));
     if (!accText)
         return;
 
     NS_ConvertUTF8toUTF16 strContent(aString, aLength);
@@ -79,72 +79,72 @@ insertTextCB(AtkEditableText *aText,
 
     MAI_LOG_DEBUG(("EditableText: insert aString=%s, aLength=%d, aPosition=%d",
                    aString, aLength, *aPosition));
 }
 
 static void
 copyTextCB(AtkEditableText *aText, gint aStartPos, gint aEndPos)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return;
 
     nsCOMPtr<nsIAccessibleEditableText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleEditableText),
                             getter_AddRefs(accText));
     if (!accText)
         return;
 
     MAI_LOG_DEBUG(("EditableText: copyTextCB, aStartPos=%d, aEndPos=%d",
                    aStartPos, aEndPos));
     accText->CopyText(aStartPos, aEndPos);
 }
 
 static void
 cutTextCB(AtkEditableText *aText, gint aStartPos, gint aEndPos)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return;
 
     nsCOMPtr<nsIAccessibleEditableText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleEditableText),
                             getter_AddRefs(accText));
     if (!accText)
         return;
     MAI_LOG_DEBUG(("EditableText: cutTextCB, aStartPos=%d, aEndPos=%d",
                    aStartPos, aEndPos));
     accText->CutText(aStartPos, aEndPos);
 }
 
 static void
 deleteTextCB(AtkEditableText *aText, gint aStartPos, gint aEndPos)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return;
 
     nsCOMPtr<nsIAccessibleEditableText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleEditableText),
                             getter_AddRefs(accText));
     if (!accText)
         return;
 
     MAI_LOG_DEBUG(("EditableText: deleteTextCB, aStartPos=%d, aEndPos=%d",
                    aStartPos, aEndPos));
     accText->DeleteText(aStartPos, aEndPos);
 }
 
 static void
 pasteTextCB(AtkEditableText *aText, gint aPosition)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return;
 
     nsCOMPtr<nsIAccessibleEditableText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleEditableText),
                             getter_AddRefs(accText));
     if (!accText)
         return;
 
     MAI_LOG_DEBUG(("EditableText: pasteTextCB, aPosition=%d", aPosition));

--- a/accessible/src/atk/nsMaiInterfaceHyperlinkImpl.cpp
+++ b/accessible/src/atk/nsMaiInterfaceHyperlinkImpl.cpp
@@ -7,17 +7,17 @@
 #include "InterfaceInitFuncs.h"
 
 #include "nsMaiHyperlink.h"
 
 extern "C" {
 static AtkHyperlink*
 getHyperlinkCB(AtkHyperlinkImpl* aImpl)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aImpl));
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aImpl));
   if (!accWrap)
     return nsnull;
 
   NS_ENSURE_TRUE(accWrap->IsLink(), nsnull);
 
   MaiHyperlink* maiHyperlink = accWrap->GetMaiHyperlink();
   NS_ENSURE_TRUE(maiHyperlink, nsnull);
   return maiHyperlink->GetAtkHyperlink();

--- a/accessible/src/atk/nsMaiInterfaceHypertext.cpp
+++ b/accessible/src/atk/nsMaiInterfaceHypertext.cpp
@@ -10,64 +10,64 @@
 #include "nsMai.h"
 #include "nsMaiHyperlink.h"
 
 extern "C" {
 
 static AtkHyperlink*
 getLinkCB(AtkHypertext *aText, gint aLinkIndex)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return nsnull;
 
-    nsHyperTextAccessible* hyperText = accWrap->AsHyperText();
-    NS_ENSURE_TRUE(hyperText, nsnull);
+  nsHyperTextAccessible* hyperText = accWrap->AsHyperText();
+  NS_ENSURE_TRUE(hyperText, nsnull);
 
-    nsAccessible* hyperLink = hyperText->GetLinkAt(aLinkIndex);
-    if (!hyperLink)
-        return nsnull;
+  Accessible* hyperLink = hyperText->GetLinkAt(aLinkIndex);
+  if (!hyperLink)
+    return nsnull;
 
-    AtkObject* hyperLinkAtkObj = nsAccessibleWrap::GetAtkObject(hyperLink);
-    nsAccessibleWrap *accChild = GetAccessibleWrap(hyperLinkAtkObj);
-    NS_ENSURE_TRUE(accChild, nsnull);
+  AtkObject* hyperLinkAtkObj = AccessibleWrap::GetAtkObject(hyperLink);
+  AccessibleWrap* accChild = GetAccessibleWrap(hyperLinkAtkObj);
+  NS_ENSURE_TRUE(accChild, nsnull);
 
-    MaiHyperlink *maiHyperlink = accChild->GetMaiHyperlink();
-    NS_ENSURE_TRUE(maiHyperlink, nsnull);
-    return maiHyperlink->GetAtkHyperlink();
+  MaiHyperlink *maiHyperlink = accChild->GetMaiHyperlink();
+  NS_ENSURE_TRUE(maiHyperlink, nsnull);
+  return maiHyperlink->GetAtkHyperlink();
 }
 
 static gint
 getLinkCountCB(AtkHypertext *aText)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return -1;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return -1;
 
-    nsHyperTextAccessible* hyperText = accWrap->AsHyperText();
-    NS_ENSURE_TRUE(hyperText, -1);
+  nsHyperTextAccessible* hyperText = accWrap->AsHyperText();
+  NS_ENSURE_TRUE(hyperText, -1);
 
-    return hyperText->GetLinkCount();
+  return hyperText->GetLinkCount();
 }
 
 static gint
 getLinkIndexCB(AtkHypertext *aText, gint aCharIndex)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return -1;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return -1;
 
-    nsHyperTextAccessible* hyperText = accWrap->AsHyperText();
-    NS_ENSURE_TRUE(hyperText, -1);
+  nsHyperTextAccessible* hyperText = accWrap->AsHyperText();
+  NS_ENSURE_TRUE(hyperText, -1);
 
-    PRInt32 index = -1;
-    nsresult rv = hyperText->GetLinkIndexAtOffset(aCharIndex, &index);
-    NS_ENSURE_SUCCESS(rv, -1);
+  PRInt32 index = -1;
+  nsresult rv = hyperText->GetLinkIndexAtOffset(aCharIndex, &index);
+  NS_ENSURE_SUCCESS(rv, -1);
 
-    return index;
+  return index;
 }
 }
 
 void
 hypertextInterfaceInitCB(AtkHypertextIface* aIface)
 {
   NS_ASSERTION(aIface, "no interface!");
   if (NS_UNLIKELY(!aIface))

--- a/accessible/src/atk/nsMaiInterfaceImage.cpp
+++ b/accessible/src/atk/nsMaiInterfaceImage.cpp
@@ -1,28 +1,28 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "nsAccessibleWrap.h"
+#include "AccessibleWrap.h"
 #include "nsHTMLImageAccessible.h"
 #include "nsMai.h"
 
 extern "C" {
 const gchar* getDescriptionCB(AtkObject* aAtkObj);
 
 static void
 getImagePositionCB(AtkImage* aImage, gint* aAccX, gint* aAccY,
                    AtkCoordType aCoordType)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aImage));
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aImage));
   if (!accWrap || !accWrap->IsImage())
     return;
 
   nsHTMLImageAccessible* image = accWrap->AsImage();
   PRUint32 geckoCoordType = (aCoordType == ATK_XY_WINDOW) ?
     nsIAccessibleCoordinateType::COORDTYPE_WINDOW_RELATIVE :
     nsIAccessibleCoordinateType::COORDTYPE_SCREEN_RELATIVE;
   // Returned in screen coordinates
@@ -33,17 +33,17 @@ static const gchar*
 getImageDescriptionCB(AtkImage* aImage)
 {
   return getDescriptionCB(ATK_OBJECT(aImage));
 }
 
 static void
 getImageSizeCB(AtkImage* aImage, gint* aAccWidth, gint* aAccHeight)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aImage));
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aImage));
   if (!accWrap || !accWrap->IsImage())
     return;
 
   accWrap->AsImage()->GetImageSize(aAccWidth, aAccHeight);
 }
 }
 
 void

--- a/accessible/src/atk/nsMaiInterfaceSelection.cpp
+++ b/accessible/src/atk/nsMaiInterfaceSelection.cpp
@@ -1,99 +1,99 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "nsAccessibleWrap.h"
+#include "AccessibleWrap.h"
 #include "nsMai.h"
 
 #include <atk/atk.h>
 
 extern "C" {
 
 static gboolean
 addSelectionCB(AtkSelection *aSelection, gint i)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
-    if (!accWrap || !accWrap->IsSelect())
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
+  if (!accWrap || !accWrap->IsSelect())
+    return FALSE;
 
-    return accWrap->AddItemToSelection(i);
+  return accWrap->AddItemToSelection(i);
 }
 
 static gboolean
 clearSelectionCB(AtkSelection *aSelection)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
-    if (!accWrap || !accWrap->IsSelect())
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
+  if (!accWrap || !accWrap->IsSelect())
+    return FALSE;
 
-    return accWrap->UnselectAll();
+  return accWrap->UnselectAll();
 }
 
 static AtkObject*
 refSelectionCB(AtkSelection *aSelection, gint i)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
-    if (!accWrap || !accWrap->IsSelect())
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
+  if (!accWrap || !accWrap->IsSelect())
+    return nsnull;
 
-    nsAccessible* selectedItem = accWrap->GetSelectedItem(i);
-    if (!selectedItem)
-        return nsnull;
+  Accessible* selectedItem = accWrap->GetSelectedItem(i);
+  if (!selectedItem)
+    return nsnull;
 
-    AtkObject* atkObj = nsAccessibleWrap::GetAtkObject(selectedItem);
-    if (atkObj) {
-        g_object_ref(atkObj);
-    }
-    return atkObj;
+  AtkObject* atkObj = AccessibleWrap::GetAtkObject(selectedItem);
+  if (atkObj)
+    g_object_ref(atkObj);
+
+  return atkObj;
 }
 
 static gint
 getSelectionCountCB(AtkSelection *aSelection)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
-    if (!accWrap || !accWrap->IsSelect())
-        return -1;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
+  if (!accWrap || !accWrap->IsSelect())
+    return -1;
 
-    return accWrap->SelectedItemCount();
+  return accWrap->SelectedItemCount();
 }
 
 static gboolean
 isChildSelectedCB(AtkSelection *aSelection, gint i)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
-    if (!accWrap || !accWrap->IsSelect())
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
+  if (!accWrap || !accWrap->IsSelect())
+    return FALSE;
 
-    return accWrap->IsItemSelected(i);
+  return accWrap->IsItemSelected(i);
 }
 
 static gboolean
 removeSelectionCB(AtkSelection *aSelection, gint i)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
-    if (!accWrap || !accWrap->IsSelect())
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
+  if (!accWrap || !accWrap->IsSelect())
+    return FALSE;
 
-    return accWrap->RemoveItemFromSelection(i);
+  return accWrap->RemoveItemFromSelection(i);
 }
 
 static gboolean
 selectAllSelectionCB(AtkSelection *aSelection)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
-    if (!accWrap || !accWrap->IsSelect())
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aSelection));
+  if (!accWrap || !accWrap->IsSelect())
+    return FALSE;
 
-    return accWrap->SelectAll();
+  return accWrap->SelectAll();
 }
 }
 
 void
 selectionInterfaceInitCB(AtkSelectionIface* aIface)
 {
   NS_ASSERTION(aIface, "Invalid aIface");
   if (NS_UNLIKELY(!aIface))

--- a/accessible/src/atk/nsMaiInterfaceTable.cpp
+++ b/accessible/src/atk/nsMaiInterfaceTable.cpp
@@ -1,127 +1,127 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "nsAccessibleWrap.h"
+#include "AccessibleWrap.h"
 #include "nsAccUtils.h"
 #include "nsIAccessibleTable.h"
 #include "TableAccessible.h"
 #include "nsMai.h"
 
 #include "nsArrayUtils.h"
 
 using namespace mozilla::a11y;
 
 extern "C" {
 static AtkObject*
 refAtCB(AtkTable *aTable, gint aRow, gint aColumn)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, nsnull);
 
     nsCOMPtr<nsIAccessible> cell;
     nsresult rv = accTable->GetCellAt(aRow, aColumn,getter_AddRefs(cell));
     if (NS_FAILED(rv) || !cell)
         return nsnull;
 
-    AtkObject *cellAtkObj = nsAccessibleWrap::GetAtkObject(cell);
+    AtkObject* cellAtkObj = AccessibleWrap::GetAtkObject(cell);
     if (cellAtkObj) {
         g_object_ref(cellAtkObj);
     }
     return cellAtkObj;
 }
 
 static gint
 getIndexAtCB(AtkTable* aTable, gint aRow, gint aColumn)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
   if (!accWrap)
     return -1;
 
   TableAccessible* table = accWrap->AsTable();
   NS_ENSURE_TRUE(table, -1);
 
   return static_cast<gint>(table->CellIndexAt(aRow, aColumn));
 }
 
 static gint
 getColumnAtIndexCB(AtkTable *aTable, gint aIndex)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return -1;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return -1;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, -1);
 
     PRInt32 col;
     nsresult rv = accTable->GetColumnIndexAt(aIndex, &col);
     NS_ENSURE_SUCCESS(rv, -1);
 
     return static_cast<gint>(col);
 }
 
 static gint
 getRowAtIndexCB(AtkTable *aTable, gint aIndex)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return -1;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return -1;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, -1);
 
     PRInt32 row;
     nsresult rv = accTable->GetRowIndexAt(aIndex, &row);
     NS_ENSURE_SUCCESS(rv, -1);
 
     return static_cast<gint>(row);
 }
 
 static gint
 getColumnCountCB(AtkTable *aTable)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return -1;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return -1;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, -1);
 
     PRInt32 count;
     nsresult rv = accTable->GetColumnCount(&count);
     NS_ENSURE_SUCCESS(rv, -1);
 
     return static_cast<gint>(count);
 }
 
 static gint
 getRowCountCB(AtkTable *aTable)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return -1;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return -1;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, -1);
 
     PRInt32 count;
     nsresult rv = accTable->GetRowCount(&count);
@@ -129,19 +129,19 @@ getRowCountCB(AtkTable *aTable)
 
     return static_cast<gint>(count);
 }
 
 static gint
 getColumnExtentAtCB(AtkTable *aTable,
                     gint aRow, gint aColumn)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return -1;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return -1;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, -1);
 
     PRInt32 extent;
     nsresult rv = accTable->GetColumnExtentAt(aRow, aColumn, &extent);
@@ -149,184 +149,184 @@ getColumnExtentAtCB(AtkTable *aTable,
 
     return static_cast<gint>(extent);
 }
 
 static gint
 getRowExtentAtCB(AtkTable *aTable,
                  gint aRow, gint aColumn)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return -1;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return -1;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, -1);
 
     PRInt32 extent;
     nsresult rv = accTable->GetRowExtentAt(aRow, aColumn, &extent);
     NS_ENSURE_SUCCESS(rv, -1);
 
     return static_cast<gint>(extent);
 }
 
 static AtkObject*
 getCaptionCB(AtkTable* aTable)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
   if (!accWrap)
     return nsnull;
 
   TableAccessible* table = accWrap->AsTable();
   NS_ENSURE_TRUE(table, nsnull);
 
-  nsAccessible* caption = table->Caption();
-  return caption ? nsAccessibleWrap::GetAtkObject(caption) : nsnull;
+  Accessible* caption = table->Caption();
+  return caption ? AccessibleWrap::GetAtkObject(caption) : nsnull;
 }
 
 static const gchar*
 getColumnDescriptionCB(AtkTable *aTable, gint aColumn)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, nsnull);
 
     nsAutoString autoStr;
     nsresult rv = accTable->GetColumnDescription(aColumn, autoStr);
     NS_ENSURE_SUCCESS(rv, nsnull);
 
-    return nsAccessibleWrap::ReturnString(autoStr);
+    return AccessibleWrap::ReturnString(autoStr);
 }
 
 static AtkObject*
 getColumnHeaderCB(AtkTable *aTable, gint aColumn)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, nsnull);
 
     nsCOMPtr<nsIAccessible> accCell;
     accTable->GetCellAt(0, aColumn, getter_AddRefs(accCell));
     if (!accCell)
         return nsnull;
 
     // If the cell at the first row is column header then assume it is column
     // header for all rows,
     if (nsAccUtils::Role(accCell) == nsIAccessibleRole::ROLE_COLUMNHEADER)
-        return nsAccessibleWrap::GetAtkObject(accCell);
+        return AccessibleWrap::GetAtkObject(accCell);
 
     // otherwise get column header for the data cell at the first row.
     nsCOMPtr<nsIAccessibleTableCell> accTableCell =
         do_QueryInterface(accCell);
 
     if (accTableCell) {
         nsCOMPtr<nsIArray> headerCells;
         accTableCell->GetColumnHeaderCells(getter_AddRefs(headerCells));
         if (headerCells) {
             nsresult rv;
             nsCOMPtr<nsIAccessible> accHeaderCell =
                 do_QueryElementAt(headerCells, 0, &rv);
             NS_ENSURE_SUCCESS(rv, nsnull);
 
-            return nsAccessibleWrap::GetAtkObject(accHeaderCell);
+            return AccessibleWrap::GetAtkObject(accHeaderCell);
         }
     }
 
     return nsnull;
 }
 
 static const gchar*
 getRowDescriptionCB(AtkTable *aTable, gint aRow)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, nsnull);
 
     nsAutoString autoStr;
     nsresult rv = accTable->GetRowDescription(aRow, autoStr);
     NS_ENSURE_SUCCESS(rv, nsnull);
 
-    return nsAccessibleWrap::ReturnString(autoStr);
+    return AccessibleWrap::ReturnString(autoStr);
 }
 
 static AtkObject*
 getRowHeaderCB(AtkTable *aTable, gint aRow)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, nsnull);
 
     nsCOMPtr<nsIAccessible> accCell;
     accTable->GetCellAt(aRow, 0, getter_AddRefs(accCell));
     if (!accCell)
       return nsnull;
 
     // If the cell at the first column is row header then assume it is row
     // header for all columns,
     if (nsAccUtils::Role(accCell) == nsIAccessibleRole::ROLE_ROWHEADER)
-        return nsAccessibleWrap::GetAtkObject(accCell);
+        return AccessibleWrap::GetAtkObject(accCell);
 
     // otherwise get row header for the data cell at the first column.
     nsCOMPtr<nsIAccessibleTableCell> accTableCell =
         do_QueryInterface(accCell);
 
     if (accTableCell) {
       nsCOMPtr<nsIArray> headerCells;
       accTableCell->GetRowHeaderCells(getter_AddRefs(headerCells));
       if (headerCells) {
         nsresult rv;
         nsCOMPtr<nsIAccessible> accHeaderCell =
             do_QueryElementAt(headerCells, 0, &rv);
         NS_ENSURE_SUCCESS(rv, nsnull);
 
-        return nsAccessibleWrap::GetAtkObject(accHeaderCell);
+        return AccessibleWrap::GetAtkObject(accHeaderCell);
       }
     }
 
     return nsnull;
 }
 
 static AtkObject*
 getSummaryCB(AtkTable *aTable)
 {
-    // Neither html:table nor xul:tree nor ARIA grid/tree have an ability to
-    // link an accessible object to specify a summary. There is closes method
-    // in nsIAccessibleTable::summary to get a summary as a string which is not
-    // mapped directly to ATK.
-    return nsnull;
+  // Neither html:table nor xul:tree nor ARIA grid/tree have an ability to
+  // link an accessible object to specify a summary. There is closes method
+  // in nsIAccessibleTable::summary to get a summary as a string which is not
+  // mapped directly to ATK.
+  return nsnull;
 }
 
 static gint
 getSelectedColumnsCB(AtkTable *aTable, gint **aSelected)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return 0;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return 0;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, 0);
 
     PRUint32 size = 0;
     PRInt32 *columns = NULL;
@@ -349,17 +349,17 @@ getSelectedColumnsCB(AtkTable *aTable, g
 
     *aSelected = atkColumns;
     return size;
 }
 
 static gint
 getSelectedRowsCB(AtkTable *aTable, gint **aSelected)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+    AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
     if (!accWrap)
         return 0;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, 0);
 
@@ -384,53 +384,53 @@ getSelectedRowsCB(AtkTable *aTable, gint
 
     *aSelected = atkRows;
     return size;
 }
 
 static gboolean
 isColumnSelectedCB(AtkTable *aTable, gint aColumn)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+    AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
     if (!accWrap)
         return FALSE;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, FALSE);
 
     bool outValue;
     nsresult rv = accTable->IsColumnSelected(aColumn, &outValue);
     return NS_FAILED(rv) ? FALSE : static_cast<gboolean>(outValue);
 }
 
 static gboolean
 isRowSelectedCB(AtkTable *aTable, gint aRow)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return FALSE;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, FALSE);
 
     bool outValue;
     nsresult rv = accTable->IsRowSelected(aRow, &outValue);
     return NS_FAILED(rv) ? FALSE : static_cast<gboolean>(outValue);
 }
 
 static gboolean
 isCellSelectedCB(AtkTable *aTable, gint aRow, gint aColumn)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
-    if (!accWrap)
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aTable));
+  if (!accWrap)
+    return FALSE;
 
     nsCOMPtr<nsIAccessibleTable> accTable;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleTable),
                             getter_AddRefs(accTable));
     NS_ENSURE_TRUE(accTable, FALSE);
 
     bool outValue;
     nsresult rv = accTable->IsCellSelected(aRow, aColumn, &outValue);

--- a/accessible/src/atk/nsMaiInterfaceText.cpp
+++ b/accessible/src/atk/nsMaiInterfaceText.cpp
@@ -11,33 +11,33 @@
 
 #include "nsIPersistentProperties2.h"
 
 using namespace mozilla::a11y;
 
 AtkAttributeSet* ConvertToAtkAttributeSet(nsIPersistentProperties* aAttributes);
 
 static void
-ConvertTexttoAsterisks(nsAccessibleWrap* accWrap, nsAString& aString)
+ConvertTexttoAsterisks(AccessibleWrap* accWrap, nsAString& aString)
 {
   // convert each char to "*" when it's "password text" 
   if (accWrap->NativeRole() == roles::PASSWORD_TEXT) {
     for (PRUint32 i = 0; i < aString.Length(); i++)
       aString.Replace(i, 1, NS_LITERAL_STRING("*"));
   }
 }
 
 extern "C" {
 
 static gchar*
 getTextCB(AtkText *aText, gint aStartOffset, gint aEndOffset)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, nsnull);
 
     nsAutoString autoStr;
     nsresult rv = accText->GetText(aStartOffset, aEndOffset, autoStr);
@@ -50,19 +50,19 @@ getTextCB(AtkText *aText, gint aStartOff
     return (cautoStr.get()) ? g_strdup(cautoStr.get()) : nsnull;
 }
 
 static gchar*
 getTextAfterOffsetCB(AtkText *aText, gint aOffset,
                      AtkTextBoundary aBoundaryType,
                      gint *aStartOffset, gint *aEndOffset)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, nsnull);
 
     nsAutoString autoStr;
     PRInt32 startOffset = 0, endOffset = 0;
@@ -79,19 +79,19 @@ getTextAfterOffsetCB(AtkText *aText, gin
     return (cautoStr.get()) ? g_strdup(cautoStr.get()) : nsnull;
 }
 
 static gchar*
 getTextAtOffsetCB(AtkText *aText, gint aOffset,
                   AtkTextBoundary aBoundaryType,
                   gint *aStartOffset, gint *aEndOffset)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, nsnull);
 
     nsAutoString autoStr;
     PRInt32 startOffset = 0, endOffset = 0;
@@ -106,17 +106,17 @@ getTextAtOffsetCB(AtkText *aText, gint a
     ConvertTexttoAsterisks(accWrap, autoStr);
     NS_ConvertUTF16toUTF8 cautoStr(autoStr);
     return (cautoStr.get()) ? g_strdup(cautoStr.get()) : nsnull;
 }
 
 static gunichar
 getCharacterAtOffsetCB(AtkText* aText, gint aOffset)
 {
-  nsAccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
   if (!accWrap)
     return 0;
 
   nsCOMPtr<nsIAccessibleText> accText;
   accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                           getter_AddRefs(accText));
   NS_ENSURE_TRUE(accText, 0);
 
@@ -134,19 +134,19 @@ getCharacterAtOffsetCB(AtkText* aText, g
   return static_cast<gunichar>(uniChar);
 }
 
 static gchar*
 getTextBeforeOffsetCB(AtkText *aText, gint aOffset,
                       AtkTextBoundary aBoundaryType,
                       gint *aStartOffset, gint *aEndOffset)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, nsnull);
 
     nsAutoString autoStr;
     PRInt32 startOffset = 0, endOffset = 0;
@@ -161,41 +161,41 @@ getTextBeforeOffsetCB(AtkText *aText, gi
     ConvertTexttoAsterisks(accWrap, autoStr);
     NS_ConvertUTF16toUTF8 cautoStr(autoStr);
     return (cautoStr.get()) ? g_strdup(cautoStr.get()) : nsnull;
 }
 
 static gint
 getCaretOffsetCB(AtkText *aText)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return 0;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return 0;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, 0);
 
     PRInt32 offset;
     nsresult rv = accText->GetCaretOffset(&offset);
     return (NS_FAILED(rv)) ? 0 : static_cast<gint>(offset);
 }
 
 static AtkAttributeSet*
 getRunAttributesCB(AtkText *aText, gint aOffset,
                    gint *aStartOffset,
                    gint *aEndOffset)
 {
-    *aStartOffset = -1;
-    *aEndOffset = -1;
+  *aStartOffset = -1;
+  *aEndOffset = -1;
 
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, nsnull);
 
     nsCOMPtr<nsIPersistentProperties> attributes;
     PRInt32 startOffset = 0, endOffset = 0;
@@ -208,19 +208,19 @@ getRunAttributesCB(AtkText *aText, gint 
     *aEndOffset = endOffset;
 
     return ConvertToAtkAttributeSet(attributes);
 }
 
 static AtkAttributeSet*
 getDefaultAttributesCB(AtkText *aText)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, nsnull);
 
     nsCOMPtr<nsIPersistentProperties> attributes;
     nsresult rv = accText->GetDefaultTextAttributes(getter_AddRefs(attributes));
@@ -231,19 +231,19 @@ getDefaultAttributesCB(AtkText *aText)
 }
 
 static void
 getCharacterExtentsCB(AtkText *aText, gint aOffset,
                       gint *aX, gint *aY,
                       gint *aWidth, gint *aHeight,
                       AtkCoordType aCoords)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if(!accWrap || !aX || !aY || !aWidth || !aHeight)
-        return;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if(!accWrap || !aX || !aY || !aWidth || !aHeight)
+    return;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     if (!accText)
         return;
 
     PRInt32 extY = 0, extX = 0;
@@ -268,19 +268,19 @@ getCharacterExtentsCB(AtkText *aText, gi
     NS_ASSERTION(NS_SUCCEEDED(rv),
                  "MaiInterfaceText::GetCharacterExtents, failed\n");
 }
 
 static void
 getRangeExtentsCB(AtkText *aText, gint aStartOffset, gint aEndOffset,
                   AtkCoordType aCoords, AtkTextRectangle *aRect)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if(!accWrap || !aRect)
-        return;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if(!accWrap || !aRect)
+    return;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     if (!accText)
         return;
 
     PRInt32 extY = 0, extX = 0;
@@ -305,33 +305,33 @@ getRangeExtentsCB(AtkText *aText, gint a
     aRect->height = extHeight;
     NS_ASSERTION(NS_SUCCEEDED(rv),
                  "MaiInterfaceText::GetRangeExtents, failed\n");
 }
 
 static gint
 getCharacterCountCB(AtkText *aText)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return 0;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return 0;
 
-    nsHyperTextAccessible* textAcc = accWrap->AsHyperText();
-    return textAcc->IsDefunct() ?
-        0 : static_cast<gint>(textAcc->CharacterCount());
+  nsHyperTextAccessible* textAcc = accWrap->AsHyperText();
+  return textAcc->IsDefunct() ?
+    0 : static_cast<gint>(textAcc->CharacterCount());
 }
 
 static gint
 getOffsetAtPointCB(AtkText *aText,
                    gint aX, gint aY,
                    AtkCoordType aCoords)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return -1;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return -1;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, -1);
 
     PRInt32 offset = 0;
     PRUint32 geckoCoordType;
@@ -342,38 +342,38 @@ getOffsetAtPointCB(AtkText *aText,
 
     accText->GetOffsetAtPoint(aX, aY, geckoCoordType, &offset);
     return static_cast<gint>(offset);
 }
 
 static gint
 getTextSelectionCountCB(AtkText *aText)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, nsnull);
 
     PRInt32 selectionCount;
     nsresult rv = accText->GetSelectionCount(&selectionCount);
  
     return NS_FAILED(rv) ? 0 : selectionCount;
 }
 
 static gchar*
 getTextSelectionCB(AtkText *aText, gint aSelectionNum,
                    gint *aStartOffset, gint *aEndOffset)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return nsnull;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return nsnull;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, nsnull);
 
     PRInt32 startOffset = 0, endOffset = 0;
     nsresult rv = accText->GetSelectionBounds(aSelectionNum,
@@ -388,72 +388,72 @@ getTextSelectionCB(AtkText *aText, gint 
 }
 
 // set methods
 static gboolean
 addTextSelectionCB(AtkText *aText,
                    gint aStartOffset,
                    gint aEndOffset)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return FALSE;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, FALSE);
 
     nsresult rv = accText->AddSelection(aStartOffset, aEndOffset);
 
     return NS_SUCCEEDED(rv) ? TRUE : FALSE;
 }
 
 static gboolean
 removeTextSelectionCB(AtkText *aText,
                       gint aSelectionNum)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return FALSE;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, FALSE);
 
     nsresult rv = accText->RemoveSelection(aSelectionNum);
 
     return NS_SUCCEEDED(rv) ? TRUE : FALSE;
 }
 
 static gboolean
 setTextSelectionCB(AtkText *aText, gint aSelectionNum,
                    gint aStartOffset, gint aEndOffset)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return FALSE;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, FALSE);
 
     nsresult rv = accText->SetSelectionBounds(aSelectionNum,
                                               aStartOffset, aEndOffset);
     return NS_SUCCEEDED(rv) ? TRUE : FALSE;
 }
 
 static gboolean
 setCaretOffsetCB(AtkText *aText, gint aOffset)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
-    if (!accWrap)
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(aText));
+  if (!accWrap)
+    return FALSE;
 
     nsCOMPtr<nsIAccessibleText> accText;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleText),
                             getter_AddRefs(accText));
     NS_ENSURE_TRUE(accText, FALSE);
 
     nsresult rv = accText->SetCaretOffset(aOffset);
     return NS_SUCCEEDED(rv) ? TRUE : FALSE;

--- a/accessible/src/atk/nsMaiInterfaceValue.cpp
+++ b/accessible/src/atk/nsMaiInterfaceValue.cpp
@@ -1,27 +1,27 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "InterfaceInitFuncs.h"
 
-#include "nsAccessibleWrap.h"
+#include "AccessibleWrap.h"
 #include "nsMai.h"
 
 extern "C" {
 
 static void
 getCurrentValueCB(AtkValue *obj, GValue *value)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
-    if (!accWrap)
-        return;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
+  if (!accWrap)
+    return;
 
     nsCOMPtr<nsIAccessibleValue> accValue;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleValue),
                             getter_AddRefs(accValue));
     if (!accValue)
         return;
 
     memset (value,  0, sizeof (GValue));
@@ -30,19 +30,19 @@ getCurrentValueCB(AtkValue *obj, GValue 
         return;
     g_value_init (value, G_TYPE_DOUBLE);
     g_value_set_double (value, accDouble);
 }
 
 static void
 getMaximumValueCB(AtkValue *obj, GValue *value)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
-    if (!accWrap)
-        return;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
+  if (!accWrap)
+    return;
 
     nsCOMPtr<nsIAccessibleValue> accValue;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleValue),
                             getter_AddRefs(accValue));
     if (!accValue)
         return;
 
     memset (value,  0, sizeof (GValue));
@@ -51,19 +51,19 @@ getMaximumValueCB(AtkValue *obj, GValue 
         return;
     g_value_init (value, G_TYPE_DOUBLE);
     g_value_set_double (value, accDouble);
 }
 
 static void
 getMinimumValueCB(AtkValue *obj, GValue *value)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
-    if (!accWrap)
-        return;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
+  if (!accWrap)
+    return;
 
     nsCOMPtr<nsIAccessibleValue> accValue;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleValue),
                             getter_AddRefs(accValue));
     if (!accValue)
         return;
 
     memset (value,  0, sizeof (GValue));
@@ -72,19 +72,19 @@ getMinimumValueCB(AtkValue *obj, GValue 
         return;
     g_value_init (value, G_TYPE_DOUBLE);
     g_value_set_double (value, accDouble);
 }
 
 static void
 getMinimumIncrementCB(AtkValue *obj, GValue *minimumIncrement)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
-    if (!accWrap)
-        return;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
+  if (!accWrap)
+    return;
 
     nsCOMPtr<nsIAccessibleValue> accValue;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleValue),
                             getter_AddRefs(accValue));
     if (!accValue)
         return;
 
     memset (minimumIncrement,  0, sizeof (GValue));
@@ -93,19 +93,19 @@ getMinimumIncrementCB(AtkValue *obj, GVa
         return;
     g_value_init (minimumIncrement, G_TYPE_DOUBLE);
     g_value_set_double (minimumIncrement, accDouble);
 }
 
 static gboolean
 setCurrentValueCB(AtkValue *obj, const GValue *value)
 {
-    nsAccessibleWrap *accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
-    if (!accWrap)
-        return FALSE;
+  AccessibleWrap* accWrap = GetAccessibleWrap(ATK_OBJECT(obj));
+  if (!accWrap)
+    return FALSE;
 
     nsCOMPtr<nsIAccessibleValue> accValue;
     accWrap->QueryInterface(NS_GET_IID(nsIAccessibleValue),
                             getter_AddRefs(accValue));
     NS_ENSURE_TRUE(accValue, FALSE);
 
     double accDouble =g_value_get_double (value);
     return !NS_FAILED(accValue->SetCurrentValue(accDouble));

--- a/accessible/src/atk/nsStateMap.h
+++ b/accessible/src/atk/nsStateMap.h
@@ -1,16 +1,16 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include <atk/atk.h>
-#include "nsAccessibleWrap.h"
+#include "AccessibleWrap.h"
 
 /******************************************************************************
 The following nsIAccessible 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.

--- a/accessible/src/base/AccCollector.cpp
+++ b/accessible/src/base/AccCollector.cpp
@@ -1,114 +1,114 @@
 /* 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 "AccCollector.h"
 
-#include "nsAccessible.h"
+#include "Accessible.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsAccCollector
 ////////////////////////////////////////////////////////////////////////////////
 
 AccCollector::
-  AccCollector(nsAccessible* aRoot, filters::FilterFuncPtr aFilterFunc) :
+  AccCollector(Accessible* aRoot, filters::FilterFuncPtr aFilterFunc) :
   mFilterFunc(aFilterFunc), mRoot(aRoot), mRootChildIdx(0)
 {
 }
 
 AccCollector::~AccCollector()
 {
 }
 
 PRUint32
 AccCollector::Count()
 {
   EnsureNGetIndex(nsnull);
   return mObjects.Length();
 }
 
-nsAccessible*
+Accessible*
 AccCollector::GetAccessibleAt(PRUint32 aIndex)
 {
-  nsAccessible *accessible = mObjects.SafeElementAt(aIndex, nsnull);
+  Accessible* accessible = mObjects.SafeElementAt(aIndex, nsnull);
   if (accessible)
     return accessible;
 
   return EnsureNGetObject(aIndex);
 }
 
 PRInt32
-AccCollector::GetIndexAt(nsAccessible *aAccessible)
+AccCollector::GetIndexAt(Accessible* aAccessible)
 {
   PRInt32 index = mObjects.IndexOf(aAccessible);
   if (index != -1)
     return index;
 
   return EnsureNGetIndex(aAccessible);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsAccCollector protected
 
-nsAccessible*
+Accessible*
 AccCollector::EnsureNGetObject(PRUint32 aIndex)
 {
   PRUint32 childCount = mRoot->ChildCount();
   while (mRootChildIdx < childCount) {
-    nsAccessible* child = mRoot->GetChildAt(mRootChildIdx++);
+    Accessible* child = mRoot->GetChildAt(mRootChildIdx++);
     if (!mFilterFunc(child))
       continue;
 
     AppendObject(child);
     if (mObjects.Length() - 1 == aIndex)
       return mObjects[aIndex];
   }
 
   return nsnull;
 }
 
 PRInt32
-AccCollector::EnsureNGetIndex(nsAccessible* aAccessible)
+AccCollector::EnsureNGetIndex(Accessible* aAccessible)
 {
   PRUint32 childCount = mRoot->ChildCount();
   while (mRootChildIdx < childCount) {
-    nsAccessible* child = mRoot->GetChildAt(mRootChildIdx++);
+    Accessible* child = mRoot->GetChildAt(mRootChildIdx++);
     if (!mFilterFunc(child))
       continue;
 
     AppendObject(child);
     if (child == aAccessible)
       return mObjects.Length() - 1;
   }
 
   return -1;
 }
 
 void
-AccCollector::AppendObject(nsAccessible* aAccessible)
+AccCollector::AppendObject(Accessible* aAccessible)
 {
   mObjects.AppendElement(aAccessible);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // EmbeddedObjCollector
 ////////////////////////////////////////////////////////////////////////////////
 
 PRInt32
-EmbeddedObjCollector::GetIndexAt(nsAccessible *aAccessible)
+EmbeddedObjCollector::GetIndexAt(Accessible* aAccessible)
 {
   if (aAccessible->mParent != mRoot)
     return -1;
 
   if (aAccessible->mIndexOfEmbeddedChild != -1)
     return aAccessible->mIndexOfEmbeddedChild;
 
   return mFilterFunc(aAccessible) ? EnsureNGetIndex(aAccessible) : -1;
 }
 
 void
-EmbeddedObjCollector::AppendObject(nsAccessible* aAccessible)
+EmbeddedObjCollector::AppendObject(Accessible* aAccessible)
 {
   aAccessible->mIndexOfEmbeddedChild = mObjects.Length();
   mObjects.AppendElement(aAccessible);
 }

--- a/accessible/src/base/AccCollector.h
+++ b/accessible/src/base/AccCollector.h
@@ -12,55 +12,55 @@
 
 /**
  * Collect accessible children complying with filter function. Provides quick
  * access to accessible by index.
  */
 class AccCollector
 {
 public:
-  AccCollector(nsAccessible* aRoot, filters::FilterFuncPtr aFilterFunc);
+  AccCollector(Accessible* aRoot, filters::FilterFuncPtr aFilterFunc);
   virtual ~AccCollector();
 
   /**
    * Return accessible count within the collection.
    */
   PRUint32 Count();
 
   /**
    * Return an accessible from the collection at the given index.
    */
-  nsAccessible* GetAccessibleAt(PRUint32 aIndex);
+  Accessible* GetAccessibleAt(PRUint32 aIndex);
 
   /**
    * Return index of the given accessible within the collection.
    */
-  virtual PRInt32 GetIndexAt(nsAccessible* aAccessible);
+  virtual PRInt32 GetIndexAt(Accessible* aAccessible);
 
 protected:
   /**
    * Ensure accessible at the given index is stored and return it.
    */
-  nsAccessible* EnsureNGetObject(PRUint32 aIndex);
+  Accessible* EnsureNGetObject(PRUint32 aIndex);
 
   /**
    * Ensure index for the given accessible is stored and return it.
    */
-  PRInt32 EnsureNGetIndex(nsAccessible* aAccessible);
+  PRInt32 EnsureNGetIndex(Accessible* aAccessible);
 
   /**
    * Append the object to collection.
    */
-  virtual void AppendObject(nsAccessible* aAccessible);
+  virtual void AppendObject(Accessible* aAccessible);
 
   filters::FilterFuncPtr mFilterFunc;
-  nsAccessible* mRoot;
+  Accessible* mRoot;
   PRUint32 mRootChildIdx;
 
-  nsTArray<nsAccessible*> mObjects;
+  nsTArray<Accessible*> mObjects;
 
 private:
   AccCollector();
   AccCollector(const AccCollector&);
   AccCollector& operator =(const AccCollector&);
 };
 
 /**
@@ -68,21 +68,21 @@ private:
  * vice versa.
  */
 class EmbeddedObjCollector : public AccCollector
 {
 public:
   virtual ~EmbeddedObjCollector() { };
 
 public:
-  virtual PRInt32 GetIndexAt(nsAccessible* aAccessible);
+  virtual PRInt32 GetIndexAt(Accessible* aAccessible);
 
 protected:
-  // Make sure it's used by nsAccessible class only.
-  EmbeddedObjCollector(nsAccessible* aRoot) :
+  // Make sure it's used by Accessible class only.
+  EmbeddedObjCollector(Accessible* aRoot) :
     AccCollector(aRoot, filters::GetEmbeddedObject) { }
 
-  virtual void AppendObject(nsAccessible* aAccessible);
+  virtual void AppendObject(Accessible* aAccessible);
 
-  friend class nsAccessible;
+  friend class Accessible;
 };
 
 #endif

--- a/accessible/src/base/AccEvent.cpp
+++ b/accessible/src/base/AccEvent.cpp
@@ -24,34 +24,34 @@ using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccEvent
 ////////////////////////////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccEvent constructors
 
-AccEvent::AccEvent(PRUint32 aEventType, nsAccessible* aAccessible,
+AccEvent::AccEvent(PRUint32 aEventType, Accessible* aAccessible,
                    EIsFromUserInput aIsFromUserInput, EEventRule aEventRule) :
   mEventType(aEventType), mEventRule(aEventRule), mAccessible(aAccessible)
 {
   CaptureIsFromUserInput(aIsFromUserInput);
 }
 
 AccEvent::AccEvent(PRUint32 aEventType, nsINode* aNode,
                    EIsFromUserInput aIsFromUserInput, EEventRule aEventRule) :
   mEventType(aEventType), mEventRule(aEventRule), mNode(aNode)
 {
   CaptureIsFromUserInput(aIsFromUserInput);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccEvent public methods
 
-nsAccessible *
+Accessible* 
 AccEvent::GetAccessible()
 {
   if (!mAccessible)
     mAccessible = GetAccessibleForNode();
 
   return mAccessible;
 }
 
@@ -100,17 +100,17 @@ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NATIVE
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 
 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(AccEvent, AddRef)
 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(AccEvent, Release)
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccEvent protected methods
 
-nsAccessible*
+Accessible*
 AccEvent::GetAccessibleForNode() const
 {
   if (mNode) {
     DocAccessible* document =
       GetAccService()->GetDocAccessible(mNode->OwnerDoc());
     if (document)
       return document->GetAccessible(mNode);
   }
@@ -163,17 +163,17 @@ AccEvent::CaptureIsFromUserInput(EIsFrom
 ////////////////////////////////////////////////////////////////////////////////
 // AccStateChangeEvent
 ////////////////////////////////////////////////////////////////////////////////
 
 // Note: we pass in eAllowDupes to the base class because we don't currently
 // support correct state change coalescence (XXX Bug 569356). Also we need to
 // decide how to coalesce events created via accessible (instead of node).
 AccStateChangeEvent::
-  AccStateChangeEvent(nsAccessible* aAccessible, PRUint64 aState,
+  AccStateChangeEvent(Accessible* aAccessible, PRUint64 aState,
                       bool aIsEnabled, EIsFromUserInput aIsFromUserInput):
   AccEvent(nsIAccessibleEvent::EVENT_STATE_CHANGE, aAccessible,
            aIsFromUserInput, eAllowDupes),
   mState(aState), mIsEnabled(aIsEnabled)
 {
 }
 
 AccStateChangeEvent::
@@ -188,17 +188,17 @@ AccStateChangeEvent::
   AccStateChangeEvent(nsINode* aNode, PRUint64 aState) :
   AccEvent(::nsIAccessibleEvent::EVENT_STATE_CHANGE, aNode,
            eAutoDetect, eAllowDupes),
   mState(aState)
 {
   // Use GetAccessibleForNode() because we do not want to store an accessible
   // since it leads to problems with delayed events in the case when
   // an accessible gets reorder event before delayed event is processed.
-  nsAccessible *accessible = GetAccessibleForNode();
+  Accessible* accessible = GetAccessibleForNode();
   mIsEnabled = accessible && ((accessible->State() & mState) != 0);
 }
 
 already_AddRefed<nsAccEvent>
 AccStateChangeEvent::CreateXPCOMObject()
 {
   nsAccEvent* event = new nsAccStateChangeEvent(this);
   NS_IF_ADDREF(event);
@@ -214,17 +214,17 @@ AccStateChangeEvent::CreateXPCOMObject()
 // events coalescence. We fire delayed text change events in DocAccessible but
 // we continue to base the event off the accessible object rather than just the
 // node. This means we won't try to create an accessible based on the node when
 // we are ready to fire the event and so we will no longer assert at that point
 // if the node was removed from the document. Either way, the AT won't work with
 // a defunct accessible so the behaviour should be equivalent.
 // XXX revisit this when coalescence is faster (eCoalesceFromSameSubtree)
 AccTextChangeEvent::
-  AccTextChangeEvent(nsAccessible* aAccessible, PRInt32 aStart,
+  AccTextChangeEvent(Accessible* aAccessible, PRInt32 aStart,
                      const nsAString& aModifiedText, bool aIsInserted,
                      EIsFromUserInput aIsFromUserInput)
   : AccEvent(aIsInserted ?
              static_cast<PRUint32>(nsIAccessibleEvent::EVENT_TEXT_INSERTED) :
              static_cast<PRUint32>(nsIAccessibleEvent::EVENT_TEXT_REMOVED),
              aAccessible, aIsFromUserInput, eAllowDupes)
   , mStart(aStart)
   , mIsInserted(aIsInserted)
@@ -245,30 +245,30 @@ AccTextChangeEvent::CreateXPCOMObject()
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccMutationEvent
 ////////////////////////////////////////////////////////////////////////////////
 
 AccMutationEvent::
-  AccMutationEvent(PRUint32 aEventType, nsAccessible* aTarget,
+  AccMutationEvent(PRUint32 aEventType, Accessible* aTarget,
                    nsINode* aTargetNode) :
   AccEvent(aEventType, aTarget, eAutoDetect, eCoalesceFromSameSubtree)
 {
   mNode = aTargetNode;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccHideEvent
 ////////////////////////////////////////////////////////////////////////////////
 
 AccHideEvent::
-  AccHideEvent(nsAccessible* aTarget, nsINode* aTargetNode) :
+  AccHideEvent(Accessible* aTarget, nsINode* aTargetNode) :
   AccMutationEvent(::nsIAccessibleEvent::EVENT_HIDE, aTarget, aTargetNode)
 {
   mParent = mAccessible->Parent();
   mNextSibling = mAccessible->NextSibling();
   mPrevSibling = mAccessible->PrevSibling();
 }
 
 already_AddRefed<nsAccEvent>
@@ -280,28 +280,28 @@ AccHideEvent::CreateXPCOMObject()
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccShowEvent
 ////////////////////////////////////////////////////////////////////////////////
 
 AccShowEvent::
-  AccShowEvent(nsAccessible* aTarget, nsINode* aTargetNode) :
+  AccShowEvent(Accessible* aTarget, nsINode* aTargetNode) :
   AccMutationEvent(::nsIAccessibleEvent::EVENT_SHOW, aTarget, aTargetNode)
 {
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccCaretMoveEvent
 ////////////////////////////////////////////////////////////////////////////////
 
 AccCaretMoveEvent::
-  AccCaretMoveEvent(nsAccessible* aAccessible, PRInt32 aCaretOffset) :
+  AccCaretMoveEvent(Accessible* aAccessible, PRInt32 aCaretOffset) :
   AccEvent(::nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED, aAccessible),
   mCaretOffset(aCaretOffset)
 {
 }
 
 AccCaretMoveEvent::
   AccCaretMoveEvent(nsINode* aNode) :
   AccEvent(::nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED, aNode),
@@ -318,17 +318,17 @@ AccCaretMoveEvent::CreateXPCOMObject()
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccSelChangeEvent
 ////////////////////////////////////////////////////////////////////////////////
 
 AccSelChangeEvent::
-  AccSelChangeEvent(nsAccessible* aWidget, nsAccessible* aItem,
+  AccSelChangeEvent(Accessible* aWidget, Accessible* aItem,
                     SelChangeType aSelChangeType) :
     AccEvent(0, aItem, eAutoDetect, eCoalesceSelectionChange),
     mWidget(aWidget), mItem(aItem), mSelChangeType(aSelChangeType),
     mPreceedingCount(0), mPackedEvent(nsnull)
 {
   if (aSelChangeType == eSelectionAdd) {
     if (mWidget->GetSelectedItem(1))
       mEventType = nsIAccessibleEvent::EVENT_SELECTION_ADD;
@@ -340,17 +340,17 @@ AccSelChangeEvent::
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccTableChangeEvent
 ////////////////////////////////////////////////////////////////////////////////
 
 AccTableChangeEvent::
-  AccTableChangeEvent(nsAccessible* aAccessible, PRUint32 aEventType,
+  AccTableChangeEvent(Accessible* aAccessible, PRUint32 aEventType,
                       PRInt32 aRowOrColIndex, PRInt32 aNumRowsOrCols) :
   AccEvent(aEventType, aAccessible),
   mRowOrColIndex(aRowOrColIndex), mNumRowsOrCols(aNumRowsOrCols)
 {
 }
 
 already_AddRefed<nsAccEvent>
 AccTableChangeEvent::CreateXPCOMObject()
@@ -361,17 +361,17 @@ AccTableChangeEvent::CreateXPCOMObject()
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccVCChangeEvent
 ////////////////////////////////////////////////////////////////////////////////
 
 AccVCChangeEvent::
-  AccVCChangeEvent(nsAccessible* aAccessible,
+  AccVCChangeEvent(Accessible* aAccessible,
                    nsIAccessible* aOldAccessible,
                    PRInt32 aOldStart, PRInt32 aOldEnd) :
     AccEvent(::nsIAccessibleEvent::EVENT_VIRTUALCURSOR_CHANGED, aAccessible),
     mOldAccessible(aOldAccessible), mOldStart(aOldStart), mOldEnd(aOldEnd)
 {
 }
 
 already_AddRefed<nsAccEvent>

--- a/accessible/src/base/AccEvent.h
+++ b/accessible/src/base/AccEvent.h
@@ -3,17 +3,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef _AccEvent_H_
 #define _AccEvent_H_
 
 #include "nsIAccessibleEvent.h"
 
-#include "nsAccessible.h"
+#include "Accessible.h"
 
 class nsAccEvent;
 class DocAccessible;
 
 // Constants used to point whether the event is from user input.
 enum EIsFromUserInput
 {
   // eNoUserInput: event is not from user input
@@ -54,31 +54,31 @@ public:
      //    will be emitted.
      eRemoveDupes,
 
      // eDoNotEmit : This event is confirmed as a duplicate, do not emit it.
      eDoNotEmit
   };
 
   // Initialize with an nsIAccessible
-  AccEvent(PRUint32 aEventType, nsAccessible* aAccessible,
+  AccEvent(PRUint32 aEventType, Accessible* aAccessible,
            EIsFromUserInput aIsFromUserInput = eAutoDetect,
            EEventRule aEventRule = eRemoveDupes);
   // Initialize with an nsIDOMNode
   AccEvent(PRUint32 aEventType, nsINode* aNode,
            EIsFromUserInput aIsFromUserInput = eAutoDetect,
            EEventRule aEventRule = eRemoveDupes);
   virtual ~AccEvent() {}
 
   // AccEvent
   PRUint32 GetEventType() const { return mEventType; }
   EEventRule GetEventRule() const { return mEventRule; }
   bool IsFromUserInput() const { return mIsFromUserInput; }
 
-  nsAccessible *GetAccessible();
+  Accessible* GetAccessible();
   DocAccessible* GetDocAccessible();
   nsINode* GetNode();
 
   /**
    * Create and return an XPCOM object for accessible event object.
    */
   virtual already_AddRefed<nsAccEvent> CreateXPCOMObject();
 
@@ -109,41 +109,41 @@ public:
    */
   NS_INLINE_DECL_REFCOUNTING(AccEvent)
   NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(AccEvent)
 
 protected:
   /**
    * Get an accessible from event target node.
    */
-  nsAccessible *GetAccessibleForNode() const;
+  Accessible* GetAccessibleForNode() const;
 
   /**
    * Determine whether the event is from user input by event state manager if
    * it's not pointed explicetly.
    */
   void CaptureIsFromUserInput(EIsFromUserInput aIsFromUserInput);
 
   bool mIsFromUserInput;
   PRUint32 mEventType;
   EEventRule mEventRule;
-  nsRefPtr<nsAccessible> mAccessible;
+  nsRefPtr<Accessible> mAccessible;
   nsCOMPtr<nsINode> mNode;
 
   friend class NotificationController;
 };
 
 
 /**
  * Accessible state change event.
  */
 class AccStateChangeEvent: public AccEvent
 {
 public:
-  AccStateChangeEvent(nsAccessible* aAccessible, PRUint64 aState,
+  AccStateChangeEvent(Accessible* aAccessible, PRUint64 aState,
                       bool aIsEnabled,
                       EIsFromUserInput aIsFromUserInput = eAutoDetect);
 
   AccStateChangeEvent(nsINode* aNode, PRUint64 aState, bool aIsEnabled);
 
   AccStateChangeEvent(nsINode* aNode, PRUint64 aState);
 
   // AccEvent
@@ -166,17 +166,17 @@ private:
 
 
 /**
  * Accessible text change event.
  */
 class AccTextChangeEvent: public AccEvent
 {
 public:
-  AccTextChangeEvent(nsAccessible* aAccessible, PRInt32 aStart,
+  AccTextChangeEvent(Accessible* aAccessible, PRInt32 aStart,
                      const nsAString& aModifiedText, bool aIsInserted,
                      EIsFromUserInput aIsFromUserInput = eAutoDetect);
 
   // AccEvent
   virtual already_AddRefed<nsAccEvent> CreateXPCOMObject();
 
   static const EventGroup kEventGroup = eTextChangeEvent;
   virtual unsigned int GetEventGroups() const
@@ -201,17 +201,17 @@ private:
 
 
 /**
  * Base class for show and hide accessible events.
  */
 class AccMutationEvent: public AccEvent
 {
 public:
-  AccMutationEvent(PRUint32 aEventType, nsAccessible* aTarget,
+  AccMutationEvent(PRUint32 aEventType, Accessible* aTarget,
                    nsINode* aTargetNode);
 
   // Event
   static const EventGroup kEventGroup = eMutationEvent;
   virtual unsigned int GetEventGroups() const
   {
     return AccEvent::GetEventGroups() | (1U << eMutationEvent);
   }
@@ -228,65 +228,65 @@ protected:
 
 
 /**
  * Accessible hide event.
  */
 class AccHideEvent: public AccMutationEvent
 {
 public:
-  AccHideEvent(nsAccessible* aTarget, nsINode* aTargetNode);
+  AccHideEvent(Accessible* aTarget, nsINode* aTargetNode);
 
   // Event
   virtual already_AddRefed<nsAccEvent> CreateXPCOMObject();
 
   static const EventGroup kEventGroup = eHideEvent;
   virtual unsigned int GetEventGroups() const
   {
     return AccMutationEvent::GetEventGroups() | (1U << eHideEvent);
   }
 
   // AccHideEvent
-  nsAccessible* TargetParent() const { return mParent; }
-  nsAccessible* TargetNextSibling() const { return mNextSibling; }
-  nsAccessible* TargetPrevSibling() const { return mPrevSibling; }
+  Accessible* TargetParent() const { return mParent; }
+  Accessible* TargetNextSibling() const { return mNextSibling; }
+  Accessible* TargetPrevSibling() const { return mPrevSibling; }
 
 protected:
-  nsRefPtr<nsAccessible> mParent;
-  nsRefPtr<nsAccessible> mNextSibling;
-  nsRefPtr<nsAccessible> mPrevSibling;
+  nsRefPtr<Accessible> mParent;
+  nsRefPtr<Accessible> mNextSibling;
+  nsRefPtr<Accessible> mPrevSibling;
 
   friend class NotificationController;
 };
 
 
 /**
  * Accessible show event.
  */
 class AccShowEvent: public AccMutationEvent
 {
 public:
-  AccShowEvent(nsAccessible* aTarget, nsINode* aTargetNode);
+  AccShowEvent(Accessible* aTarget, nsINode* aTargetNode);
 
   // Event
   static const EventGroup kEventGroup = eShowEvent;
   virtual unsigned int GetEventGroups() const
   {
     return AccMutationEvent::GetEventGroups() | (1U << eShowEvent);
   }
 };
 
 
 /**
  * Accessible caret move event.
  */
 class AccCaretMoveEvent: public AccEvent
 {
 public:
-  AccCaretMoveEvent(nsAccessible* aAccessible, PRInt32 aCaretOffset);
+  AccCaretMoveEvent(Accessible* aAccessible, PRInt32 aCaretOffset);
   AccCaretMoveEvent(nsINode* aNode);
 
   // AccEvent
   virtual already_AddRefed<nsAccEvent> CreateXPCOMObject();
 
   static const EventGroup kEventGroup = eCaretMoveEvent;
   virtual unsigned int GetEventGroups() const
   {
@@ -307,49 +307,49 @@ private:
 class AccSelChangeEvent : public AccEvent
 {
 public:
   enum SelChangeType {
     eSelectionAdd,
     eSelectionRemove
   };
 
-  AccSelChangeEvent(nsAccessible* aWidget, nsAccessible* aItem,
+  AccSelChangeEvent(Accessible* aWidget, Accessible* aItem,
                     SelChangeType aSelChangeType);
 
   virtual ~AccSelChangeEvent() { }
 
   // AccEvent
   static const EventGroup kEventGroup = eSelectionChangeEvent;
   virtual unsigned int GetEventGroups() const
   {
     return AccEvent::GetEventGroups() | (1U << eSelectionChangeEvent);
   }
 
   // AccSelChangeEvent
-  nsAccessible* Widget() const { return mWidget; }
+  Accessible* Widget() const { return mWidget; }
 
 private:
-  nsRefPtr<nsAccessible> mWidget;
-  nsRefPtr<nsAccessible> mItem;
+  nsRefPtr<Accessible> mWidget;
+  nsRefPtr<Accessible> mItem;
   SelChangeType mSelChangeType;
   PRUint32 mPreceedingCount;
   AccSelChangeEvent* mPackedEvent;
 
   friend class NotificationController;
 };
 
 
 /**
  * Accessible table change event.
  */
 class AccTableChangeEvent : public AccEvent
 {
 public:
-  AccTableChangeEvent(nsAccessible* aAccessible, PRUint32 aEventType,
+  AccTableChangeEvent(Accessible* aAccessible, PRUint32 aEventType,
                       PRInt32 aRowOrColIndex, PRInt32 aNumRowsOrCols);
 
   // AccEvent
   virtual already_AddRefed<nsAccEvent> CreateXPCOMObject();
 
   static const EventGroup kEventGroup = eTableChangeEvent;
   virtual unsigned int GetEventGroups() const
   {
@@ -366,17 +366,17 @@ private:
 };
 
 /**
  * Accessible virtual cursor change event.
  */
 class AccVCChangeEvent : public AccEvent
 {
 public:
-  AccVCChangeEvent(nsAccessible* aAccessible,
+  AccVCChangeEvent(Accessible* aAccessible,
                    nsIAccessible* aOldAccessible,
                    PRInt32 aOldStart, PRInt32 aOldEnd);
 
   virtual ~AccVCChangeEvent() { }
 
   // AccEvent
   virtual already_AddRefed<nsAccEvent> CreateXPCOMObject();