Bug 634218 - dexpcom accessible state methods, r=surkov
authorTrevor Saunders <trev.saunders@gmail.com>
Sun, 10 Apr 2011 08:38:06 +0900
changeset 67790 f15bfa1cb14b56e067e1cfcf2f2eb75a6b27691d
parent 67789 a8449b5e644016c651b590fa9ca5b569bc3c52d5
child 67791 56d25b561e19d465520d6d369d80b66b194df30c
child 68041 bcc0d10b5d4b1a7e9f86376676bf0830e8fb4e31
push id1
push userroot
push dateTue, 26 Apr 2011 22:38:44 +0000
treeherdermozilla-beta@bfdb6e623a36 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerssurkov
bugs634218
milestone2.2a1pre
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 634218 - dexpcom accessible state methods, r=surkov
accessible/src/atk/nsAccessibleWrap.cpp
accessible/src/atk/nsStateMap.h
accessible/src/base/AccEvent.cpp
accessible/src/base/AccEvent.h
accessible/src/base/AccGroupInfo.cpp
accessible/src/base/States.h
accessible/src/base/filters.cpp
accessible/src/base/nsARIAGridAccessible.cpp
accessible/src/base/nsARIAGridAccessible.h
accessible/src/base/nsARIAMap.cpp
accessible/src/base/nsARIAMap.h
accessible/src/base/nsAccDocManager.cpp
accessible/src/base/nsAccDocManager.h
accessible/src/base/nsAccUtils.cpp
accessible/src/base/nsAccUtils.h
accessible/src/base/nsAccessibilityService.cpp
accessible/src/base/nsAccessible.cpp
accessible/src/base/nsAccessible.h
accessible/src/base/nsApplicationAccessible.cpp
accessible/src/base/nsApplicationAccessible.h
accessible/src/base/nsBaseWidgetAccessible.cpp
accessible/src/base/nsBaseWidgetAccessible.h
accessible/src/base/nsDocAccessible.cpp
accessible/src/base/nsDocAccessible.h
accessible/src/base/nsOuterDocAccessible.cpp
accessible/src/base/nsOuterDocAccessible.h
accessible/src/base/nsRootAccessible.cpp
accessible/src/base/nsRootAccessible.h
accessible/src/html/nsHTMLFormControlAccessible.cpp
accessible/src/html/nsHTMLFormControlAccessible.h
accessible/src/html/nsHTMLImageAccessible.cpp
accessible/src/html/nsHTMLImageAccessible.h
accessible/src/html/nsHTMLImageMapAccessible.cpp
accessible/src/html/nsHTMLImageMapAccessible.h
accessible/src/html/nsHTMLLinkAccessible.cpp
accessible/src/html/nsHTMLLinkAccessible.h
accessible/src/html/nsHTMLSelectAccessible.cpp
accessible/src/html/nsHTMLSelectAccessible.h
accessible/src/html/nsHTMLTableAccessible.cpp
accessible/src/html/nsHTMLTableAccessible.h
accessible/src/html/nsHTMLTextAccessible.cpp
accessible/src/html/nsHTMLTextAccessible.h
accessible/src/html/nsHyperTextAccessible.cpp
accessible/src/html/nsHyperTextAccessible.h
accessible/src/mac/mozAccessible.mm
accessible/src/mac/mozActionElements.mm
accessible/src/mac/mozTextAccessible.mm
accessible/src/mac/nsAccessibleWrap.h
accessible/src/msaa/CAccessibleComponent.cpp
accessible/src/msaa/nsAccessibleWrap.cpp
accessible/src/msaa/nsHTMLWin32ObjectAccessible.cpp
accessible/src/msaa/nsHTMLWin32ObjectAccessible.h
accessible/src/xforms/nsXFormsAccessible.cpp
accessible/src/xforms/nsXFormsAccessible.h
accessible/src/xforms/nsXFormsFormControlsAccessible.cpp
accessible/src/xforms/nsXFormsFormControlsAccessible.h
accessible/src/xforms/nsXFormsWidgetsAccessible.cpp
accessible/src/xforms/nsXFormsWidgetsAccessible.h
accessible/src/xpcom/nsAccEvent.cpp
accessible/src/xul/nsXULAlertAccessible.cpp
accessible/src/xul/nsXULAlertAccessible.h
accessible/src/xul/nsXULColorPickerAccessible.cpp
accessible/src/xul/nsXULColorPickerAccessible.h
accessible/src/xul/nsXULComboboxAccessible.cpp
accessible/src/xul/nsXULComboboxAccessible.h
accessible/src/xul/nsXULFormControlAccessible.cpp
accessible/src/xul/nsXULFormControlAccessible.h
accessible/src/xul/nsXULListboxAccessible.cpp
accessible/src/xul/nsXULListboxAccessible.h
accessible/src/xul/nsXULMenuAccessible.cpp
accessible/src/xul/nsXULMenuAccessible.h
accessible/src/xul/nsXULSliderAccessible.cpp
accessible/src/xul/nsXULSliderAccessible.h
accessible/src/xul/nsXULTabAccessible.cpp
accessible/src/xul/nsXULTabAccessible.h
accessible/src/xul/nsXULTextAccessible.cpp
accessible/src/xul/nsXULTextAccessible.h
accessible/src/xul/nsXULTreeAccessible.cpp
accessible/src/xul/nsXULTreeAccessible.h
accessible/src/xul/nsXULTreeGridAccessible.cpp
accessible/src/xul/nsXULTreeGridAccessible.h
--- a/accessible/src/atk/nsAccessibleWrap.cpp
+++ b/accessible/src/atk/nsAccessibleWrap.cpp
@@ -47,16 +47,17 @@
 #include "nsDocAccessibleWrap.h"
 #include "nsIAccessibleValue.h"
 #include "nsString.h"
 #include "nsAutoPtr.h"
 #include "prprf.h"
 #include "nsRoleMap.h"
 #include "nsRelUtils.h"
 #include "nsStateMap.h"
+#include "States.h"
 
 #include "nsMaiInterfaceComponent.h"
 #include "nsMaiInterfaceAction.h"
 #include "nsMaiInterfaceText.h"
 #include "nsMaiInterfaceEditableText.h"
 #include "nsMaiInterfaceSelection.h"
 #include "nsMaiInterfaceValue.h"
 #include "nsMaiInterfaceHypertext.h"
@@ -791,27 +792,25 @@ ConvertToAtkAttributeSet(nsIPersistentPr
         objAttr->value = g_strdup(NS_ConvertUTF16toUTF8(value).get());
         objAttributeSet = g_slist_prepend(objAttributeSet, objAttr);
     }
 
     //libspi will free it
     return objAttributeSet;
 }
 
-AtkAttributeSet *
-GetAttributeSet(nsIAccessible* aAccessible)
+AtkAttributeSet*
+GetAttributeSet(nsAccessible* aAccessible)
 {
     nsCOMPtr<nsIPersistentProperties> attributes;
     aAccessible->GetAttributes(getter_AddRefs(attributes));
 
     if (attributes) {
         // Deal with attributes that we only need to expose in ATK
-        PRUint32 state;
-        aAccessible->GetState(&state, nsnull);
-        if (state & nsIAccessibleStates::STATE_HASPOPUP) {
+        if (aAccessible->State() & states::HASPOPUP) {
           // There is no ATK state for haspopup, must use object attribute to expose the same info
           nsAutoString oldValueUnused;
           attributes->SetStringProperty(NS_LITERAL_CSTRING("haspopup"), NS_LITERAL_STRING("true"),
                                         oldValueUnused);
         }
 
         return ConvertToAtkAttributeSet(attributes);
     }
@@ -900,60 +899,52 @@ getIndexInParentCB(AtkObject *aAtkObj)
     nsAccessible *parent = accWrap->GetParent();
     if (!parent) {
         return -1; // No parent
     }
 
     return parent->GetIndexOfEmbeddedChild(accWrap);
 }
 
-static void TranslateStates(PRUint32 aState, const AtkStateMap *aStateMap,
-                            AtkStateSet *aStateSet)
+static void
+TranslateStates(PRUint64 aState, AtkStateSet* aStateSet)
 {
-  NS_ASSERTION(aStateSet, "Can't pass in null state set");
 
   // Convert every state to an entry in AtkStateMap
   PRUint32 stateIndex = 0;
-  PRUint32 bitMask = 1;
-  while (aStateMap[stateIndex].stateMapEntryType != kNoSuchState) {
-    if (aStateMap[stateIndex].atkState) {    // There's potentially an ATK state for this
+  PRUint64 bitMask = 1;
+  while (gAtkStateMap[stateIndex].stateMapEntryType != kNoSuchState) {
+    if (gAtkStateMap[stateIndex].atkState) { // There's potentially an ATK state for this
       PRBool isStateOn = (aState & bitMask) != 0;
-      if (aStateMap[stateIndex].stateMapEntryType == kMapOpposite) {
+      if (gAtkStateMap[stateIndex].stateMapEntryType == kMapOpposite) {
         isStateOn = !isStateOn;
       }
       if (isStateOn) {
-        atk_state_set_add_state(aStateSet, aStateMap[stateIndex].atkState);
+        atk_state_set_add_state(aStateSet, gAtkStateMap[stateIndex].atkState);
       }
     }
-    // Map extended state
     bitMask <<= 1;
     ++ stateIndex;
   }
 }
 
 AtkStateSet *
 refStateSetCB(AtkObject *aAtkObj)
 {
     AtkStateSet *state_set = nsnull;
     state_set = ATK_OBJECT_CLASS(parent_class)->ref_state_set(aAtkObj);
 
     nsAccessibleWrap *accWrap = GetAccessibleWrap(aAtkObj);
     if (!accWrap) {
-        TranslateStates(nsIAccessibleStates::EXT_STATE_DEFUNCT,
-                        gAtkStateMapExt, state_set);
+        TranslateStates(states::DEFUNCT, state_set);
         return state_set;
     }
 
     // Map states
-    PRUint32 accState = 0, accExtState = 0;
-    nsresult rv = accWrap->GetState(&accState, &accExtState);
-    NS_ENSURE_SUCCESS(rv, state_set);
-
-    TranslateStates(accState, gAtkStateMap, state_set);
-    TranslateStates(accExtState, gAtkStateMapExt, state_set);
+    TranslateStates(accWrap->State(), state_set);
 
     return state_set;
 }
 
 AtkRelationSet *
 refRelationSetCB(AtkObject *aAtkObj)
 {
     AtkRelationSet *relation_set = nsnull;
@@ -1081,19 +1072,17 @@ nsAccessibleWrap::FirePlatformEvent(AccE
     case nsIAccessibleEvent::EVENT_FOCUS:
       {
         MAI_LOG_DEBUG(("\n\nReceived: EVENT_FOCUS\n"));
         nsRootAccessible* rootAccWrap = accWrap->RootAccessible();
         if (rootAccWrap && rootAccWrap->mActivated) {
             atk_focus_tracker_notify(atkObj);
             // Fire state change event for focus
             nsRefPtr<AccEvent> stateChangeEvent =
-              new AccStateChangeEvent(accessible,
-                                      nsIAccessibleStates::STATE_FOCUSED,
-                                      PR_FALSE, PR_TRUE);
+              new AccStateChangeEvent(accessible, states::FOCUSED, PR_TRUE);
             return FireAtkStateChangeEvent(stateChangeEvent, atkObj);
         }
       } break;
 
     case nsIAccessibleEvent::EVENT_VALUE_CHANGE:
       {
         MAI_LOG_DEBUG(("\n\nReceived: EVENT_VALUE_CHANGE\n"));
         nsCOMPtr<nsIAccessibleValue> value(do_QueryObject(accessible));
@@ -1332,36 +1321,32 @@ nsresult
 nsAccessibleWrap::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);
 
-    PRUint32 state = event->GetState();
-    PRBool isExtra = event->IsExtraState();
     PRBool isEnabled = event->IsStateEnabled();
-
-    PRInt32 stateIndex = AtkStateMap::GetStateIndexFor(state);
+    PRInt32 stateIndex = AtkStateMap::GetStateIndexFor(event->GetState());
     if (stateIndex >= 0) {
-        const AtkStateMap *atkStateMap = isExtra ? gAtkStateMapExt : gAtkStateMap;
-        NS_ASSERTION(atkStateMap[stateIndex].stateMapEntryType != kNoSuchState,
+        NS_ASSERTION(gAtkStateMap[stateIndex].stateMapEntryType != kNoSuchState,
                      "No such state");
 
-        if (atkStateMap[stateIndex].atkState != kNone) {
-            NS_ASSERTION(atkStateMap[stateIndex].stateMapEntryType != kNoStateChange,
+        if (gAtkStateMap[stateIndex].atkState != kNone) {
+            NS_ASSERTION(gAtkStateMap[stateIndex].stateMapEntryType != kNoStateChange,
                          "State changes should not fired for this state");
 
-            if (atkStateMap[stateIndex].stateMapEntryType == kMapOpposite)
+            if (gAtkStateMap[stateIndex].stateMapEntryType == kMapOpposite)
                 isEnabled = !isEnabled;
 
             // Fire state change for first state if there is one to map
             atk_object_notify_state_change(aObject,
-                                           atkStateMap[stateIndex].atkState,
+                                           gAtkStateMap[stateIndex].atkState,
                                            isEnabled);
         }
     }
 
     return NS_OK;
 }
 
 nsresult
--- a/accessible/src/atk/nsStateMap.h
+++ b/accessible/src/atk/nsStateMap.h
@@ -75,90 +75,71 @@ enum EStateMapEntryType {
 };
 
 const AtkStateType kNone = ATK_STATE_INVALID;
 
 struct AtkStateMap {
   AtkStateType atkState;
   EStateMapEntryType stateMapEntryType;
 
-  static PRInt32 GetStateIndexFor(PRUint32 aState)
+  static PRInt32 GetStateIndexFor(PRUint64 aState)
   {
     PRInt32 stateIndex = -1;
     while (aState > 0) {
       ++ stateIndex;
       aState >>= 1;
     }
     return stateIndex;  // Returns -1 if not mapped
   }
 };
 
 
 // Map array from cross platform roles to  ATK roles
-static const AtkStateMap gAtkStateMap[] = {                       // Cross Platform States
-  { kNone,                                    kMapOpposite },     // nsIAccessibleStates::STATE_UNAVAILABLE     = 0x00000001
-  { ATK_STATE_SELECTED,                       kMapDirectly },     // nsIAccessibleStates::STATE_SELECTED        = 0x00000002
-  { ATK_STATE_FOCUSED,                        kMapDirectly },     // nsIAccessibleStates::STATE_FOCUSED         = 0x00000004
-  { ATK_STATE_PRESSED,                        kMapDirectly },     // nsIAccessibleStates::STATE_PRESSED         = 0x00000008
-  { ATK_STATE_CHECKED,                        kMapDirectly },     // nsIAccessibleStates::STATE_CHECKED         = 0x00000010
-  { ATK_STATE_INDETERMINATE,                  kMapDirectly },     // nsIAccessibleStates::STATE_MIXED           = 0x00000020
-  { kNone,                                    kMapDirectly },     // nsIAccessibleStates::STATE_READONLY        = 0x00000040
-  { kNone,                                    kMapDirectly },     // nsIAccessibleStates::STATE_HOTTRACKED      = 0x00000080
-  { ATK_STATE_DEFAULT,                        kMapDirectly },     // nsIAccessibleStates::STATE_DEFAULT         = 0x00000100
-  { ATK_STATE_EXPANDED,                       kMapDirectly },     // nsIAccessibleStates::STATE_EXPANDED        = 0x00000200
-  { kNone,                                    kNoStateChange },   // nsIAccessibleStates::STATE_COLLAPSED       = 0x00000400
-  { ATK_STATE_BUSY,                           kMapDirectly },     // nsIAccessibleStates::STATE_BUSY            = 0x00000800
-  { kNone,                                    kMapDirectly },     // nsIAccessibleStates::STATE_FLOATING        = 0x00001000
-  { kNone,                                    kMapDirectly },     // nsIAccessibleStates::STATE_CHECKABLE       = 0x00002000
-  { ATK_STATE_ANIMATED,                       kMapDirectly },     // nsIAccessibleStates::STATE_ANIMATED        = 0x00004000
-  { ATK_STATE_VISIBLE,                        kMapOpposite },     // nsIAccessibleStates::STATE_INVISIBLE       = 0x00008000
-  { ATK_STATE_SHOWING,                        kMapOpposite },     // nsIAccessibleStates::STATE_OFFSCREEN       = 0x00010000
-  { ATK_STATE_RESIZABLE,                      kMapDirectly },     // nsIAccessibleStates::STATE_SIZEABLE        = 0x00020000
-  { kNone,                                    kMapDirectly },     // nsIAccessibleStates::STATE_MOVEABLE        = 0x00040000
-  { kNone,                                    kMapDirectly },     // nsIAccessibleStates::STATE_SELFVOICING     = 0x00080000
-  { ATK_STATE_FOCUSABLE,                      kMapDirectly },     // nsIAccessibleStates::STATE_FOCUSABLE       = 0x00100000
-  { ATK_STATE_SELECTABLE,                     kMapDirectly },     // nsIAccessibleStates::STATE_SELECTABLE      = 0x00200000
-  { kNone,                                    kMapDirectly },     // nsIAccessibleStates::STATE_LINKED          = 0x00400000
-  { ATK_STATE_VISITED,                        kMapDirectly },     // nsIAccessibleStates::STATE_TRAVERSED       = 0x00800000
-  { ATK_STATE_MULTISELECTABLE,                kMapDirectly },     // nsIAccessibleStates::STATE_MULTISELECTABLE = 0x01000000
-  { kNone,                                    kMapDirectly },     // nsIAccessibleStates::STATE_EXTSELECTABLE   = 0x02000000
-  { ATK_STATE_REQUIRED,                       kMapDirectly },     // nsIAccessibleStates::STATE_REQUIRED        = 0x04000000
-  { kNone,                                    kMapDirectly },     // nsIAccessibleStates::STATE_ALERT_MEDIUM    = 0x08000000
-  { ATK_STATE_INVALID_ENTRY,                  kMapDirectly },     // nsIAccessibleStates::STATE_INVALID         = 0x10000000
-  { kNone,                                    kMapDirectly },     // nsIAccessibleStates::STATE_PROTECTED       = 0x20000000
-  { kNone,                                    kMapDirectly },     // nsIAccessibleStates::STATE_HASPOPUP        = 0x40000000
-  { kNone,                                    kNoSuchState },     //                                            = 0x80000000
+static const AtkStateMap gAtkStateMap[] = {                     // Cross Platform States
+  { kNone,                                    kMapOpposite },   // states::UNAVAILABLE             = 1 << 0
+  { ATK_STATE_SELECTED,                       kMapDirectly },   // states::SELECTED                = 1 << 1
+  { ATK_STATE_FOCUSED,                        kMapDirectly },   // states::FOCUSED                 = 1 << 2
+  { ATK_STATE_PRESSED,                        kMapDirectly },   // states::PRESSED                 = 1 << 3
+  { ATK_STATE_CHECKED,                        kMapDirectly },   // states::CHECKED                 = 1 << 4
+  { ATK_STATE_INDETERMINATE,                  kMapDirectly },   // states::MIXED                   = 1 << 5
+  { kNone,                                    kMapDirectly },   // states::READONLY                = 1 << 6
+  { kNone,                                    kMapDirectly },   // states::HOTTRACKED              = 1 << 7
+  { ATK_STATE_DEFAULT,                        kMapDirectly },   // states::DEFAULT                 = 1 << 8
+  { ATK_STATE_EXPANDED,                       kMapDirectly },   // states::EXPANDED                = 1 << 9
+  { kNone,                                    kNoStateChange }, // states::COLLAPSED               = 1 << 10
+  { ATK_STATE_BUSY,                           kMapDirectly },   // states::BUSY                    = 1 << 11
+  { kNone,                                    kMapDirectly },   // states::FLOATING                = 1 << 12
+  { kNone,                                    kMapDirectly },   // states::CHECKABLE               = 1 << 13
+  { ATK_STATE_ANIMATED,                       kMapDirectly },   // states::ANIMATED                = 1 << 14
+  { ATK_STATE_VISIBLE,                        kMapOpposite },   // states::INVISIBLE               = 1 << 15
+  { ATK_STATE_SHOWING,                        kMapOpposite },   // states::OFFSCREEN               = 1 << 16
+  { ATK_STATE_RESIZABLE,                      kMapDirectly },   // states::SIZEABLE                = 1 << 17
+  { kNone,                                    kMapDirectly },   // states::MOVEABLE                = 1 << 18
+  { kNone,                                    kMapDirectly },   // states::SELFVOICING             = 1 << 19
+  { ATK_STATE_FOCUSABLE,                      kMapDirectly },   // states::FOCUSABLE               = 1 << 20
+  { ATK_STATE_SELECTABLE,                     kMapDirectly },   // states::SELECTABLE              = 1 << 21
+  { kNone,                                    kMapDirectly },   // states::LINKED                  = 1 << 22
+  { ATK_STATE_VISITED,                        kMapDirectly },   // states::TRAVERSED               = 1 << 23
+  { ATK_STATE_MULTISELECTABLE,                kMapDirectly },   // states::MULTISELECTABLE         = 1 << 24
+  { kNone,                                    kMapDirectly },   // states::EXTSELECTABLE           = 1 << 25
+  { ATK_STATE_REQUIRED,                       kMapDirectly },   // states::STATE_REQUIRED          = 1 << 26
+  { kNone,                                    kMapDirectly },   // states::ALERT_MEDIUM            = 1 << 27
+  { ATK_STATE_INVALID_ENTRY,                  kMapDirectly },   // states::INVALID                 = 1 << 28
+  { kNone,                                    kMapDirectly },   // states::PROTECTED               = 1 << 29
+  { kNone,                                    kMapDirectly },   // states::HASPOPUP                = 1 << 30
+  { ATK_STATE_SUPPORTS_AUTOCOMPLETION,        kMapDirectly },   // states::SUPPORTS_AUTOCOMPLETION = 1 << 31
+  { ATK_STATE_DEFUNCT,                        kMapDirectly },   // states::DEFUNCT                 = 1 << 32
+  { ATK_STATE_SELECTABLE_TEXT,                kMapDirectly },   // states::SELECTABLE_TEXT         = 1 << 33
+  { ATK_STATE_EDITABLE,                       kMapDirectly },   // states::EDITABLE                = 1 << 34
+  { ATK_STATE_ACTIVE,                         kMapDirectly },   // states::ACTIVE                  = 1 << 35
+  { ATK_STATE_MODAL,                          kMapDirectly },   // states::MODAL                   = 1 << 36
+  { ATK_STATE_MULTI_LINE,                     kMapDirectly },   // states::MULTI_LINE              = 1 << 37
+  { ATK_STATE_HORIZONTAL,                     kMapDirectly },   // states::HORIZONTAL              = 1 << 38
+  { ATK_STATE_OPAQUE,                         kMapDirectly },   // states::OPAQUE                  = 1 << 39
+  { ATK_STATE_SINGLE_LINE,                    kMapDirectly },   // states::SINGLE_LINE             = 1 << 40
+  { ATK_STATE_TRANSIENT,                      kMapDirectly },   // states::TRANSIENT               = 1 << 41
+  { ATK_STATE_VERTICAL,                       kMapDirectly },   // states::VERTICAL                = 1 << 42
+  { ATK_STATE_STALE,                          kMapDirectly },   // states::STALE                   = 1 << 43
+  { ATK_STATE_ENABLED,                        kMapDirectly },   // states::ENABLED                 = 1 << 44
+  { ATK_STATE_SENSITIVE,                      kMapDirectly },   // states::SENSITIVE               = 1 << 45
+  { ATK_STATE_EXPANDABLE,                     kMapDirectly },   // states::EXPANDABLE              = 1 << 46
+  { kNone,                                    kNoSuchState },   //                                 = 1 << 47
 };
-
-static const AtkStateMap gAtkStateMapExt[] = {                    // Cross Platform States
-  { ATK_STATE_SUPPORTS_AUTOCOMPLETION,        kMapDirectly },     // nsIAccessibleStates::EXT_STATE_SUPPORTS_AUTOCOMPLETION = 0x00000001
-  { ATK_STATE_DEFUNCT,                        kMapDirectly },     // nsIAccessibleStates::EXT_STATE_DEFUNCT                 = 0x00000002
-  { ATK_STATE_SELECTABLE_TEXT,                kMapDirectly },     // nsIAccessibleStates::EXT_STATE_SELECTABLE_TEXT         = 0x00000004
-  { ATK_STATE_EDITABLE,                       kMapDirectly },     // nsIAccessibleStates::EXT_STATE_EDITABLE                = 0x00000008
-  { ATK_STATE_ACTIVE,                         kMapDirectly },     // nsIAccessibleStates::EXT_STATE_ACTIVE                  = 0x00000010
-  { ATK_STATE_MODAL,                          kMapDirectly },     // nsIAccessibleStates::EXT_STATE_MODAL                   = 0x00000020
-  { ATK_STATE_MULTI_LINE,                     kMapDirectly },     // nsIAccessibleStates::EXT_STATE_MULTI_LINE              = 0x00000040
-  { ATK_STATE_HORIZONTAL,                     kMapDirectly },     // nsIAccessibleStates::EXT_STATE_HORIZONTAL              = 0x00000080
-  { ATK_STATE_OPAQUE,                         kMapDirectly },     // nsIAccessibleStates::EXT_STATE_OPAQUE                  = 0x00000100
-  { ATK_STATE_SINGLE_LINE,                    kMapDirectly },     // nsIAccessibleStates::EXT_STATE_SINGLE_LINE             = 0x00000200
-  { ATK_STATE_TRANSIENT,                      kMapDirectly },     // nsIAccessibleStates::EXT_STATE_TRANSIENT               = 0x00000400
-  { ATK_STATE_VERTICAL,                       kMapDirectly },     // nsIAccessibleStates::EXT_STATE_VERTICAL                = 0x00000800
-  { ATK_STATE_STALE,                          kMapDirectly },     // nsIAccessibleStates::EXT_STATE_STALE                   = 0x00001000
-  { ATK_STATE_ENABLED,                        kMapDirectly },     // nsIAccessibleStates::EXT_STATE_ENABLED                 = 0x00002000
-  { ATK_STATE_SENSITIVE,                      kMapDirectly },     // nsIAccessibleStates::EXT_STATE_SENSITIVE               = 0x00004000
-  { ATK_STATE_EXPANDABLE,                     kMapDirectly },     // nsIAccessibleStates::EXT_STATE_EXPANDABLE              = 0x00008000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x00010000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x00020000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x00040000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x00080000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x00100000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x00200000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x00400000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x00800000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x01000000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x02000000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x04000000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x08000000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x10000000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x20000000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x40000000
-  { kNone,                                    kNoSuchState },     //                                                        = 0x80000000
-};
--- a/accessible/src/base/AccEvent.cpp
+++ b/accessible/src/base/AccEvent.cpp
@@ -216,49 +216,40 @@ 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,
-                      PRUint32 aState, PRBool aIsExtraState,
+  AccStateChangeEvent(nsAccessible* aAccessible, PRUint64 aState,
                       PRBool aIsEnabled, EIsFromUserInput aIsFromUserInput):
   AccEvent(nsIAccessibleEvent::EVENT_STATE_CHANGE, aAccessible,
            aIsFromUserInput, eAllowDupes),
-  mState(aState), mIsExtraState(aIsExtraState), mIsEnabled(aIsEnabled)
+  mState(aState), mIsEnabled(aIsEnabled)
 {
 }
 
 AccStateChangeEvent::
-  AccStateChangeEvent(nsINode* aNode, PRUint32 aState, PRBool aIsExtraState,
-                      PRBool aIsEnabled):
+  AccStateChangeEvent(nsINode* aNode, PRUint64 aState, PRBool aIsEnabled):
   AccEvent(::nsIAccessibleEvent::EVENT_STATE_CHANGE, aNode),
-  mState(aState), mIsExtraState(aIsExtraState), mIsEnabled(aIsEnabled)
+  mState(aState), mIsEnabled(aIsEnabled)
 {
 }
 
 AccStateChangeEvent::
-  AccStateChangeEvent(nsINode* aNode, PRUint32 aState, PRBool aIsExtraState) :
-  AccEvent(::nsIAccessibleEvent::EVENT_STATE_CHANGE, aNode),
-  mState(aState), mIsExtraState(aIsExtraState)
+  AccStateChangeEvent(nsINode* aNode, PRUint64 aState) :
+  AccEvent(::nsIAccessibleEvent::EVENT_STATE_CHANGE, aNode), 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();
-  if (accessible) {
-    PRUint32 state = 0, extraState = 0;
-    accessible->GetState(&state, mIsExtraState ? &extraState : nsnull);
-    mIsEnabled = ((mIsExtraState ? extraState : state) & mState) != 0;
-  } else {
-    mIsEnabled = PR_FALSE;
-  }
+  mIsEnabled = accessible && ((accessible->State() & mState) != 0);
 }
 
 already_AddRefed<nsAccEvent>
 AccStateChangeEvent::CreateXPCOMObject()
 {
   nsAccEvent* event = new nsAccStateChangeEvent(this);
   NS_IF_ADDREF(event);
   return event;
--- a/accessible/src/base/AccEvent.h
+++ b/accessible/src/base/AccEvent.h
@@ -163,43 +163,39 @@ protected:
 
 
 /**
  * Accessible state change event.
  */
 class AccStateChangeEvent: public AccEvent
 {
 public:
-  AccStateChangeEvent(nsAccessible* aAccessible,
-                      PRUint32 aState, PRBool aIsExtraState,
+  AccStateChangeEvent(nsAccessible* aAccessible, PRUint64 aState,
                       PRBool aIsEnabled,
                       EIsFromUserInput aIsFromUserInput = eAutoDetect);
 
-  AccStateChangeEvent(nsINode* aNode, PRUint32 aState, PRBool aIsExtraState,
-                      PRBool aIsEnabled);
+  AccStateChangeEvent(nsINode* aNode, PRUint64 aState, PRBool aIsEnabled);
 
-  AccStateChangeEvent(nsINode* aNode, PRUint32 aState, PRBool aIsExtraState);
+  AccStateChangeEvent(nsINode* aNode, PRUint64 aState);
 
   // AccEvent
   virtual already_AddRefed<nsAccEvent> CreateXPCOMObject();
 
   static const EventGroup kEventGroup = eStateChangeEvent;
   virtual unsigned int GetEventGroups() const
   {
     return AccEvent::GetEventGroups() | (1U << eStateChangeEvent);
   }
 
   // AccStateChangeEvent
-  PRUint32 GetState() const { return mState; }
-  PRBool IsExtraState() const { return mIsExtraState; }
+  PRUint64 GetState() const { return mState; }
   PRBool IsStateEnabled() const { return mIsEnabled; }
 
 private:
-  PRUint32 mState;
-  PRBool mIsExtraState;
+  PRUint64 mState;
   PRBool mIsEnabled;
 };
 
 
 /**
  * Accessible text change event.
  */
 class AccTextChangeEvent: public AccEvent
--- a/accessible/src/base/AccGroupInfo.cpp
+++ b/accessible/src/base/AccGroupInfo.cpp
@@ -32,16 +32,18 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "AccGroupInfo.h"
 
+#include "States.h"
+
 AccGroupInfo::AccGroupInfo(nsAccessible* aItem, PRUint32 aRole) :
   mPosInSet(0), mSetSize(0), mParent(nsnull)
 {
   MOZ_COUNT_CTOR(AccGroupInfo);
   nsAccessible* parent = aItem->GetParent();
   if (!parent)
     return;
 
@@ -54,18 +56,17 @@ AccGroupInfo::AccGroupInfo(nsAccessible*
     nsAccessible* sibling = parent->GetChildAt(idx);
     PRUint32 siblingRole = sibling->Role();
 
     // If the sibling is separator then the group is ended.
     if (siblingRole == nsIAccessibleRole::ROLE_SEPARATOR)
       break;
 
     // If sibling is not visible and hasn't the same base role.
-    if (BaseRole(siblingRole) != aRole ||
-        nsAccUtils::State(sibling) & nsIAccessibleStates::STATE_INVISIBLE)
+    if (BaseRole(siblingRole) != aRole || sibling->State() & states::INVISIBLE)
       continue;
 
     // Check if it's hierarchical flatten structure, i.e. if the sibling
     // level is lesser than this one then group is ended, if the sibling level
     // is greater than this one then the group is split by some child elements
     // (group will be continued).
     PRInt32 siblingLevel = nsAccUtils::GetARIAOrDefaultLevel(sibling);
     if (siblingLevel < level) {
@@ -98,18 +99,17 @@ AccGroupInfo::AccGroupInfo(nsAccessible*
 
     PRUint32 siblingRole = sibling->Role();
 
     // If the sibling is separator then the group is ended.
     if (siblingRole == nsIAccessibleRole::ROLE_SEPARATOR)
       break;
 
     // If sibling is visible and has the same base role
-    if (BaseRole(siblingRole) != aRole ||
-        nsAccUtils::State(sibling) & nsIAccessibleStates::STATE_INVISIBLE)
+    if (BaseRole(siblingRole) != aRole || sibling->State() & states::INVISIBLE)
       continue;
 
     // and check if it's hierarchical flatten structure.
     PRInt32 siblingLevel = nsAccUtils::GetARIAOrDefaultLevel(sibling);
     if (siblingLevel < level)
       break;
 
     // Skip subset.
new file mode 100644
--- /dev/null
+++ b/accessible/src/base/States.h
@@ -0,0 +1,309 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2: */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ * http://www.mozilla.org/MPL/
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Trevor Saunders
+ * Portions created by the Initial Developer are Copyright (C) 2011
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *   Trevor Saunders <trev.saunders@gmail.com> (original author)
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK ***** */
+
+#ifndef _states_h_
+#define _states_h_
+
+#include <prtypes.h>
+
+namespace states {
+
+  /**
+   * The object is disabled, opposite to enabled and sensitive.
+   */
+  const PRUint64 UNAVAILABLE = ((PRUint64) 0x1) << 0;
+
+  /**
+   * The object is selected.
+   */
+  const PRUint64 SELECTED = ((PRUint64) 0x1) << 1;
+
+  /**
+   * The object has the keyboard focus.
+   */
+  const PRUint64 FOCUSED = ((PRUint64) 0x1) << 2;
+
+  /**
+   * The object is pressed.
+   */
+  const PRUint64 PRESSED = ((PRUint64) 0x1) << 3;
+
+  /**
+   * The checkable object is checked, applied to check box controls,
+   * @see CHECKABLE and MIXED states.
+   */
+  const PRUint64 CHECKED = ((PRUint64) 0x1) << 4;
+
+  /**
+   * Indicates that the state of a three-state check box or tool bar button is
+   * undetermined.  The check box is neither checked or unchecked, and is
+   * in the third or mixed state.
+   */
+  const PRUint64 MIXED = ((PRUint64) 0x1) << 5;
+
+  /**
+   * The object is designated read-only, so it can't be edited.
+   */
+  const PRUint64 READONLY = ((PRUint64) 0x1) << 6;
+
+  /**
+   * The object is hot-tracked by the mouse, which means that its appearance
+   * has changed to indicate that the mouse pointer is located over it.
+   *
+   * This is currently unused.
+   */
+  const PRUint64 HOTTRACKED = ((PRUint64) 0x1) << 7;
+
+  /**
+   * This object is the default button in a window.
+   */
+  const PRUint64 DEFAULT = ((PRUint64) 0x1) << 8;
+
+  /**
+   * The expandable object's children are displayed, the opposite of collapsed,
+   * applied to trees, list and other controls.
+   * @see COLLAPSED state
+   */
+  const PRUint64 EXPANDED = ((PRUint64) 0x1) << 9;
+
+  /**
+   * The expandable object's children are not displayed, the opposite of
+   * expanded, applied to tree lists and other controls, 
+   * @see EXPANDED state.
+   */
+  const PRUint64 COLLAPSED = ((PRUint64) 0x1) << 10;
+
+  /**
+   * The control or document can not accept input at this time.
+   */
+  const PRUint64 BUSY = ((PRUint64) 0x1) << 11;
+
+  /**
+   * The object is out of normal flow, may be outside of boundaries of its
+   * parent.
+   */
+  const PRUint64 FLOATING = ((PRUint64) 0x1) << 12;
+
+  /**
+   * The object can be checked.
+   */
+  const PRUint64 CHECKABLE = ((PRUint64) 0x1) << 13;
+
+  /**
+   * This object is a graphic which is rapidly changing appearance.
+   */
+  const PRUint64 ANIMATED = ((PRUint64) 0x1) << 14;
+
+  /**
+   * The object is programmatically hidden.
+   * So user action like scrolling or switching tabs won't make this visible.
+   */
+  const PRUint64 INVISIBLE = ((PRUint64) 0x1) << 15;
+
+  /**
+   * The object is scrolled off screen.
+   * User action such as scrolling or changing tab may make the object
+   * visible.
+   */
+  const PRUint64 OFFSCREEN = ((PRUint64) 0x1) << 16;
+
+  /**
+   * The object can be resized.
+   */
+  const PRUint64 SIZEABLE = ((PRUint64) 0x1) << 17;
+
+  /**
+   * The object can be moved to a different position.
+   */
+  const PRUint64 MOVEABLE = ((PRUint64) 0x1) << 18;
+
+  /**
+   * The object describes itself with speech.
+   * Other speech related assistive technology may want to avoid speaking
+   * information about this object, because the object is already doing this.
+   */
+  const PRUint64 SELFVOICING = ((PRUint64) 0x1) << 19;
+
+  /**
+   * The object can have the focus and become focused.
+   */
+  const PRUint64 FOCUSABLE = ((PRUint64) 0x1) << 20;
+
+  /**
+   * The object can be selected.
+   */
+  const PRUint64 SELECTABLE = ((PRUint64) 0x1) << 21;
+
+  /**
+   * This object is a link.
+   */
+  const PRUint64 LINKED = ((PRUint64) 0x1) << 22;
+
+  /**
+   * This is used for links that have been traversed
+   * i.e. the linked page has been visited.
+   */
+  const PRUint64 TRAVERSED = ((PRUint64) 0x1) << 23;
+
+  /**
+   * Supports multiple selection.
+   */
+  const PRUint64 MULTISELECTABLE = ((PRUint64) 0x1) << 24;
+
+  /**
+   * Supports extended selection.
+   * All objects supporting this are also multipselectable.
+   * This only makes sense for msaa see bug 635690.
+   */
+  const PRUint64 EXTSELECTABLE = ((PRUint64) 0x1) << 25;
+
+  /**
+   * The user is required to interact with this object.
+   */
+  const PRUint64 REQUIRED = ((PRUint64) 0x1) << 26;
+
+  /**
+   * The object is an alert, notifying the user of something important.
+   */
+  const PRUint64 ALERT = ((PRUint64) 0x1) << 27;
+
+  /**
+   * Used for text fields containing invalid values.
+   */
+  const PRUint64 INVALID = ((PRUint64) 0x1) << 28;
+
+  /**
+   * The controls value can not be obtained, and is returned as a set of "*"s.
+   */
+  const PRUint64 PROTECTED = ((PRUint64) 0x1) << 29;
+
+  /**
+   * The object can be invoked to show a pop up menu or window.
+   */
+ const PRUint64 HASPOPUP = ((PRUint64) 0x1) << 30;
+
+ /**
+  * The editable area has some kind of autocompletion.
+  */
+  const PRUint64 SUPPORTS_AUTOCOMPLETION = ((PRUint64) 0x1) << 31;
+
+  /**
+   * The object is no longer available to be queried.
+   */
+  const PRUint64 DEFUNCT = ((PRUint64) 0x1) << 32;
+
+  /**
+   * The text is selectable, the object must implement the text interface.
+   */
+  const PRUint64 SELECTABLE_TEXT = ((PRUint64) 0x1) << 33;
+
+  /**
+   * The text in this object can be edited.
+   */
+  const PRUint64 EDITABLE = ((PRUint64) 0x1) << 34;
+
+  /**
+   * This window is currently the active window.
+   */
+  const PRUint64 ACTIVE = ((PRUint64) 0x1) << 35;
+
+  /**
+   * Indicates that the object is modal. Modal objects have the behavior
+   * that something must be done with the object before the user can
+   * interact with an object in a different window.
+   */
+  const PRUint64 MODAL = ((PRUint64) 0x1) << 36;
+
+  /**
+   * Edit control that can take multiple lines.
+  */
+  const PRUint64 MULTI_LINE = ((PRUint64) 0x1) << 37;
+
+  /**
+   * Uses horizontal layout.
+   */
+  const PRUint64 HORIZONTAL = ((PRUint64) 0x1) << 38;
+
+  /**
+   * Indicates this object paints every pixel within its rectangular region.
+   */
+  const PRUint64 OPAQUE1 = ((PRUint64) 0x1) << 39;
+
+  /**
+   * This text object can only contain 1 line of text.
+   */
+  const PRUint64 SINGLE_LINE = ((PRUint64) 0x1) << 40;
+
+  /**
+   * The parent object manages descendants, and this object may only exist
+   * while it is visible or has focus.
+   * For example the focused cell of a table or the current element of a list box may have this state.
+   */
+  const PRUint64 TRANSIENT = ((PRUint64) 0x1) << 41;
+
+  /**
+   * Uses vertical layout.
+   * Especially used for sliders and scrollbars.
+   */
+  const PRUint64 VERTICAL = ((PRUint64) 0x1) << 42;
+
+  /**
+   * Object not dead, but not up-to-date either.
+   */
+  const PRUint64 STALE = ((PRUint64) 0x1) << 43;
+
+  /**
+   * A widget that is not unavailable.
+   */
+  const PRUint64 ENABLED = ((PRUint64) 0x1) << 44;
+
+  /**
+   * Same as ENABLED state for now see bug 636158
+   */
+  const PRUint64 SENSITIVE = ((PRUint64) 0x1) << 45;
+
+  /**
+   * The object is expandable, provides a UI to expand/collapse its children
+   * @see EXPANDED and COLLAPSED states.
+   */
+  const PRUint64 EXPANDABLE = ((PRUint64) 0x1) << 46;
+}
+
+#endif
+	
--- a/accessible/src/base/filters.cpp
+++ b/accessible/src/base/filters.cpp
@@ -34,27 +34,28 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "filters.h"
 
 #include "nsAccessible.h"
 #include "nsAccUtils.h"
+#include "States.h"
 
 bool
 filters::GetSelected(nsAccessible* aAccessible)
 {
-  return nsAccUtils::State(aAccessible) & nsIAccessibleStates::STATE_SELECTED;
+  return aAccessible->State() & states::SELECTED;
 }
 
 bool
 filters::GetSelectable(nsAccessible* aAccessible)
 {
-  return nsAccUtils::State(aAccessible) & nsIAccessibleStates::STATE_SELECTABLE;
+  return aAccessible->State() & states::SELECTABLE;
 }
 
 bool
 filters::GetRow(nsAccessible* aAccessible)
 {
   return aAccessible->Role() == nsIAccessibleRole::ROLE_ROW;
 }
 
--- a/accessible/src/base/nsARIAGridAccessible.cpp
+++ b/accessible/src/base/nsARIAGridAccessible.cpp
@@ -35,16 +35,17 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsARIAGridAccessible.h"
 
 #include "AccIterator.h"
 #include "nsAccUtils.h"
+#include "States.h"
 
 #include "nsIMutableArray.h"
 #include "nsComponentManagerUtils.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsARIAGridAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -1104,43 +1105,37 @@ nsARIAGridCellAccessible::IsSelected(PRB
 
   *aIsSelected = PR_TRUE;
   return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsAccessible
 
-nsresult
-nsARIAGridCellAccessible::GetARIAState(PRUint32 *aState, PRUint32 *aExtraState)
+void
+nsARIAGridCellAccessible::ApplyARIAState(PRUint64* aState)
 {
-  nsresult rv = nsHyperTextAccessibleWrap::GetARIAState(aState, aExtraState);
-  NS_ENSURE_SUCCESS(rv, rv);
+  nsHyperTextAccessibleWrap::ApplyARIAState(aState);
 
   // Return if the gridcell has aria-selected="true".
-  if (*aState & nsIAccessibleStates::STATE_SELECTED)
-    return NS_OK;
+  if (*aState & states::SELECTED)
+    return;
 
   // Check aria-selected="true" on the row.
   nsAccessible* row = GetParent();
   if (!row || row->Role() != nsIAccessibleRole::ROLE_ROW)
-    return NS_OK;
+    return;
 
   nsIContent *rowContent = row->GetContent();
   if (nsAccUtils::HasDefinedARIAToken(rowContent,
                                       nsAccessibilityAtoms::aria_selected) &&
       !rowContent->AttrValueIs(kNameSpaceID_None,
                                nsAccessibilityAtoms::aria_selected,
-                               nsAccessibilityAtoms::_false, eCaseMatters)) {
-
-    *aState |= nsIAccessibleStates::STATE_SELECTABLE |
-      nsIAccessibleStates::STATE_SELECTED;
-  }
-
-  return NS_OK;
+                               nsAccessibilityAtoms::_false, eCaseMatters))
+    *aState |= states::SELECTABLE | states::SELECTED;
 }
 
 nsresult
 nsARIAGridCellAccessible::GetAttributesInternal(nsIPersistentProperties *aAttributes)
 {
   if (IsDefunct())
     return NS_ERROR_FAILURE;
   
--- a/accessible/src/base/nsARIAGridAccessible.h
+++ b/accessible/src/base/nsARIAGridAccessible.h
@@ -114,13 +114,13 @@ public:
 
   // nsISupports
   NS_DECL_ISUPPORTS_INHERITED
 
   // nsIAccessibleTableCell
   NS_DECL_NSIACCESSIBLETABLECELL
 
   // nsAccessible
-  virtual nsresult GetARIAState(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual void ApplyARIAState(PRUint64* aState);
   virtual nsresult GetAttributesInternal(nsIPersistentProperties *aAttributes);
 };
 
 #endif
--- a/accessible/src/base/nsARIAMap.cpp
+++ b/accessible/src/base/nsARIAMap.cpp
@@ -35,17 +35,17 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsARIAMap.h"
 
 #include "nsIAccessibleRole.h"
-#include "nsIAccessibleStates.h"
+#include "States.h"
 
 #include "nsAccessibilityAtoms.h"
 #include "nsIContent.h"
 
 /**
  *  This list of WAI-defined roles are currently hardcoded.
  *  Eventually we will most likely be loading an RDF resource that contains this information
  *  Using RDF will also allow for role extensibility. See bug 280138.
@@ -91,17 +91,17 @@ nsRoleMapEntry nsARIAMap::gWAIRoleMap[] 
   },
   {
     "article",
     nsIAccessibleRole::ROLE_DOCUMENT,
     kUseMapRole,
     eNoValue,
     eNoAction,
     eNoLiveAttr,
-    nsIAccessibleStates::STATE_READONLY
+    states::READONLY
   },
   {
     "button",
     nsIAccessibleRole::ROLE_PUSHBUTTON,
     kUseMapRole,
     eNoValue,
     eClickAction,
     eNoLiveAttr,
@@ -132,17 +132,17 @@ nsRoleMapEntry nsARIAMap::gWAIRoleMap[] 
   },
   {
     "combobox",
     nsIAccessibleRole::ROLE_COMBOBOX,
     kUseMapRole,
     eHasValueMinMax,
     eOpenCloseAction,
     eNoLiveAttr,
-    nsIAccessibleStates::STATE_COLLAPSED | nsIAccessibleStates::STATE_HASPOPUP,
+    states::COLLAPSED | states::HASPOPUP,
     eARIAAutoComplete,
     eARIAReadonly
   },
   {
     "dialog",
     nsIAccessibleRole::ROLE_DIALOG,
     kUseMapRole,
     eNoValue,
@@ -161,26 +161,26 @@ nsRoleMapEntry nsARIAMap::gWAIRoleMap[] 
   },
   {
     "document",
     nsIAccessibleRole::ROLE_DOCUMENT,
     kUseMapRole,
     eNoValue,
     eNoAction,
     eNoLiveAttr,
-    nsIAccessibleStates::STATE_READONLY
+    states::READONLY
   },
   {
     "grid",
     nsIAccessibleRole::ROLE_TABLE,
     kUseMapRole,
     eNoValue,
     eNoAction,
     eNoLiveAttr,
-    nsIAccessibleStates::STATE_FOCUSABLE,
+    states::FOCUSABLE,
     eARIAMultiSelectable,
     eARIAReadonly
   },
   {
     "gridcell",
     nsIAccessibleRole::ROLE_GRID_CELL,
     kUseMapRole,
     eNoValue,
@@ -228,26 +228,26 @@ nsRoleMapEntry nsARIAMap::gWAIRoleMap[] 
   },
   {
     "link",
     nsIAccessibleRole::ROLE_LINK,
     kUseMapRole,
     eNoValue,
     eJumpAction,
     eNoLiveAttr,
-    nsIAccessibleStates::STATE_LINKED
+    states::LINKED
   },
   {
     "list",
     nsIAccessibleRole::ROLE_LIST,
     kUseMapRole,
     eNoValue,
     eNoAction,
     eNoLiveAttr,
-    nsIAccessibleStates::STATE_READONLY,
+    states::READONLY,
     eARIAMultiSelectable
   },
   {
     "listbox",
     nsIAccessibleRole::ROLE_LISTBOX,
     kUseMapRole,
     eNoValue,
     eNoAction,
@@ -258,17 +258,17 @@ nsRoleMapEntry nsARIAMap::gWAIRoleMap[] 
   },
   {
     "listitem",
     nsIAccessibleRole::ROLE_LISTITEM,
     kUseMapRole,
     eNoValue,
     eNoAction, // XXX: should depend on state, parent accessible
     eNoLiveAttr,
-    nsIAccessibleStates::STATE_READONLY,
+    states::READONLY,
     eARIASelectable,
     eARIACheckedMixed
   },
   {
     "log",
     nsIAccessibleRole::ROLE_NOTHING,
     kUseNativeRole,
     eNoValue,
@@ -365,17 +365,17 @@ nsRoleMapEntry nsARIAMap::gWAIRoleMap[] 
   },
   {
     "progressbar",
     nsIAccessibleRole::ROLE_PROGRESSBAR,
     kUseMapRole,
     eHasValueMinMax,
     eNoAction,
     eNoLiveAttr,
-    nsIAccessibleStates::STATE_READONLY
+    states::READONLY
   },
   {
     "radio",
     nsIAccessibleRole::ROLE_RADIOBUTTON,
     kUseMapRole,
     eNoValue,
     eSelectAction,
     eNoLiveAttr,
@@ -595,96 +595,85 @@ nsRoleMapEntry nsARIAMap::gEmptyRoleMap 
 };
 
 nsStateMapEntry nsARIAMap::gWAIStateMap[] = {
   // eARIANone
   nsStateMapEntry(),
 
   // eARIAAutoComplete
   nsStateMapEntry(&nsAccessibilityAtoms::aria_autocomplete,
-                  "inline", 0, nsIAccessibleStates::EXT_STATE_SUPPORTS_AUTOCOMPLETION,
-                  "list", nsIAccessibleStates::STATE_HASPOPUP, nsIAccessibleStates::EXT_STATE_SUPPORTS_AUTOCOMPLETION,
-                  "both", nsIAccessibleStates::STATE_HASPOPUP, nsIAccessibleStates::EXT_STATE_SUPPORTS_AUTOCOMPLETION),
+                  "inline", states::SUPPORTS_AUTOCOMPLETION,
+                  "list", states::HASPOPUP | states::SUPPORTS_AUTOCOMPLETION,
+                  "both", states::HASPOPUP | states::SUPPORTS_AUTOCOMPLETION),
 
   // eARIABusy
   nsStateMapEntry(&nsAccessibilityAtoms::aria_busy,
-                  "true", nsIAccessibleStates::STATE_BUSY, 0,
-                  "error", nsIAccessibleStates::STATE_INVALID, 0),
+                  "true", states::BUSY,
+                  "error", states::INVALID),
 
   // eARIACheckableBool
   nsStateMapEntry(&nsAccessibilityAtoms::aria_checked, kBoolType,
-                  nsIAccessibleStates::STATE_CHECKABLE,
-                  nsIAccessibleStates::STATE_CHECKED, 0,
-                  0, 0, PR_TRUE),
+                  states::CHECKABLE, states::CHECKED, 0, PR_TRUE),
 
   // eARIACheckableMixed
   nsStateMapEntry(&nsAccessibilityAtoms::aria_checked, kMixedType,
-                  nsIAccessibleStates::STATE_CHECKABLE,
-                  nsIAccessibleStates::STATE_CHECKED, 0,
-                  0, 0, PR_TRUE),
+                  states::CHECKABLE, states::CHECKED, 0, PR_TRUE),
 
   // eARIACheckedMixed
   nsStateMapEntry(&nsAccessibilityAtoms::aria_checked, kMixedType,
-                  nsIAccessibleStates::STATE_CHECKABLE,
-                  nsIAccessibleStates::STATE_CHECKED, 0),
+                  states::CHECKABLE, states::CHECKED, 0),
 
   // eARIADisabled
-  nsStateMapEntry(&nsAccessibilityAtoms::aria_disabled, kBoolType, 0,
-                  nsIAccessibleStates::STATE_UNAVAILABLE, 0),
+  nsStateMapEntry(&nsAccessibilityAtoms::aria_disabled, kBoolType,
+                  0, states::UNAVAILABLE),
 
   // eARIAExpanded
-  nsStateMapEntry(&nsAccessibilityAtoms::aria_expanded, kBoolType, 0,
-                  nsIAccessibleStates::STATE_EXPANDED, 0,
-                  nsIAccessibleStates::STATE_COLLAPSED, 0),
+  nsStateMapEntry(&nsAccessibilityAtoms::aria_expanded, kBoolType,
+                  0, states::EXPANDED, states::COLLAPSED),
 
   // eARIAHasPopup
-  nsStateMapEntry(&nsAccessibilityAtoms::aria_haspopup, kBoolType, 0,
-                  nsIAccessibleStates::STATE_HASPOPUP, 0),
+  nsStateMapEntry(&nsAccessibilityAtoms::aria_haspopup, kBoolType,
+                  0, states::HASPOPUP),
 
   // eARIAInvalid
-  nsStateMapEntry(&nsAccessibilityAtoms::aria_invalid, kBoolType, 0,
-                  nsIAccessibleStates::STATE_INVALID, 0),
+  nsStateMapEntry(&nsAccessibilityAtoms::aria_invalid, kBoolType,
+                  0, states::INVALID),
 
   // eARIAMultiline
-  nsStateMapEntry(&nsAccessibilityAtoms::aria_multiline, kBoolType, 0,
-                  0, nsIAccessibleStates::EXT_STATE_MULTI_LINE,
-                  0, nsIAccessibleStates::EXT_STATE_SINGLE_LINE, PR_TRUE),
+  nsStateMapEntry(&nsAccessibilityAtoms::aria_multiline, kBoolType,
+                  0, states::MULTI_LINE, states::SINGLE_LINE, PR_TRUE),
 
   // eARIAMultiSelectable
-  nsStateMapEntry(&nsAccessibilityAtoms::aria_multiselectable, kBoolType, 0,
-                  nsIAccessibleStates::STATE_MULTISELECTABLE | nsIAccessibleStates::STATE_EXTSELECTABLE, 0),
+  nsStateMapEntry(&nsAccessibilityAtoms::aria_multiselectable, kBoolType,
+                  0, states::MULTISELECTABLE | states::EXTSELECTABLE),
 
   // eARIAOrientation
   nsStateMapEntry(&nsAccessibilityAtoms::aria_orientation, eUseFirstState,
-                  "vertical", 0, nsIAccessibleStates::EXT_STATE_VERTICAL,
-                  "horizontal", 0, nsIAccessibleStates::EXT_STATE_HORIZONTAL),
+                  "vertical", states::VERTICAL,
+                  "horizontal", states::HORIZONTAL),
 
   // eARIAPressed
   nsStateMapEntry(&nsAccessibilityAtoms::aria_pressed, kMixedType,
-                  nsIAccessibleStates::STATE_CHECKABLE,
-                  nsIAccessibleStates::STATE_PRESSED, 0),
+                  states::CHECKABLE, states::PRESSED),
 
   // eARIAReadonly
-  nsStateMapEntry(&nsAccessibilityAtoms::aria_readonly, kBoolType, 0,
-                  nsIAccessibleStates::STATE_READONLY, 0),
+  nsStateMapEntry(&nsAccessibilityAtoms::aria_readonly, kBoolType,
+                  0, states::READONLY),
 
   // eARIAReadonlyOrEditable
-  nsStateMapEntry(&nsAccessibilityAtoms::aria_readonly, kBoolType, 0,
-                  nsIAccessibleStates::STATE_READONLY, 0,
-                  0, nsIAccessibleStates::EXT_STATE_EDITABLE, PR_TRUE),
+  nsStateMapEntry(&nsAccessibilityAtoms::aria_readonly, kBoolType,
+                  0, states::READONLY, states::EDITABLE, PR_TRUE),
 
   // eARIARequired
-  nsStateMapEntry(&nsAccessibilityAtoms::aria_required, kBoolType, 0,
-                  nsIAccessibleStates::STATE_REQUIRED, 0),
+  nsStateMapEntry(&nsAccessibilityAtoms::aria_required, kBoolType,
+                  0, states::REQUIRED),
 
   // eARIASelectable
   nsStateMapEntry(&nsAccessibilityAtoms::aria_selected, kBoolType,
-                  nsIAccessibleStates::STATE_SELECTABLE,
-                  nsIAccessibleStates::STATE_SELECTED, 0,
-                  0, 0, PR_TRUE)
+                  states::SELECTABLE, states::SELECTED, 0, PR_TRUE)
 };
 
 /**
  * Universal (Global) states:
  * The following state rules are applied to any accessible element,
  * whether there is an ARIA role or not:
  */
 eStateMapEntryID nsARIAMap::gWAIUnivStateMap[] = {
@@ -747,93 +736,76 @@ PRUint32 nsARIAMap::gWAIUnivAttrMapLengt
 // nsStateMapEntry
 
 nsStateMapEntry::nsStateMapEntry() :
   mAttributeName(nsnull),
   mIsToken(PR_FALSE),
   mPermanentState(0),
   mValue1(nsnull),
   mState1(0),
-  mExtraState1(0),
   mValue2(nsnull),
   mState2(0),
-  mExtraState2(0),
   mValue3(nsnull),
   mState3(0),
-  mExtraState3(0),
   mDefaultState(0),
-  mDefaultExtraState(0),
   mDefinedIfAbsent(PR_FALSE)
 {}
 
-nsStateMapEntry::nsStateMapEntry(nsIAtom **aAttrName, eStateValueType aType,
-                                 PRUint32 aPermanentState,
-                                 PRUint32 aTrueState, PRUint32 aTrueExtraState,
-                                 PRUint32 aFalseState, PRUint32 aFalseExtraState,
+nsStateMapEntry::nsStateMapEntry(nsIAtom** aAttrName, eStateValueType aType,
+                                 PRUint64 aPermanentState,
+                                 PRUint64 aTrueState,
+                                 PRUint64 aFalseState,
                                  PRBool aDefinedIfAbsent) :
   mAttributeName(aAttrName),
   mIsToken(PR_TRUE),
   mPermanentState(aPermanentState),
   mValue1("false"),
   mState1(aFalseState),
-  mExtraState1(aFalseExtraState),
   mValue2(nsnull),
   mState2(0),
-  mExtraState2(0),
   mValue3(nsnull),
   mState3(0),
-  mExtraState3(0),
   mDefaultState(aTrueState),
-  mDefaultExtraState(aTrueExtraState),
   mDefinedIfAbsent(aDefinedIfAbsent)
 {
   if (aType == kMixedType) {
     mValue2 = "mixed";
-    mState2 = nsIAccessibleStates::STATE_MIXED;
+    mState2 = states::MIXED;
   }
 }
 
-nsStateMapEntry::nsStateMapEntry(nsIAtom **aAttrName,
-                                 const char *aValue1,
-                                 PRUint32 aState1, PRUint32 aExtraState1,
-                                 const char *aValue2,
-                                 PRUint32 aState2, PRUint32 aExtraState2,
-                                 const char *aValue3,
-                                 PRUint32 aState3, PRUint32 aExtraState3) :
+nsStateMapEntry::nsStateMapEntry(nsIAtom** aAttrName,
+                                 const char* aValue1, PRUint64 aState1,
+                                 const char* aValue2, PRUint64 aState2,
+                                 const char* aValue3, PRUint64 aState3) :
   mAttributeName(aAttrName), mIsToken(PR_FALSE), mPermanentState(0),
-  mValue1(aValue1), mState1(aState1), mExtraState1(aExtraState1),
-  mValue2(aValue2), mState2(aState2), mExtraState2(aExtraState2),
-  mValue3(aValue3), mState3(aState3), mExtraState3(aExtraState3),
-  mDefaultState(0), mDefaultExtraState(0), mDefinedIfAbsent(PR_FALSE)
+  mValue1(aValue1), mState1(aState1),
+  mValue2(aValue2), mState2(aState2),
+  mValue3(aValue3), mState3(aState3),
+  mDefaultState(0), mDefinedIfAbsent(PR_FALSE)
 {
 }
 
-nsStateMapEntry::nsStateMapEntry(nsIAtom **aAttrName,
+nsStateMapEntry::nsStateMapEntry(nsIAtom** aAttrName,
                                  EDefaultStateRule aDefaultStateRule,
-                                 const char *aValue1,
-                                 PRUint32 aState1, PRUint32 aExtraState1,
-                                 const char *aValue2,
-                                 PRUint32 aState2, PRUint32 aExtraState2,
-                                 const char *aValue3,
-                                 PRUint32 aState3, PRUint32 aExtraState3) :
+                                 const char* aValue1, PRUint64 aState1,
+                                 const char* aValue2, PRUint64 aState2,
+                                 const char* aValue3, PRUint64 aState3) :
   mAttributeName(aAttrName), mIsToken(PR_TRUE), mPermanentState(0),
-  mValue1(aValue1), mState1(aState1), mExtraState1(aExtraState1),
-  mValue2(aValue2), mState2(aState2), mExtraState2(aExtraState2),
-  mValue3(aValue3), mState3(aState3), mExtraState3(aExtraState3),
-  mDefaultState(0), mDefaultExtraState(0), mDefinedIfAbsent(PR_TRUE)
+  mValue1(aValue1), mState1(aState1),
+  mValue2(aValue2), mState2(aState2),
+  mValue3(aValue3), mState3(aState3),
+  mDefaultState(0), mDefinedIfAbsent(PR_TRUE)
 {
-  if (aDefaultStateRule == eUseFirstState) {
+  if (aDefaultStateRule == eUseFirstState)
     mDefaultState = aState1;
-    mDefaultExtraState = aExtraState1;
-  }
 }
 
 PRBool
-nsStateMapEntry::MapToStates(nsIContent *aContent,
-                             PRUint32 *aState, PRUint32 *aExtraState,
+nsStateMapEntry::MapToStates(nsIContent* aContent, PRUint64* aState,
                              eStateMapEntryID aStateMapEntryID)
 {
   // Return true if we should continue.
   if (aStateMapEntryID == eARIANone)
     return PR_FALSE;
 
   const nsStateMapEntry& entry = nsARIAMap::gWAIStateMap[aStateMapEntryID];
 
@@ -841,19 +813,16 @@ nsStateMapEntry::MapToStates(nsIContent 
     // If attribute is considered as defined when it's absent then let's act
     // attribute value is "false" supposedly.
     PRBool hasAttr = aContent->HasAttr(kNameSpaceID_None, *entry.mAttributeName);
     if (entry.mDefinedIfAbsent && !hasAttr) {
       if (entry.mPermanentState)
         *aState |= entry.mPermanentState;
       if (entry.mState1)
         *aState |= entry.mState1;
-      if (aExtraState && entry.mExtraState1)
-        *aExtraState |= entry.mExtraState1;
-
       return PR_TRUE;
     }
 
     // We only have attribute state mappings for NMTOKEN (and boolean) based
     // ARIA attributes. According to spec, a value of "undefined" is to be
     // treated equivalent to "", or the absence of the attribute. We bail out
     // for this case here.
     // Note: If this method happens to be called with a non-token based
@@ -882,45 +851,34 @@ nsStateMapEntry::MapToStates(nsIContent 
   // states.
   PRBool applyDefaultStates = PR_TRUE;
   if (entry.mValue1) {
     if (attrValue.EqualsASCII(entry.mValue1)) {
       applyDefaultStates = PR_FALSE;
 
       if (entry.mState1)
         *aState |= entry.mState1;
-
-      if (aExtraState && entry.mExtraState1)
-        *aExtraState |= entry.mExtraState1;
-
     } else if (entry.mValue2) {
       if (attrValue.EqualsASCII(entry.mValue2)) {
         applyDefaultStates = PR_FALSE;
 
         if (entry.mState2)
           *aState |= entry.mState2;
 
-        if (aExtraState && entry.mExtraState2)
-          *aExtraState |= entry.mExtraState2;
-
       } else if (entry.mValue3) {
         if (attrValue.EqualsASCII(entry.mValue3)) {
           applyDefaultStates = PR_FALSE;
 
           if (entry.mState3)
             *aState |= entry.mState3;
 
-          if (aExtraState && entry.mExtraState3)
-            *aExtraState |= entry.mExtraState3;
         }
       }
     }
   }
 
   if (applyDefaultStates) {
     if (entry.mDefaultState)
       *aState |= entry.mDefaultState;
-    if (entry.mDefaultExtraState && aExtraState)
-      *aExtraState |= entry.mDefaultExtraState;
   }
 
   return PR_TRUE;
 }
--- a/accessible/src/base/nsARIAMap.h
+++ b/accessible/src/base/nsARIAMap.h
@@ -194,81 +194,72 @@ public:
   /**
    * Used to create stub.
    */
   nsStateMapEntry();
 
   /**
    * Used for ARIA attributes having boolean or mixed values.
    */
-  nsStateMapEntry(nsIAtom **aAttrName, eStateValueType aType,
-                  PRUint32 aPermanentState,
-                  PRUint32 aTrueState, PRUint32 aTrueExtraState,
-                  PRUint32 aFalseState = 0, PRUint32 aFalseExtraState = 0,
+  nsStateMapEntry(nsIAtom** aAttrName, eStateValueType aType,
+                  PRUint64 aPermanentState,
+                  PRUint64 aTrueState,
+                  PRUint64 aFalseState = 0,
                   PRBool aDefinedIfAbsent = PR_FALSE);
 
   /**
    * Used for ARIA attributes having enumerated values.
    */
-  nsStateMapEntry(nsIAtom **aAttrName,
-                  const char *aValue1, PRUint32 aState1, PRUint32 aExtraState1,
-                  const char *aValue2, PRUint32 aState2, PRUint32 aExtraState2,
-                  const char *aValue3 = 0, PRUint32 aState3 = 0,
-                  PRUint32 aExtraState3 = 0);
+  nsStateMapEntry(nsIAtom** aAttrName,
+                  const char* aValue1, PRUint64 aState1,
+                  const char* aValue2, PRUint64 aState2,
+                  const char* aValue3 = 0, PRUint64 aState3 = 0);
 
   /**
    * Used for ARIA attributes having enumerated values, and where a default
    * attribute state should be assumed when not supplied by the author.
    */
-  nsStateMapEntry(nsIAtom **aAttrName,
-                  EDefaultStateRule aDefaultStateRule,
-                  const char *aValue1, PRUint32 aState1, PRUint32 aExtraState1,
-                  const char *aValue2, PRUint32 aState2, PRUint32 aExtraState2,
-                  const char *aValue3 = 0, PRUint32 aState3 = 0,
-                  PRUint32 aExtraState3 = 0);
+  nsStateMapEntry(nsIAtom** aAttrName, EDefaultStateRule aDefaultStateRule,
+                  const char* aValue1, PRUint64 aState1,
+                  const char* aValue2, PRUint64 aState2,
+                  const char* aValue3 = 0, PRUint64 aState3 = 0);
 
   /**
    * Maps ARIA state map pointed by state map entry ID to accessible states.
    *
    * @param  aContent         [in] node of the accessible
    * @param  aState           [in/out] accessible states
-   * @param  aExtraState      [in/out] accessible extra states
    * @param  aStateMapEntryID [in] state map entry ID
    * @return                   true if state map entry ID is valid
    */
-  static PRBool MapToStates(nsIContent *aContent,
-                            PRUint32 *aState, PRUint32 *aExtraState,
+  static PRBool MapToStates(nsIContent* aContent, PRUint64* aState,
                             eStateMapEntryID aStateMapEntryID);
 
 private:
   // ARIA attribute name
   nsIAtom** mAttributeName;
 
   // Indicates if attribute is token (can be undefined)
   PRBool mIsToken;
 
   // State applied always if attribute is defined
-  PRUint32 mPermanentState;
+  PRUint64 mPermanentState;
 
   // States applied if attribute value is matched to the stored value
   const char* mValue1;
-  PRUint32 mState1;
-  PRUint32 mExtraState1;
+  PRUint64 mState1;
 
   const char* mValue2;
-  PRUint32 mState2;
-  PRUint32 mExtraState2;
+  PRUint64 mState2;
 
   const char* mValue3;
-  PRUint32 mState3;
-  PRUint32 mExtraState3;
+  PRUint64 mState3;
 
   // States applied if no stored values above are matched
-  PRUint32 mDefaultState;
-  PRUint32 mDefaultExtraState;
+  PRUint64 mDefaultState;
 
   // Permanent and false states are applied if attribute is absent
   PRBool mDefinedIfAbsent;
 };
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // Role map entry
@@ -293,17 +284,17 @@ struct nsRoleMapEntry
   // Action mapping rule, how to expose nsIAccessible action
   EActionRule actionRule;
 
   // 'live' and 'container-live' object attributes mapping rule: how to expose
   // these object attributes if ARIA 'live' attribute is missed.
   ELiveAttrRule liveAttRule;
 
   // Automatic state mapping rule: always include in nsIAccessibleStates
-  PRUint32 state;   // or kNoReqStates if no nsIAccessibleStates are automatic for this role.
+  PRUint64 state;   // or kNoReqStates if no nsIAccessibleStates are automatic for this role.
   
   // ARIA properties supported for this role
   // (in other words, the aria-foo attribute to nsIAccessibleStates mapping rules)
   // Currently you cannot have unlimited mappings, because
   // a variable sized array would not allow the use of
   // C++'s struct initialization feature.
   eStateMapEntryID attributeMap1;
   eStateMapEntryID attributeMap2;
--- a/accessible/src/base/nsAccDocManager.cpp
+++ b/accessible/src/base/nsAccDocManager.cpp
@@ -38,16 +38,17 @@
 
 #include "nsAccDocManager.h"
 
 #include "nsAccessibilityService.h"
 #include "nsAccUtils.h"
 #include "nsApplicationAccessible.h"
 #include "nsOuterDocAccessible.h"
 #include "nsRootAccessibleWrap.h"
+#include "States.h"
 
 #include "nsCURILoader.h"
 #include "nsDocShellLoadTypes.h"
 #include "nsIChannel.h"
 #include "nsIContentViewer.h"
 #include "nsIDOMDocument.h"
 #include "nsIEventListenerManager.h"
 #include "nsIDOMEventTarget.h"
@@ -216,18 +217,17 @@ nsAccDocManager::OnStateChange(nsIWebPro
 
   // Mark the document accessible as loading, if it stays alive then we'll mark
   // it as loaded when we receive proper notification.
   docAcc->MarkAsLoading();
 
   // Fire state busy change event. Use delayed event since we don't care
   // actually if event isn't delivered when the document goes away like a shot.
   nsRefPtr<AccEvent> stateEvent =
-    new AccStateChangeEvent(document, nsIAccessibleStates::STATE_BUSY,
-                            PR_FALSE, PR_TRUE);
+    new AccStateChangeEvent(document, states::BUSY, PR_TRUE);
   docAcc->FireDelayedAccessibleEvent(stateEvent);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAccDocManager::OnProgressChange(nsIWebProgress *aWebProgress,
                                   nsIRequest *aRequest,
@@ -351,18 +351,17 @@ nsAccDocManager::HandleDOMDocumentLoad(n
   // Fire complete/load stopped if the load event type is given.
   if (aLoadEventType) {
     nsRefPtr<AccEvent> loadEvent = new AccEvent(aLoadEventType, aDocument);
     docAcc->FireDelayedAccessibleEvent(loadEvent);
   }
 
   // Fire busy state change event.
   nsRefPtr<AccEvent> stateEvent =
-    new AccStateChangeEvent(aDocument, nsIAccessibleStates::STATE_BUSY,
-                            PR_FALSE, PR_FALSE);
+    new AccStateChangeEvent(aDocument, states::BUSY, PR_FALSE);
   docAcc->FireDelayedAccessibleEvent(stateEvent);
 }
 
 PRBool
 nsAccDocManager::IsEventTargetDocument(nsIDocument *aDocument) const
 {
   nsCOMPtr<nsISupports> container = aDocument->GetContainer();
   nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem =
--- a/accessible/src/base/nsAccDocManager.h
+++ b/accessible/src/base/nsAccDocManager.h
@@ -365,17 +365,17 @@ private:
   if (type == nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_STOPPED) {               \
     strEventType.AssignLiteral("load stopped");                                \
   } else if (type == nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE) {       \
     strEventType.AssignLiteral("load complete");                               \
   } else if (type == nsIAccessibleEvent::EVENT_DOCUMENT_RELOAD) {              \
       strEventType.AssignLiteral("reload");                                    \
   } else if (type == nsIAccessibleEvent::EVENT_STATE_CHANGE) {                 \
     AccStateChangeEvent* event = downcast_accEvent(aEvent);                    \
-    if (event->GetState() == nsIAccessibleStates::STATE_BUSY) {                \
+    if (event->GetState() == states::BUSY) {                                   \
       strEventType.AssignLiteral("busy ");                                     \
       if (event->IsStateEnabled())                                             \
         strEventType.AppendLiteral("true");                                    \
       else                                                                     \
         strEventType.AppendLiteral("false");                                   \
     }                                                                          \
   }
 
--- a/accessible/src/base/nsAccUtils.cpp
+++ b/accessible/src/base/nsAccUtils.cpp
@@ -34,17 +34,17 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsCoreUtils.h"
 #include "nsAccUtils.h"
 
-#include "nsIAccessibleStates.h"
+#include "States.h"
 #include "nsIAccessibleTypes.h"
 
 #include "nsAccessibilityService.h"
 #include "nsAccessibilityAtoms.h"
 #include "nsARIAMap.h"
 #include "nsDocAccessible.h"
 #include "nsHyperTextAccessible.h"
 #include "nsHTMLTableAccessible.h"
@@ -157,18 +157,17 @@ nsAccUtils::GetPositionAndSizeForXULSele
 
   for (PRUint32 index = 0; index < itemsCount; index++) {
     nsCOMPtr<nsIDOMXULSelectControlItemElement> currItem;
     control->GetItemAtIndex(index, getter_AddRefs(currItem));
     nsCOMPtr<nsINode> currNode(do_QueryInterface(currItem));
 
     nsAccessible* itemAcc = GetAccService()->GetAccessible(currNode);
 
-    if (!itemAcc ||
-        State(itemAcc) & nsIAccessibleStates::STATE_INVISIBLE) {
+    if (!itemAcc || itemAcc->State() & states::INVISIBLE) {
       (*aSetSize)--;
       if (index < static_cast<PRUint32>(indexOf))
         (*aPosInSet)--;
     }
   }
 
   (*aPosInSet)++; // group position is 1-index based.
 }
@@ -204,18 +203,17 @@ nsAccUtils::GetPositionAndSizeForXULCont
 
     nsAccessible* itemAcc = GetAccService()->GetAccessible(itemNode);
 
     if (itemAcc) {
       PRUint32 itemRole = Role(itemAcc);
       if (itemRole == nsIAccessibleRole::ROLE_SEPARATOR)
         break; // We reached the beginning of our group.
 
-      PRUint32 itemState = State(itemAcc);
-      if (!(itemState & nsIAccessibleStates::STATE_INVISIBLE)) {
+      if (!(itemAcc->State() & states::INVISIBLE)) {
         (*aSetSize)++;
         (*aPosInSet)++;
       }
     }
   }
 
   for (PRInt32 index = indexOf + 1; index < static_cast<PRInt32>(itemsCount);
        index++) {
@@ -225,18 +223,17 @@ nsAccUtils::GetPositionAndSizeForXULCont
     
     nsAccessible* itemAcc = GetAccService()->GetAccessible(itemNode);
 
     if (itemAcc) {
       PRUint32 itemRole = Role(itemAcc);
       if (itemRole == nsIAccessibleRole::ROLE_SEPARATOR)
         break; // We reached the end of our group.
 
-      PRUint32 itemState = State(itemAcc);
-      if (!(itemState & nsIAccessibleStates::STATE_INVISIBLE))
+      if (!(itemAcc->State() & states::INVISIBLE))
         (*aSetSize)++;
     }
   }
 }
 
 PRInt32
 nsAccUtils::GetLevelForXULContainerItem(nsIContent *aContent)
 {
@@ -344,42 +341,44 @@ nsAccUtils::GetAncestorWithRole(nsAccess
       return parent;
 
     if (parent == document)
       break;
   }
   return nsnull;
 }
 
-nsAccessible *
-nsAccUtils::GetSelectableContainer(nsAccessible *aAccessible, PRUint32 aState)
+nsAccessible*
+nsAccUtils::GetSelectableContainer(nsAccessible* aAccessible, PRUint64 aState)
 {
   if (!aAccessible)
     return nsnull;
 
-  if (!(aState & nsIAccessibleStates::STATE_SELECTABLE))
+  if (!(aState & states::SELECTABLE))
     return nsnull;
 
   nsAccessible* parent = aAccessible;
   while ((parent = parent->GetParent()) && !parent->IsSelect()) {
     if (Role(parent) == nsIAccessibleRole::ROLE_PANE)
       return nsnull;
   }
   return parent;
 }
 
-nsAccessible *
-nsAccUtils::GetMultiSelectableContainer(nsINode *aNode)
+nsAccessible*
+nsAccUtils::GetMultiSelectableContainer(nsINode* aNode)
 {
-  nsAccessible *accessible = GetAccService()->GetAccessible(aNode);
-  nsAccessible *container = GetSelectableContainer(accessible,
-                                                   State(accessible));
+  nsAccessible* accessible = GetAccService()->GetAccessible(aNode);
+  if (accessible) {
+    nsAccessible* container = GetSelectableContainer(accessible,
+                                                     accessible->State());
+    if (container && container->State() & states::MULTISELECTABLE)
+      return container;
+  }
 
-  if (State(container) & nsIAccessibleStates::STATE_MULTISELECTABLE)
-    return container;
   return nsnull;
 }
 
 PRBool
 nsAccUtils::IsARIASelected(nsAccessible *aAccessible)
 {
   return aAccessible->GetContent()->
     AttrValueIs(kNameSpaceID_None, nsAccessibilityAtoms::aria_selected,
--- a/accessible/src/base/nsAccUtils.h
+++ b/accessible/src/base/nsAccUtils.h
@@ -194,18 +194,18 @@ public:
                                              PRUint32 aRole);
 
   /**
    * Return single or multi selectable container for the given item.
    *
    * @param  aAccessible  [in] the item accessible
    * @param  aState       [in] the state of the item accessible
    */
-  static nsAccessible *GetSelectableContainer(nsAccessible *aAccessible,
-                                              PRUint32 aState);
+  static nsAccessible* GetSelectableContainer(nsAccessible* aAccessible,
+                                              PRUint64 aState);
 
   /**
    * Return multi selectable container for the given item.
    */
   static nsAccessible *GetMultiSelectableContainer(nsINode *aNode);
 
   /**
    * Return true if the DOM node of given accessible has aria-selected="true"
@@ -286,41 +286,16 @@ public:
     PRUint32 role = nsIAccessibleRole::ROLE_NOTHING;
     if (aAcc)
       aAcc->GetRole(&role);
 
     return role;
   }
 
   /**
-   * Return the state for the given accessible.
-   */
-  static PRUint32 State(nsIAccessible *aAcc)
-  {
-    PRUint32 state = 0;
-    if (aAcc)
-      aAcc->GetState(&state, nsnull);
-
-    return state;
-  }
-
-  /**
-   * Return the extended state for the given accessible.
-   */
-  static PRUint32 ExtendedState(nsIAccessible *aAcc)
-  {
-    PRUint32 state = 0;
-    PRUint32 extstate = 0;
-    if (aAcc)
-      aAcc->GetState(&state, &extstate);
-
-    return extstate;
-  }
-
-  /**
    * Get the ARIA attribute characteristics for a given ARIA attribute.
    * 
    * @param aAtom  ARIA attribute
    * @return       A bitflag representing the attribute characteristics
    *               (see nsARIAMap.h for possible bit masks, prefixed "ARIA_")
    */
   static PRUint8 GetAttributeCharacteristics(nsIAtom* aAtom);
 
@@ -365,16 +340,36 @@ public:
   {
     PRUint32 role = Role(aAcc);
     return role != nsIAccessibleRole::ROLE_TEXT_LEAF &&
            role != nsIAccessibleRole::ROLE_WHITESPACE &&
            role != nsIAccessibleRole::ROLE_STATICTEXT;
   }
 
   /**
+   * Transform nsIAccessibleStates constants to internal state constant.
+   */
+  static inline PRUint64 To64State(PRUint32 aState1, PRUint32 aState2)
+  {
+    return static_cast<PRUint64>(aState1) +
+        (static_cast<PRUint64>(aState2) << 31);
+  }
+
+  /**
+   * Transform internal state constant to nsIAccessibleStates constants.
+   */
+  static inline void To32States(PRUint64 aState64,
+                                PRUint32* aState1, PRUint32* aState2)
+  {
+    *aState1 = aState64 & 0x7fffffff;
+    if (aState2)
+      *aState2 = static_cast<PRUint32>(aState64 >> 31);
+  }
+
+  /**
    * Return true if the given accessible can't have children. Used when exposing
    * to platform accessibility APIs, should the children be pruned off?
    */
   static PRBool MustPrune(nsIAccessible *aAccessible);
 
   /**
    * Search hint enum constants. Used by GetHeaderCellsFor() method.
    */
--- a/accessible/src/base/nsAccessibilityService.cpp
+++ b/accessible/src/base/nsAccessibilityService.cpp
@@ -50,16 +50,17 @@
 #include "nsHTMLImageMapAccessible.h"
 #include "nsHTMLLinkAccessible.h"
 #include "nsHTMLSelectAccessible.h"
 #include "nsHTMLTableAccessibleWrap.h"
 #include "nsHTMLTextAccessible.h"
 #include "nsHyperTextAccessibleWrap.h"
 #include "nsIAccessibilityService.h"
 #include "nsIAccessibleProvider.h"
+#include "States.h"
 
 #include "nsIDOMDocument.h"
 #include "nsIDOMHTMLAreaElement.h"
 #include "nsIDOMHTMLLegendElement.h"
 #include "nsIDOMHTMLObjectElement.h"
 #include "nsIDOMHTMLOptGroupElement.h"
 #include "nsIDOMHTMLOptionElement.h"
 #include "nsIDOMXULElement.h"
@@ -625,123 +626,124 @@ nsAccessibilityService::GetStringRole(PR
     return NS_OK;
   }
 
   CopyUTF8toUTF16(kRoleNames[aRole], aString);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsAccessibilityService::GetStringStates(PRUint32 aStates, PRUint32 aExtraStates,
+nsAccessibilityService::GetStringStates(PRUint32 aState, PRUint32 aExtraState,
                                         nsIDOMDOMStringList **aStringStates)
 {
   nsAccessibleDOMStringList *stringStates = new nsAccessibleDOMStringList();
   NS_ENSURE_TRUE(stringStates, NS_ERROR_OUT_OF_MEMORY);
 
-  //states
-  if (aStates & nsIAccessibleStates::STATE_UNAVAILABLE)
+  PRUint64 state = nsAccUtils::To64State(aState, aExtraState);
+
+  // states
+  if (state & states::UNAVAILABLE)
     stringStates->Add(NS_LITERAL_STRING("unavailable"));
-  if (aStates & nsIAccessibleStates::STATE_SELECTED)
+  if (state & states::SELECTED)
     stringStates->Add(NS_LITERAL_STRING("selected"));
-  if (aStates & nsIAccessibleStates::STATE_FOCUSED)
+  if (state & states::FOCUSED)
     stringStates->Add(NS_LITERAL_STRING("focused"));
-  if (aStates & nsIAccessibleStates::STATE_PRESSED)
+  if (state & states::PRESSED)
     stringStates->Add(NS_LITERAL_STRING("pressed"));
-  if (aStates & nsIAccessibleStates::STATE_CHECKED)
+  if (state & states::CHECKED)
     stringStates->Add(NS_LITERAL_STRING("checked"));
-  if (aStates & nsIAccessibleStates::STATE_MIXED)
+  if (state & states::MIXED)
     stringStates->Add(NS_LITERAL_STRING("mixed"));
-  if (aStates & nsIAccessibleStates::STATE_READONLY)
+  if (state & states::READONLY)
     stringStates->Add(NS_LITERAL_STRING("readonly"));
-  if (aStates & nsIAccessibleStates::STATE_HOTTRACKED)
+  if (state & states::HOTTRACKED)
     stringStates->Add(NS_LITERAL_STRING("hottracked"));
-  if (aStates & nsIAccessibleStates::STATE_DEFAULT)
+  if (state & states::DEFAULT)
     stringStates->Add(NS_LITERAL_STRING("default"));
-  if (aStates & nsIAccessibleStates::STATE_EXPANDED)
+  if (state & states::EXPANDED)
     stringStates->Add(NS_LITERAL_STRING("expanded"));
-  if (aStates & nsIAccessibleStates::STATE_COLLAPSED)
+  if (state & states::COLLAPSED)
     stringStates->Add(NS_LITERAL_STRING("collapsed"));
-  if (aStates & nsIAccessibleStates::STATE_BUSY)
+  if (state & states::BUSY)
     stringStates->Add(NS_LITERAL_STRING("busy"));
-  if (aStates & nsIAccessibleStates::STATE_FLOATING)
+  if (state & states::FLOATING)
     stringStates->Add(NS_LITERAL_STRING("floating"));
-  if (aStates & nsIAccessibleStates::STATE_ANIMATED)
+  if (state & states::ANIMATED)
     stringStates->Add(NS_LITERAL_STRING("animated"));
-  if (aStates & nsIAccessibleStates::STATE_INVISIBLE)
+  if (state & states::INVISIBLE)
     stringStates->Add(NS_LITERAL_STRING("invisible"));
-  if (aStates & nsIAccessibleStates::STATE_OFFSCREEN)
+  if (state & states::OFFSCREEN)
     stringStates->Add(NS_LITERAL_STRING("offscreen"));
-  if (aStates & nsIAccessibleStates::STATE_SIZEABLE)
+  if (state & states::SIZEABLE)
     stringStates->Add(NS_LITERAL_STRING("sizeable"));
-  if (aStates & nsIAccessibleStates::STATE_MOVEABLE)
+  if (state & states::MOVEABLE)
     stringStates->Add(NS_LITERAL_STRING("moveable"));
-  if (aStates & nsIAccessibleStates::STATE_SELFVOICING)
+  if (state & states::SELFVOICING)
     stringStates->Add(NS_LITERAL_STRING("selfvoicing"));
-  if (aStates & nsIAccessibleStates::STATE_FOCUSABLE)
+  if (state & states::FOCUSABLE)
     stringStates->Add(NS_LITERAL_STRING("focusable"));
-  if (aStates & nsIAccessibleStates::STATE_SELECTABLE)
+  if (state & states::SELECTABLE)
     stringStates->Add(NS_LITERAL_STRING("selectable"));
-  if (aStates & nsIAccessibleStates::STATE_LINKED)
+  if (state & states::LINKED)
     stringStates->Add(NS_LITERAL_STRING("linked"));
-  if (aStates & nsIAccessibleStates::STATE_TRAVERSED)
+  if (state & states::TRAVERSED)
     stringStates->Add(NS_LITERAL_STRING("traversed"));
-  if (aStates & nsIAccessibleStates::STATE_MULTISELECTABLE)
+  if (state & states::MULTISELECTABLE)
     stringStates->Add(NS_LITERAL_STRING("multiselectable"));
-  if (aStates & nsIAccessibleStates::STATE_EXTSELECTABLE)
+  if (state & states::EXTSELECTABLE)
     stringStates->Add(NS_LITERAL_STRING("extselectable"));
-  if (aStates & nsIAccessibleStates::STATE_PROTECTED)
+  if (state & states::PROTECTED)
     stringStates->Add(NS_LITERAL_STRING("protected"));
-  if (aStates & nsIAccessibleStates::STATE_HASPOPUP)
+  if (state & states::HASPOPUP)
     stringStates->Add(NS_LITERAL_STRING("haspopup"));
-  if (aStates & nsIAccessibleStates::STATE_REQUIRED)
+  if (state & states::REQUIRED)
     stringStates->Add(NS_LITERAL_STRING("required"));
-  if (aStates & nsIAccessibleStates::STATE_IMPORTANT)
-    stringStates->Add(NS_LITERAL_STRING("important"));
-  if (aStates & nsIAccessibleStates::STATE_INVALID)
+  if (state & states::ALERT)
+    stringStates->Add(NS_LITERAL_STRING("alert"));
+  if (state & states::INVALID)
     stringStates->Add(NS_LITERAL_STRING("invalid"));
-  if (aStates & nsIAccessibleStates::STATE_CHECKABLE)
+  if (state & states::CHECKABLE)
     stringStates->Add(NS_LITERAL_STRING("checkable"));
 
-  //extraStates
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_SUPPORTS_AUTOCOMPLETION)
+  // extraStates
+  if (state & states::SUPPORTS_AUTOCOMPLETION)
     stringStates->Add(NS_LITERAL_STRING("autocompletion"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_DEFUNCT)
+  if (state & states::DEFUNCT)
     stringStates->Add(NS_LITERAL_STRING("defunct"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_SELECTABLE_TEXT)
+  if (state & states::SELECTABLE_TEXT)
     stringStates->Add(NS_LITERAL_STRING("selectable text"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_EDITABLE)
+  if (state & states::EDITABLE)
     stringStates->Add(NS_LITERAL_STRING("editable"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_ACTIVE)
+  if (state & states::ACTIVE)
     stringStates->Add(NS_LITERAL_STRING("active"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_MODAL)
+  if (state & states::MODAL)
     stringStates->Add(NS_LITERAL_STRING("modal"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_MULTI_LINE)
+  if (state & states::MULTI_LINE)
     stringStates->Add(NS_LITERAL_STRING("multi line"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_HORIZONTAL)
+  if (state & states::HORIZONTAL)
     stringStates->Add(NS_LITERAL_STRING("horizontal"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_OPAQUE)
+  if (state & states::OPAQUE1)
     stringStates->Add(NS_LITERAL_STRING("opaque"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_SINGLE_LINE)
+  if (state & states::SINGLE_LINE)
     stringStates->Add(NS_LITERAL_STRING("single line"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_TRANSIENT)
+  if (state & states::TRANSIENT)
     stringStates->Add(NS_LITERAL_STRING("transient"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_VERTICAL)
+  if (state & states::VERTICAL)
     stringStates->Add(NS_LITERAL_STRING("vertical"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_STALE)
+  if (state & states::STALE)
     stringStates->Add(NS_LITERAL_STRING("stale"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_ENABLED)
+  if (state & states::ENABLED)
     stringStates->Add(NS_LITERAL_STRING("enabled"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_SENSITIVE)
+  if (state & states::SENSITIVE)
     stringStates->Add(NS_LITERAL_STRING("sensitive"));
-  if (aExtraStates & nsIAccessibleStates::EXT_STATE_EXPANDABLE)
+  if (state & states::EXPANDABLE)
     stringStates->Add(NS_LITERAL_STRING("expandable"));
 
   //unknown states
   PRUint32 stringStatesLength = 0;
-
   stringStates->GetLength(&stringStatesLength);
   if (!stringStatesLength)
     stringStates->Add(NS_LITERAL_STRING("unknown"));
 
   NS_ADDREF(*aStringStates = stringStates);
   return NS_OK;
 }
 
--- a/accessible/src/base/nsAccessible.cpp
+++ b/accessible/src/base/nsAccessible.cpp
@@ -47,16 +47,17 @@
 #include "nsDocAccessible.h"
 #include "nsEventShell.h"
 
 #include "nsAccEvent.h"
 #include "nsAccessibilityService.h"
 #include "nsAccTreeWalker.h"
 #include "nsRelUtils.h"
 #include "nsTextEquivUtils.h"
+#include "States.h"
 
 #include "nsIDOMElement.h"
 #include "nsIDOMDocument.h"
 #include "nsIDOMDocumentXBL.h"
 #include "nsIDOMDocumentTraversal.h"
 #include "nsIDOMHTMLDocument.h"
 #include "nsIDOMHTMLFormElement.h"
 #include "nsIDOMNodeFilter.h"
@@ -607,22 +608,23 @@ nsresult nsAccessible::GetFullKeyName(co
                                                     getter_Copies(separator)))) {
     return NS_ERROR_FAILURE;
   }
 
   aStringOut = modifierName + separator + aKeyName; 
   return NS_OK;
 }
 
-PRBool nsAccessible::IsVisible(PRBool *aIsOffscreen) 
+PRBool
+nsAccessible::IsVisible(PRBool* aIsOffscreen)
 {
-  // We need to know if at least a kMinPixels around the object is visible
-  // Otherwise it will be marked nsIAccessibleStates::STATE_OFFSCREEN
-  // The STATE_INVISIBLE flag is for elements which are programmatically hidden
-  
+  // We need to know if at least a kMinPixels around the object is visible,
+  // otherwise it will be marked states::OFFSCREEN. The states::INVISIBLE flag
+  // is for elements which are programmatically hidden.
+
   *aIsOffscreen = PR_TRUE;
   if (IsDefunct())
     return PR_FALSE;
 
   const PRUint16 kMinPixels  = 12;
    // Set up the variables we need, return false if we can't get at them all
   nsCOMPtr<nsIPresShell> shell(GetPresShell());
   if (!shell) 
@@ -685,85 +687,77 @@ PRBool nsAccessible::IsVisible(PRBool *a
   nsIView* view = frameWithView->GetViewExternal();
   PRBool isVisible = CheckVisibilityInParentChain(doc, view);
   if (isVisible && rectVisibility == nsRectVisibility_kVisible) {
     *aIsOffscreen = PR_FALSE;
   }
   return isVisible;
 }
 
-nsresult
-nsAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsAccessible::NativeState()
 {
-  *aState = 0;
-
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_DEFUNCT;
-
-    return NS_OK_DEFUNCT_OBJECT;
-  }
-
-  if (aExtraState)
-    *aExtraState = 0;
-
+  if (IsDefunct())
+    return states::DEFUNCT;
+
+  PRUint64 state = 0;
   nsEventStates intrinsicState = mContent->IntrinsicState();
 
   if (intrinsicState.HasState(NS_EVENT_STATE_INVALID))
-    *aState |= nsIAccessibleStates::STATE_INVALID;
+    state |= states::INVALID;
 
   if (intrinsicState.HasState(NS_EVENT_STATE_REQUIRED))
-    *aState |= nsIAccessibleStates::STATE_REQUIRED;
+    state |= states::REQUIRED;
 
   PRBool disabled = mContent->IsHTML() ? 
     (intrinsicState.HasState(NS_EVENT_STATE_DISABLED)) :
     (mContent->AttrValueIs(kNameSpaceID_None,
                            nsAccessibilityAtoms::disabled,
                            nsAccessibilityAtoms::_true,
                            eCaseMatters));
 
   // Set unavailable state based on disabled state, otherwise set focus states
   if (disabled) {
-    *aState |= nsIAccessibleStates::STATE_UNAVAILABLE;
+    state |= states::UNAVAILABLE;
   }
   else if (mContent->IsElement()) {
     nsIFrame *frame = GetFrame();
     if (frame && frame->IsFocusable()) {
-      *aState |= nsIAccessibleStates::STATE_FOCUSABLE;
+      state |= states::FOCUSABLE;
     }
 
     if (gLastFocusedNode == mContent) {
-      *aState |= nsIAccessibleStates::STATE_FOCUSED;
+      state |= states::FOCUSED;
     }
   }
 
-  // Check if nsIAccessibleStates::STATE_INVISIBLE and
-  // STATE_OFFSCREEN flags should be turned on for this object.
+  // Check if states::INVISIBLE and
+  // states::OFFSCREEN flags should be turned on for this object.
   PRBool isOffscreen;
   if (!IsVisible(&isOffscreen)) {
-    *aState |= nsIAccessibleStates::STATE_INVISIBLE;
+    state |= states::INVISIBLE;
   }
   if (isOffscreen) {
-    *aState |= nsIAccessibleStates::STATE_OFFSCREEN;
+    state |= states::OFFSCREEN;
   }
 
   nsIFrame *frame = GetFrame();
   if (frame && (frame->GetStateBits() & NS_FRAME_OUT_OF_FLOW))
-    *aState |= nsIAccessibleStates::STATE_FLOATING;
+    state |= states::FLOATING;
 
   // Check if a XUL element has the popup attribute (an attached popup menu).
   if (mContent->IsXUL())
     if (mContent->HasAttr(kNameSpaceID_None, nsAccessibilityAtoms::popup))
-      *aState |= nsIAccessibleStates::STATE_HASPOPUP;
+      state |= states::HASPOPUP;
 
   // Add 'linked' state for simple xlink.
   if (nsCoreUtils::IsXLink(mContent))
-    *aState |= nsIAccessibleStates::STATE_LINKED;
-
-  return NS_OK;
+    state |= states::LINKED;
+
+  return state;
 }
 
   /* readonly attribute boolean focusedChild; */
 NS_IMETHODIMP
 nsAccessible::GetFocusedChild(nsIAccessible **aFocusedChild) 
 { 
   nsAccessible *focusedChild = nsnull;
   if (gLastFocusedNode == mContent) {
@@ -838,17 +832,17 @@ nsAccessible::GetChildAtPoint(PRInt32 aX
     PRInt32 childCount = GetChildCount();
     for (PRInt32 childIdx = 0; childIdx < childCount; childIdx++) {
       nsAccessible *child = GetChildAt(childIdx);
 
       PRInt32 childX, childY, childWidth, childHeight;
       child->GetBounds(&childX, &childY, &childWidth, &childHeight);
       if (aX >= childX && aX < childX + childWidth &&
           aY >= childY && aY < childY + childHeight &&
-          (nsAccUtils::State(child) & nsIAccessibleStates::STATE_INVISIBLE) == 0) {
+          (child->State() & states::INVISIBLE) == 0) {
 
         if (aWhichChild == eDeepestChild)
           return child->GetChildAtPoint(aX, aY, eDeepestChild);
 
         return child;
       }
     }
 
@@ -1048,18 +1042,17 @@ nsIFrame* nsAccessible::GetBoundsFrame()
 
 /* void removeSelection (); */
 NS_IMETHODIMP nsAccessible::SetSelected(PRBool aSelect)
 {
   // Add or remove selection
   if (IsDefunct())
     return NS_ERROR_FAILURE;
 
-  PRUint32 state = nsAccUtils::State(this);
-  if (state & nsIAccessibleStates::STATE_SELECTABLE) {
+  if (State() & states::SELECTABLE) {
     nsCOMPtr<nsIAccessible> multiSelect =
       nsAccUtils::GetMultiSelectableContainer(mContent);
     if (!multiSelect) {
       return aSelect ? TakeFocus() : NS_ERROR_FAILURE;
     }
 
     if (mRoleMapEntry) {
       if (aSelect) {
@@ -1077,18 +1070,17 @@ NS_IMETHODIMP nsAccessible::SetSelected(
 
 /* void takeSelection (); */
 NS_IMETHODIMP nsAccessible::TakeSelection()
 {
   // Select only this item
   if (IsDefunct())
     return NS_ERROR_FAILURE;
 
-  PRUint32 state = nsAccUtils::State(this);
-  if (state & nsIAccessibleStates::STATE_SELECTABLE) {
+  if (State() & states::SELECTABLE) {
     nsCOMPtr<nsIAccessible> multiSelect =
       nsAccUtils::GetMultiSelectableContainer(mContent);
     if (multiSelect) {
       nsCOMPtr<nsIAccessibleSelectable> selectable = do_QueryInterface(multiSelect);
       selectable->ClearSelection();
     }
     return SetSelected(PR_TRUE);
   }
@@ -1326,17 +1318,17 @@ nsAccessible::GetAttributes(nsIPersisten
     // We test for the value interface because we don't want to expose traditional get_accValue()
     // information such as URL's on links and documents, or text in an input
     nsAutoString valuetext;
     GetValue(valuetext);
     attributes->SetStringProperty(NS_LITERAL_CSTRING("valuetext"), valuetext, oldValueUnused);
   }
 
   // Expose checkable object attribute if the accessible has checkable state
-  if (nsAccUtils::State(this) & nsIAccessibleStates::STATE_CHECKABLE)
+  if (State() & states::CHECKABLE)
     nsAccUtils::SetAccAttr(attributes, nsAccessibilityAtoms::checkable, NS_LITERAL_STRING("true"));
 
   // Group attributes (level/setsize/posinset)
   PRInt32 level = 0, posInSet = 0, setSize = 0;
   rv = GroupPosition(&level, &setSize, &posInSet);
   if (NS_SUCCEEDED(rv))
     nsAccUtils::SetAccGroupAttrs(attributes, level, setSize, posInSet);
 
@@ -1492,17 +1484,17 @@ nsAccessible::GroupPosition(PRInt32 *aGr
                            aGroupLevel);
   nsCoreUtils::GetUIntAttr(mContent, nsAccessibilityAtoms::aria_posinset,
                            aPositionInGroup);
   nsCoreUtils::GetUIntAttr(mContent, nsAccessibilityAtoms::aria_setsize,
                            aSimilarItemsInGroup);
 
   // If ARIA is missed and the accessible is visible then calculate group
   // position from hierarchy.
-  if (nsAccUtils::State(this) & nsIAccessibleStates::STATE_INVISIBLE)
+  if (State() & states::INVISIBLE)
     return NS_OK;
 
   // Calculate group level if ARIA is missed.
   if (*aGroupLevel == 0) {
     PRInt32 level = GetLevelInternal();
     if (level != 0)
       *aGroupLevel = level;
   }
@@ -1519,176 +1511,176 @@ nsAccessible::GroupPosition(PRInt32 *aGr
         *aSimilarItemsInGroup = setSize;
     }
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsAccessible::GetState(PRUint32 *aState, PRUint32 *aExtraState)
+nsAccessible::GetState(PRUint32* aState, PRUint32* aExtraState)
 {
   NS_ENSURE_ARG_POINTER(aState);
 
-  nsresult rv = GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  nsAccUtils::To32States(State(), aState, aExtraState);
+  return NS_OK;
+}
+
+PRUint64
+nsAccessible::State()
+{
+  PRUint64 state = NativeState();
+  if (state & states::DEFUNCT)
+    return state;
 
   // Apply ARIA states to be sure accessible states will be overriden.
-  GetARIAState(aState, aExtraState);
+  ApplyARIAState(&state);
 
   if (mRoleMapEntry && mRoleMapEntry->role == nsIAccessibleRole::ROLE_PAGETAB) {
-    if (*aState & nsIAccessibleStates::STATE_FOCUSED) {
-      *aState |= nsIAccessibleStates::STATE_SELECTED;
+    if (state & states::FOCUSED) {
+      state |= states::SELECTED;
     } else {
       // Expose 'selected' state on ARIA tab if the focus is on internal element
       // of related tabpanel.
       nsCOMPtr<nsIAccessible> tabPanel = nsRelUtils::
         GetRelatedAccessible(this, nsIAccessibleRelation::RELATION_LABEL_FOR);
 
       if (nsAccUtils::Role(tabPanel) == nsIAccessibleRole::ROLE_PROPERTYPAGE) {
         nsRefPtr<nsAccessible> tabPanelAcc(do_QueryObject(tabPanel));
         nsINode *tabPanelNode = tabPanelAcc->GetNode();
         if (nsCoreUtils::IsAncestorOf(tabPanelNode, gLastFocusedNode))
-          *aState |= nsIAccessibleStates::STATE_SELECTED;
+          state |= states::SELECTED;
       }
     }
   }
 
-  const PRUint32 kExpandCollapseStates =
-    nsIAccessibleStates::STATE_COLLAPSED | nsIAccessibleStates::STATE_EXPANDED;
-  if ((*aState & kExpandCollapseStates) == kExpandCollapseStates) {
+  const PRUint32 kExpandCollapseStates = states::COLLAPSED | states::EXPANDED;
+  if ((state & kExpandCollapseStates) == kExpandCollapseStates) {
     // Cannot be both expanded and collapsed -- this happens in ARIA expanded
     // combobox because of limitation of nsARIAMap.
     // XXX: Perhaps we will be able to make this less hacky if we support
     // extended states in nsARIAMap, e.g. derive COLLAPSED from
     // EXPANDABLE && !EXPANDED.
-    *aState &= ~nsIAccessibleStates::STATE_COLLAPSED;
+    state &= ~states::COLLAPSED;
   }
 
-  // Set additional states which presence depends on another states.
-  if (!aExtraState)
-    return NS_OK;
-
-  if (!(*aState & nsIAccessibleStates::STATE_UNAVAILABLE)) {
-    *aExtraState |= nsIAccessibleStates::EXT_STATE_ENABLED |
-                    nsIAccessibleStates::EXT_STATE_SENSITIVE;
+  if (!(state & states::UNAVAILABLE)) {
+    state |= states::ENABLED | states::SENSITIVE;
   }
 
-  if ((*aState & nsIAccessibleStates::STATE_COLLAPSED) ||
-      (*aState & nsIAccessibleStates::STATE_EXPANDED))
-    *aExtraState |= nsIAccessibleStates::EXT_STATE_EXPANDABLE;
+  if ((state & states::COLLAPSED) || (state & states::EXPANDED))
+    state |= states::EXPANDABLE;
 
   if (mRoleMapEntry) {
     // If an object has an ancestor with the activedescendant property
     // pointing at it, we mark it as ACTIVE even if it's not currently focused.
     // This allows screen reader virtual buffer modes to know which descendant
     // is the current one that would get focus if the user navigates to the container widget.
     nsAutoString id;
     if (nsCoreUtils::GetID(mContent, id)) {
       nsIContent *ancestorContent = mContent;
       nsAutoString activeID;
       while ((ancestorContent = ancestorContent->GetParent()) != nsnull) {
         if (ancestorContent->GetAttr(kNameSpaceID_None, nsAccessibilityAtoms::aria_activedescendant, activeID)) {
           if (id == activeID) {
-            *aExtraState |= nsIAccessibleStates::EXT_STATE_ACTIVE;
+            state |= states::ACTIVE;
           }
           break;
         }
       }
     }
   }
 
   // For some reasons DOM node may have not a frame. We tract such accessibles
   // as invisible.
   nsIFrame *frame = GetFrame();
   if (!frame)
-    return NS_OK;
+    return state;
 
   const nsStyleDisplay* display = frame->GetStyleDisplay();
   if (display && display->mOpacity == 1.0f &&
-      !(*aState & nsIAccessibleStates::STATE_INVISIBLE)) {
-    *aExtraState |= nsIAccessibleStates::EXT_STATE_OPAQUE;
+      !(state & states::INVISIBLE)) {
+    state |= states::OPAQUE1;
   }
 
   const nsStyleXUL *xulStyle = frame->GetStyleXUL();
   if (xulStyle) {
     // In XUL all boxes are either vertical or horizontal
     if (xulStyle->mBoxOrient == NS_STYLE_BOX_ORIENT_VERTICAL) {
-      *aExtraState |= nsIAccessibleStates::EXT_STATE_VERTICAL;
+      state |= states::VERTICAL;
     }
     else {
-      *aExtraState |= nsIAccessibleStates::EXT_STATE_HORIZONTAL;
+      state |= states::HORIZONTAL;
     }
   }
   
   // If we are editable, force readonly bit off
-  if (*aExtraState & nsIAccessibleStates::EXT_STATE_EDITABLE)
-    *aState &= ~nsIAccessibleStates::STATE_READONLY;
+  if (state & states::EDITABLE)
+    state &= ~states::READONLY;
  
-  return NS_OK;
+  return state;
 }
 
-nsresult
-nsAccessible::GetARIAState(PRUint32 *aState, PRUint32 *aExtraState)
+void
+nsAccessible::ApplyARIAState(PRUint64* aState)
 {
   // Test for universal states first
   PRUint32 index = 0;
-  while (nsStateMapEntry::MapToStates(mContent, aState, aExtraState,
+  while (nsStateMapEntry::MapToStates(mContent, aState,
                                       nsARIAMap::gWAIUnivStateMap[index])) {
     ++ index;
   }
 
   if (mRoleMapEntry) {
 
     // We only force the readonly bit off if we have a real mapping for the aria
     // role. This preserves the ability for screen readers to use readonly
     // (primarily on the document) as the hint for creating a virtual buffer.
     if (mRoleMapEntry->role != nsIAccessibleRole::ROLE_NOTHING)
-      *aState &= ~nsIAccessibleStates::STATE_READONLY;
+      *aState &= ~states::READONLY;
 
     if (mContent->HasAttr(kNameSpaceID_None, mContent->GetIDAttributeName())) {
       // If has a role & ID and aria-activedescendant on the container, assume focusable
       nsIContent *ancestorContent = mContent;
       while ((ancestorContent = ancestorContent->GetParent()) != nsnull) {
         if (ancestorContent->HasAttr(kNameSpaceID_None, nsAccessibilityAtoms::aria_activedescendant)) {
             // ancestor has activedescendant property, this content could be active
-          *aState |= nsIAccessibleStates::STATE_FOCUSABLE;
+          *aState |= states::FOCUSABLE;
           break;
         }
       }
     }
   }
 
-  if (*aState & nsIAccessibleStates::STATE_FOCUSABLE) {
+  if (*aState & states::FOCUSABLE) {
     // Special case: aria-disabled propagates from ancestors down to any focusable descendant
     nsIContent *ancestorContent = mContent;
     while ((ancestorContent = ancestorContent->GetParent()) != nsnull) {
       if (ancestorContent->AttrValueIs(kNameSpaceID_None, nsAccessibilityAtoms::aria_disabled,
                                        nsAccessibilityAtoms::_true, eCaseMatters)) {
           // ancestor has aria-disabled property, this is disabled
-        *aState |= nsIAccessibleStates::STATE_UNAVAILABLE;
+        *aState |= states::UNAVAILABLE;
         break;
       }
     }    
   }
 
   if (!mRoleMapEntry)
-    return NS_OK;
+    return;
 
   // Note: the readonly bitflag will be overridden later if content is editable
   *aState |= mRoleMapEntry->state;
-  if (nsStateMapEntry::MapToStates(mContent, aState, aExtraState,
+  if (nsStateMapEntry::MapToStates(mContent, aState,
                                    mRoleMapEntry->attributeMap1) &&
-      nsStateMapEntry::MapToStates(mContent, aState, aExtraState,
+      nsStateMapEntry::MapToStates(mContent, aState,
                                    mRoleMapEntry->attributeMap2)) {
-    nsStateMapEntry::MapToStates(mContent, aState, aExtraState,
+    nsStateMapEntry::MapToStates(mContent, aState,
                                  mRoleMapEntry->attributeMap3);
   }
 
-  return NS_OK;
 }
 
 // Not implemented by this class
 
 /* DOMString getValue (); */
 NS_IMETHODIMP
 nsAccessible::GetValue(nsAString& aValue)
 {
@@ -1757,20 +1749,19 @@ NS_IMETHODIMP
 nsAccessible::SetCurrentValue(double aValue)
 {
   if (IsDefunct())
     return NS_ERROR_FAILURE;
 
   if (!mRoleMapEntry || mRoleMapEntry->valueRule == eNoValue)
     return NS_OK_NO_ARIA_VALUE;
 
-  const PRUint32 kValueCannotChange = nsIAccessibleStates::STATE_READONLY |
-                                      nsIAccessibleStates::STATE_UNAVAILABLE;
-
-  if (nsAccUtils::State(this) & kValueCannotChange)
+  const PRUint32 kValueCannotChange = states::READONLY | states::UNAVAILABLE;
+
+  if (State() & kValueCannotChange)
     return NS_ERROR_FAILURE;
 
   double minValue = 0;
   if (NS_SUCCEEDED(GetMinimumValue(&minValue)) && aValue < minValue)
     return NS_ERROR_INVALID_ARG;
 
   double maxValue = 0;
   if (NS_SUCCEEDED(GetMaximumValue(&maxValue)) && aValue > maxValue)
@@ -1874,17 +1865,17 @@ NS_IMETHODIMP
 nsAccessible::GetNumActions(PRUint8 *aNumActions)
 {
   NS_ENSURE_ARG_POINTER(aNumActions);
   *aNumActions = 0;
 
   if (IsDefunct())
     return NS_ERROR_FAILURE;
 
-  PRUint32 actionRule = GetActionRule(nsAccUtils::State(this));
+  PRUint32 actionRule = GetActionRule(State());
   if (actionRule == eNoAction)
     return NS_OK;
 
   *aNumActions = 1;
   return NS_OK;
 }
 
 /* DOMString getAccActionName (in PRUint8 index); */
@@ -1894,43 +1885,43 @@ nsAccessible::GetActionName(PRUint8 aInd
   aName.Truncate();
 
   if (aIndex != 0)
     return NS_ERROR_INVALID_ARG;
 
   if (IsDefunct())
     return NS_ERROR_FAILURE;
 
-  PRUint32 states = nsAccUtils::State(this);
+  PRUint64 states = State();
   PRUint32 actionRule = GetActionRule(states);
 
  switch (actionRule) {
    case eActivateAction:
      aName.AssignLiteral("activate");
      return NS_OK;
 
    case eClickAction:
      aName.AssignLiteral("click");
      return NS_OK;
 
    case eCheckUncheckAction:
-     if (states & nsIAccessibleStates::STATE_CHECKED)
+     if (states & states::CHECKED)
        aName.AssignLiteral("uncheck");
-     else if (states & nsIAccessibleStates::STATE_MIXED)
+     else if (states & states::MIXED)
        aName.AssignLiteral("cycle");
      else
        aName.AssignLiteral("check");
      return NS_OK;
 
    case eJumpAction:
      aName.AssignLiteral("jump");
      return NS_OK;
 
    case eOpenCloseAction:
-     if (states & nsIAccessibleStates::STATE_COLLAPSED)
+     if (states & states::COLLAPSED)
        aName.AssignLiteral("open");
      else
        aName.AssignLiteral("close");
      return NS_OK;
 
    case eSelectAction:
      aName.AssignLiteral("select");
      return NS_OK;
@@ -1939,17 +1930,17 @@ nsAccessible::GetActionName(PRUint8 aInd
      aName.AssignLiteral("switch");
      return NS_OK;
      
    case eSortAction:
      aName.AssignLiteral("sort");
      return NS_OK;
    
    case eExpandAction:
-     if (states & nsIAccessibleStates::STATE_COLLAPSED)
+     if (states & states::COLLAPSED)
        aName.AssignLiteral("expand");
      else
        aName.AssignLiteral("collapse");
      return NS_OK;
   }
 
   return NS_ERROR_INVALID_ARG;
 }
@@ -1971,17 +1962,17 @@ NS_IMETHODIMP
 nsAccessible::DoAction(PRUint8 aIndex)
 {
   if (aIndex != 0)
     return NS_ERROR_INVALID_ARG;
 
   if (IsDefunct())
     return NS_ERROR_FAILURE;
 
-  if (GetActionRule(nsAccUtils::State(this)) != eNoAction) {
+  if (GetActionRule(State()) != eNoAction) {
     DoCommand();
     return NS_OK;
   }
 
   return NS_ERROR_INVALID_ARG;
 }
 
 /* DOMString getHelp (); */
@@ -2797,20 +2788,20 @@ nsAccessible::InsertChildAt(PRUint32 aIn
 }
 
 PRBool
 nsAccessible::RemoveChild(nsAccessible* aChild)
 {
   if (!aChild)
     return PR_FALSE;
 
-  PRInt32 index = aChild->mIndexInParent;
-  if (aChild->mParent != this || index == -1)
+  if (aChild->mParent != this || aChild->mIndexInParent == -1)
     return PR_FALSE;
 
+  PRUint32 index = static_cast<PRUint32>(aChild->mIndexInParent);
   if (index >= mChildren.Length() || mChildren[index] != aChild) {
     NS_ERROR("Child is bound to parent but parent hasn't this child at its index!");
     aChild->UnbindFromParent();
     return PR_FALSE;
   }
 
   for (PRUint32 idx = index + 1; idx < mChildren.Length(); idx++) {
     NS_ASSERTION(mChildren[idx]->mIndexInParent == idx, "Accessible child index doesn't match");
@@ -2925,18 +2916,17 @@ nsAccessible::EndOffset()
   return hyperText ? (hyperText->GetChildOffset(this) + 1) : 0;
 }
 
 bool
 nsAccessible::IsValid()
 {
   NS_PRECONDITION(IsHyperLink(), "IsValid is called on not hyper link!");
 
-  PRUint32 state = nsAccUtils::State(this);
-  return (0 == (state & nsIAccessibleStates::STATE_INVALID));
+  return (0 == (State() & states::INVALID));
   // XXX In order to implement this we would need to follow every link
   // Perhaps we can get information about invalid links from the cache
   // In the mean time authors can use role="link" aria-invalid="true"
   // to force it for links they internally know to be invalid
 }
 
 bool
 nsAccessible::IsSelected()
@@ -3049,17 +3039,17 @@ nsAccessible::IsItemSelected(PRUint32 aI
 {
   PRUint32 index = 0;
   AccIterator iter(this, filters::GetSelectable, AccIterator::eTreeNav);
   nsAccessible* selected = nsnull;
   while ((selected = iter.GetNext()) && index < aIndex)
     index++;
 
   return selected &&
-    nsAccUtils::State(selected) & nsIAccessibleStates::STATE_SELECTED;
+    selected->State() & states::SELECTED;
 }
 
 bool
 nsAccessible::AddItemToSelection(PRUint32 aIndex)
 {
   PRUint32 index = 0;
   AccIterator iter(this, filters::GetSelectable, AccIterator::eTreeNav);
   nsAccessible* selected = nsnull;
@@ -3316,19 +3306,19 @@ nsAccessible::GetAttrValue(nsIAtom *aPro
   double value = attrValue.ToDouble(&error);
   if (NS_SUCCEEDED(error))
     *aValue = value;
 
   return NS_OK;
 }
 
 PRUint32
-nsAccessible::GetActionRule(PRUint32 aStates)
+nsAccessible::GetActionRule(PRUint64 aStates)
 {
-  if (aStates & nsIAccessibleStates::STATE_UNAVAILABLE)
+  if (aStates & states::UNAVAILABLE)
     return eNoAction;
   
   // Check if it's simple xlink.
   if (nsCoreUtils::IsXLink(mContent))
     return eJumpAction;
 
   // Return "click" action on elements that have an attached popup menu.
   if (mContent->IsXUL())
--- a/accessible/src/base/nsAccessible.h
+++ b/accessible/src/base/nsAccessible.h
@@ -125,19 +125,18 @@ public:
   nsresult GetARIAName(nsAString& aName);
 
   /**
    * Maps ARIA state attributes to state of accessible. Note the given state
    * argument should hold states for accessible before you pass it into this
    * method.
    *
    * @param  [in/out] where to fill the states into.
-   * @param  [in/out] where to fill the extra states into
    */
-  virtual nsresult GetARIAState(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual void ApplyARIAState(PRUint64* aState);
 
   /**
    * Returns the accessible name provided by native markup. It doesn't take
    * into account ARIA markup used to specify the name.
    *
    * @param  aName             [out] the accessible name
    *
    * @return NS_OK_EMPTY_NAME  points empty name was specified by native markup
@@ -171,22 +170,25 @@ public:
 
   /**
    * Returns enumerated accessible role from native markup (see constants in
    * nsIAccessibleRole). Doesn't take into account ARIA roles.
    */
   virtual PRUint32 NativeRole();
 
   /**
-   * Return the state of accessible that doesn't take into account ARIA states.
-   * Use nsIAccessible::state to get all states for accessible. If
-   * second argument is omitted then second bit field of accessible state won't
-   * be calculated.
+   * Return all states of accessible (including ARIA states).
    */
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 State();
+
+  /**
+   * Return the states of accessible, not taking into account ARIA states.
+   * Use State() to get complete set of states.
+   */
+  virtual PRUint64 NativeState();
 
   /**
    * Returns attributes for accessible without explicitly setted ARIA
    * attributes.
    */
   virtual nsresult GetAttributesInternal(nsIPersistentProperties *aAttributes);
 
   /**
@@ -615,17 +617,17 @@ protected:
   nsresult GetAttrValue(nsIAtom *aAriaProperty, double *aValue);
 
   /**
    * Return the action rule based on ARIA enum constants EActionRule
    * (see nsARIAMap.h). Used by GetNumActions() and GetActionName().
    *
    * @param aStates  [in] states of the accessible
    */
-  PRUint32 GetActionRule(PRUint32 aStates);
+  PRUint32 GetActionRule(PRUint64 aStates);
 
   /**
    * Return group info.
    */
   AccGroupInfo* GetGroupInfo();
 
   /**
    * Fires platform accessible event. It's notification method only. It does
--- a/accessible/src/base/nsApplicationAccessible.cpp
+++ b/accessible/src/base/nsApplicationAccessible.cpp
@@ -37,16 +37,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
  
 #include "nsApplicationAccessible.h"
 
+#include "States.h"
 #include "nsAccessibilityService.h"
 #include "nsAccUtils.h"
 
 #include "nsIComponentManager.h"
 #include "nsIDOMDocument.h"
 #include "nsIDOMWindow.h"
 #include "nsIWindowMediator.h"
 #include "nsServiceManagerUtils.h"
@@ -135,22 +136,20 @@ nsApplicationAccessible::GetDescription(
 
 NS_IMETHODIMP
 nsApplicationAccessible::GetKeyboardShortcut(nsAString &aKeyboardShortcut)
 {
   aKeyboardShortcut.Truncate();
   return NS_OK;
 }
 
-NS_IMETHODIMP
-nsApplicationAccessible::GetState(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsApplicationAccessible::State()
 {
-  NS_ENSURE_ARG_POINTER(aState);
-  GetStateInternal(aState, aExtraState);
-  return NS_OK;
+  return NativeState();
 }
 
 NS_IMETHODIMP
 nsApplicationAccessible::GetAttributes(nsIPersistentProperties **aAttributes)
 {
   NS_ENSURE_ARG_POINTER(aAttributes);
   *aAttributes = nsnull;
   return NS_OK;
@@ -357,45 +356,31 @@ bool
 nsApplicationAccessible::IsPrimaryForNode() const
 {
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsAccessible public methods
 
-nsresult
-nsApplicationAccessible::GetARIAState(PRUint32 *aState, PRUint32 *aExtraState)
+void
+nsApplicationAccessible::ApplyARIAState(PRUint64* aState)
 {
-  return NS_OK;
 }
 
 PRUint32
 nsApplicationAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_APP_ROOT;
 }
 
-nsresult
-nsApplicationAccessible::GetStateInternal(PRUint32 *aState,
-                                          PRUint32 *aExtraState)
+PRUint64
+nsApplicationAccessible::NativeState()
 {
-  *aState = 0;
-
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_DEFUNCT;
-
-    return NS_OK_DEFUNCT_OBJECT;
-  }
-
-  if (aExtraState)
-    *aExtraState = 0;
-
-  return NS_OK;
+  return IsDefunct() ? states::DEFUNCT : 0;
 }
 
 void
 nsApplicationAccessible::InvalidateChildren()
 {
   // Do nothing because application children are kept updated by AppendChild()
   // and RemoveChild() method calls.
 }
--- a/accessible/src/base/nsApplicationAccessible.h
+++ b/accessible/src/base/nsApplicationAccessible.h
@@ -89,17 +89,16 @@ public:
   // nsIAccessible
   NS_IMETHOD GetParent(nsIAccessible **aParent);
   NS_IMETHOD GetNextSibling(nsIAccessible **aNextSibling);
   NS_IMETHOD GetPreviousSibling(nsIAccessible **aPreviousSibling);
   NS_IMETHOD GetName(nsAString &aName);
   NS_IMETHOD GetValue(nsAString &aValue);
   NS_IMETHOD GetDescription(nsAString &aDescription);
   NS_IMETHOD GetKeyboardShortcut(nsAString &aKeyboardShortcut);
-  NS_IMETHOD GetState(PRUint32 *aState , PRUint32 *aExtraState );
   NS_IMETHOD GetAttributes(nsIPersistentProperties **aAttributes);
   NS_IMETHOD GroupPosition(PRInt32 *aGroupLevel, PRInt32 *aSimilarItemsInGroup,
                            PRInt32 *aPositionInGroup);
   NS_IMETHOD GetRelationByType(PRUint32 aRelationType,
                                nsIAccessibleRelation **aRelation);
   NS_IMETHOD GetRelationsCount(PRUint32 *aRelationsCount);
   NS_IMETHOD GetRelation(PRUint32 aIndex, nsIAccessibleRelation **aRelation);
   NS_IMETHOD GetRelations(nsIArray **aRelations);
@@ -118,19 +117,20 @@ public:
 
   // nsAccessNode
   virtual PRBool IsDefunct();
   virtual PRBool Init();
   virtual void Shutdown();
   virtual bool IsPrimaryForNode() const;
 
   // nsAccessible
-  virtual nsresult GetARIAState(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual void ApplyARIAState(PRUint64* aState);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 State();
+  virtual PRUint64 NativeState();
   virtual nsAccessible* GetChildAtPoint(PRInt32 aX, PRInt32 aY,
                                         EWhichChildAtPoint aWhichChild);
 
   virtual void InvalidateChildren();
 
 protected:
 
   // nsAccessible
--- a/accessible/src/base/nsBaseWidgetAccessible.cpp
+++ b/accessible/src/base/nsBaseWidgetAccessible.cpp
@@ -34,16 +34,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsBaseWidgetAccessible.h"
 
+#include "States.h"
 #include "nsAccessibilityAtoms.h"
 #include "nsAccessibilityService.h"
 #include "nsAccUtils.h"
 #include "nsCoreUtils.h"
 #include "nsHyperTextAccessibleWrap.h"
 
 #include "nsIDOMNSHTMLElement.h"
 #include "nsGUIEvent.h"
@@ -108,30 +109,28 @@ nsLinkableAccessible::TakeFocus()
 {
   nsAccessible *actionAcc = GetActionAccessible();
   if (actionAcc)
     return actionAcc->TakeFocus();
 
   return nsAccessibleWrap::TakeFocus();
 }
 
-nsresult
-nsLinkableAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsLinkableAccessible::NativeState()
 {
-  nsresult rv = nsAccessibleWrap::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
+  PRUint64 states = nsAccessibleWrap::NativeState();
   if (mIsLink) {
-    *aState |= nsIAccessibleStates::STATE_LINKED;
-    nsAccessible *actionAcc = GetActionAccessible();
-    if (nsAccUtils::State(actionAcc) & nsIAccessibleStates::STATE_TRAVERSED)
-      *aState |= nsIAccessibleStates::STATE_TRAVERSED;
+    states |= states::LINKED;
+    nsAccessible* actionAcc = GetActionAccessible();
+    if (actionAcc->State() & states::TRAVERSED)
+      states |= states::TRAVERSED;
   }
 
-  return NS_OK;
+  return states;
 }
 
 NS_IMETHODIMP
 nsLinkableAccessible::GetValue(nsAString& aValue)
 {
   aValue.Truncate();
 
   nsAccessible::GetValue(aValue);
@@ -255,17 +254,17 @@ nsLinkableAccessible::BindToParent(nsAcc
     return;
   }
 
   while ((walkUpContent = walkUpContent->GetParent())) {
     nsAccessible* walkUpAcc =
       GetAccService()->GetAccessibleInWeakShell(walkUpContent, mWeakShell);
 
     if (walkUpAcc && walkUpAcc->Role() == nsIAccessibleRole::ROLE_LINK &&
-        nsAccUtils::State(walkUpAcc) & nsIAccessibleStates::STATE_LINKED) {
+        walkUpAcc->State() & states::LINKED) {
       mIsLink = PR_TRUE;
       mActionContent = walkUpContent;
       return;
     }
 
     isOnclick = nsCoreUtils::HasClickListener(walkUpContent);
     if (isOnclick) {
       mActionContent = walkUpContent;
--- a/accessible/src/base/nsBaseWidgetAccessible.h
+++ b/accessible/src/base/nsBaseWidgetAccessible.h
@@ -94,17 +94,17 @@ public:
   NS_IMETHOD GetValue(nsAString& _retval);
   NS_IMETHOD TakeFocus();
   NS_IMETHOD GetKeyboardShortcut(nsAString& _retval);
 
   // nsAccessNode
   virtual void Shutdown();
 
   // nsAccessible
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
   // HyperLinkAccessible
   virtual already_AddRefed<nsIURI> GetAnchorURI(PRUint32 aAnchorIndex);
 
 protected:
   // nsAccessible
   virtual void BindToParent(nsAccessible* aParent, PRUint32 aIndexInParent);
 
--- a/accessible/src/base/nsDocAccessible.cpp
+++ b/accessible/src/base/nsDocAccessible.cpp
@@ -31,16 +31,17 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
+#include "States.h"
 #include "nsAccCache.h"
 #include "nsAccessibilityAtoms.h"
 #include "nsAccessibilityService.h"
 #include "nsAccTreeWalker.h"
 #include "nsAccUtils.h"
 #include "nsRootAccessible.h"
 #include "nsTextEquivUtils.h"
 
@@ -78,17 +79,17 @@
 #include "nsIXULDocument.h"
 #endif
 
 namespace dom = mozilla::dom;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Static member initialization
 
-PRUint32 nsDocAccessible::gLastFocusedAccessiblesState = 0;
+PRUint64 nsDocAccessible::gLastFocusedAccessiblesState = 0;
 
 static nsIAtom** kRelationAttrs[] =
 {
   &nsAccessibilityAtoms::aria_labelledby,
   &nsAccessibilityAtoms::aria_describedby,
   &nsAccessibilityAtoms::aria_owns,
   &nsAccessibilityAtoms::aria_controls,
   &nsAccessibilityAtoms::aria_flowto,
@@ -285,92 +286,75 @@ nsDocAccessible::GetDescription(nsAStrin
                              description);
     aDescription = description;
   }
 
   return NS_OK;
 }
 
 // nsAccessible public method
-nsresult
-nsDocAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsDocAccessible::NativeState()
 {
-  *aState = 0;
-
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_DEFUNCT;
 
-    return NS_OK_DEFUNCT_OBJECT;
-  }
+  if (IsDefunct())
+    return states::DEFUNCT;
 
-  if (aExtraState) {
-    // The root content of the document might be removed so that mContent is
-    // out of date.
-    *aExtraState = (mContent->GetCurrentDoc() == mDocument) ?
-      0 : nsIAccessibleStates::EXT_STATE_STALE;
-  }
+  // The root content of the document might be removed so that mContent is
+  // out of date.
+  PRUint64 state = (mContent->GetCurrentDoc() == mDocument) ?
+    0 : states::STALE;
 
 #ifdef MOZ_XUL
   nsCOMPtr<nsIXULDocument> xulDoc(do_QueryInterface(mDocument));
   if (!xulDoc)
 #endif
   {
     // XXX Need to invent better check to see if doc is focusable,
     // which it should be if it is scrollable. A XUL document could be focusable.
     // See bug 376803.
-    *aState |= nsIAccessibleStates::STATE_FOCUSABLE;
+    state |= states::FOCUSABLE;
     if (gLastFocusedNode == mDocument)
-      *aState |= nsIAccessibleStates::STATE_FOCUSED;
+      state |= states::FOCUSED;
   }
 
   // Expose state busy until the document is loaded or tree is constructed.
   if (!mIsLoaded || !mNotificationController->IsTreeConstructed()) {
-    *aState |= nsIAccessibleStates::STATE_BUSY;
-    if (aExtraState) {
-      *aExtraState |= nsIAccessibleStates::EXT_STATE_STALE;
-    }
+    state |= states::BUSY | states::STALE;
   }
  
   nsIFrame* frame = GetFrame();
   while (frame != nsnull && !frame->HasView()) {
     frame = frame->GetParent();
   }
  
   if (frame == nsnull ||
       !CheckVisibilityInParentChain(mDocument, frame->GetViewExternal())) {
-    *aState |= nsIAccessibleStates::STATE_INVISIBLE |
-               nsIAccessibleStates::STATE_OFFSCREEN;
+    state |= states::INVISIBLE | states::OFFSCREEN;
   }
 
   nsCOMPtr<nsIEditor> editor;
   GetAssociatedEditor(getter_AddRefs(editor));
-  if (!editor) {
-    *aState |= nsIAccessibleStates::STATE_READONLY;
-  }
-  else if (aExtraState) {
-    *aExtraState |= nsIAccessibleStates::EXT_STATE_EDITABLE;
-  }
+  state |= editor ? states::EDITABLE : states::READONLY;
 
-  return NS_OK;
+  return state;
 }
 
 // nsAccessible public method
-nsresult
-nsDocAccessible::GetARIAState(PRUint32 *aState, PRUint32 *aExtraState)
+void
+nsDocAccessible::ApplyARIAState(PRUint64* aState)
 {
   // Combine with states from outer doc
-  NS_ENSURE_ARG_POINTER(aState);
-  nsresult rv = nsAccessible::GetARIAState(aState, aExtraState);
-  NS_ENSURE_SUCCESS(rv, rv);
+  // 
+  nsAccessible::ApplyARIAState(aState);
 
-  if (mParent)  // Allow iframe/frame etc. to have final state override via ARIA
-    return mParent->GetARIAState(aState, aExtraState);
+  // Allow iframe/frame etc. to have final state override via ARIA
+  if (mParent)
+    mParent->ApplyARIAState(aState);
 
-  return rv;
 }
 
 NS_IMETHODIMP
 nsDocAccessible::GetAttributes(nsIPersistentProperties **aAttributes)
 {
   nsAccessible::GetAttributes(aAttributes);
   if (mParent) {
     mParent->GetAttributes(aAttributes); // Add parent attributes (override inner)
@@ -392,19 +376,18 @@ NS_IMETHODIMP nsDocAccessible::GetFocuse
   return NS_OK;
 }
 
 NS_IMETHODIMP nsDocAccessible::TakeFocus()
 {
   if (IsDefunct())
     return NS_ERROR_FAILURE;
 
-  PRUint32 state;
-  GetStateInternal(&state, nsnull);
-  if (0 == (state & nsIAccessibleStates::STATE_FOCUSABLE)) {
+  PRUint64 state = NativeState();
+  if (0 == (state & states::FOCUSABLE)) {
     return NS_ERROR_FAILURE; // Not focusable
   }
 
   // Focus the document.
   nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
   NS_ENSURE_STATE(fm);
 
   nsCOMPtr<nsIDOMElement> newFocus;
@@ -910,18 +893,17 @@ NS_IMETHODIMP nsDocAccessible::Observe(n
                                        const PRUnichar *aData)
 {
   if (!nsCRT::strcmp(aTopic,"obs_documentCreated")) {    
     // State editable will now be set, readonly is now clear
     // Normally we only fire delayed events created from the node, not an
     // accessible object. See the AccStateChangeEvent constructor for details
     // about this exceptional case.
     nsRefPtr<AccEvent> event =
-      new AccStateChangeEvent(this, nsIAccessibleStates::EXT_STATE_EDITABLE,
-                              PR_TRUE, PR_TRUE);
+      new AccStateChangeEvent(this, states::EDITABLE, PR_TRUE);
     FireDelayedAccessibleEvent(event);
   }
 
   return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIDocumentObserver
@@ -992,17 +974,17 @@ nsDocAccessible::AttributeChanged(nsIDoc
   // dependent IDs cache when its accessible is created.
   if (aModType == nsIDOMMutationEvent::MODIFICATION ||
       aModType == nsIDOMMutationEvent::ADDITION) {
     AddDependentIDsFor(accessible, aAttribute);
   }
 
   // If it was the focused node, cache the new state.
   if (aElement == gLastFocusedNode)
-    gLastFocusedAccessiblesState = nsAccUtils::State(accessible);
+    gLastFocusedAccessiblesState = accessible->State();
 }
 
 // nsDocAccessible protected member
 void
 nsDocAccessible::AttributeChangedImpl(nsIContent* aContent, PRInt32 aNameSpaceID, nsIAtom* aAttribute)
 {
   // Fire accessible event after short timer, because we need to wait for
   // DOM attribute & resulting layout to actually change. Otherwise,
@@ -1028,26 +1010,22 @@ nsDocAccessible::AttributeChangedImpl(ns
     // Note. Checking the XUL or HTML namespace would not seem to gain us
     // anything, because disabled attribute really is going to mean the same
     // thing in any namespace.
 
     // Note. We use the attribute instead of the disabled state bit because
     // ARIA's aria-disabled does not affect the disabled state bit.
 
     nsRefPtr<AccEvent> enabledChangeEvent =
-      new AccStateChangeEvent(aContent,
-                              nsIAccessibleStates::EXT_STATE_ENABLED,
-                              PR_TRUE);
+      new AccStateChangeEvent(aContent, states::ENABLED);
 
     FireDelayedAccessibleEvent(enabledChangeEvent);
 
     nsRefPtr<AccEvent> sensitiveChangeEvent =
-      new AccStateChangeEvent(aContent,
-                              nsIAccessibleStates::EXT_STATE_SENSITIVE,
-                              PR_TRUE);
+      new AccStateChangeEvent(aContent, states::SENSITIVE);
 
     FireDelayedAccessibleEvent(sensitiveChangeEvent);
     return;
   }
 
   // Check for namespaced ARIA attribute
   if (aNameSpaceID == kNameSpaceID_None) {
     // Check for hyphenated aria-foo property?
@@ -1095,43 +1073,39 @@ nsDocAccessible::AttributeChangedImpl(ns
 
       FireDelayedAccessibleEvent(nsIAccessibleEvent::EVENT_SELECTION_ADD,
                                  aContent);
     }
   }
 
   if (aAttribute == nsAccessibilityAtoms::contenteditable) {
     nsRefPtr<AccEvent> editableChangeEvent =
-      new AccStateChangeEvent(aContent,
-                              nsIAccessibleStates::EXT_STATE_EDITABLE,
-                              PR_TRUE);
+      new AccStateChangeEvent(aContent, states::EDITABLE);
     FireDelayedAccessibleEvent(editableChangeEvent);
     return;
   }
 }
 
 // nsDocAccessible protected member
 void
 nsDocAccessible::ARIAAttributeChanged(nsIContent* aContent, nsIAtom* aAttribute)
 {
   // Note: For universal/global ARIA states and properties we don't care if
   // there is an ARIA role present or not.
 
   if (aAttribute == nsAccessibilityAtoms::aria_required) {
     nsRefPtr<AccEvent> event =
-      new AccStateChangeEvent(aContent, nsIAccessibleStates::STATE_REQUIRED,
-                              PR_FALSE);
+      new AccStateChangeEvent(aContent, states::REQUIRED);
     FireDelayedAccessibleEvent(event);
     return;
   }
 
   if (aAttribute == nsAccessibilityAtoms::aria_invalid) {
     nsRefPtr<AccEvent> event =
-      new AccStateChangeEvent(aContent, nsIAccessibleStates::STATE_INVALID,
-                              PR_FALSE);
+      new AccStateChangeEvent(aContent, states::INVALID);
     FireDelayedAccessibleEvent(event);
     return;
   }
 
   if (aAttribute == nsAccessibilityAtoms::aria_activedescendant) {
     // The activedescendant universal property redirects accessible focus events
     // to the element with the id that activedescendant points to
     nsCOMPtr<nsINode> focusedNode = GetCurrentFocus();
@@ -1152,64 +1126,60 @@ nsDocAccessible::ARIAAttributeChanged(ns
       aAttribute == nsAccessibilityAtoms::aria_hidden) {
     FireDelayedAccessibleEvent(nsIAccessibleEvent::EVENT_OBJECT_ATTRIBUTE_CHANGED,
                                aContent);
   }
 
   // We treat aria-expanded as a global ARIA state for historical reasons
   if (aAttribute == nsAccessibilityAtoms::aria_expanded) {
     nsRefPtr<AccEvent> event =
-      new AccStateChangeEvent(aContent, nsIAccessibleStates::STATE_EXPANDED,
-                              PR_FALSE);
+      new AccStateChangeEvent(aContent, states::EXPANDED);
     FireDelayedAccessibleEvent(event);
     return;
   }
 
   if (!aContent->HasAttr(kNameSpaceID_None, nsAccessibilityAtoms::role)) {
     // We don't care about these other ARIA attribute changes unless there is
     // an ARIA role set for the element
     // XXX: we should check the role map to see if the changed property is
     // relevant for that particular role.
     return;
   }
 
   // The following ARIA attributes only take affect when dynamic content role is present
   if (aAttribute == nsAccessibilityAtoms::aria_checked ||
       aAttribute == nsAccessibilityAtoms::aria_pressed) {
     const PRUint32 kState = (aAttribute == nsAccessibilityAtoms::aria_checked) ?
-                            nsIAccessibleStates::STATE_CHECKED : 
-                            nsIAccessibleStates::STATE_PRESSED;
+                            states::CHECKED : states::PRESSED;
     nsRefPtr<AccEvent> event =
-      new AccStateChangeEvent(aContent, kState, PR_FALSE);
+      new AccStateChangeEvent(aContent, kState);
     FireDelayedAccessibleEvent(event);
     if (aContent == gLastFocusedNode) {
       // State changes for MIXED state currently only supported for focused item, because
       // otherwise we would need access to the old attribute value in this listener.
       // This is because we don't know if the previous value of aria-checked or aria-pressed was "mixed"
       // without caching that info.
       nsAccessible *accessible = event->GetAccessible();
       if (accessible) {
-        PRBool wasMixed = (gLastFocusedAccessiblesState & nsIAccessibleStates::STATE_MIXED) != 0;
+        PRBool wasMixed = (gLastFocusedAccessiblesState & states::MIXED) != 0;
         PRBool isMixed  =
-          (nsAccUtils::State(accessible) & nsIAccessibleStates::STATE_MIXED) != 0;
+          (accessible->State() & states::MIXED) != 0;
         if (wasMixed != isMixed) {
           nsRefPtr<AccEvent> event =
-            new AccStateChangeEvent(aContent, nsIAccessibleStates::STATE_MIXED,
-                                    PR_FALSE, isMixed);
+            new AccStateChangeEvent(aContent, states::MIXED, isMixed);
           FireDelayedAccessibleEvent(event);
         }
       }
     }
     return;
   }
 
   if (aAttribute == nsAccessibilityAtoms::aria_readonly) {
     nsRefPtr<AccEvent> event =
-      new AccStateChangeEvent(aContent, nsIAccessibleStates::STATE_READONLY,
-                              PR_FALSE);
+      new AccStateChangeEvent(aContent, states::READONLY);
     FireDelayedAccessibleEvent(event);
     return;
   }
 
   // Fire value change event whenever aria-valuetext is changed, or
   // when aria-valuenow is changed and aria-valuetext is empty
   if (aAttribute == nsAccessibilityAtoms::aria_valuetext ||      
       (aAttribute == nsAccessibilityAtoms::aria_valuenow &&
@@ -1236,18 +1206,17 @@ void nsDocAccessible::ContentStateChange
                                           nsEventStates aStateMask)
 {
   if (aStateMask.HasState(NS_EVENT_STATE_CHECKED)) {
     nsHTMLSelectOptionAccessible::SelectionChangedIfOption(aContent);
   }
 
   if (aStateMask.HasState(NS_EVENT_STATE_INVALID)) {
     nsRefPtr<AccEvent> event =
-      new AccStateChangeEvent(aContent, nsIAccessibleStates::STATE_INVALID,
-                              PR_FALSE, PR_TRUE);
+      new AccStateChangeEvent(aContent, states::INVALID, PR_TRUE);
     FireDelayedAccessibleEvent(event);
    }
 }
 
 void nsDocAccessible::DocumentStatesChanged(nsIDocument* aDocument,
                                             nsEventStates aStateMask)
 {
 }
--- a/accessible/src/base/nsDocAccessible.h
+++ b/accessible/src/base/nsDocAccessible.h
@@ -110,18 +110,18 @@ public:
   virtual void Shutdown();
   virtual nsIFrame* GetFrame() const;
   virtual PRBool IsDefunct();
   virtual nsINode* GetNode() const { return mDocument; }
   virtual nsIDocument* GetDocumentNode() const { return mDocument; }
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
-  virtual nsresult GetARIAState(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
+  virtual void ApplyARIAState(PRUint64* aState);
 
   virtual void SetRoleMapEntry(nsRoleMapEntry* aRoleMapEntry);
 
 #ifdef DEBUG_ACCDOCMGR
   virtual nsresult HandleAccEvent(AccEvent* aAccEvent);
 #endif
 
   // nsIAccessibleText
@@ -496,17 +496,17 @@ protected:
 
 protected:
 
   /**
    * Specifies if the document was loaded, used for error pages only.
    */
   PRPackedBool mIsLoaded;
 
-    static PRUint32 gLastFocusedAccessiblesState;
+  static PRUint64 gLastFocusedAccessiblesState;
 
   nsTArray<nsRefPtr<nsDocAccessible> > mChildDocuments;
 
   /**
    * A storage class for pairing content with one of its relation attributes.
    */
   class AttrRelProvider
   {
--- a/accessible/src/base/nsOuterDocAccessible.cpp
+++ b/accessible/src/base/nsOuterDocAccessible.cpp
@@ -33,16 +33,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsOuterDocAccessible.h"
 
+#include "States.h"
 #include "nsAccUtils.h"
 #include "nsDocAccessible.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsOuterDocAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsOuterDocAccessible::
@@ -61,24 +62,20 @@ NS_IMPL_ISUPPORTS_INHERITED0(nsOuterDocA
 // nsAccessible public (DON'T add methods here)
 
 PRUint32
 nsOuterDocAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_INTERNAL_FRAME;
 }
 
-nsresult
-nsOuterDocAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsOuterDocAccessible::NativeState()
 {
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
-  *aState &= ~nsIAccessibleStates::STATE_FOCUSABLE;
-  return NS_OK;
+  return nsAccessible::NativeState() & ~states::FOCUSABLE;
 }
 
 nsAccessible*
 nsOuterDocAccessible::GetChildAtPoint(PRInt32 aX, PRInt32 aY,
                                       EWhichChildAtPoint aWhichChild)
 {
   PRInt32 docX = 0, docY = 0, docWidth = 0, docHeight = 0;
   nsresult rv = GetBounds(&docX, &docY, &docWidth, &docHeight);
--- a/accessible/src/base/nsOuterDocAccessible.h
+++ b/accessible/src/base/nsOuterDocAccessible.h
@@ -63,17 +63,17 @@ public:
   NS_IMETHOD GetActionDescription(PRUint8 aIndex, nsAString& aDescription);
   NS_IMETHOD DoAction(PRUint8 aIndex);
 
   // nsAccessNode
   virtual void Shutdown();
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual nsresult GetAttributesInternal(nsIPersistentProperties *aAttributes);
   virtual nsAccessible* GetChildAtPoint(PRInt32 aX, PRInt32 aY,
                                         EWhichChildAtPoint aWhichChild);
 
   virtual void InvalidateChildren();
   virtual PRBool AppendChild(nsAccessible *aAccessible);
   virtual PRBool RemoveChild(nsAccessible *aAccessible);
 
--- a/accessible/src/base/nsRootAccessible.cpp
+++ b/accessible/src/base/nsRootAccessible.cpp
@@ -30,16 +30,17 @@
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
+#include "States.h"
 #include "nsAccessibilityService.h"
 #include "nsApplicationAccessibleWrap.h"
 #include "nsAccUtils.h"
 #include "nsCoreUtils.h"
 #include "nsRelUtils.h"
 
 #include "mozilla/dom/Element.h"
 #include "nsHTMLSelectAccessible.h"
@@ -180,56 +181,52 @@ PRUint32 nsRootAccessible::GetChromeFlag
     return 0;
   }
   PRUint32 chromeFlags;
   xulWin->GetChromeFlags(&chromeFlags);
   return chromeFlags;
 }
 #endif
 
-nsresult
-nsRootAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsRootAccessible::NativeState()
 {
-  nsresult rv = nsDocAccessibleWrap::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 states = nsDocAccessibleWrap::NativeState();
 
 #ifdef MOZ_XUL
   PRUint32 chromeFlags = GetChromeFlags();
   if (chromeFlags & nsIWebBrowserChrome::CHROME_WINDOW_RESIZE) {
-    *aState |= nsIAccessibleStates::STATE_SIZEABLE;
+    states |= states::SIZEABLE;
   }
   if (chromeFlags & nsIWebBrowserChrome::CHROME_TITLEBAR) {
     // If it has a titlebar it's movable
     // XXX unless it's minimized or maximized, but not sure
     //     how to detect that
-    *aState |= nsIAccessibleStates::STATE_MOVEABLE;
+    states |= states::MOVEABLE;
   }
 #endif
 
-  if (!aExtraState)
-    return NS_OK;
-
   nsCOMPtr<nsIFocusManager> fm = do_GetService(FOCUSMANAGER_CONTRACTID);
   if (fm) {
     nsCOMPtr<nsIDOMWindow> rootWindow;
     GetWindow(getter_AddRefs(rootWindow));
 
     nsCOMPtr<nsIDOMWindow> activeWindow;
     fm->GetActiveWindow(getter_AddRefs(activeWindow));
     if (activeWindow == rootWindow)
-      *aExtraState |= nsIAccessibleStates::EXT_STATE_ACTIVE;
+      states |= states::ACTIVE;
   }
 
 #ifdef MOZ_XUL
   if (GetChromeFlags() & nsIWebBrowserChrome::CHROME_MODAL) {
-    *aExtraState |= nsIAccessibleStates::EXT_STATE_MODAL;
+    states |= states::MODAL;
   }
 #endif
 
-  return NS_OK;
+  return states;
 }
 
 const char* const docEvents[] = {
 #ifdef DEBUG_DRAGDROPSTART
   // Capture mouse over events and fire fake DRAGDROPSTART event to simplify
   // debugging a11y objects with event viewers
   "mouseover",
 #endif
@@ -360,17 +357,17 @@ nsRootAccessible::FireAccessibleFocusEve
   // aForceEvent == PR_TRUE
   nsINode* focusNode = focusAccessible->GetNode();
   if (gLastFocusedNode == focusNode && !aForceEvent)
     return;
 
   nsDocAccessible* focusDocument = focusAccessible->GetDocAccessible();
   NS_ASSERTION(focusDocument, "No document while accessible is in document?!");
 
-  gLastFocusedAccessiblesState = nsAccUtils::State(focusAccessible);
+  gLastFocusedAccessiblesState = focusAccessible->State();
 
   // Fire menu start/end events for ARIA menus.
   if (focusAccessible->ARIARole() == nsIAccessibleRole::ROLE_MENUITEM) {
     // The focus is inside a menu.
     if (!mCurrentARIAMenubar) {
       // Entering ARIA menu. Fire menu start event.
       nsAccessible* menuBarAccessible =
         nsAccUtils::GetAncestorWithRole(focusAccessible,
@@ -554,44 +551,41 @@ nsRootAccessible::ProcessDOMEvent(nsIDOM
         HandleTreeInvalidatedEvent(aDOMEvent, treeAcc);
         return;
       }
     }
   }
 #endif
 
   if (eventType.EqualsLiteral("RadioStateChange")) {
-    PRUint32 state = nsAccUtils::State(accessible);
+    PRUint64 state = accessible->State();
 
     // radiogroup in prefWindow is exposed as a list,
     // and panebutton is exposed as XULListitem in A11y.
     // nsXULListitemAccessible::GetStateInternal uses STATE_SELECTED in this case,
-    // so we need to check nsIAccessibleStates::STATE_SELECTED also.
-    PRBool isEnabled = (state & (nsIAccessibleStates::STATE_CHECKED |
-                        nsIAccessibleStates::STATE_SELECTED)) != 0;
+    // so we need to check states::SELECTED also.
+    PRBool isEnabled = (state & (states::CHECKED | states::SELECTED)) != 0;
 
     nsRefPtr<AccEvent> accEvent =
-      new AccStateChangeEvent(accessible, nsIAccessibleStates::STATE_CHECKED,
-                              PR_FALSE, isEnabled);
+      new AccStateChangeEvent(accessible, states::CHECKED, isEnabled);
     nsEventShell::FireEvent(accEvent);
 
     if (isEnabled)
       FireAccessibleFocusEvent(accessible, origTargetContent);
 
     return;
   }
 
   if (eventType.EqualsLiteral("CheckboxStateChange")) {
-    PRUint32 state = nsAccUtils::State(accessible);
+    PRUint64 state = accessible->State();
 
-    PRBool isEnabled = !!(state & nsIAccessibleStates::STATE_CHECKED);
+    PRBool isEnabled = !!(state & states::CHECKED);
 
     nsRefPtr<AccEvent> accEvent =
-      new AccStateChangeEvent(accessible, nsIAccessibleStates::STATE_CHECKED,
-                              PR_FALSE, isEnabled);
+      new AccStateChangeEvent(accessible, states::CHECKED, isEnabled);
 
     nsEventShell::FireEvent(accEvent);
     return;
   }
 
   nsAccessible *treeItemAccessible = nsnull;
 #ifdef MOZ_XUL
   // If it's a tree element, need the currently selected item
@@ -610,22 +604,21 @@ nsRootAccessible::ProcessDOMEvent(nsIDOM
         }
       }
     }
   }
 #endif
 
 #ifdef MOZ_XUL
   if (treeItemAccessible && eventType.EqualsLiteral("OpenStateChange")) {
-    PRUint32 state = nsAccUtils::State(accessible); // collapsed/expanded changed
-    PRBool isEnabled = (state & nsIAccessibleStates::STATE_EXPANDED) != 0;
+    PRUint64 state = accessible->State();
+    PRBool isEnabled = (state & states::EXPANDED) != 0;
 
     nsRefPtr<AccEvent> accEvent =
-      new AccStateChangeEvent(accessible, nsIAccessibleStates::STATE_EXPANDED,
-                              PR_FALSE, isEnabled);
+      new AccStateChangeEvent(accessible, states::EXPANDED, isEnabled);
     nsEventShell::FireEvent(accEvent);
     return;
   }
 
   if (treeItemAccessible && eventType.EqualsLiteral("select")) {
     // If multiselect tree, we should fire selectionadd or selection removed
     if (gLastFocusedNode == targetNode) {
       nsCOMPtr<nsIDOMXULMultiSelectControlElement> multiSel =
@@ -719,17 +712,17 @@ nsRootAccessible::ProcessDOMEvent(nsIDOM
         return;
       } else {
         nsAccessible *containerAccessible = accessible->GetParent();
         if (!containerAccessible)
           return;
         // It is not top level menuitem
         // Only fire focus event if it is not inside collapsed popup
         // and not a listitem of a combo box
-        if (nsAccUtils::State(containerAccessible) & nsIAccessibleStates::STATE_COLLAPSED) {
+        if (containerAccessible->State() & states::COLLAPSED) {
           nsAccessible *containerParent = containerAccessible->GetParent();
           if (!containerParent)
             return;
           if (containerParent->Role() != nsIAccessibleRole::ROLE_COMBOBOX) {
             return;
           }
         }
       }
@@ -812,17 +805,17 @@ nsRootAccessible::GetContentDocShell(nsI
     if (!accDoc)
       return nsnull;
 
     // If ancestor chain of accessibles is not completely visible,
     // don't use this one. This happens for example if it's inside
     // a background tab (tabbed browsing)
     nsAccessible *parent = accDoc->GetParent();
     while (parent) {
-      if (nsAccUtils::State(parent) & nsIAccessibleStates::STATE_INVISIBLE)
+      if (parent->State() & states::INVISIBLE)
         return nsnull;
 
       if (parent == this)
         break; // Don't check past original root accessible we started with
 
       parent = parent->GetParent();
     }
 
@@ -900,19 +893,17 @@ nsRootAccessible::HandlePopupShownEvent(
     nsAccessible* combobox = aAccessible->GetParent();
     if (!combobox)
       return;
 
     PRUint32 comboboxRole = combobox->Role();
     if (comboboxRole == nsIAccessibleRole::ROLE_COMBOBOX ||
         comboboxRole == nsIAccessibleRole::ROLE_AUTOCOMPLETE) {
       nsRefPtr<AccEvent> event =
-        new AccStateChangeEvent(combobox,
-                                nsIAccessibleStates::STATE_EXPANDED,
-                                PR_FALSE, PR_TRUE);
+        new AccStateChangeEvent(combobox, states::EXPANDED, PR_TRUE);
       if (event)
         nsEventShell::FireEvent(event);
     }
   }
 }
 
 void
 nsRootAccessible::HandlePopupHidingEvent(nsINode* aNode,
@@ -938,19 +929,17 @@ nsRootAccessible::HandlePopupHidingEvent
   nsAccessible* combobox = aAccessible->GetParent();
   if (!combobox)
     return;
 
   PRUint32 comboboxRole = combobox->Role();
   if (comboboxRole == nsIAccessibleRole::ROLE_COMBOBOX ||
       comboboxRole == nsIAccessibleRole::ROLE_AUTOCOMPLETE) {
     nsRefPtr<AccEvent> event =
-      new AccStateChangeEvent(combobox,
-                              nsIAccessibleStates::STATE_EXPANDED,
-                              PR_FALSE, PR_FALSE);
+      new AccStateChangeEvent(combobox, states::EXPANDED, PR_FALSE);
     if (event)
       nsEventShell::FireEvent(event);
   }
 }
 
 #ifdef MOZ_XUL
 void
 nsRootAccessible::HandleTreeRowCountChangedEvent(nsIDOMEvent* aEvent,
--- a/accessible/src/base/nsRootAccessible.h
+++ b/accessible/src/base/nsRootAccessible.h
@@ -80,17 +80,17 @@ public:
   // nsIDOMEventListener
   NS_IMETHOD HandleEvent(nsIDOMEvent* aEvent);
 
   // nsAccessNode
   virtual void Shutdown();
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
   // nsRootAccessible
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_ROOTACCESSIBLE_IMPL_CID)
 
   /**
    * Fire an accessible focus event for the focused accessible and attach a new
    * selection listener to real focused element, if necessary.
    *
--- a/accessible/src/html/nsHTMLFormControlAccessible.cpp
+++ b/accessible/src/html/nsHTMLFormControlAccessible.cpp
@@ -33,16 +33,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHTMLFormControlAccessible.h"
 
+#include "States.h"
 #include "nsAccessibilityAtoms.h"
 #include "nsAccUtils.h"
 #include "nsRelUtils.h"
 #include "nsTextEquivUtils.h"
 
 #include "nsIDOMDocument.h"
 #include "nsIDOMHTMLInputElement.h"
 #include "nsIDOMNSHTMLElement.h"
@@ -80,23 +81,21 @@ NS_IMETHODIMP nsHTMLCheckboxAccessible::
   *_retval = 1;
   return NS_OK;
 }
 
 NS_IMETHODIMP nsHTMLCheckboxAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
 {
   if (aIndex == eAction_Click) {    // 0 is the magic value for default action
     // cycle, check or uncheck
-    PRUint32 state;
-    nsresult rv = GetStateInternal(&state, nsnull);
-    NS_ENSURE_SUCCESS(rv, rv);
+    PRUint64 state = NativeState();
 
-    if (state & nsIAccessibleStates::STATE_CHECKED)
+    if (state & states::CHECKED)
       aName.AssignLiteral("uncheck"); 
-    else if (state & nsIAccessibleStates::STATE_MIXED)
+    else if (state & states::MIXED)
       aName.AssignLiteral("cycle"); 
     else
       aName.AssignLiteral("check"); 
 
     return NS_OK;
   }
   return NS_ERROR_INVALID_ARG;
 }
@@ -106,75 +105,70 @@ nsHTMLCheckboxAccessible::DoAction(PRUin
 {
   if (aIndex != 0)
     return NS_ERROR_INVALID_ARG;
 
   DoCommand();
   return NS_OK;
 }
 
-nsresult
-nsHTMLCheckboxAccessible::GetStateInternal(PRUint32 *aState,
-                                           PRUint32 *aExtraState)
+PRUint64
+nsHTMLCheckboxAccessible::NativeState()
 {
-  nsresult rv = nsFormControlAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsFormControlAccessible::NativeState();
 
-  *aState |= nsIAccessibleStates::STATE_CHECKABLE;
-
-  PRBool state = PR_FALSE;   // Radio buttons and check boxes can be checked or mixed
+  state |= states::CHECKABLE;
+  PRBool checkState = PR_FALSE;   // Radio buttons and check boxes can be checked or mixed
 
   nsCOMPtr<nsIDOMHTMLInputElement> htmlCheckboxElement =
     do_QueryInterface(mContent);
            
   if (htmlCheckboxElement) {
-    htmlCheckboxElement->GetIndeterminate(&state);
+    htmlCheckboxElement->GetIndeterminate(&checkState);
 
-    if (state) {
-      *aState |= nsIAccessibleStates::STATE_MIXED;
+    if (checkState) {
+      state |= states::MIXED;
     } else {   // indeterminate can't be checked at the same time.
-      htmlCheckboxElement->GetChecked(&state);
+      htmlCheckboxElement->GetChecked(&checkState);
     
-      if (state)
-        *aState |= nsIAccessibleStates::STATE_CHECKED;
+      if (checkState)
+        state |= states::CHECKED;
     }
   }
-  return NS_OK;
+  return state;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsHTMLRadioButtonAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsHTMLRadioButtonAccessible::
   nsHTMLRadioButtonAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
   nsRadioButtonAccessible(aContent, aShell)
 {
 }
 
-nsresult
-nsHTMLRadioButtonAccessible::GetStateInternal(PRUint32 *aState,
-                                              PRUint32 *aExtraState)
+PRUint64
+nsHTMLRadioButtonAccessible::NativeState()
 {
-  nsresult rv = nsAccessibleWrap::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsAccessibleWrap::NativeState();
 
-  *aState |= nsIAccessibleStates::STATE_CHECKABLE;
+  state |= states::CHECKABLE;
   
   PRBool checked = PR_FALSE;   // Radio buttons and check boxes can be checked
 
   nsCOMPtr<nsIDOMHTMLInputElement> htmlRadioElement =
     do_QueryInterface(mContent);
   if (htmlRadioElement)
     htmlRadioElement->GetChecked(&checked);
 
   if (checked)
-    *aState |= nsIAccessibleStates::STATE_CHECKED;
+    state |= states::CHECKED;
 
-  return NS_OK;
+  return state;
 }
 
 void
 nsHTMLRadioButtonAccessible::GetPositionAndSizeInternal(PRInt32 *aPosInSet,
                                                         PRInt32 *aSetSize)
 {
   nsAutoString nsURI;
   mContent->NodeInfo()->GetNamespaceURI(nsURI);
@@ -261,29 +255,26 @@ nsHTMLButtonAccessible::DoAction(PRUint8
 {
   if (aIndex != eAction_Click)
     return NS_ERROR_INVALID_ARG;
 
   DoCommand();
   return NS_OK;
 }
 
-nsresult
-nsHTMLButtonAccessible::GetStateInternal(PRUint32 *aState,
-                                         PRUint32 *aExtraState)
+PRUint64
+nsHTMLButtonAccessible::NativeState()
 {
-  nsresult rv = nsHyperTextAccessibleWrap::GetStateInternal(aState,
-                                                            aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsHyperTextAccessibleWrap::NativeState();
 
   if (mContent->AttrValueIs(kNameSpaceID_None, nsAccessibilityAtoms::type,
                             nsAccessibilityAtoms::submit, eIgnoreCase))
-    *aState |= nsIAccessibleStates::STATE_DEFAULT;
+    state |= states::DEFAULT;
 
-  return NS_OK;
+  return state;
 }
 
 PRUint32
 nsHTMLButtonAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_PUSHBUTTON;
 }
 
@@ -358,31 +349,28 @@ nsHTML4ButtonAccessible::DoAction(PRUint
 }
 
 PRUint32
 nsHTML4ButtonAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_PUSHBUTTON;
 }
 
-nsresult
-nsHTML4ButtonAccessible::GetStateInternal(PRUint32 *aState,
-                                          PRUint32 *aExtraState)
+PRUint64
+nsHTML4ButtonAccessible::NativeState()
 {
-  nsresult rv = nsHyperTextAccessibleWrap::GetStateInternal(aState,
-                                                            aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsHyperTextAccessibleWrap::NativeState();
 
-  *aState |= nsIAccessibleStates::STATE_FOCUSABLE;
+  state |= states::FOCUSABLE;
 
   if (mContent->AttrValueIs(kNameSpaceID_None, nsAccessibilityAtoms::type,
                             nsAccessibilityAtoms::submit, eIgnoreCase))
-    *aState |= nsIAccessibleStates::STATE_DEFAULT;
+    state |= states::DEFAULT;
 
-  return NS_OK;
+  return state;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsHTMLTextFieldAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsHTMLTextFieldAccessible::
@@ -429,87 +417,76 @@ nsHTMLTextFieldAccessible::GetNameIntern
   // text inputs and textareas might have useful placeholder text
   mContent->GetAttr(kNameSpaceID_None, nsAccessibilityAtoms::placeholder, aName);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP nsHTMLTextFieldAccessible::GetValue(nsAString& _retval)
 {
-  PRUint32 state;
-  nsresult rv = GetStateInternal(&state, nsnull);
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  if (state & nsIAccessibleStates::STATE_PROTECTED)    // Don't return password text!
+  if (NativeState() & states::PROTECTED)    // Don't return password text!
     return NS_ERROR_FAILURE;
 
   nsCOMPtr<nsIDOMHTMLTextAreaElement> textArea(do_QueryInterface(mContent));
   if (textArea) {
     return textArea->GetValue(_retval);
   }
   
   nsCOMPtr<nsIDOMHTMLInputElement> inputElement(do_QueryInterface(mContent));
   if (inputElement) {
     return inputElement->GetValue(_retval);
   }
 
   return NS_ERROR_FAILURE;
 }
 
-nsresult
-nsHTMLTextFieldAccessible::GetStateInternal(PRUint32 *aState,
-                                            PRUint32 *aExtraState)
+PRUint64
+nsHTMLTextFieldAccessible::NativeState()
 {
-  nsresult rv = nsHyperTextAccessibleWrap::GetStateInternal(aState,
-                                                            aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsHyperTextAccessibleWrap::NativeState();
 
   // can be focusable, focused, protected. readonly, unavailable, selected
   if (mContent->AttrValueIs(kNameSpaceID_None, nsAccessibilityAtoms::type,
                             nsAccessibilityAtoms::password, eIgnoreCase)) {
-    *aState |= nsIAccessibleStates::STATE_PROTECTED;
+    state |= states::PROTECTED;
   }
   else {
     nsAccessible* parent = GetParent();
     if (parent && parent->Role() == nsIAccessibleRole::ROLE_AUTOCOMPLETE)
-      *aState |= nsIAccessibleStates::STATE_HASPOPUP;
+      state |= states::HASPOPUP;
   }
 
   if (mContent->HasAttr(kNameSpaceID_None, nsAccessibilityAtoms::readonly)) {
-    *aState |= nsIAccessibleStates::STATE_READONLY;
+    state |= states::READONLY;
   }
 
-  if (!aExtraState)
-    return NS_OK;
-
   nsCOMPtr<nsIDOMHTMLInputElement> htmlInput(do_QueryInterface(mContent));
   // Is it an <input> or a <textarea> ?
   if (htmlInput) {
-    *aExtraState |= nsIAccessibleStates::EXT_STATE_SINGLE_LINE;
+    state |= states::SINGLE_LINE;
   }
   else {
-    *aExtraState |= nsIAccessibleStates::EXT_STATE_MULTI_LINE;
+    state |= states::MULTI_LINE;
   }
 
-  if (!(*aExtraState & nsIAccessibleStates::EXT_STATE_EDITABLE))
-    return NS_OK;
+  if (!(state & states::EDITABLE))
+    return state;
 
   nsCOMPtr<nsIContent> bindingContent = mContent->GetBindingParent();
   if (bindingContent &&
       bindingContent->NodeInfo()->Equals(nsAccessibilityAtoms::textbox,
                                          kNameSpaceID_XUL)) {
      if (bindingContent->AttrValueIs(kNameSpaceID_None, nsAccessibilityAtoms::type,
                                      nsAccessibilityAtoms::autocomplete,
                                      eIgnoreCase)) {
        // If parent is XUL textbox and value of @type attribute is "autocomplete",
        // then this accessible supports autocompletion.
-       *aExtraState |= nsIAccessibleStates::EXT_STATE_SUPPORTS_AUTOCOMPLETION;
+       state |= states::SUPPORTS_AUTOCOMPLETION;
      }
-  } else if (gIsFormFillEnabled && htmlInput &&
-             !(*aState & nsIAccessibleStates::STATE_PROTECTED)) {
+  } else if (gIsFormFillEnabled && htmlInput && !(state & states::PROTECTED)) {
     // Check to see if autocompletion is allowed on this input. We don't expose
     // it for password fields even though the entire password can be remembered
     // for a page if the user asks it to be. However, the kind of autocomplete
     // we're talking here is based on what the user types, where a popup of
     // possible choices comes up.
     nsAutoString autocomplete;
     mContent->GetAttr(kNameSpaceID_None, nsAccessibilityAtoms::autocomplete,
                       autocomplete);
@@ -519,21 +496,21 @@ nsHTMLTextFieldAccessible::GetStateInter
       htmlInput->GetForm(getter_AddRefs(form));
       nsCOMPtr<nsIContent> formContent(do_QueryInterface(form));
       if (formContent) {
         formContent->GetAttr(kNameSpaceID_None,
                              nsAccessibilityAtoms::autocomplete, autocomplete);
       }
 
       if (!formContent || !autocomplete.LowerCaseEqualsLiteral("off"))
-        *aExtraState |= nsIAccessibleStates::EXT_STATE_SUPPORTS_AUTOCOMPLETION;
+        state |= states::SUPPORTS_AUTOCOMPLETION;
     }
   }
 
-  return NS_OK;
+  return state;
 }
 
 NS_IMETHODIMP nsHTMLTextFieldAccessible::GetNumActions(PRUint8 *_retval)
 {
   *_retval = 1;
   return NS_OK;;
 }
 
--- a/accessible/src/html/nsHTMLFormControlAccessible.h
+++ b/accessible/src/html/nsHTMLFormControlAccessible.h
@@ -55,31 +55,31 @@ public:
 
   // nsIAccessible
   NS_IMETHOD GetNumActions(PRUint8 *_retval);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 index);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * Accessible for HTML input@type="radio" element.
  */
 class nsHTMLRadioButtonAccessible : public nsRadioButtonAccessible
 {
 
 public:
   nsHTMLRadioButtonAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsAccessible
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual void GetPositionAndSizeInternal(PRInt32 *aPosInSet,
                                           PRInt32 *aSetSize);
 };
 
 
 /**
  * Accessible for HTML input@type="button", @type="submit", @type="image"
  * elements.
@@ -95,17 +95,17 @@ public:
   // nsIAccessible
   NS_IMETHOD GetNumActions(PRUint8 *_retval);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 index);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * Accessible for HTML button element.
  */
 class nsHTML4ButtonAccessible : public nsHyperTextAccessibleWrap
 {
@@ -117,17 +117,17 @@ public:
 
   // nsIAccessible
   NS_IMETHOD GetNumActions(PRUint8 *_retval);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 index);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * Accessible for HTML input@type="text" element.
  */
 class nsHTMLTextFieldAccessible : public nsHyperTextAccessibleWrap
 {
@@ -146,17 +146,17 @@ public:
   NS_IMETHOD DoAction(PRUint8 index);
 
   // nsIAccessibleEditableText
   NS_IMETHOD GetAssociatedEditor(nsIEditor **aEditor);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * Accessible for HTML fieldset element.
  */
 class nsHTMLGroupboxAccessible : public nsHyperTextAccessibleWrap
 {
--- a/accessible/src/html/nsHTMLImageAccessible.cpp
+++ b/accessible/src/html/nsHTMLImageAccessible.cpp
@@ -33,16 +33,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHTMLImageAccessible.h"
 
+#include "States.h"
 #include "nsAccessibilityAtoms.h"
 #include "nsAccUtils.h"
 
 #include "imgIContainer.h"
 #include "imgIRequest.h"
 #include "nsIDocument.h"
 #include "nsIImageLoadingContent.h"
 #include "nsILink.h"
@@ -63,44 +64,43 @@ nsHTMLImageAccessible::
 }
 
 NS_IMPL_ISUPPORTS_INHERITED1(nsHTMLImageAccessible, nsAccessible,
                              nsIAccessibleImage)
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsAccessible public
 
-nsresult
-nsHTMLImageAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsHTMLImageAccessible::NativeState()
 {
   // The state is a bitfield, get our inherited state, then logically OR it with
-  // STATE_ANIMATED if this is an animated image.
+  // states::ANIMATED if this is an animated image.
 
-  nsresult rv = nsLinkableAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsLinkableAccessible::NativeState();
 
   nsCOMPtr<nsIImageLoadingContent> content(do_QueryInterface(mContent));
   nsCOMPtr<imgIRequest> imageRequest;
 
   if (content)
     content->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
                         getter_AddRefs(imageRequest));
 
   nsCOMPtr<imgIContainer> imgContainer;
   if (imageRequest)
     imageRequest->GetImage(getter_AddRefs(imgContainer));
 
   if (imgContainer) {
     PRBool animated;
     imgContainer->GetAnimated(&animated);
     if (animated)
-      *aState |= nsIAccessibleStates::STATE_ANIMATED;
+      state |= states::ANIMATED;
   }
 
-  return NS_OK;
+  return state;
 }
 
 nsresult
 nsHTMLImageAccessible::GetNameInternal(nsAString& aName)
 {
   PRBool hasAltAttrib =
     mContent->GetAttr(kNameSpaceID_None, nsAccessibilityAtoms::alt, aName);
   if (!aName.IsEmpty())
--- a/accessible/src/html/nsHTMLImageAccessible.h
+++ b/accessible/src/html/nsHTMLImageAccessible.h
@@ -62,17 +62,17 @@ public:
   NS_IMETHOD DoAction(PRUint8 index);
 
   // nsIAccessibleImage
   NS_DECL_NSIACCESSIBLEIMAGE
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual nsresult GetAttributesInternal(nsIPersistentProperties *aAttributes);
 
 private:
   /**
    * Determine if this image accessible has a longdesc attribute.
    *
    * @returns  true if the longdesc attribute is present.
    */
--- a/accessible/src/html/nsHTMLImageMapAccessible.cpp
+++ b/accessible/src/html/nsHTMLImageMapAccessible.cpp
@@ -228,27 +228,27 @@ nsHTMLAreaAccessible::GetBounds(PRInt32 
   *aY += orgRectPixels.y;
 
   return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsHTMLAreaAccessible: nsAccessible public
 
-nsresult
-nsHTMLAreaAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsHTMLAreaAccessible::NativeState()
 {
   // Bypass the link states specialization for non links.
   if (mRoleMapEntry &&
       mRoleMapEntry->role != nsIAccessibleRole::ROLE_NOTHING &&
       mRoleMapEntry->role != nsIAccessibleRole::ROLE_LINK) {
-    return nsAccessible::GetStateInternal(aState,aExtraState);
+    return nsAccessible::NativeState();
   }
 
-  return nsHTMLLinkAccessible::GetStateInternal(aState, aExtraState);
+  return nsHTMLLinkAccessible::NativeState();
 }
 
 nsAccessible*
 nsHTMLAreaAccessible::GetChildAtPoint(PRInt32 aX, PRInt32 aY,
                                       EWhichChildAtPoint aWhichChild)
 {
   // Don't walk into area accessibles.
   return this;
--- a/accessible/src/html/nsHTMLImageMapAccessible.h
+++ b/accessible/src/html/nsHTMLImageMapAccessible.h
@@ -88,17 +88,17 @@ public:
 
   // nsIAccessible
   NS_IMETHOD GetDescription(nsAString& aDescription);
 
   NS_IMETHOD GetBounds(PRInt32 *x, PRInt32 *y, PRInt32 *width, PRInt32 *height);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual nsAccessible* GetChildAtPoint(PRInt32 aX, PRInt32 aY,
                                         EWhichChildAtPoint aWhichChild);
 
   // HyperLinkAccessible
   virtual PRUint32 StartOffset();
   virtual PRUint32 EndOffset();
 
 protected:
--- a/accessible/src/html/nsHTMLLinkAccessible.cpp
+++ b/accessible/src/html/nsHTMLLinkAccessible.cpp
@@ -34,16 +34,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHTMLLinkAccessible.h"
 
+#include "States.h"
 #include "nsCoreUtils.h"
 
 #include "nsIEventStateManager.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsHTMLLinkAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -61,50 +62,48 @@ NS_IMPL_ISUPPORTS_INHERITED1(nsHTMLLinkA
 // nsIAccessible
 
 PRUint32
 nsHTMLLinkAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_LINK;
 }
 
-nsresult
-nsHTMLLinkAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsHTMLLinkAccessible::NativeState()
 {
-  nsresult rv = nsHyperTextAccessibleWrap::GetStateInternal(aState,
-                                                            aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 states = nsHyperTextAccessibleWrap::NativeState();
 
-  *aState  &= ~nsIAccessibleStates::STATE_READONLY;
+  states  &= ~states::READONLY;
 
   if (mContent->HasAttr(kNameSpaceID_None, nsAccessibilityAtoms::name)) {
     // This is how we indicate it is a named anchor
     // In other words, this anchor can be selected as a location :)
     // There is no other better state to use to indicate this.
-    *aState |= nsIAccessibleStates::STATE_SELECTABLE;
+    states |= states::SELECTABLE;
   }
 
   nsEventStates state = mContent->IntrinsicState();
   if (state.HasAtLeastOneOfStates(NS_EVENT_STATE_VISITED |
                                   NS_EVENT_STATE_UNVISITED)) {
-    *aState |= nsIAccessibleStates::STATE_LINKED;
+    states |= states::LINKED;
 
     if (state.HasState(NS_EVENT_STATE_VISITED))
-      *aState |= nsIAccessibleStates::STATE_TRAVERSED;
+      states |= states::TRAVERSED;
 
-    return NS_OK;
+    return states;
   }
 
   // This is a either named anchor (a link with also a name attribute) or
   // it doesn't have any attributes. Check if 'click' event handler is
   // registered, otherwise bail out.
   if (nsCoreUtils::HasClickListener(mContent))
-    *aState |= nsIAccessibleStates::STATE_LINKED;
+    states |= states::LINKED;
 
-  return NS_OK;
+  return states;
 }
 
 NS_IMETHODIMP
 nsHTMLLinkAccessible::GetValue(nsAString& aValue)
 {
   aValue.Truncate();
 
   nsresult rv = nsHyperTextAccessible::GetValue(aValue);
--- a/accessible/src/html/nsHTMLLinkAccessible.h
+++ b/accessible/src/html/nsHTMLLinkAccessible.h
@@ -53,17 +53,17 @@ public:
   NS_IMETHOD GetValue(nsAString& aValue);
 
   NS_IMETHOD GetNumActions(PRUint8 *aNumActions);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 aIndex);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
   // HyperLinkAccessible
   virtual bool IsHyperLink();
   virtual already_AddRefed<nsIURI> GetAnchorURI(PRUint32 aAnchorIndex);
 
 protected:
   enum { eAction_Jump = 0 };
 
--- a/accessible/src/html/nsHTMLSelectAccessible.cpp
+++ b/accessible/src/html/nsHTMLSelectAccessible.cpp
@@ -39,16 +39,17 @@
 #include "nsHTMLSelectAccessible.h"
 
 #include "nsAccessibilityService.h"
 #include "nsAccUtils.h"
 #include "nsDocAccessible.h"
 #include "nsEventShell.h"
 #include "nsIAccessibleEvent.h"
 #include "nsTextEquivUtils.h"
+#include "States.h"
 
 #include "nsCOMPtr.h"
 #include "nsIFrame.h"
 #include "nsIComboboxControlFrame.h"
 #include "nsIDocument.h"
 #include "nsIDOMHTMLInputElement.h"
 #include "nsIDOMHTMLOptGroupElement.h"
 #include "nsIDOMHTMLSelectElement.h"
@@ -64,41 +65,37 @@ nsHTMLSelectListAccessible::
   nsHTMLSelectListAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
   nsAccessibleWrap(aContent, aShell)
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsHTMLSelectListAccessible: nsAccessible public
 
-nsresult
-nsHTMLSelectListAccessible::GetStateInternal(PRUint32 *aState,
-                                             PRUint32 *aExtraState)
+PRUint64
+nsHTMLSelectListAccessible::NativeState()
 {
-  nsresult rv = nsAccessibleWrap::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsAccessibleWrap::NativeState();
 
   // As a nsHTMLSelectListAccessible we can have the following states:
-  //   nsIAccessibleStates::STATE_MULTISELECTABLE
-  //   nsIAccessibleStates::STATE_EXTSELECTABLE
+  //   states::MULTISELECTABLE, states::EXTSELECTABLE
 
-  if (*aState & nsIAccessibleStates::STATE_FOCUSED) {
+  if (state & states::FOCUSED) {
     // Treat first focusable option node as actual focus, in order
     // to avoid confusing JAWS, which needs focus on the option
     nsCOMPtr<nsIContent> focusedOption =
       nsHTMLSelectOptionAccessible::GetFocusedOption(mContent);
     if (focusedOption) { // Clear focused state since it is on option
-      *aState &= ~nsIAccessibleStates::STATE_FOCUSED;
+      state &= ~states::FOCUSED;
     }
   }
   if (mContent->HasAttr(kNameSpaceID_None, nsAccessibilityAtoms::multiple))
-    *aState |= nsIAccessibleStates::STATE_MULTISELECTABLE |
-               nsIAccessibleStates::STATE_EXTSELECTABLE;
+    state |= states::MULTISELECTABLE | states::EXTSELECTABLE;
 
-  return NS_OK;
+  return state;
 }
 
 PRUint32
 nsHTMLSelectListAccessible::NativeRole()
 {
   if (mParent && mParent->Role() == nsIAccessibleRole::ROLE_COMBOBOX)
     return nsIAccessibleRole::ROLE_COMBOBOX_LIST;
 
@@ -224,116 +221,103 @@ nsHTMLSelectOptionAccessible::GetNameInt
   }
 
   return NS_OK;
 }
 
 // nsAccessible protected
 nsIFrame* nsHTMLSelectOptionAccessible::GetBoundsFrame()
 {
-  PRUint32 state = 0;
-  nsCOMPtr<nsIContent> content = GetSelectState(&state);
-  if (state & nsIAccessibleStates::STATE_COLLAPSED) {
+  PRUint64 state = 0;
+  nsIContent* content = GetSelectState(&state);
+  if (state & states::COLLAPSED) {
     if (content) {
       return content->GetPrimaryFrame();
     }
 
     return nsnull;
   }
 
   return nsAccessible::GetBoundsFrame();
 }
 
-/**
-  * As a nsHTMLSelectOptionAccessible we can have the following states:
-  *     STATE_SELECTABLE
-  *     STATE_SELECTED
-  *     STATE_FOCUSED
-  *     STATE_FOCUSABLE
-  *     STATE_OFFSCREEN
-  */
-nsresult
-nsHTMLSelectOptionAccessible::GetStateInternal(PRUint32 *aState,
-                                               PRUint32 *aExtraState)
+PRUint64
+nsHTMLSelectOptionAccessible::NativeState()
 {
+  // As a nsHTMLSelectOptionAccessible we can have the following states:
+  // SELECTABLE, SELECTED, FOCUSED, FOCUSABLE, OFFSCREEN
   // Upcall to nsAccessible, but skip nsHyperTextAccessible impl
-  // because we don't want EXT_STATE_EDITABLE or EXT_STATE_SELECTABLE_TEXT
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  // because we don't want EDITABLE or SELECTABLE_TEXT
+  PRUint64 state = nsAccessible::NativeState();
 
-  PRUint32 selectState = 0, selectExtState = 0;
-  nsCOMPtr<nsIContent> selectContent = GetSelectState(&selectState,
-                                                      &selectExtState);
-  if (selectState & nsIAccessibleStates::STATE_INVISIBLE) {
-    return NS_OK;
-  }
+  PRUint64 selectState = 0;
+  nsIContent* selectContent = GetSelectState(&selectState);
+  if (selectState & states::INVISIBLE)
+    return state;
 
   NS_ENSURE_TRUE(selectContent, NS_ERROR_FAILURE);
 
   // Is disabled?
-  if (0 == (*aState & nsIAccessibleStates::STATE_UNAVAILABLE)) {
-    *aState |= (nsIAccessibleStates::STATE_FOCUSABLE |
-                nsIAccessibleStates::STATE_SELECTABLE);
+  if (0 == (state & states::UNAVAILABLE)) {
+    state |= (states::FOCUSABLE | states::SELECTABLE);
     // When the list is focused but no option is actually focused,
     // Firefox draws a focus ring around the first non-disabled option.
-    // We need to indicated STATE_FOCUSED in that case, because it
+    // We need to indicate states::FOCUSED in that case, because it
     // prevents JAWS from ignoring the list
     // GetFocusedOption() ensures that an option node is
     // returned in this case, as long as some focusable option exists
     // in the listbox
     nsCOMPtr<nsIContent> focusedOption = GetFocusedOption(selectContent);
     if (focusedOption == mContent)
-      *aState |= nsIAccessibleStates::STATE_FOCUSED;
+      state |= states::FOCUSED;
   }
 
   // Are we selected?
   PRBool isSelected = PR_FALSE;
   nsCOMPtr<nsIDOMHTMLOptionElement> option(do_QueryInterface(mContent));
   if (option) {
     option->GetSelected(&isSelected);
-    if ( isSelected ) 
-      *aState |= nsIAccessibleStates::STATE_SELECTED;
+    if (isSelected)
+      state |= states::SELECTED;
+
   }
 
-  if (selectState & nsIAccessibleStates::STATE_OFFSCREEN) {
-    *aState |= nsIAccessibleStates::STATE_OFFSCREEN;
+  if (selectState & states::OFFSCREEN) {
+    state |= states::OFFSCREEN;
   }
-  else if (selectState & nsIAccessibleStates::STATE_COLLAPSED) {
-    // <select> is COLLAPSED: add STATE_OFFSCREEN, if not the currently
+  else if (selectState & states::COLLAPSED) {
+    // <select> is COLLAPSED: add OFFSCREEN, if not the currently
     // visible option
     if (!isSelected) {
-      *aState |= nsIAccessibleStates::STATE_OFFSCREEN;
+      state |= states::OFFSCREEN;
     }
     else {
       // Clear offscreen and invisible for currently showing option
-      *aState &= ~nsIAccessibleStates::STATE_OFFSCREEN;
-      *aState &= ~nsIAccessibleStates::STATE_INVISIBLE;
-       if (aExtraState) {
-         *aExtraState |= selectExtState & nsIAccessibleStates::EXT_STATE_OPAQUE;
-       }
+      state &= ~(states::OFFSCREEN | states::INVISIBLE);
+      state |= selectState & states::OPAQUE1;
     }
   }
   else {
     // XXX list frames are weird, don't rely on nsAccessible's general
     // visibility implementation unless they get reimplemented in layout
-    *aState &= ~nsIAccessibleStates::STATE_OFFSCREEN;
-    // <select> is not collapsed: compare bounds to calculate STATE_OFFSCREEN
+    state &= ~states::OFFSCREEN;
+    // <select> is not collapsed: compare bounds to calculate OFFSCREEN
     nsAccessible* listAcc = GetParent();
     if (listAcc) {
       PRInt32 optionX, optionY, optionWidth, optionHeight;
       PRInt32 listX, listY, listWidth, listHeight;
       GetBounds(&optionX, &optionY, &optionWidth, &optionHeight);
       listAcc->GetBounds(&listX, &listY, &listWidth, &listHeight);
       if (optionY < listY || optionY + optionHeight > listY + listHeight) {
-        *aState |= nsIAccessibleStates::STATE_OFFSCREEN;
+        state |= states::OFFSCREEN;
       }
     }
   }
  
-  return NS_OK;
+  return state;
 }
 
 PRInt32
 nsHTMLSelectOptionAccessible::GetLevelInternal()
 {
   nsIContent *parentContent = mContent->GetParent();
 
   PRInt32 level =
@@ -548,51 +532,48 @@ nsHTMLSelectOptionAccessible::SelectionC
   nsRefPtr<AccEvent> selWithinEvent =
     new AccEvent(nsIAccessibleEvent::EVENT_SELECTION_WITHIN, multiSelect);
 
   if (!selWithinEvent)
     return;
 
   option->GetDocAccessible()->FireDelayedAccessibleEvent(selWithinEvent);
 
-  PRUint32 state = nsAccUtils::State(option);
+  PRUint64 state = option->State();
   PRUint32 eventType;
-  if (state & nsIAccessibleStates::STATE_SELECTED) {
+  if (state & states::SELECTED) {
     eventType = nsIAccessibleEvent::EVENT_SELECTION_ADD;
   }
   else {
     eventType = nsIAccessibleEvent::EVENT_SELECTION_REMOVE;
   }
 
   nsRefPtr<AccEvent> selAddRemoveEvent = new AccEvent(eventType, option);
 
   if (selAddRemoveEvent)
     option->GetDocAccessible()->FireDelayedAccessibleEvent(selAddRemoveEvent);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsHTMLSelectOptionAccessible: private methods
 
-nsIContent* nsHTMLSelectOptionAccessible::GetSelectState(PRUint32* aState,
-                                                         PRUint32* aExtraState)
+nsIContent*
+nsHTMLSelectOptionAccessible::GetSelectState(PRUint64* aState)
 {
   *aState = 0;
 
-  if (aExtraState)
-    *aExtraState = 0;
-
   nsIContent *content = mContent;
   while (content && content->Tag() != nsAccessibilityAtoms::select) {
     content = content->GetParent();
   }
 
   if (content) {
     nsAccessible* selAcc = GetAccService()->GetAccessible(content);
     if (selAcc) {
-      selAcc->GetState(aState, aExtraState);
+      *aState = selAcc->State();
       return content;
     }
   }
   return nsnull; 
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -607,28 +588,24 @@ nsHTMLSelectOptGroupAccessible::
 }
 
 PRUint32
 nsHTMLSelectOptGroupAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_HEADING;
 }
 
-nsresult
-nsHTMLSelectOptGroupAccessible::GetStateInternal(PRUint32 *aState,
-                                                 PRUint32 *aExtraState)
+PRUint64
+nsHTMLSelectOptGroupAccessible::NativeState()
 {
-  nsresult rv = nsHTMLSelectOptionAccessible::GetStateInternal(aState,
-                                                               aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsHTMLSelectOptionAccessible::NativeState();
 
-  *aState &= ~(nsIAccessibleStates::STATE_FOCUSABLE |
-               nsIAccessibleStates::STATE_SELECTABLE);
+  state &= ~(states::FOCUSABLE | states::SELECTABLE);
 
-  return NS_OK;
+  return state;
 }
 
 NS_IMETHODIMP nsHTMLSelectOptGroupAccessible::DoAction(PRUint8 index)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP nsHTMLSelectOptGroupAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
@@ -721,45 +698,38 @@ nsHTMLComboboxAccessible::Shutdown()
 
   if (mListAccessible) {
     mListAccessible->Shutdown();
     mListAccessible = nsnull;
   }
 }
 
 /**
-  * As a nsHTMLComboboxAccessible we can have the following states:
-  *     STATE_FOCUSED
-  *     STATE_FOCUSABLE
-  *     STATE_HASPOPUP
-  *     STATE_EXPANDED
-  *     STATE_COLLAPSED
   */
-nsresult
-nsHTMLComboboxAccessible::GetStateInternal(PRUint32 *aState,
-                                           PRUint32 *aExtraState)
+PRUint64
+nsHTMLComboboxAccessible::NativeState()
 {
+  // As a nsHTMLComboboxAccessible we can have the following states:
+  // FOCUSED, FOCUSABLE, HASPOPUP, EXPANDED, COLLAPSED
   // Get focus status from base class
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsAccessible::NativeState();
 
   nsIFrame *frame = GetBoundsFrame();
   nsIComboboxControlFrame *comboFrame = do_QueryFrame(frame);
   if (comboFrame && comboFrame->IsDroppedDown()) {
-    *aState |= nsIAccessibleStates::STATE_EXPANDED;
+    state |= states::EXPANDED;
   }
   else {
-    *aState &= ~nsIAccessibleStates::STATE_FOCUSED; // Focus is on an option
-    *aState |= nsIAccessibleStates::STATE_COLLAPSED;
+    state &= ~states::FOCUSED; // Focus is on an option
+    state |= states::COLLAPSED;
   }
 
-  *aState |= nsIAccessibleStates::STATE_HASPOPUP |
-             nsIAccessibleStates::STATE_FOCUSABLE;
+  state |= states::HASPOPUP | states::FOCUSABLE;
 
-  return NS_OK;
+  return state;
 }
 
 NS_IMETHODIMP nsHTMLComboboxAccessible::GetDescription(nsAString& aDescription)
 {
   aDescription.Truncate();
   // First check to see if combo box itself has a description, perhaps through
   // tooltip (title attribute) or via aria-describedby
   nsAccessible::GetDescription(aDescription);
@@ -889,54 +859,47 @@ bool
 nsHTMLComboboxListAccessible::IsPrimaryForNode() const
 {
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsHTMLComboboxAccessible: nsAccessible
 
-/**
-  * As a nsHTMLComboboxListAccessible we can have the following states:
-  *     STATE_FOCUSED
-  *     STATE_FOCUSABLE
-  *     STATE_INVISIBLE
-  *     STATE_FLOATING
-  */
-nsresult
-nsHTMLComboboxListAccessible::GetStateInternal(PRUint32 *aState,
-                                               PRUint32 *aExtraState)
+PRUint64
+nsHTMLComboboxListAccessible::NativeState()
 {
+  // As a nsHTMLComboboxListAccessible we can have the following states:
+  // FOCUSED, FOCUSABLE, FLOATING, INVISIBLE
   // Get focus status from base class
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsAccessible::NativeState();
 
   nsIFrame *boundsFrame = GetBoundsFrame();
   nsIComboboxControlFrame* comboFrame = do_QueryFrame(boundsFrame);
   if (comboFrame && comboFrame->IsDroppedDown())
-    *aState |= nsIAccessibleStates::STATE_FLOATING;
+    state |= states::FLOATING;
   else
-    *aState |= nsIAccessibleStates::STATE_INVISIBLE;
+    state |= states::INVISIBLE;
 
-  return NS_OK;
+  return state;
 }
 
 /**
   * Gets the bounds for the areaFrame.
   *     Walks the Frame tree and checks for proper frames.
   */
 void nsHTMLComboboxListAccessible::GetBoundsRect(nsRect& aBounds, nsIFrame** aBoundingFrame)
 {
   *aBoundingFrame = nsnull;
 
   nsAccessible* comboAcc = GetParent();
   if (!comboAcc)
     return;
 
-  if (0 == (nsAccUtils::State(comboAcc) & nsIAccessibleStates::STATE_COLLAPSED)) {
+  if (0 == (comboAcc->State() & states::COLLAPSED)) {
     nsHTMLSelectListAccessible::GetBoundsRect(aBounds, aBoundingFrame);
     return;
   }
 
   // Get the first option.
   nsIContent* content = mContent->GetChildAt(0);
   if (!content) {
     return;
--- a/accessible/src/html/nsHTMLSelectAccessible.h
+++ b/accessible/src/html/nsHTMLSelectAccessible.h
@@ -69,17 +69,17 @@ class nsHTMLSelectListAccessible : publi
 {
 public:
   
   nsHTMLSelectListAccessible(nsIContent *aContent, nsIWeakReference *aShell);
   virtual ~nsHTMLSelectListAccessible() {}
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
   // SelectAccessible
   virtual bool IsSelect();
   virtual bool SelectAll();
   virtual bool UnselectAll();
 
 protected:
 
@@ -109,17 +109,17 @@ public:
   NS_IMETHOD DoAction(PRUint8 index);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD GetNumActions(PRUint8 *_retval);
   NS_IMETHOD SetSelected(PRBool aSelect);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
   virtual PRInt32 GetLevelInternal();
   virtual void GetPositionAndSizeInternal(PRInt32 *aPosInSet,
                                           PRInt32 *aSetSize);
 
   /**
    * Return focused option if any.
    */
@@ -131,20 +131,19 @@ protected:
   // nsAccessible
   virtual nsIFrame* GetBoundsFrame();
 
 private:
   
   /**
    * Get Select element's accessible state
    * @param aState, Select element state
-   * @param aExtraState, Select element extra state
    * @return Select element content, returns null if not avaliable
    */ 
-  nsIContent* GetSelectState(PRUint32* aState, PRUint32* aExtraState = nsnull);
+  nsIContent* GetSelectState(PRUint64* aState);
 };
 
 /*
  * Opt Groups inside the select, contained within the list
  */
 class nsHTMLSelectOptGroupAccessible : public nsHTMLSelectOptionAccessible
 {
 public:
@@ -154,17 +153,17 @@ public:
 
   // nsIAccessible
   NS_IMETHOD DoAction(PRUint8 index);  
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD GetNumActions(PRUint8 *_retval);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
 protected:
   // nsAccessible
   virtual void CacheChildren();
 };
 
 /** ------------------------------------------------------ */
 /**  Finally, the Combobox widgets                         */
@@ -190,17 +189,17 @@ public:
   NS_IMETHOD GetNumActions(PRUint8 *aNumActions);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
 
   // nsAccessNode
   virtual void Shutdown();
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual void InvalidateChildren();
 
 protected:
   // nsAccessible
   virtual void CacheChildren();
 
   // nsHTMLComboboxAccessible
 
@@ -227,13 +226,13 @@ public:
                                nsIWeakReference* aShell);
   virtual ~nsHTMLComboboxListAccessible() {}
 
   // nsAccessNode
   virtual nsIFrame* GetFrame() const;
   virtual bool IsPrimaryForNode() const;
 
   // nsAccessible
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual void GetBoundsRect(nsRect& aBounds, nsIFrame** aBoundingFrame);
 };
 
 #endif
--- a/accessible/src/html/nsHTMLTableAccessible.cpp
+++ b/accessible/src/html/nsHTMLTableAccessible.cpp
@@ -34,16 +34,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHTMLTableAccessible.h"
 
+#include "States.h"
 #include "nsAccessibilityService.h"
 #include "nsAccTreeWalker.h"
 #include "nsAccUtils.h"
 #include "nsDocAccessible.h"
 #include "nsRelUtils.h"
 #include "nsTextEquivUtils.h"
 
 #include "nsIDOMElement.h"
@@ -87,35 +88,33 @@ NS_IMPL_ISUPPORTS_INHERITED1(nsHTMLTable
 // nsHTMLTableCellAccessible: nsAccessible implementation
 
 PRUint32
 nsHTMLTableCellAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_CELL;
 }
 
-nsresult
-nsHTMLTableCellAccessible::GetStateInternal(PRUint32 *aState,
-                                            PRUint32 *aExtraState)
+PRUint64
+nsHTMLTableCellAccessible::NativeState()
 {
-  nsresult rv= nsHyperTextAccessibleWrap::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsHyperTextAccessibleWrap::NativeState();
 
   nsIFrame *frame = mContent->GetPrimaryFrame();
   NS_ASSERTION(frame, "No frame for valid cell accessible!");
 
   if (frame) {
-    *aState |= nsIAccessibleStates::STATE_SELECTABLE;
+    state |= states::SELECTABLE;
     PRBool isSelected = PR_FALSE;
     frame->GetSelected(&isSelected);
     if (isSelected)
-      *aState |= nsIAccessibleStates::STATE_SELECTED;
+      state |= states::SELECTED;
   }
 
-  return NS_OK;
+  return state;
 }
 
 nsresult
 nsHTMLTableCellAccessible::GetAttributesInternal(nsIPersistentProperties *aAttributes)
 {
   if (IsDefunct())
     return NS_ERROR_FAILURE;
 
@@ -451,24 +450,20 @@ nsHTMLTableAccessible::CacheChildren()
 }
 
 PRUint32
 nsHTMLTableAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_TABLE;
 }
 
-nsresult
-nsHTMLTableAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsHTMLTableAccessible::NativeState()
 {
-  nsresult rv= nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
-  *aState |= nsIAccessibleStates::STATE_READONLY;
-  return NS_OK;
+  return nsAccessible::NativeState() | states::READONLY;
 }
 
 nsresult
 nsHTMLTableAccessible::GetNameInternal(nsAString& aName)
 {
   nsAccessible::GetNameInternal(aName);
 
   if (aName.IsEmpty())
@@ -1362,19 +1357,18 @@ nsHTMLTableAccessible::IsProbablyForLayo
 
   *aIsProbablyForLayout = PR_FALSE;
 
   if (IsDefunct())
     return NS_ERROR_FAILURE;
 
   nsDocAccessible *docAccessible = GetDocAccessible();
   if (docAccessible) {
-    PRUint32 state, extState;
-    docAccessible->GetState(&state, &extState);
-    if (extState & nsIAccessibleStates::EXT_STATE_EDITABLE) {  // Need to see all elements while document is being edited
+    PRUint64 docState = docAccessible->State();
+    if (docState & states::EDITABLE) {  // Need to see all elements while document is being edited
       RETURN_LAYOUT_ANSWER(PR_FALSE, "In editable document");
     }
   }
 
   // Check to see if an ARIA role overrides the role from native markup,
   // but for which we still expose table semantics (treegrid, for example).
   PRBool hasNonTableRole = (Role() != nsIAccessibleRole::ROLE_TABLE);
   if (hasNonTableRole) {
--- a/accessible/src/html/nsHTMLTableAccessible.h
+++ b/accessible/src/html/nsHTMLTableAccessible.h
@@ -57,17 +57,17 @@ public:
   // nsISupports
   NS_DECL_ISUPPORTS_INHERITED
 
   // nsIAccessibleTableCell
   NS_DECL_NSIACCESSIBLETABLECELL
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual nsresult GetAttributesInternal(nsIPersistentProperties *aAttributes);
 
 protected:
   /**
    * Return host table accessible.
    */
   already_AddRefed<nsIAccessibleTable> GetTableAccessible();
   
@@ -133,17 +133,17 @@ public:
   // nsIAccessible
   NS_IMETHOD GetDescription(nsAString& aDescription);
   NS_IMETHOD GetRelationByType(PRUint32 aRelationType,
                                nsIAccessibleRelation **aRelation);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual nsresult GetAttributesInternal(nsIPersistentProperties *aAttributes);
 
   // nsHTMLTableAccessible
 
   /**
    * Retun cell element at the given row and column index.
    */
   nsresult GetCellAt(PRInt32 aRowIndex, PRInt32 aColIndex,
--- a/accessible/src/html/nsHTMLTextAccessible.cpp
+++ b/accessible/src/html/nsHTMLTextAccessible.cpp
@@ -38,16 +38,17 @@
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHTMLTextAccessible.h"
 
 #include "nsDocAccessible.h"
 #include "nsAccUtils.h"
 #include "nsRelUtils.h"
 #include "nsTextEquivUtils.h"
+#include "States.h"
 
 #include "nsIFrame.h"
 #include "nsPresContext.h"
 #include "nsBlockFrame.h"
 #include "nsISelection.h"
 #include "nsISelectionController.h"
 #include "nsComponentManagerUtils.h"
 
@@ -79,32 +80,30 @@ nsHTMLTextAccessible::NativeRole()
   // after accessible is shutdown/DEFUNCT
   if (frame && frame->IsGeneratedContentFrame()) {
     return nsIAccessibleRole::ROLE_STATICTEXT;
   }
 
   return nsTextAccessible::NativeRole();
 }
 
-nsresult
-nsHTMLTextAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsHTMLTextAccessible::NativeState()
 {
-  nsresult rv = nsTextAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsTextAccessible::NativeState();
 
   nsDocAccessible *docAccessible = GetDocAccessible();
   if (docAccessible) {
-     PRUint32 state, extState;
-     docAccessible->GetState(&state, &extState);
-     if (0 == (extState & nsIAccessibleStates::EXT_STATE_EDITABLE)) {
-       *aState |= nsIAccessibleStates::STATE_READONLY; // Links not focusable in editor
+     PRUint64 docState = docAccessible->State();
+     if (0 == (docState & states::EDITABLE)) {
+       state |= states::READONLY; // Links not focusable in editor
      }
   }
 
-  return NS_OK;
+  return state;
 }
 
 nsresult
 nsHTMLTextAccessible::GetAttributesInternal(nsIPersistentProperties *aAttributes)
 {
   if (NativeRole() == nsIAccessibleRole::ROLE_STATICTEXT) {
     nsAutoString oldValueUnused;
     aAttributes->SetStringProperty(NS_LITERAL_CSTRING("auto-generated"),
@@ -143,33 +142,20 @@ nsHTMLBRAccessible::
 }
 
 PRUint32
 nsHTMLBRAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_WHITESPACE;
 }
 
-nsresult
-nsHTMLBRAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsHTMLBRAccessible::NativeState()
 {
-  *aState = 0;
-
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_DEFUNCT;
-
-    return NS_OK_DEFUNCT_OBJECT;
-  }
-
-  *aState = nsIAccessibleStates::STATE_READONLY;
-  if (aExtraState)
-    *aExtraState = 0;
-
-  return NS_OK;
+  return IsDefunct() ? states::DEFUNCT : states::READONLY;
 }
 
 nsresult
 nsHTMLBRAccessible::GetNameInternal(nsAString& aName)
 {
   aName = static_cast<PRUnichar>('\n');    // Newline char
   return NS_OK;
 }
@@ -277,25 +263,20 @@ nsHTMLLIAccessible::Shutdown()
 }
 
 PRUint32
 nsHTMLLIAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_LISTITEM;
 }
 
-nsresult
-nsHTMLLIAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsHTMLLIAccessible::NativeState()
 {
-  nsresult rv = nsHyperTextAccessibleWrap::GetStateInternal(aState,
-                                                            aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
-  *aState |= nsIAccessibleStates::STATE_READONLY;
-  return NS_OK;
+  return nsHyperTextAccessibleWrap::NativeState() | states::READONLY;
 }
 
 NS_IMETHODIMP nsHTMLLIAccessible::GetBounds(PRInt32 *x, PRInt32 *y, PRInt32 *width, PRInt32 *height)
 {
   nsresult rv = nsAccessibleWrap::GetBounds(x, y, width, height);
   if (NS_FAILED(rv) || !mBullet)
     return rv;
 
@@ -392,25 +373,24 @@ nsHTMLListBulletAccessible::GetName(nsAS
 }
 
 PRUint32
 nsHTMLListBulletAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_STATICTEXT;
 }
 
-nsresult
-nsHTMLListBulletAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsHTMLListBulletAccessible::NativeState()
 {
-  nsresult rv = nsLeafAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsLeafAccessible::NativeState();
 
-  *aState &= ~nsIAccessibleStates::STATE_FOCUSABLE;
-  *aState |= nsIAccessibleStates::STATE_READONLY;
-  return NS_OK;
+  state &= ~states::FOCUSABLE;
+  state |= states::READONLY;
+  return state;
 }
 
 void
 nsHTMLListBulletAccessible::AppendTextTo(nsAString& aText, PRUint32 aStartOffset,
                                          PRUint32 aLength)
 {
   nsAutoString bulletText;
   nsBlockFrame* blockFrame = do_QueryFrame(mContent->GetPrimaryFrame());
@@ -434,19 +414,14 @@ nsHTMLListAccessible::
 NS_IMPL_ISUPPORTS_INHERITED0(nsHTMLListAccessible, nsHyperTextAccessible)
 
 PRUint32
 nsHTMLListAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_LIST;
 }
 
-nsresult
-nsHTMLListAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsHTMLListAccessible::NativeState()
 {
-  nsresult rv = nsHyperTextAccessibleWrap::GetStateInternal(aState,
-                                                            aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
-  *aState |= nsIAccessibleStates::STATE_READONLY;
-  return NS_OK;
+  return nsHyperTextAccessibleWrap::NativeState() | states::READONLY;
 }
 
--- a/accessible/src/html/nsHTMLTextAccessible.h
+++ b/accessible/src/html/nsHTMLTextAccessible.h
@@ -56,17 +56,17 @@ public:
   NS_DECL_ISUPPORTS_INHERITED
 
   // nsIAccessible
   NS_IMETHOD GetName(nsAString& aName);
 
   // nsAccessible
   virtual nsresult GetAttributesInternal(nsIPersistentProperties *aAttributes);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 /**
  * Used for HTML hr element.
  */
 class nsHTMLHRAccessible : public nsLeafAccessible
 {
 public:
@@ -82,17 +82,17 @@ public:
 class nsHTMLBRAccessible : public nsLeafAccessible
 {
 public:
   nsHTMLBRAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 /**
  * Used for HTML label element.
  */
 class nsHTMLLabelAccessible : public nsHyperTextAccessibleWrap
 {
 public:
@@ -135,17 +135,17 @@ public:
   // nsIAccessible
   NS_IMETHOD GetName(nsAString& aName);
 
   // nsAccessNode
   virtual bool IsPrimaryForNode() const;
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual void AppendTextTo(nsAString& aText, PRUint32 aStartOffset = 0,
                             PRUint32 aLength = PR_UINT32_MAX);
 };
 
 /**
  * Used for HTML list (like HTML ul).
  */
 class nsHTMLListAccessible : public nsHyperTextAccessibleWrap
@@ -153,17 +153,17 @@ class nsHTMLListAccessible : public nsHy
 public:
   nsHTMLListAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsISupports
   NS_DECL_ISUPPORTS_INHERITED
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 /**
  * Used for HTML list item (e.g. HTML li).
  */
 class nsHTMLLIAccessible : public nsHyperTextAccessibleWrap
 {
 public:
@@ -175,17 +175,17 @@ public:
   // nsAccessNode
   virtual void Shutdown();
 
   // nsIAccessible
   NS_IMETHOD GetBounds(PRInt32 *x, PRInt32 *y, PRInt32 *width, PRInt32 *height);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
   // nsHTMLLIAccessible
   void UpdateBullet(bool aHasBullet);
 
 protected:
   // nsAccessible
   virtual void CacheChildren();
 
--- a/accessible/src/html/nsHyperTextAccessible.cpp
+++ b/accessible/src/html/nsHyperTextAccessible.cpp
@@ -34,16 +34,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHyperTextAccessible.h"
 
+#include "States.h"
 #include "nsAccessibilityAtoms.h"
 #include "nsAccessibilityService.h"
 #include "nsAccUtils.h"
 #include "nsTextAttrs.h"
 
 #include "nsIClipboard.h"
 #include "nsContentCID.h"
 #include "nsIDOMAbstractView.h"
@@ -168,42 +169,38 @@ nsHyperTextAccessible::NativeRole()
     // An html:input @type="file" is the only input that is exposed as a
     // blockframe. It must be exposed as ROLE_TEXT_CONTAINER for JAWS.
     return nsIAccessibleRole::ROLE_PARAGRAPH;
   }
 
   return nsIAccessibleRole::ROLE_TEXT_CONTAINER; // In ATK this works
 }
 
-nsresult
-nsHyperTextAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsHyperTextAccessible::NativeState()
 {
-  nsresult rv = nsAccessibleWrap::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
-  if (!aExtraState)
-    return NS_OK;
+  PRUint64 states = nsAccessibleWrap::NativeState();
 
   nsCOMPtr<nsIEditor> editor;
   GetAssociatedEditor(getter_AddRefs(editor));
   if (editor) {
     PRUint32 flags;
     editor->GetFlags(&flags);
     if (0 == (flags & nsIPlaintextEditor::eEditorReadonlyMask)) {
-      *aExtraState |= nsIAccessibleStates::EXT_STATE_EDITABLE;
+      states |= states::EDITABLE;
     }
   } else if (mContent->Tag() == nsAccessibilityAtoms::article) {
     // We want <article> to behave like a document in terms of readonly state.
-    *aState |= nsIAccessibleStates::STATE_READONLY;
+    states |= states::READONLY;
   }
 
   if (GetChildCount() > 0)
-    *aExtraState |= nsIAccessibleStates::EXT_STATE_SELECTABLE_TEXT;
+    states |= states::SELECTABLE_TEXT;
 
-  return NS_OK;
+  return states;
 }
 
 // Substring must be entirely within the same text node
 nsIntRect nsHyperTextAccessible::GetBoundsForString(nsIFrame *aFrame, PRUint32 aStartRenderedOffset,
                                                     PRUint32 aEndRenderedOffset)
 {
   nsIntRect screenRect;
   NS_ENSURE_TRUE(aFrame, screenRect);
--- a/accessible/src/html/nsHyperTextAccessible.h
+++ b/accessible/src/html/nsHyperTextAccessible.h
@@ -82,17 +82,17 @@ public:
   NS_DECL_NSIACCESSIBLEHYPERTEXT
   NS_DECL_NSIACCESSIBLEEDITABLETEXT
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_HYPERTEXTACCESSIBLE_IMPL_CID)
 
   // nsAccessible
   virtual PRInt32 GetLevelInternal();
   virtual nsresult GetAttributesInternal(nsIPersistentProperties *aAttributes);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
   virtual void InvalidateChildren();
   virtual PRBool RemoveChild(nsAccessible* aAccessible);
 
   // nsHyperTextAccessible (static helper method)
 
   // Convert content offset to rendered text offset  
   static nsresult ContentToRenderedOffset(nsIFrame *aFrame, PRInt32 aContentOffset,
--- a/accessible/src/mac/mozAccessible.mm
+++ b/accessible/src/mac/mozAccessible.mm
@@ -543,39 +543,33 @@ GetNativeFromGeckoAccessible(nsIAccessib
 
   return [NSString stringWithFormat:@"(%p) %@", self, [self role]];
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 
 - (BOOL)isFocused
 {
-  PRUint32 state = 0;
-  mGeckoAccessible->GetState (&state, nsnull);
-  return (state & nsIAccessibleStates::STATE_FOCUSED) != 0;
+  return (mGeckoAccessible->State() & states::FOCUSED) != 0;
 }
 
 - (BOOL)canBeFocused
 {
-  PRUint32 state = 0;
-  mGeckoAccessible->GetState (&state, nsnull);
-  return (state & nsIAccessibleStates::STATE_FOCUSABLE) != 0;
+  return mGeckoAccessible->State() & states::FOCUSABLE;
 }
 
 - (BOOL)focus
 {
   nsresult rv = mGeckoAccessible->TakeFocus();
   return NS_SUCCEEDED(rv);
 }
 
 - (BOOL)isEnabled
 {
-  PRUint32 state = 0;
-  mGeckoAccessible->GetState (&state, nsnull);
-  return (state & nsIAccessibleStates::STATE_UNAVAILABLE) == 0;
+  return (mGeckoAccessible->State() & states::UNAVAILABLE) == 0;
 }
 
 // The root accessible calls this when the focused node was
 // changed to us.
 - (void)didReceiveFocus
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
 
--- a/accessible/src/mac/mozActionElements.mm
+++ b/accessible/src/mac/mozActionElements.mm
@@ -152,22 +152,21 @@ enum CheckboxValue {
   
   return nil;
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
 }
 
 - (int)isChecked
 {
-  PRUint32 state = 0;
-  mGeckoAccessible->GetStateInternal(&state, nsnull);
+  PRUint64 state = mGeckoAccessible->NativeState();
 
   // check if we're checked or in a mixed state
-  if (state & nsIAccessibleStates::STATE_CHECKED) {
-    return (state & nsIAccessibleStates::STATE_MIXED) ? kMixed : kChecked;
+  if (state & states::CHECKED) {
+    return (state & states::MIXED) ? kMixed : kChecked;
   }
   
   return kUnchecked;
 }
 
 - (id)value
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
--- a/accessible/src/mac/mozTextAccessible.mm
+++ b/accessible/src/mac/mozTextAccessible.mm
@@ -133,21 +133,18 @@ extern const NSString *kTopLevelUIElemen
 
 - (BOOL)isReadOnly
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
 
   if ([[self role] isEqualToString:NSAccessibilityStaticTextRole])
     return YES;
     
-  if (mGeckoEditableTextAccessible) {
-    PRUint32 state = 0;
-    mGeckoAccessible->GetState(&state, nsnull);
-    return (state & nsIAccessibleStates::STATE_READONLY) == 0;
-  }
+  if (mGeckoEditableTextAccessible)
+    return (mGeckoEditableTextAccessible->State() & states::READONLY) == 0;
 
   return NO;
 
   NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NO);
 }
 
 - (void)setText:(NSString*)newString
 {
--- a/accessible/src/mac/nsAccessibleWrap.h
+++ b/accessible/src/mac/nsAccessibleWrap.h
@@ -79,19 +79,17 @@ class nsAccessibleWrap : public nsAccess
 
     // ignored means that the accessible might still have children, but is not displayed
     // to the user. it also has no native accessible object represented for it.
     PRBool IsIgnored();
     
     PRInt32 GetUnignoredChildCount(PRBool aDeepCount);
     
     PRBool HasPopup () {
-      PRUint32 state = 0;
-      GetStateInternal(&state, nsnull);
-      return (state & nsIAccessibleStates::STATE_HASPOPUP);
+      return (NativeState() & states::HASPOPUP);
     }
     
     // return this accessible's all children, adhering to "flat" accessibles by not returning their children.
     void GetUnignoredChildren(nsTArray<nsRefPtr<nsAccessibleWrap> > &aChildrenArray);
     virtual already_AddRefed<nsIAccessible> GetUnignoredParent();
     
   protected:
 
--- a/accessible/src/msaa/CAccessibleComponent.cpp
+++ b/accessible/src/msaa/CAccessibleComponent.cpp
@@ -37,22 +37,19 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "CAccessibleComponent.h"
 
 #include "AccessibleComponent_i.c"
 
-#include "nsIAccessNode.h"
-#include "nsIAccessible.h"
-#include "nsIAccessibleStates.h"
-#include "nsAccessNodeWrap.h"
+#include "nsAccessible.h"
+#include "States.h"
 
-#include "nsCOMPtr.h"
 #include "nsString.h"
 
 #include "nsIDOMCSSPrimitiveValue.h"
 #include "nsIDOMNSRGBAColor.h"
 
 enum {
   IA2AlphaShift = 24,
   IA2RedShift = 16,
@@ -80,31 +77,27 @@ CAccessibleComponent::QueryInterface(REF
 
 STDMETHODIMP
 CAccessibleComponent::get_locationInParent(long *aX, long *aY)
 {
 __try {
   *aX = 0;
   *aY = 0;
 
-  nsCOMPtr<nsIAccessible> acc(do_QueryObject(this));
+  nsRefPtr<nsAccessible> acc(do_QueryObject(this));
   if (!acc)
     return E_FAIL;
 
   // If the object is not on any screen the returned position is (0,0).
-  PRUint32 states = 0;
-  nsresult rv = acc->GetState(&states, nsnull);
-  if (NS_FAILED(rv))
-    return GetHRESULT(rv);
-
-  if (states & nsIAccessibleStates::STATE_INVISIBLE)
+  PRUint64 state = acc->State();
+  if (state & states::INVISIBLE)
     return S_OK;
 
   PRInt32 x = 0, y = 0, width = 0, height = 0;
-  rv = acc->GetBounds(&x, &y, &width, &height);
+  nsresult rv = acc->GetBounds(&x, &y, &width, &height);
   if (NS_FAILED(rv))
     return GetHRESULT(rv);
 
   nsCOMPtr<nsIAccessible> parentAcc;
   rv = acc->GetParent(getter_AddRefs(parentAcc));
   if (NS_FAILED(rv))
     return GetHRESULT(rv);
 
--- a/accessible/src/msaa/nsAccessibleWrap.cpp
+++ b/accessible/src/msaa/nsAccessibleWrap.cpp
@@ -38,16 +38,17 @@
 
 #include "nsAccessibleWrap.h"
 
 #include "nsAccessibilityAtoms.h"
 #include "nsAccUtils.h"
 #include "nsCoreUtils.h"
 #include "nsRelUtils.h"
 #include "nsWinUtils.h"
+#include "States.h"
 
 #include "nsIAccessibleDocument.h"
 #include "nsIAccessibleEvent.h"
 #include "nsIAccessibleWin32Object.h"
 
 #include "Accessible2_i.c"
 #include "AccessibleStates.h"
 
@@ -430,21 +431,27 @@ STDMETHODIMP nsAccessibleWrap::get_accSt
   VariantInit(pvarState);
   pvarState->vt = VT_I4;
   pvarState->lVal = 0;
 
   nsAccessible *xpAccessible = GetXPAccessibleFor(varChild);
   if (!xpAccessible)
     return E_FAIL;
 
-  PRUint32 state = 0;
-  if (NS_FAILED(xpAccessible->GetState(&state, nsnull)))
-    return E_FAIL;
+  // MSAA only has 31 states and the lowest 31 bits of our state bit mask
+  // are the same states as MSAA.
+  // Note: we map the following Gecko states to different MSAA states:
+  //   REQUIRED -> ALERT_LOW
+  //   ALERT -> ALERT_MEDIUM
+  //   INVALID -> ALERT_HIGH
+  //   CHECKABLE -> MARQUEED
 
-  pvarState->lVal = state;
+  PRUint32 msaaState = 0;
+  nsAccUtils::To32States(xpAccessible->State(), &msaaState, nsnull);
+  pvarState->lVal = msaaState;
 } __except(FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
   return S_OK;
 }
 
 
 STDMETHODIMP nsAccessibleWrap::get_accHelp(
       /* [optional][in] */ VARIANT varChild,
       /* [retval][out] */ BSTR __RPC_FAR *pszHelp)
@@ -1238,57 +1245,54 @@ nsAccessibleWrap::get_groupPosition(long
 STDMETHODIMP
 nsAccessibleWrap::get_states(AccessibleStates *aStates)
 {
 __try {
   *aStates = 0;
 
   // XXX: bug 344674 should come with better approach that we have here.
 
-  PRUint32 states = 0, extraStates = 0;
-  nsresult rv = GetState(&states, &extraStates);
-  if (NS_FAILED(rv))
-    return GetHRESULT(rv);
+  PRUint64 state = State();
 
-  if (states & nsIAccessibleStates::STATE_INVALID)
+  if (state & states::INVALID)
     *aStates |= IA2_STATE_INVALID_ENTRY;
-  if (states & nsIAccessibleStates::STATE_REQUIRED)
+  if (state & states::REQUIRED)
     *aStates |= IA2_STATE_REQUIRED;
 
   // The following IA2 states are not supported by Gecko
   // IA2_STATE_ARMED
   // IA2_STATE_MANAGES_DESCENDANTS
   // IA2_STATE_ICONIFIED
   // IA2_STATE_INVALID // This is not a state, it is the absence of a state
 
-  if (extraStates & nsIAccessibleStates::EXT_STATE_ACTIVE)
+  if (state & states::ACTIVE)
     *aStates |= IA2_STATE_ACTIVE;
-  if (extraStates & nsIAccessibleStates::EXT_STATE_DEFUNCT)
+  if (state & states::DEFUNCT)
     *aStates |= IA2_STATE_DEFUNCT;
-  if (extraStates & nsIAccessibleStates::EXT_STATE_EDITABLE)
+  if (state & states::EDITABLE)
     *aStates |= IA2_STATE_EDITABLE;
-  if (extraStates & nsIAccessibleStates::EXT_STATE_HORIZONTAL)
+  if (state & states::HORIZONTAL)
     *aStates |= IA2_STATE_HORIZONTAL;
-  if (extraStates & nsIAccessibleStates::EXT_STATE_MODAL)
+  if (state & states::MODAL)
     *aStates |= IA2_STATE_MODAL;
-  if (extraStates & nsIAccessibleStates::EXT_STATE_MULTI_LINE)
+  if (state & states::MULTI_LINE)
     *aStates |= IA2_STATE_MULTI_LINE;
-  if (extraStates & nsIAccessibleStates::EXT_STATE_OPAQUE)
+  if (state & states::OPAQUE1)
     *aStates |= IA2_STATE_OPAQUE;
-  if (extraStates & nsIAccessibleStates::EXT_STATE_SELECTABLE_TEXT)
+  if (state & states::SELECTABLE_TEXT)
     *aStates |= IA2_STATE_SELECTABLE_TEXT;
-  if (extraStates & nsIAccessibleStates::EXT_STATE_SINGLE_LINE)
+  if (state & states::SINGLE_LINE)
     *aStates |= IA2_STATE_SINGLE_LINE;
-  if (extraStates & nsIAccessibleStates::EXT_STATE_STALE)
+  if (state & states::STALE)
     *aStates |= IA2_STATE_STALE;
-  if (extraStates & nsIAccessibleStates::EXT_STATE_SUPPORTS_AUTOCOMPLETION)
+  if (state & states::SUPPORTS_AUTOCOMPLETION)
     *aStates |= IA2_STATE_SUPPORTS_AUTOCOMPLETION;
-  if (extraStates & nsIAccessibleStates::EXT_STATE_TRANSIENT)
+  if (state & states::TRANSIENT)
     *aStates |= IA2_STATE_TRANSIENT;
-  if (extraStates & nsIAccessibleStates::EXT_STATE_VERTICAL)
+  if (state & states::VERTICAL)
     *aStates |= IA2_STATE_VERTICAL;
 
   return S_OK;
 
 } __except(nsAccessNodeWrap::FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
   return E_FAIL;
 }
 
--- a/accessible/src/msaa/nsHTMLWin32ObjectAccessible.cpp
+++ b/accessible/src/msaa/nsHTMLWin32ObjectAccessible.cpp
@@ -33,16 +33,18 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHTMLWin32ObjectAccessible.h"
 
+#include "States.h"
+
 ////////////////////////////////////////////////////////////////////////////////
 // nsHTMLWin32ObjectOwnerAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsHTMLWin32ObjectOwnerAccessible::
   nsHTMLWin32ObjectOwnerAccessible(nsIContent *aContent,
                                    nsIWeakReference *aShell, void *aHwnd) :
   nsAccessibleWrap(aContent, aShell), mHwnd(aHwnd)
@@ -65,30 +67,25 @@ nsHTMLWin32ObjectOwnerAccessible::Shutdo
 // nsHTMLWin32ObjectOwnerAccessible: nsAccessible implementation
 
 PRUint32
 nsHTMLWin32ObjectOwnerAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_EMBEDDED_OBJECT;
 }
 
-nsresult
-nsHTMLWin32ObjectOwnerAccessible::GetStateInternal(PRUint32 *aState,
-                                                   PRUint32 *aExtraState)
+PRUint64
+nsHTMLWin32ObjectOwnerAccessible::NativeState()
 {
-  nsresult rv = nsAccessibleWrap::GetStateInternal(aState, aExtraState);
-  if (rv == NS_OK_DEFUNCT_OBJECT)
-    return rv;
-
   // XXX: No HWND means this is windowless plugin which is not accessible in
   // the meantime.
-  if (!mHwnd)
-    *aState = nsIAccessibleStates::STATE_UNAVAILABLE;
+  if (mHwnd)
+    return nsAccessibleWrap::NativeState();
 
-  return rv;
+  return IsDefunct() ? states::DEFUNCT : states::UNAVAILABLE;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsHTMLWin32ObjectOwnerAccessible: nsAccessible protected implementation
 
 void
 nsHTMLWin32ObjectOwnerAccessible::CacheChildren()
 {
--- a/accessible/src/msaa/nsHTMLWin32ObjectAccessible.h
+++ b/accessible/src/msaa/nsHTMLWin32ObjectAccessible.h
@@ -57,17 +57,17 @@ public:
                                    nsIWeakReference *aShell, void *aHwnd);
   virtual ~nsHTMLWin32ObjectOwnerAccessible() {}
 
   // nsAccessNode
   virtual void Shutdown();
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
 protected:
 
   // nsAccessible
   virtual void CacheChildren();
 
   void* mHwnd;
   nsRefPtr<nsAccessible> mNativeAccessible;
--- a/accessible/src/xforms/nsXFormsAccessible.cpp
+++ b/accessible/src/xforms/nsXFormsAccessible.cpp
@@ -33,16 +33,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsXFormsAccessible.h"
 
+#include "States.h"
 #include "nsAccessibilityService.h"
 #include "nsAccUtils.h"
 #include "nsTextEquivUtils.h"
 
 #include "nscore.h"
 #include "nsServiceManagerUtils.h"
 #include "nsIDOMElement.h"
 #include "nsIDOMNodeList.h"
@@ -144,68 +145,58 @@ nsXFormsAccessible::CacheSelectChildren(
 NS_IMETHODIMP
 nsXFormsAccessible::GetValue(nsAString& aValue)
 {
   NS_ENSURE_TRUE(sXFormsService, NS_ERROR_FAILURE);
   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
   return sXFormsService->GetValue(DOMNode, aValue);
 }
 
-nsresult
-nsXFormsAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsXFormsAccessible::NativeState()
 {
-  NS_ENSURE_ARG_POINTER(aState);
-  *aState = 0;
 
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_DEFUNCT;
+  if (IsDefunct())
+    return states::DEFUNCT;
 
-    return NS_OK_DEFUNCT_OBJECT;
-  }
-
-  if (aExtraState)
-    *aExtraState = 0;
-
-  NS_ENSURE_TRUE(sXFormsService, NS_ERROR_FAILURE);
+  NS_ENSURE_TRUE(sXFormsService, 0);
 
   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
 
   PRBool isRelevant = PR_FALSE;
   nsresult rv = sXFormsService->IsRelevant(DOMNode, &isRelevant);
-  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_SUCCESS(rv, 0);
 
   PRBool isReadonly = PR_FALSE;
   rv = sXFormsService->IsReadonly(DOMNode, &isReadonly);
-  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_SUCCESS(rv, 0);
 
   PRBool isRequired = PR_FALSE;
   rv = sXFormsService->IsRequired(DOMNode, &isRequired);
-  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_SUCCESS(rv, 0);
 
   PRBool isValid = PR_FALSE;
   rv = sXFormsService->IsValid(DOMNode, &isValid);
-  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_SUCCESS(rv, 0);
 
-  rv = nsHyperTextAccessibleWrap::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_SUCCESS(rv, rv);
+  PRUint64 states = nsHyperTextAccessibleWrap::NativeState();
 
   if (!isRelevant)
-    *aState |= nsIAccessibleStates::STATE_UNAVAILABLE;
+    states |= states::UNAVAILABLE;
 
   if (isReadonly)
-    *aState |= nsIAccessibleStates::STATE_READONLY;
+    states |= states::READONLY;
 
   if (isRequired)
-    *aState |= nsIAccessibleStates::STATE_REQUIRED;
+    states |= states::REQUIRED;
 
   if (!isValid)
-    *aState |= nsIAccessibleStates::STATE_INVALID;
+    states |= states::INVALID;
 
-  return NS_OK;
+  return states;
 }
 
 nsresult
 nsXFormsAccessible::GetNameInternal(nsAString& aName)
 {
   // search the xforms:label element
   return GetBoundChildElementValue(NS_LITERAL_STRING("label"), aName);
 }
@@ -262,55 +253,47 @@ nsXFormsContainerAccessible::GetAllowsAn
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXFormsEditableAccessible::
   nsXFormsEditableAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
   nsXFormsAccessible(aContent, aShell)
 {
 }
 
-nsresult
-nsXFormsEditableAccessible::GetStateInternal(PRUint32 *aState,
-                                             PRUint32 *aExtraState)
+PRUint64
+nsXFormsEditableAccessible::NativeState()
 {
-  NS_ENSURE_ARG_POINTER(aState);
-
-  nsresult rv = nsXFormsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
-  if (!aExtraState)
-    return NS_OK;
+  PRUint64 state = nsXFormsAccessible::NativeState();
 
   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
 
   PRBool isReadonly = PR_FALSE;
-  rv = sXFormsService->IsReadonly(DOMNode, &isReadonly);
-  NS_ENSURE_SUCCESS(rv, rv);
+  nsresult rv = sXFormsService->IsReadonly(DOMNode, &isReadonly);
+  NS_ENSURE_SUCCESS(rv, state);
 
   if (!isReadonly) {
     PRBool isRelevant = PR_FALSE;
     rv = sXFormsService->IsRelevant(DOMNode, &isRelevant);
-    NS_ENSURE_SUCCESS(rv, rv);
+    NS_ENSURE_SUCCESS(rv, state);
     if (isRelevant) {
-      *aExtraState |= nsIAccessibleStates::EXT_STATE_EDITABLE |
-                      nsIAccessibleStates::EXT_STATE_SELECTABLE_TEXT;
+      state |= states::EDITABLE | states::SELECTABLE_TEXT;
     }
   }
 
   nsCOMPtr<nsIEditor> editor;
   GetAssociatedEditor(getter_AddRefs(editor));
-  NS_ENSURE_TRUE(editor, NS_ERROR_FAILURE);
+  NS_ENSURE_TRUE(editor, state);
   PRUint32 flags;
   editor->GetFlags(&flags);
   if (flags & nsIPlaintextEditor::eEditorSingleLineMask)
-    *aExtraState |= nsIAccessibleStates::EXT_STATE_SINGLE_LINE;
+    state |= states::SINGLE_LINE;
   else
-    *aExtraState |= nsIAccessibleStates::EXT_STATE_MULTI_LINE;
+    state |= states::MULTI_LINE;
 
-  return NS_OK;
+  return state;
 }
 
 NS_IMETHODIMP
 nsXFormsEditableAccessible::GetAssociatedEditor(nsIEditor **aEditor)
 {
   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
   return sXFormsService->GetEditor(DOMNode, aEditor);
 }
@@ -430,17 +413,16 @@ nsXFormsSelectableAccessible::AddItemToS
 
 bool
 nsXFormsSelectableAccessible::RemoveItemFromSelection(PRUint32 aIndex)
 {
   nsCOMPtr<nsIDOMNode> itemDOMNode(do_QueryInterface(GetItemByIndex(&aIndex)));
   if (!itemDOMNode)
     return false;
 
-  nsresult rv;
   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
   if (mIsSelect1Element) {
     nsCOMPtr<nsIDOMNode> selItemDOMNode;
     sXFormsService->GetSelectedItemForSelect1(DOMNode,
                                               getter_AddRefs(selItemDOMNode));
     if (selItemDOMNode == itemDOMNode)
       sXFormsService->SetSelectedItemForSelect1(DOMNode, nsnull);
 
@@ -485,17 +467,16 @@ nsXFormsSelectableAccessible::GetSelecte
 
 bool
 nsXFormsSelectableAccessible::IsItemSelected(PRUint32 aIndex)
 {
   nsCOMPtr<nsIDOMNode> itemDOMNode(do_QueryInterface(GetItemByIndex(&aIndex)));
   if (!itemDOMNode)
     return false;
 
-  nsresult rv;
   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
   if (mIsSelect1Element) {
     nsCOMPtr<nsIDOMNode> selItemDOMNode;
     sXFormsService->GetSelectedItemForSelect1(DOMNode,
                                               getter_AddRefs(selItemDOMNode));
     return selItemDOMNode == itemDOMNode;
   }
 
--- a/accessible/src/xforms/nsXFormsAccessible.h
+++ b/accessible/src/xforms/nsXFormsAccessible.h
@@ -82,17 +82,17 @@ public:
 
   // nsAccessible
 
   // Returns value of child xforms 'label' element.
   virtual nsresult GetNameInternal(nsAString& aName);
 
   // Returns state of xforms element taking into account state of instance node
   // that it is bound to.
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
   // Denies accessible nodes in anonymous content of xforms element by
   // always returning PR_FALSE value.
   virtual PRBool GetAllowsAnonChildAccessibles();
 
 protected:
   // Returns value of first child xforms element by tagname that is bound to
   // instance node.
@@ -144,17 +144,17 @@ class nsXFormsEditableAccessible : publi
 {
 public:
   nsXFormsEditableAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsIAccessibleEditableText
   NS_IMETHOD GetAssociatedEditor(nsIEditor **aEditor);
 
   // nsAccessible
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * The class is base for accessible objects for XForms select and XForms
  * select1 elements.
  */
 class nsXFormsSelectableAccessible : public nsXFormsEditableAccessible
--- a/accessible/src/xforms/nsXFormsFormControlsAccessible.cpp
+++ b/accessible/src/xforms/nsXFormsFormControlsAccessible.cpp
@@ -33,16 +33,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsXFormsFormControlsAccessible.h"
 
+#include "States.h"
 #include "nsTextEquivUtils.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXFormsLabelAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXFormsLabelAccessible::
   nsXFormsLabelAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
@@ -204,32 +205,30 @@ nsXFormsInputBooleanAccessible::
 }
 
 PRUint32
 nsXFormsInputBooleanAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_CHECKBUTTON;
 }
 
-nsresult
-nsXFormsInputBooleanAccessible::GetStateInternal(PRUint32 *aState,
-                                                 PRUint32 *aExtraState)
+PRUint64
+nsXFormsInputBooleanAccessible::NativeState()
 {
-  nsresult rv = nsXFormsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsXFormsAccessible::NativeState();
 
   nsAutoString value;
   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
-  rv = sXFormsService->GetValue(DOMNode, value);
-  NS_ENSURE_SUCCESS(rv, rv);
+  nsresult rv = sXFormsService->GetValue(DOMNode, value);
+  NS_ENSURE_SUCCESS(rv, state);
 
   if (value.EqualsLiteral("true"))
-    *aState |= nsIAccessibleStates::STATE_CHECKED;
+    state |= states::CHECKED;
 
-  return NS_OK;
+  return state;
 }
 
 NS_IMETHODIMP
 nsXFormsInputBooleanAccessible::GetNumActions(PRUint8 *aCount)
 {
   NS_ENSURE_ARG_POINTER(aCount);
 
   *aCount = 1;
@@ -294,25 +293,20 @@ nsXFormsSecretAccessible::
 }
 
 PRUint32
 nsXFormsSecretAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_PASSWORD_TEXT;
 }
 
-nsresult
-nsXFormsSecretAccessible::GetStateInternal(PRUint32 *aState,
-                                           PRUint32 *aExtraState)
+PRUint64
+nsXFormsSecretAccessible::NativeState()
 {
-  nsresult rv = nsXFormsInputAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
-  *aState |= nsIAccessibleStates::STATE_PROTECTED;
-  return NS_OK;
+  return nsXFormsInputAccessible::NativeState() | states::PROTECTED;
 }
 
 NS_IMETHODIMP
 nsXFormsSecretAccessible::GetValue(nsAString& aValue)
 {
   return NS_ERROR_FAILURE;
 }
 
@@ -328,32 +322,30 @@ nsXFormsRangeAccessible::
 }
 
 PRUint32
 nsXFormsRangeAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_SLIDER;
 }
 
-nsresult
-nsXFormsRangeAccessible::GetStateInternal(PRUint32 *aState,
-                                          PRUint32 *aExtraState)
+PRUint64
+nsXFormsRangeAccessible::NativeState()
 {
-  nsresult rv = nsXFormsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsXFormsAccessible::NativeState();
 
   PRUint32 isInRange = nsIXFormsUtilityService::STATE_NOT_A_RANGE;
   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
-  rv = sXFormsService->IsInRange(DOMNode, &isInRange);
-  NS_ENSURE_SUCCESS(rv, rv);
+  nsresult rv = sXFormsService->IsInRange(DOMNode, &isInRange);
+  NS_ENSURE_SUCCESS(rv, state);
 
   if (isInRange == nsIXFormsUtilityService::STATE_OUT_OF_RANGE)
-    *aState |= nsIAccessibleStates::STATE_INVALID;
+    state |= states::INVALID;
 
-  return NS_OK;
+  return state;
 }
 
 NS_IMETHODIMP
 nsXFormsRangeAccessible::GetMaximumValue(double *aMaximumValue)
 {
   NS_ENSURE_ARG_POINTER(aMaximumValue);
 
   nsAutoString value;
@@ -417,33 +409,30 @@ nsXFormsRangeAccessible::GetCurrentValue
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXFormsSelectAccessible::
   nsXFormsSelectAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
   nsXFormsContainerAccessible(aContent, aShell)
 {
 }
 
-nsresult
-nsXFormsSelectAccessible::GetStateInternal(PRUint32 *aState,
-                                           PRUint32 *aExtraState)
+PRUint64
+nsXFormsSelectAccessible::NativeState()
 {
-  nsresult rv = nsXFormsContainerAccessible::GetStateInternal(aState,
-                                                              aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsXFormsContainerAccessible::NativeState();
 
   PRUint32 isInRange = nsIXFormsUtilityService::STATE_NOT_A_RANGE;
   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
-  rv = sXFormsService->IsInRange(DOMNode, &isInRange);
-  NS_ENSURE_SUCCESS(rv, rv);
+  nsresult rv = sXFormsService->IsInRange(DOMNode, &isInRange);
+  NS_ENSURE_SUCCESS(rv, state);
 
   if (isInRange == nsIXFormsUtilityService::STATE_OUT_OF_RANGE)
-    *aState |= nsIAccessibleStates::STATE_INVALID;
+    state |= states::INVALID;
 
-  return NS_OK;
+  return state;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXFormsChoicesAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXFormsChoicesAccessible::
@@ -506,28 +495,25 @@ nsXFormsItemCheckgroupAccessible::
 }
 
 PRUint32
 nsXFormsItemCheckgroupAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_CHECKBUTTON;
 }
 
-nsresult
-nsXFormsItemCheckgroupAccessible::GetStateInternal(PRUint32 *aState,
-                                                   PRUint32 *aExtraState)
+PRUint64
+nsXFormsItemCheckgroupAccessible::NativeState()
 {
-  nsresult rv = nsXFormsSelectableItemAccessible::GetStateInternal(aState,
-                                                                   aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsXFormsSelectableItemAccessible::NativeState();
 
   if (IsItemSelected())
-    *aState |= nsIAccessibleStates::STATE_CHECKED;
+    state |= states::CHECKED;
 
-  return NS_OK;
+  return state;
 }
 
 NS_IMETHODIMP
 nsXFormsItemCheckgroupAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
 {
   if (aIndex != eAction_Click)
     return NS_ERROR_INVALID_ARG;
 
@@ -551,28 +537,25 @@ nsXFormsItemRadiogroupAccessible::
 }
 
 PRUint32
 nsXFormsItemRadiogroupAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_RADIOBUTTON;
 }
 
-nsresult
-nsXFormsItemRadiogroupAccessible::GetStateInternal(PRUint32 *aState,
-                                                   PRUint32 *aExtraState)
+PRUint64
+nsXFormsItemRadiogroupAccessible::NativeState()
 {
-  nsresult rv = nsXFormsSelectableItemAccessible::GetStateInternal(aState,
-                                                                   aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsXFormsSelectableItemAccessible::NativeState();
 
   if (IsItemSelected())
-    *aState |= nsIAccessibleStates::STATE_CHECKED;
+    state |= states::CHECKED;
 
-  return NS_OK;
+  return state;
 }
 
 NS_IMETHODIMP
 nsXFormsItemRadiogroupAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
 {
   if (aIndex != eAction_Click)
     return NS_ERROR_INVALID_ARG;
 
@@ -592,37 +575,32 @@ nsXFormsSelectComboboxAccessible::
 }
 
 PRUint32
 nsXFormsSelectComboboxAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_COMBOBOX;
 }
 
-nsresult
-nsXFormsSelectComboboxAccessible::GetStateInternal(PRUint32 *aState,
-                                                   PRUint32 *aExtraState)
+PRUint64
+nsXFormsSelectComboboxAccessible::NativeState()
 {
-  nsresult rv = nsXFormsSelectableAccessible::GetStateInternal(aState,
-                                                               aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsXFormsSelectableAccessible::NativeState();
 
   PRBool isOpen = PR_FALSE;
   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
-  rv = sXFormsService->IsDropmarkerOpen(DOMNode, &isOpen);
-  NS_ENSURE_SUCCESS(rv, rv);
+  nsresult rv = sXFormsService->IsDropmarkerOpen(DOMNode, &isOpen);
+  NS_ENSURE_SUCCESS(rv, state);
 
   if (isOpen)
-    *aState = nsIAccessibleStates::STATE_EXPANDED;
+    state |= states::EXPANDED;
   else
-    *aState = nsIAccessibleStates::STATE_COLLAPSED;
+    state |= states::COLLAPSED;
 
-  *aState |= nsIAccessibleStates::STATE_HASPOPUP |
-             nsIAccessibleStates::STATE_FOCUSABLE;
-  return NS_OK;
+  return state | states::HASPOPUP | states::FOCUSABLE;
 }
 
 PRBool
 nsXFormsSelectComboboxAccessible::GetAllowsAnonChildAccessibles()
 {
   return PR_TRUE;
 }
 
@@ -638,32 +616,29 @@ nsXFormsItemComboboxAccessible::
 }
 
 PRUint32
 nsXFormsItemComboboxAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_LISTITEM;
 }
 
-nsresult
-nsXFormsItemComboboxAccessible::GetStateInternal(PRUint32 *aState,
-                                                 PRUint32 *aExtraState)
+PRUint64
+nsXFormsItemComboboxAccessible::NativeState()
 {
-  nsresult rv = nsXFormsSelectableItemAccessible::GetStateInternal(aState,
-                                                                   aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsXFormsSelectableItemAccessible::NativeState();
 
-  if (*aState & nsIAccessibleStates::STATE_UNAVAILABLE)
-    return NS_OK;
+  if (state & states::UNAVAILABLE)
+    return state;
 
-  *aState |= nsIAccessibleStates::STATE_SELECTABLE;
+  state |= states::SELECTABLE;
   if (IsItemSelected())
-    *aState |= nsIAccessibleStates::STATE_SELECTED;
+    state |= states::SELECTED;
 
-  return NS_OK;
+  return state;
 }
 
 NS_IMETHODIMP
 nsXFormsItemComboboxAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
 {
   if (aIndex != eAction_Click)
     return NS_ERROR_INVALID_ARG;
 
--- a/accessible/src/xforms/nsXFormsFormControlsAccessible.h
+++ b/accessible/src/xforms/nsXFormsFormControlsAccessible.h
@@ -122,17 +122,17 @@ public:
 
   // nsIAccessible
   NS_IMETHOD GetNumActions(PRUint8 *aCount);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 aIndex);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 /**
  * Accessible object for xforms:input[type="xsd:date"].
  */
 
 class nsXFormsInputDateAccessible : public nsXFormsContainerAccessible
 {
@@ -152,17 +152,17 @@ class nsXFormsSecretAccessible : public 
 public:
   nsXFormsSecretAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsIAccessible
   NS_IMETHOD GetValue(nsAString& aValue);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * Accessible object for xforms:range.
  */
 
 class nsXFormsRangeAccessible : public nsXFormsAccessible
@@ -173,32 +173,32 @@ public:
   // nsIAccessibleValue
   NS_IMETHOD GetMaximumValue(double *aMaximumValue);
   NS_IMETHOD GetMinimumValue(double *aMinimumValue);
   NS_IMETHOD GetMinimumIncrement(double *aMinimumIncrement);
   NS_IMETHOD GetCurrentValue(double *aCurrentValue);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * Accessible object for xforms:select and xforms:select1 that are implemented
  * using host document's native widget.
  */
 
 class nsXFormsSelectAccessible : public nsXFormsContainerAccessible
 {
 public:
   nsXFormsSelectAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsAccessible
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * Accessible object for xforms:choices.
  */
 
 class nsXFormsChoicesAccessible : public nsXFormsAccessible
@@ -249,17 +249,17 @@ public:
   nsXFormsItemCheckgroupAccessible(nsIContent *aContent,
                                    nsIWeakReference *aShell);
 
   // nsIAccessible
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * Accessible object for a xforms:item when it is represented by a radiobutton.
  * This occurs when the item is contained in a xforms:select1 with full
  * appearance. Such a xforms:select1 is represented as a radiogroup.
  */
@@ -270,34 +270,34 @@ public:
   nsXFormsItemRadiogroupAccessible(nsIContent *aContent,
                                    nsIWeakReference *aShell);
 
   // nsIAccessible
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * Accessible object for xforms:select1 of minimal appearance that is
  * represented by combobox.
  */
 
 class nsXFormsSelectComboboxAccessible : public nsXFormsSelectableAccessible
 {
 public:
   nsXFormsSelectComboboxAccessible(nsIContent *aContent,
                                    nsIWeakReference *aShell);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual PRBool GetAllowsAnonChildAccessibles();
 };
 
 
 /**
  * Accessible object for xforms:item element when it is represented by a
  * listitem. This occurs when the item is contained in a xforms:select with
  * minimal appearance. Such a xforms:select is represented by a combobox.
@@ -309,13 +309,13 @@ public:
   nsXFormsItemComboboxAccessible(nsIContent *aContent,
                                  nsIWeakReference *aShell);
 
   // nsIAccessible
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 #endif
 
--- a/accessible/src/xforms/nsXFormsWidgetsAccessible.cpp
+++ b/accessible/src/xforms/nsXFormsWidgetsAccessible.cpp
@@ -33,16 +33,18 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsXFormsWidgetsAccessible.h"
 
+#include "States.h"
+
 ////////////////////////////////////////////////////////////////////////////////
 // nsXFormsDropmarkerWidgetAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXFormsDropmarkerWidgetAccessible::
   nsXFormsDropmarkerWidgetAccessible(nsIContent *aContent,
                                      nsIWeakReference *aShell) :
   nsLeafAccessible(aContent, aShell)
@@ -50,42 +52,29 @@ nsXFormsDropmarkerWidgetAccessible::
 }
 
 PRUint32
 nsXFormsDropmarkerWidgetAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_PUSHBUTTON;
 }
 
-nsresult
-nsXFormsDropmarkerWidgetAccessible::GetStateInternal(PRUint32 *aState,
-                                                     PRUint32 *aExtraState)
+PRUint64
+nsXFormsDropmarkerWidgetAccessible::NativeState()
 {
-  NS_ENSURE_ARG_POINTER(aState);
-  *aState = 0;
 
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_DEFUNCT;
-
-    return NS_OK_DEFUNCT_OBJECT;
-  }
-
-  if (aExtraState)
-    *aExtraState = 0;
+  if (IsDefunct())
+    return states::DEFUNCT;
 
   PRBool isOpen = PR_FALSE;
   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
   nsresult rv = sXFormsService->IsDropmarkerOpen(DOMNode, &isOpen);
-  NS_ENSURE_SUCCESS(rv, rv);
+  NS_ENSURE_SUCCESS(rv, 0);
 
-  if (isOpen)
-    *aState = nsIAccessibleStates::STATE_PRESSED;
-
-  return NS_OK;
+  return isOpen ? states::PRESSED: 0;
 }
 
 NS_IMETHODIMP
 nsXFormsDropmarkerWidgetAccessible::GetNumActions(PRUint8 *aCount)
 {
   NS_ENSURE_ARG_POINTER(aCount);
 
   *aCount = 1;
@@ -152,38 +141,34 @@ nsXFormsComboboxPopupWidgetAccessible::
 }
 
 PRUint32
 nsXFormsComboboxPopupWidgetAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_LIST;
 }
 
-nsresult
-nsXFormsComboboxPopupWidgetAccessible::GetStateInternal(PRUint32 *aState,
-                                                        PRUint32 *aExtraState)
+PRUint64
+nsXFormsComboboxPopupWidgetAccessible::NativeState()
 {
-  NS_ENSURE_ARG_POINTER(aState);
-
-  nsresult rv = nsXFormsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsXFormsAccessible::NativeState();
 
   PRBool isOpen = PR_FALSE;
   nsCOMPtr<nsIDOMNode> DOMNode(do_QueryInterface(mContent));
-  rv = sXFormsService->IsDropmarkerOpen(DOMNode, &isOpen);
-  NS_ENSURE_SUCCESS(rv, rv);
+  nsresult rv = sXFormsService->IsDropmarkerOpen(DOMNode, &isOpen);
+  NS_ENSURE_SUCCESS(rv, state);
 
-  *aState |= nsIAccessibleStates::STATE_FOCUSABLE;
+  state |= states::FOCUSABLE;
 
   if (isOpen)
-    *aState = nsIAccessibleStates::STATE_FLOATING;
+    state = states::FLOATING;
   else
-    *aState = nsIAccessibleStates::STATE_INVISIBLE;
+    state = states::INVISIBLE;
 
-  return NS_OK;
+  return state;
 }
 
 NS_IMETHODIMP
 nsXFormsComboboxPopupWidgetAccessible::GetValue(nsAString& aValue)
 {
   aValue.Truncate();
   return NS_OK;
 }
--- a/accessible/src/xforms/nsXFormsWidgetsAccessible.h
+++ b/accessible/src/xforms/nsXFormsWidgetsAccessible.h
@@ -56,17 +56,17 @@ public:
 
   // nsIAccessible
   NS_IMETHOD GetNumActions(PRUint8 *aCount);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 aIndex);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * Accessible object for calendar widget. It is used by xforms:input[xsd:date].
  */
 class nsXFormsCalendarWidgetAccessible : public nsAccessibleWrap
 {
@@ -91,16 +91,16 @@ public:
 
   // nsIAccessible
   NS_IMETHOD GetValue(nsAString& aValue);
   NS_IMETHOD GetDescription(nsAString& aDescription);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
 protected:
   // nsAccessible
   virtual void CacheChildren();
 };
 
 #endif
--- a/accessible/src/xpcom/nsAccEvent.cpp
+++ b/accessible/src/xpcom/nsAccEvent.cpp
@@ -32,16 +32,17 @@
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsAccEvent.h"
+#include "nsAccUtils.h"
 #include "nsDocAccessible.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsAccEvent
 ////////////////////////////////////////////////////////////////////////////////
 
 NS_IMPL_ISUPPORTS1(nsAccEvent, nsIAccessibleEvent)
 
@@ -98,25 +99,35 @@ nsAccEvent::GetAccessibleDocument(nsIAcc
 
 NS_IMPL_ISUPPORTS_INHERITED1(nsAccStateChangeEvent, nsAccEvent,
                              nsIAccessibleStateChangeEvent)
 
 NS_IMETHODIMP
 nsAccStateChangeEvent::GetState(PRUint32* aState)
 {
   NS_ENSURE_ARG_POINTER(aState);
-  *aState = static_cast<AccStateChangeEvent*>(mEvent.get())->GetState();
+
+  PRUint32 state1 = 0, state2 = 0;
+  PRUint64 state = static_cast<AccStateChangeEvent*>(mEvent.get())->GetState();
+  nsAccUtils::To32States(state, &state1, &state2);
+
+  *aState = state1 | state2; // only one state is not 0
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAccStateChangeEvent::IsExtraState(PRBool* aIsExtraState)
 {
   NS_ENSURE_ARG_POINTER(aIsExtraState);
-  *aIsExtraState = static_cast<AccStateChangeEvent*>(mEvent.get())->IsExtraState();
+
+  PRUint32 state1 = 0, state2 = 0;
+  PRUint64 state = static_cast<AccStateChangeEvent*>(mEvent.get())->GetState();
+  nsAccUtils::To32States(state, &state1, &state2);
+
+  *aIsExtraState = (state2 != 0);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAccStateChangeEvent::IsEnabled(PRBool* aIsEnabled)
 {
   NS_ENSURE_ARG_POINTER(aIsEnabled);
   *aIsEnabled = static_cast<AccStateChangeEvent*>(mEvent.get())->IsStateEnabled();
--- a/accessible/src/xul/nsXULAlertAccessible.cpp
+++ b/accessible/src/xul/nsXULAlertAccessible.cpp
@@ -32,16 +32,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsXULAlertAccessible.h"
 
+#include "States.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULAlertAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXULAlertAccessible::
   nsXULAlertAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
   nsAccessibleWrap(aContent, aShell)
@@ -51,25 +52,20 @@ nsXULAlertAccessible::
 NS_IMPL_ISUPPORTS_INHERITED0(nsXULAlertAccessible, nsAccessible)
 
 PRUint32
 nsXULAlertAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_ALERT;
 }
 
-nsresult
-nsXULAlertAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsXULAlertAccessible::NativeState()
 {
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
-  // XUL has no markup for low, medium or high
-  *aState |= nsIAccessibleStates::STATE_ALERT_MEDIUM;
-  return NS_OK;
+  return nsAccessible::NativeState() | states::ALERT;
 }
 
 NS_IMETHODIMP
 nsXULAlertAccessible::GetName(nsAString& aName)
 {
   // Screen readers need to read contents of alert, not the accessible name.
   // If we have both some screen readers will read the alert twice.
   aName.Truncate();
--- a/accessible/src/xul/nsXULAlertAccessible.h
+++ b/accessible/src/xul/nsXULAlertAccessible.h
@@ -51,12 +51,12 @@ public:
 
   NS_DECL_ISUPPORTS_INHERITED
 
   // nsIAccessible
   NS_IMETHOD GetName(nsAString& aName);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 #endif  
--- a/accessible/src/xul/nsXULColorPickerAccessible.cpp
+++ b/accessible/src/xul/nsXULColorPickerAccessible.cpp
@@ -33,16 +33,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsXULColorPickerAccessible.h"
 
+#include "States.h"
 #include "nsAccUtils.h"
 #include "nsAccTreeWalker.h"
 #include "nsCoreUtils.h"
 #include "nsDocAccessible.h"
 
 #include "nsIDOMElement.h"
 
 
@@ -75,40 +76,38 @@ nsXULColorPickerTileAccessible::GetValue
 // nsXULColorPickerTileAccessible: nsAccessible
 
 PRUint32
 nsXULColorPickerTileAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_PUSHBUTTON;
 }
 
-nsresult
-nsXULColorPickerTileAccessible::GetStateInternal(PRUint32 *aState,
-                                                 PRUint32 *aExtraState)
+PRUint64
+nsXULColorPickerTileAccessible::NativeState()
 {
   // Possible states: focused, focusable, selected.
 
   // get focus and disable status from base class
-  nsresult rv = nsAccessibleWrap::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 states = nsAccessibleWrap::NativeState();
 
-  *aState |= nsIAccessibleStates::STATE_FOCUSABLE;
+  states |= states::FOCUSABLE;
 
   // Focused?
   PRBool isFocused = mContent->HasAttr(kNameSpaceID_None,
                                        nsAccessibilityAtoms::hover);
   if (isFocused)
-    *aState |= nsIAccessibleStates::STATE_FOCUSED;
+    states |= states::FOCUSED;
 
   PRBool isSelected = mContent->HasAttr(kNameSpaceID_None,
                                         nsAccessibilityAtoms::selected);
   if (isSelected)
-    *aState |= nsIAccessibleStates::STATE_SELECTED;
+    states |= states::SELECTED;
 
-  return NS_OK;
+  return states;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULColorPickerAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXULColorPickerAccessible::
@@ -128,30 +127,27 @@ nsXULColorPickerAccessible::Init()
 
   nsCoreUtils::GeneratePopupTree(mContent, PR_TRUE);
   return PR_TRUE;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULColorPickerAccessible: nsAccessible
 
-nsresult
-nsXULColorPickerAccessible::GetStateInternal(PRUint32 *aState,
-                                             PRUint32 *aExtraState)
+PRUint64
+nsXULColorPickerAccessible::NativeState()
 {
   // Possible states: focused, focusable, unavailable(disabled).
 
   // get focus and disable status from base class
-  nsresult rv = nsAccessibleWrap::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 states = nsAccessibleWrap::NativeState();
 
-  *aState |= nsIAccessibleStates::STATE_FOCUSABLE |
-             nsIAccessibleStates::STATE_HASPOPUP;
+  states |= states::FOCUSABLE | states::HASPOPUP;
 
-  return NS_OK;
+  return states;
 }
 
 PRUint32
 nsXULColorPickerAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_BUTTONDROPDOWNGRID;
 }
 
--- a/accessible/src/xul/nsXULColorPickerAccessible.h
+++ b/accessible/src/xul/nsXULColorPickerAccessible.h
@@ -51,34 +51,34 @@ public:
   nsXULColorPickerTileAccessible(nsIContent *aContent,
                                  nsIWeakReference *aShell);
 
   // nsIAccessible
   NS_IMETHOD GetValue(nsAString& _retval);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * Used for colorpicker button (xul:colorpicker@type="button").
  */
 class nsXULColorPickerAccessible : public nsXULColorPickerTileAccessible
 {
 public:
   nsXULColorPickerAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsAccessNode
   virtual PRBool Init();
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
 protected:
 
   // nsAccessible
   virtual void CacheChildren();
 };
 
 #endif  
--- a/accessible/src/xul/nsXULComboboxAccessible.cpp
+++ b/accessible/src/xul/nsXULComboboxAccessible.cpp
@@ -35,16 +35,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsXULComboboxAccessible.h"
 
+#include "States.h"
 #include "nsAccessibilityService.h"
 #include "nsCoreUtils.h"
 
 #include "nsIDOMXULMenuListElement.h"
 #include "nsIDOMXULSelectCntrlItemEl.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULComboboxAccessible
@@ -70,47 +71,44 @@ PRUint32
 nsXULComboboxAccessible::NativeRole()
 {
   if (mContent->AttrValueIs(kNameSpaceID_None, nsAccessibilityAtoms::type,
                             nsAccessibilityAtoms::autocomplete, eIgnoreCase))
     return nsIAccessibleRole::ROLE_AUTOCOMPLETE;
   return nsIAccessibleRole::ROLE_COMBOBOX;
 }
 
-nsresult
-nsXULComboboxAccessible::GetStateInternal(PRUint32 *aState,
-                                          PRUint32 *aExtraState)
+PRUint64
+nsXULComboboxAccessible::NativeState()
 {
   // As a nsComboboxAccessible we can have the following states:
   //     STATE_FOCUSED
   //     STATE_FOCUSABLE
   //     STATE_HASPOPUP
   //     STATE_EXPANDED
   //     STATE_COLLAPSED
 
   // Get focus status from base class
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 states = nsAccessible::NativeState();
 
   nsCOMPtr<nsIDOMXULMenuListElement> menuList(do_QueryInterface(mContent));
   if (menuList) {
     PRBool isOpen;
     menuList->GetOpen(&isOpen);
     if (isOpen) {
-      *aState |= nsIAccessibleStates::STATE_EXPANDED;
+      states |= states::EXPANDED;
     }
     else {
-      *aState |= nsIAccessibleStates::STATE_COLLAPSED;
+      states |= states::COLLAPSED;
     }
   }
 
-  *aState |= nsIAccessibleStates::STATE_HASPOPUP |
-             nsIAccessibleStates::STATE_FOCUSABLE;
+  states |= states::HASPOPUP | states::FOCUSABLE;
 
-  return NS_OK;
+  return states;
 }
 
 NS_IMETHODIMP
 nsXULComboboxAccessible::GetValue(nsAString& aValue)
 {
   aValue.Truncate();
 
   if (IsDefunct())
--- a/accessible/src/xul/nsXULComboboxAccessible.h
+++ b/accessible/src/xul/nsXULComboboxAccessible.h
@@ -60,13 +60,13 @@ public:
   NS_IMETHOD GetNumActions(PRUint8 *aNumActions);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
 
   // nsAccessNode
   virtual PRBool Init();
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual PRBool GetAllowsAnonChildAccessibles();
 };
 
 #endif
--- a/accessible/src/xul/nsXULFormControlAccessible.cpp
+++ b/accessible/src/xul/nsXULFormControlAccessible.cpp
@@ -40,16 +40,17 @@
 #include "nsXULFormControlAccessible.h"
 
 #include "nsAccessibilityAtoms.h"
 #include "nsAccUtils.h"
 #include "nsAccTreeWalker.h"
 #include "nsCoreUtils.h"
 #include "nsDocAccessible.h"
 #include "nsRelUtils.h"
+#include "States.h"
 
 // NOTE: alphabetically ordered
 #include "nsHTMLFormControlAccessible.h"
 #include "nsXULMenuAccessible.h"
 #include "nsIDOMHTMLInputElement.h"
 #include "nsIDOMNSEditableElement.h"
 #include "nsIDOMXULButtonElement.h"
 #include "nsIDOMXULCheckboxElement.h"
@@ -127,62 +128,61 @@ nsXULButtonAccessible::Init()
 // nsXULButtonAccessible: nsAccessible
 
 PRUint32
 nsXULButtonAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_PUSHBUTTON;
 }
 
-nsresult
-nsXULButtonAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsXULButtonAccessible::NativeState()
 {
   // Possible states: focused, focusable, unavailable(disabled).
 
   // get focus and disable status from base class
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsAccessible::NativeState();
 
   PRBool disabled = PR_FALSE;
   nsCOMPtr<nsIDOMXULControlElement> xulFormElement(do_QueryInterface(mContent));
   if (xulFormElement) {
     xulFormElement->GetDisabled(&disabled);
     if (disabled)
-      *aState |= nsIAccessibleStates::STATE_UNAVAILABLE;
+      state |= states::UNAVAILABLE;
     else 
-      *aState |= nsIAccessibleStates::STATE_FOCUSABLE;
+      state |= states::FOCUSABLE;
   }
 
   // Buttons can be checked -- they simply appear pressed in rather than checked
   nsCOMPtr<nsIDOMXULButtonElement> xulButtonElement(do_QueryInterface(mContent));
   if (xulButtonElement) {
     nsAutoString type;
     xulButtonElement->GetType(type);
     if (type.EqualsLiteral("checkbox") || type.EqualsLiteral("radio")) {
-      *aState |= nsIAccessibleStates::STATE_CHECKABLE;
+      state |= states::CHECKABLE;
       PRBool checked = PR_FALSE;
       PRInt32 checkState = 0;
       xulButtonElement->GetChecked(&checked);
       if (checked) {
-        *aState |= nsIAccessibleStates::STATE_PRESSED;
+        state |= states::PRESSED;
         xulButtonElement->GetCheckState(&checkState);
         if (checkState == nsIDOMXULButtonElement::CHECKSTATE_MIXED) { 
-          *aState |= nsIAccessibleStates::STATE_MIXED;
+          state |= states::MIXED;
         }
       }
     }
   }
 
   if (ContainsMenu())
-    *aState |= nsIAccessibleStates::STATE_HASPOPUP;
+    state |= states::HASPOPUP;
 
   if (mContent->HasAttr(kNameSpaceID_None, nsAccessibilityAtoms::_default))
-    *aState |= nsIAccessibleStates::STATE_DEFAULT;
+    state |= states::DEFAULT;
 
-  return NS_OK;
+  return state;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULButtonAccessible: nsAccessible protected
 
 void
 nsXULButtonAccessible::CacheChildren()
 {
@@ -322,36 +322,24 @@ NS_IMETHODIMP nsXULDropmarkerAccessible:
 }
 
 PRUint32
 nsXULDropmarkerAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_PUSHBUTTON;
 }
 
-nsresult
-nsXULDropmarkerAccessible::GetStateInternal(PRUint32 *aState,
-                                            PRUint32 *aExtraState)
+PRUint64
+nsXULDropmarkerAccessible::NativeState()
 {
-  *aState = 0;
-
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_DEFUNCT;
 
-    return NS_OK_DEFUNCT_OBJECT;
-  }
+  if (IsDefunct())
+    return states::DEFUNCT;
 
-  if (aExtraState)
-    *aExtraState = 0;
-
-  if (DropmarkerOpen(PR_FALSE))
-    *aState = nsIAccessibleStates::STATE_PRESSED;
-
-  return NS_OK;
+  return DropmarkerOpen(PR_FALSE) ? states::PRESSED : 0;
 }
 
                       
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULCheckboxAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXULCheckboxAccessible::
@@ -374,21 +362,18 @@ NS_IMETHODIMP nsXULCheckboxAccessible::G
 
 /**
   * Return the name of our only action
   */
 NS_IMETHODIMP nsXULCheckboxAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
 {
   if (aIndex == eAction_Click) {
     // check or uncheck
-    PRUint32 state;
-    nsresult rv = GetStateInternal(&state, nsnull);
-    NS_ENSURE_SUCCESS(rv, rv);
 
-    if (state & nsIAccessibleStates::STATE_CHECKED)
+    if (NativeState() & states::CHECKED)
       aName.AssignLiteral("uncheck");
     else
       aName.AssignLiteral("check");
 
     return NS_OK;
   }
   return NS_ERROR_INVALID_ARG;
 }
@@ -401,45 +386,41 @@ nsXULCheckboxAccessible::DoAction(PRUint
 {
   if (aIndex != eAction_Click)
     return NS_ERROR_INVALID_ARG;
 
   DoCommand();
   return NS_OK;
 }
 
-/**
-  * Possible states: focused, focusable, unavailable(disabled), checked
-  */
-nsresult
-nsXULCheckboxAccessible::GetStateInternal(PRUint32 *aState,
-                                          PRUint32 *aExtraState)
+PRUint64
+nsXULCheckboxAccessible::NativeState()
 {
+  // Possible states: focused, focusable, unavailable(disabled), checked
   // Get focus and disable status from base class
-  nsresult rv = nsFormControlAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsFormControlAccessible::NativeState();
   
-  *aState |= nsIAccessibleStates::STATE_CHECKABLE;
+  state |= states::CHECKABLE;
   
   // Determine Checked state
   nsCOMPtr<nsIDOMXULCheckboxElement> xulCheckboxElement =
     do_QueryInterface(mContent);
   if (xulCheckboxElement) {
     PRBool checked = PR_FALSE;
     xulCheckboxElement->GetChecked(&checked);
     if (checked) {
-      *aState |= nsIAccessibleStates::STATE_CHECKED;
+      state |= states::CHECKED;
       PRInt32 checkState = 0;
       xulCheckboxElement->GetCheckState(&checkState);
       if (checkState == nsIDOMXULCheckboxElement::CHECKSTATE_MIXED)
-        *aState |= nsIAccessibleStates::STATE_MIXED;
+        state |= states::MIXED;
     }
   }
 
-  return NS_OK;
+  return state;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULGroupboxAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXULGroupboxAccessible::
   nsXULGroupboxAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
@@ -640,37 +621,35 @@ nsXULProgressMeterAccessible::SetCurrent
 
 nsXULRadioButtonAccessible::
   nsXULRadioButtonAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
   nsRadioButtonAccessible(aContent, aShell)
 {
 }
 
 /** We are Focusable and can be Checked and focused */
-nsresult
-nsXULRadioButtonAccessible::GetStateInternal(PRUint32 *aState,
-                                             PRUint32 *aExtraState)
+PRUint64
+nsXULRadioButtonAccessible::NativeState()
 {
-  nsresult rv = nsFormControlAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsFormControlAccessible::NativeState();
 
-  *aState |= nsIAccessibleStates::STATE_CHECKABLE;
+  state |= states::CHECKABLE;
   
   PRBool selected = PR_FALSE;   // Radio buttons can be selected
 
   nsCOMPtr<nsIDOMXULSelectControlItemElement> radioButton =
     do_QueryInterface(mContent);
   if (radioButton) {
     radioButton->GetSelected(&selected);
     if (selected) {
-      *aState |= nsIAccessibleStates::STATE_CHECKED;
+      state |= states::CHECKED;
     }
   }
 
-  return NS_OK;
+  return state;
 }
 
 void
 nsXULRadioButtonAccessible::GetPositionAndSizeInternal(PRInt32 *aPosInSet,
                                                        PRInt32 *aSetSize)
 {
   nsAccUtils::GetPositionAndSizeForXULSelectControlItem(mContent, aPosInSet,
                                                         aSetSize);
@@ -697,30 +676,23 @@ nsXULRadioGroupAccessible::
 }
 
 PRUint32
 nsXULRadioGroupAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_GROUPING;
 }
 
-nsresult
-nsXULRadioGroupAccessible::GetStateInternal(PRUint32 *aState,
-                                            PRUint32 *aExtraState)
+PRUint64
+nsXULRadioGroupAccessible::NativeState()
 {
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
   // The radio group is not focusable. Sometimes the focus controller will
   // report that it is focused. That means that the actual selected radio button
   // should be considered focused.
-  *aState &= ~(nsIAccessibleStates::STATE_FOCUSABLE |
-               nsIAccessibleStates::STATE_FOCUSED);
-
-  return NS_OK;
+  return nsAccessible::NativeState() & ~(states::FOCUSABLE | states::FOCUSED);
 }
 
                       
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULStatusBarAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXULStatusBarAccessible::
@@ -835,33 +807,20 @@ nsXULToolbarSeparatorAccessible::
 }
 
 PRUint32
 nsXULToolbarSeparatorAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_SEPARATOR;
 }
 
-nsresult
-nsXULToolbarSeparatorAccessible::GetStateInternal(PRUint32 *aState,
-                                                  PRUint32 *aExtraState)
+PRUint64
+nsXULToolbarSeparatorAccessible::NativeState()
 {
-  *aState = 0;  // no special state flags for toolbar separator
-
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_DEFUNCT;
-
-    return NS_OK_DEFUNCT_OBJECT;
-  }
-
-  if (aExtraState)
-    *aExtraState = 0;
-
-  return NS_OK;
+  return IsDefunct() ? states::DEFUNCT : 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULTextFieldAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXULTextFieldAccessible::
  nsXULTextFieldAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
@@ -871,81 +830,72 @@ nsXULTextFieldAccessible::
 
 NS_IMPL_ISUPPORTS_INHERITED3(nsXULTextFieldAccessible, nsAccessible, nsHyperTextAccessible, nsIAccessibleText, nsIAccessibleEditableText)
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULTextFieldAccessible: nsIAccessible
 
 NS_IMETHODIMP nsXULTextFieldAccessible::GetValue(nsAString& aValue)
 {
-  PRUint32 state;
-  nsresult rv = GetStateInternal(&state, nsnull);
-  NS_ENSURE_SUCCESS(rv, rv);
+  PRUint64 state = NativeState();
 
-  if (state & nsIAccessibleStates::STATE_PROTECTED)    // Don't return password text!
+  if (state & states::PROTECTED)    // Don't return password text!
     return NS_ERROR_FAILURE;
 
   nsCOMPtr<nsIDOMXULTextBoxElement> textBox(do_QueryInterface(mContent));
   if (textBox) {
     return textBox->GetValue(aValue);
   }
   nsCOMPtr<nsIDOMXULMenuListElement> menuList(do_QueryInterface(mContent));
   if (menuList) {
     return menuList->GetLabel(aValue);
   }
   return NS_ERROR_FAILURE;
 }
 
-nsresult
-nsXULTextFieldAccessible::GetARIAState(PRUint32 *aState, PRUint32 *aExtraState)
+void
+nsXULTextFieldAccessible::ApplyARIAState(PRUint64* aState)
 {
-  nsresult rv = nsHyperTextAccessibleWrap::GetARIAState(aState, aExtraState);
-  NS_ENSURE_SUCCESS(rv, rv);
+  nsHyperTextAccessibleWrap::ApplyARIAState(aState);
 
-  nsStateMapEntry::MapToStates(mContent, aState, aExtraState, eARIAAutoComplete);
+  nsStateMapEntry::MapToStates(mContent, aState, eARIAAutoComplete);
 
-  return NS_OK;
 }
 
-nsresult
-nsXULTextFieldAccessible::GetStateInternal(PRUint32 *aState,
-                                           PRUint32 *aExtraState)
+PRUint64
+nsXULTextFieldAccessible::NativeState()
 {
-  nsresult rv = nsHyperTextAccessibleWrap::GetStateInternal(aState,
-                                                            aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsHyperTextAccessibleWrap::NativeState();
 
   nsCOMPtr<nsIContent> inputField(GetInputField());
-  NS_ENSURE_TRUE(inputField, NS_ERROR_FAILURE);
+  NS_ENSURE_TRUE(inputField, state);
 
-  // Create a temporary accessible from the HTML text field
-  // to get the accessible state from. Doesn't add to cache
-  // because Init() is not called.
+  // Create a temporary accessible from the HTML text field to get
+  // the accessible state from. Doesn't add to cache into document cache.
   nsRefPtr<nsHTMLTextFieldAccessible> tempAccessible =
     new nsHTMLTextFieldAccessible(inputField, mWeakShell);
   if (!tempAccessible)
-    return NS_ERROR_OUT_OF_MEMORY;
+    return state;
 
-  rv = tempAccessible->GetStateInternal(aState, aExtraState);
-  NS_ENSURE_SUCCESS(rv, rv);
+  state |= tempAccessible->NativeState();
 
   if (gLastFocusedNode == mContent)
-    *aState |= nsIAccessibleStates::STATE_FOCUSED;
+    state |= states::FOCUSED;
 
   nsCOMPtr<nsIDOMXULMenuListElement> menuList(do_QueryInterface(mContent));
   if (menuList) {
     // <xul:menulist droppable="false">
     if (!mContent->AttrValueIs(kNameSpaceID_None,
                                nsAccessibilityAtoms::editable,
                                nsAccessibilityAtoms::_true, eIgnoreCase)) {
-      *aState |= nsIAccessibleStates::STATE_READONLY;
+      state |= states::READONLY;
     }
   }
 
-  return NS_OK;
+  return state;
 }
 
 PRUint32
 nsXULTextFieldAccessible::NativeRole()
 {
   if (mContent->AttrValueIs(kNameSpaceID_None, nsAccessibilityAtoms::type,
                             nsAccessibilityAtoms::password, eIgnoreCase))
     return nsIAccessibleRole::ROLE_PASSWORD_TEXT;
--- a/accessible/src/xul/nsXULFormControlAccessible.h
+++ b/accessible/src/xul/nsXULFormControlAccessible.h
@@ -66,17 +66,17 @@ public:
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 index);
 
   // nsAccessNode
   virtual PRBool Init();
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
 protected:
 
   // nsAccessible
   virtual void CacheChildren();
 
   // nsXULButtonAccessible
   PRBool ContainsMenu();
@@ -94,17 +94,17 @@ public:
 
   // nsIAccessible
   NS_IMETHOD GetNumActions(PRUint8 *_retval);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 index);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 /**
  * Used for XUL dropmarker element.
  */
 class nsXULDropmarkerAccessible : public nsFormControlAccessible
 {
 public:
@@ -113,17 +113,17 @@ public:
 
   // nsIAccessible
   NS_IMETHOD GetNumActions(PRUint8 *_retval);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 index);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
 private:
   PRBool DropmarkerOpen(PRBool aToggleOpen);
 };
 
 /**
  * Used for XUL groupbox element.
  */
@@ -162,32 +162,32 @@ public:
  */
 class nsXULRadioButtonAccessible : public nsRadioButtonAccessible
 {
 
 public:
   nsXULRadioButtonAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsAccessible
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
   virtual void GetPositionAndSizeInternal(PRInt32 *aPosInSet,
                                           PRInt32 *aSetSize);
+  virtual PRUint64 NativeState();
 };
 
 /**
  * Used for XUL radiogroup element.
  */
 class nsXULRadioGroupAccessible : public nsXULSelectableAccessible
 {
 public:
   nsXULRadioGroupAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 /**
  * Used for XUL statusbar element.
  */
 class nsXULStatusBarAccessible : public nsAccessibleWrap
 {
 public:
@@ -232,17 +232,17 @@ public:
 class nsXULToolbarSeparatorAccessible : public nsLeafAccessible
 {
 public:
   nsXULToolbarSeparatorAccessible(nsIContent* aContent,
                                   nsIWeakReference *aShell);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 /**
  * Used for XUL textbox element.
  */
 class nsXULTextFieldAccessible : public nsHyperTextAccessibleWrap
 {
 public:
@@ -257,19 +257,19 @@ public:
   NS_IMETHOD GetNumActions(PRUint8 *_retval);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 index);
 
   // nsIAccessibleEditableText
   NS_IMETHOD GetAssociatedEditor(nsIEditor **aEditor);
 
   // nsAccessible
-  virtual nsresult GetARIAState(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual void ApplyARIAState(PRUint64* aState);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual PRBool GetAllowsAnonChildAccessibles();
 
 protected:
   // nsAccessible
   virtual void CacheChildren();
 
   // nsXULTextFieldAccessible
   already_AddRefed<nsIContent> GetInputField() const;
--- a/accessible/src/xul/nsXULListboxAccessible.cpp
+++ b/accessible/src/xul/nsXULListboxAccessible.cpp
@@ -35,16 +35,17 @@
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsXULListboxAccessible.h"
 
+#include "States.h"
 #include "nsAccessibilityService.h"
 #include "nsAccUtils.h"
 
 #include "nsIDOMXULPopupElement.h"
 #include "nsIDOMXULMultSelectCntrlEl.h"
 #include "nsIDOMXULSelectCntrlItemEl.h"
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -58,36 +59,20 @@ nsXULColumnsAccessible::
 }
 
 PRUint32
 nsXULColumnsAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_LIST;
 }
 
-nsresult
-nsXULColumnsAccessible::GetStateInternal(PRUint32 *aState,
-                                         PRUint32 *aExtraState)
+PRUint64
+nsXULColumnsAccessible::NativeState()
 {
-  NS_ENSURE_ARG_POINTER(aState);
-  *aState = 0;
-
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_DEFUNCT;
-
-    return NS_OK_DEFUNCT_OBJECT;
-  }
-
-  *aState = nsIAccessibleStates::STATE_READONLY;
-
-  if (aExtraState)
-    *aExtraState = 0;
-
-  return NS_OK;
+  return IsDefunct() ? states::DEFUNCT : states::READONLY;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULColumnItemAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXULColumnItemAccessible::
@@ -97,34 +82,20 @@ nsXULColumnItemAccessible::
 }
 
 PRUint32
 nsXULColumnItemAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_COLUMNHEADER;
 }
 
-nsresult
-nsXULColumnItemAccessible::GetStateInternal(PRUint32 *aState,
-                                            PRUint32 *aExtraState)
+PRUint64
+nsXULColumnItemAccessible::NativeState()
 {
-  NS_ENSURE_ARG_POINTER(aState);
-
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_DEFUNCT;
-
-    return NS_OK_DEFUNCT_OBJECT;
-  }
-
-  *aState = nsIAccessibleStates::STATE_READONLY;
-  if (aExtraState)
-    *aExtraState = 0;
-
-  return NS_OK;
+  return IsDefunct() ? states::DEFUNCT : states::READONLY;
 }
 
 NS_IMETHODIMP
 nsXULColumnItemAccessible::GetNumActions(PRUint8 *aNumActions)
 {
   NS_ENSURE_ARG_POINTER(aNumActions);
 
   *aNumActions = 1;
@@ -189,38 +160,33 @@ nsXULListboxAccessible::IsMulticolumn()
     return PR_FALSE;
 
   return numColumns > 1;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULListboxAccessible. nsIAccessible
 
-nsresult
-nsXULListboxAccessible::GetStateInternal(PRUint32 *aState,
-                                         PRUint32 *aExtraState)
+PRUint64
+nsXULListboxAccessible::NativeState()
 {
   // As a nsXULListboxAccessible we can have the following states:
-  //   STATE_FOCUSED
-  //   STATE_READONLY
-  //   STATE_FOCUSABLE
+  //   FOCUSED, READONLY, FOCUSABLE
 
   // Get focus status from base class
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 states = nsAccessible::NativeState();
 
   // see if we are multiple select if so set ourselves as such
 
   if (mContent->AttrValueIs(kNameSpaceID_None, nsAccessibilityAtoms::seltype,
                             nsAccessibilityAtoms::multiple, eCaseMatters)) {
-      *aState |= nsIAccessibleStates::STATE_MULTISELECTABLE |
-                 nsIAccessibleStates::STATE_EXTSELECTABLE;
+      states |= states::MULTISELECTABLE | states::EXTSELECTABLE;
   }
 
-  return NS_OK;
+  return states;
 }
 
 /**
   * Our value is the label of our ( first ) selected child.
   */
 NS_IMETHODIMP nsXULListboxAccessible::GetValue(nsAString& _retval)
 {
   _retval.Truncate();
@@ -932,65 +898,52 @@ nsXULListitemAccessible::NativeRole()
     return nsIAccessibleRole::ROLE_CHECKBUTTON;
 
   if (mParent && mParent->Role() == nsIAccessibleRole::ROLE_COMBOBOX_LIST)
     return nsIAccessibleRole::ROLE_COMBOBOX_OPTION;
 
   return nsIAccessibleRole::ROLE_RICH_OPTION;
 }
 
-nsresult
-nsXULListitemAccessible::GetStateInternal(PRUint32 *aState,
-                                          PRUint32 *aExtraState)
+PRUint64
+nsXULListitemAccessible::NativeState()
 {
   if (mIsCheckbox) {
-    return nsXULMenuitemAccessible::GetStateInternal(aState, aExtraState);
+    return nsXULMenuitemAccessible::NativeState();
   }
 
-  *aState = 0;
-
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_DEFUNCT;
+  if (IsDefunct())
+    return states::DEFUNCT;
 
-    return NS_OK_DEFUNCT_OBJECT;
-  }
-
-  if (aExtraState)
-    *aExtraState = 0;
-
-  *aState = nsIAccessibleStates::STATE_FOCUSABLE |
-            nsIAccessibleStates::STATE_SELECTABLE;
+  PRUint64 states = states::FOCUSABLE | states::SELECTABLE;
 
   nsCOMPtr<nsIDOMXULSelectControlItemElement> listItem =
     do_QueryInterface(mContent);
 
   if (listItem) {
     PRBool isSelected;
     listItem->GetSelected(&isSelected);
     if (isSelected)
-      *aState |= nsIAccessibleStates::STATE_SELECTED;
+      states |= states::SELECTED;
 
     if (gLastFocusedNode == mContent)
-      *aState |= nsIAccessibleStates::STATE_FOCUSED;
+      states |= states::FOCUSED;
 
   }
 
-  return NS_OK;
+  return states;
 }
 
 NS_IMETHODIMP nsXULListitemAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
 {
   if (aIndex == eAction_Click && mIsCheckbox) {
     // check or uncheck
-    PRUint32 state;
-    nsresult rv = GetStateInternal(&state, nsnull);
-    NS_ENSURE_SUCCESS(rv, rv);
+    PRUint64 states = NativeState();
 
-    if (state & nsIAccessibleStates::STATE_CHECKED)
+    if (states & states::CHECKED)
       aName.AssignLiteral("uncheck");
     else
       aName.AssignLiteral("check");
 
     return NS_OK;
   }
   return NS_ERROR_INVALID_ARG;
 }
--- a/accessible/src/xul/nsXULListboxAccessible.h
+++ b/accessible/src/xul/nsXULListboxAccessible.h
@@ -54,17 +54,17 @@ class nsIWeakReference;
  */
 class nsXULColumnsAccessible : public nsAccessibleWrap
 {
 public:
   nsXULColumnsAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 /**
  * nsXULColumnAccessible are accessibles for list and tree column elements
  * (xul:listcol and xul:treecol).
  */
 class nsXULColumnItemAccessible : public nsLeafAccessible
 {
@@ -73,17 +73,17 @@ public:
 
   // nsIAccessible
   NS_IMETHOD GetNumActions(PRUint8 *aNumActions);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 aIndex);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
   enum { eAction_Click = 0 };
 };
 
 /*
  * A class the represents the XUL Listbox widget.
  */
 class nsXULListboxAccessible : public nsXULSelectableAccessible,
@@ -96,17 +96,17 @@ public:
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSIACCESSIBLETABLE
 
   // nsIAccessible
   NS_IMETHOD GetValue(nsAString& aValue);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
 protected:
   PRBool IsMulticolumn();
 };
 
 /**
   * Listitems -- used in listboxes 
   */
@@ -123,17 +123,17 @@ public:
   // nsIAccessible
   NS_IMETHOD GetActionName(PRUint8 index, nsAString& aName);
   // Don't use XUL menuitems's description attribute
   NS_IMETHOD GetDescription(nsAString& aDesc) { return nsAccessibleWrap::GetDescription(aDesc); }
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual void GetPositionAndSizeInternal(PRInt32 *aPosInSet,
                                           PRInt32 *aSetSize);
   virtual PRBool GetAllowsAnonChildAccessibles();
 
 protected:
   /**
    * Return listbox accessible for the listitem.
    */
--- a/accessible/src/xul/nsXULMenuAccessible.cpp
+++ b/accessible/src/xul/nsXULMenuAccessible.cpp
@@ -36,16 +36,17 @@
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsXULMenuAccessible.h"
 
 #include "nsAccessibilityService.h"
 #include "nsAccUtils.h"
 #include "nsXULFormControlAccessible.h"
+#include "States.h"
 
 #include "nsIDOMElement.h"
 #include "nsIDOMXULElement.h"
 #include "nsIMutableArray.h"
 #include "nsIDOMXULContainerElement.h"
 #include "nsIDOMXULSelectCntrlItemEl.h"
 #include "nsIDOMXULMultSelectCntrlEl.h"
 #include "nsIDOMKeyEvent.h"
@@ -284,113 +285,105 @@ nsXULMenuitemAccessible::Init()
 {
   if (!nsAccessibleWrap::Init())
     return PR_FALSE;
 
   nsCoreUtils::GeneratePopupTree(mContent);
   return PR_TRUE;
 }
 
-nsresult
-nsXULMenuitemAccessible::GetStateInternal(PRUint32 *aState,
-                                          PRUint32 *aExtraState)
+PRUint64
+nsXULMenuitemAccessible::NativeState()
 {
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsAccessible::NativeState();
 
   // Focused?
   if (mContent->HasAttr(kNameSpaceID_None,
                         nsAccessibilityAtoms::_moz_menuactive))
-    *aState |= nsIAccessibleStates::STATE_FOCUSED;
+    state |= states::FOCUSED;
 
   // Has Popup?
   if (mContent->NodeInfo()->Equals(nsAccessibilityAtoms::menu,
                                    kNameSpaceID_XUL)) {
-    *aState |= nsIAccessibleStates::STATE_HASPOPUP;
+    state |= states::HASPOPUP;
     if (mContent->HasAttr(kNameSpaceID_None, nsAccessibilityAtoms::open))
-      *aState |= nsIAccessibleStates::STATE_EXPANDED;
+      state |= states::EXPANDED;
     else
-      *aState |= nsIAccessibleStates::STATE_COLLAPSED;
+      state |= states::COLLAPSED;
   }
 
   // Checkable/checked?
   static nsIContent::AttrValuesArray strings[] =
     { &nsAccessibilityAtoms::radio, &nsAccessibilityAtoms::checkbox, nsnull };
 
   if (mContent->FindAttrValueIn(kNameSpaceID_None,
                                 nsAccessibilityAtoms::type,
                                 strings, eCaseMatters) >= 0) {
 
     // Checkable?
-    *aState |= nsIAccessibleStates::STATE_CHECKABLE;
+    state |= states::CHECKABLE;
 
     // Checked?
     if (mContent->AttrValueIs(kNameSpaceID_None, nsAccessibilityAtoms::checked,
                               nsAccessibilityAtoms::_true, eCaseMatters))
-      *aState |= nsIAccessibleStates::STATE_CHECKED;
+      state |= states::CHECKED;
   }
 
   // Combo box listitem
   PRBool isComboboxOption = (Role() == nsIAccessibleRole::ROLE_COMBOBOX_OPTION);
   if (isComboboxOption) {
     // Is selected?
     PRBool isSelected = PR_FALSE;
     nsCOMPtr<nsIDOMXULSelectControlItemElement>
       item(do_QueryInterface(mContent));
-    NS_ENSURE_TRUE(item, NS_ERROR_FAILURE);
+    NS_ENSURE_TRUE(item, state);
     item->GetSelected(&isSelected);
 
     // Is collapsed?
     PRBool isCollapsed = PR_FALSE;
     nsAccessible* parentAcc = GetParent();
-    if (nsAccUtils::State(parentAcc) & nsIAccessibleStates::STATE_INVISIBLE)
+    if (parentAcc->State() & states::INVISIBLE)
       isCollapsed = PR_TRUE;
 
     if (isSelected) {
-      *aState |= nsIAccessibleStates::STATE_SELECTED;
+      state |= states::SELECTED;
 
       // Selected and collapsed?
       if (isCollapsed) {
         // Set selected option offscreen/invisible according to combobox state
         nsAccessible* grandParentAcc = parentAcc->GetParent();
-        NS_ENSURE_TRUE(grandParentAcc, NS_ERROR_FAILURE);
+        NS_ENSURE_TRUE(grandParentAcc, state);
         NS_ASSERTION(grandParentAcc->Role() == nsIAccessibleRole::ROLE_COMBOBOX,
                      "grandparent of combobox listitem is not combobox");
-        PRUint32 grandParentState, grandParentExtState;
-        grandParentAcc->GetState(&grandParentState, &grandParentExtState);
-        *aState &= ~(nsIAccessibleStates::STATE_OFFSCREEN |
-                     nsIAccessibleStates::STATE_INVISIBLE);
-        *aState |= (grandParentState & nsIAccessibleStates::STATE_OFFSCREEN) |
-                   (grandParentState & nsIAccessibleStates::STATE_INVISIBLE);
-        if (aExtraState) {
-          *aExtraState |=
-            grandParentExtState & nsIAccessibleStates::EXT_STATE_OPAQUE;
-        }
+        PRUint64 grandParentState = grandParentAcc->State();
+        state &= ~(states::OFFSCREEN | states::INVISIBLE);
+        state |= (grandParentState & states::OFFSCREEN) |
+                 (grandParentState & states::INVISIBLE) |
+                 (grandParentState & states::OPAQUE1);
       } // isCollapsed
     } // isSelected
   } // ROLE_COMBOBOX_OPTION
 
   // Set focusable and selectable for items that are available
   // and whose metric setting does allow disabled items to be focused.
-  if (*aState & nsIAccessibleStates::STATE_UNAVAILABLE) {
+  if (state & states::UNAVAILABLE) {
     // Honour the LookAndFeel metric.
     nsCOMPtr<nsILookAndFeel> lookNFeel(do_GetService(kLookAndFeelCID));
     PRInt32 skipDisabledMenuItems = 0;
     lookNFeel->GetMetric(nsILookAndFeel::eMetric_SkipNavigatingDisabledMenuItem,
                          skipDisabledMenuItems);
     // We don't want the focusable and selectable states for combobox items,
     // so exclude them here as well.
     if (skipDisabledMenuItems || isComboboxOption) {
-      return NS_OK;
+      return state;
     }
   }
-  *aState|= (nsIAccessibleStates::STATE_FOCUSABLE |
-             nsIAccessibleStates::STATE_SELECTABLE);
+  state |= (states::FOCUSABLE | states::SELECTABLE);
 
-  return NS_OK;
+  return state;
 }
 
 nsresult
 nsXULMenuitemAccessible::GetNameInternal(nsAString& aName)
 {
   mContent->GetAttr(kNameSpaceID_None, nsAccessibilityAtoms::label, aName);
   return NS_OK;
 }
@@ -555,28 +548,22 @@ NS_IMETHODIMP nsXULMenuitemAccessible::G
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXULMenuSeparatorAccessible::
   nsXULMenuSeparatorAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
   nsXULMenuitemAccessible(aContent, aShell)
 {
 }
 
-nsresult
-nsXULMenuSeparatorAccessible::GetStateInternal(PRUint32 *aState,
-                                               PRUint32 *aExtraState)
+PRUint64
+nsXULMenuSeparatorAccessible::NativeState()
 {
   // Isn't focusable, but can be offscreen/invisible -- only copy those states
-  nsresult rv = nsXULMenuitemAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
-  *aState &= (nsIAccessibleStates::STATE_OFFSCREEN | 
-              nsIAccessibleStates::STATE_INVISIBLE);
-
-  return NS_OK;
+  return nsXULMenuitemAccessible::NativeState() &
+    (states::OFFSCREEN | states::INVISIBLE);
 }
 
 nsresult
 nsXULMenuSeparatorAccessible::GetNameInternal(nsAString& aName)
 {
   return NS_OK;
 }
 
@@ -609,47 +596,44 @@ NS_IMETHODIMP nsXULMenuSeparatorAccessib
 nsXULMenupopupAccessible::
   nsXULMenupopupAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
   nsXULSelectableAccessible(aContent, aShell)
 { 
   // May be the anonymous <menupopup> inside <menulist> (a combobox)
   mSelectControl = do_QueryInterface(mContent->GetParent());
 }
 
-nsresult
-nsXULMenupopupAccessible::GetStateInternal(PRUint32 *aState,
-                                           PRUint32 *aExtraState)
+PRUint64
+nsXULMenupopupAccessible::NativeState()
 {
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsAccessible::NativeState();
 
 #ifdef DEBUG_A11Y
   // We are onscreen if our parent is active
   PRBool isActive = mContent->HasAttr(kNameSpaceID_None,
                                       nsAccessibilityAtoms::menuactive);
   if (!isActive) {
     nsAccessible* parent(GetParent());
-    NS_ENSURE_STATE(parent);
+    NS_ENSURE_TRUE(parent, state);
 
     nsIContent *parentContent = parnet->GetContent();
-    NS_ENSURE_STATE(parentContent);
+    NS_ENSURE_TRUE(parentContent, state);
 
     isActive = parentContent->HasAttr(kNameSpaceID_None,
                                       nsAccessibilityAtoms::open);
   }
 
-  NS_ASSERTION(isActive || *aState & nsIAccessibleStates::STATE_INVISIBLE,
-               "XULMenupopup doesn't have STATE_INVISIBLE when it's inactive");
+  NS_ASSERTION(isActive || states & states::INVISIBLE,
+               "XULMenupopup doesn't have INVISIBLE when it's inactive");
 #endif
 
-  if (*aState & nsIAccessibleStates::STATE_INVISIBLE)
-    *aState |= (nsIAccessibleStates::STATE_OFFSCREEN |
-                nsIAccessibleStates::STATE_COLLAPSED);
+  if (state & states::INVISIBLE)
+    state |= states::OFFSCREEN | states::COLLAPSED;
 
-  return NS_OK;
+  return state;
 }
 
 nsresult
 nsXULMenupopupAccessible::GetNameInternal(nsAString& aName)
 {
   nsIContent *content = mContent;
   while (content && aName.IsEmpty()) {
     content->GetAttr(kNameSpaceID_None, nsAccessibilityAtoms::label, aName);
@@ -689,26 +673,24 @@ nsXULMenupopupAccessible::NativeRole()
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXULMenubarAccessible::
   nsXULMenubarAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
   nsAccessibleWrap(aContent, aShell)
 {
 }
 
-nsresult
-nsXULMenubarAccessible::GetStateInternal(PRUint32 *aState,
-                                         PRUint32 *aExtraState)
+PRUint64
+nsXULMenubarAccessible::NativeState()
 {
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsAccessible::NativeState();
 
-  // Menu bar iteself is not actually focusable
-  *aState &= ~nsIAccessibleStates::STATE_FOCUSABLE;
-  return rv;
+  // Menu bar itself is not actually focusable
+  state &= ~states::FOCUSABLE;
+  return state;
 }
 
 
 nsresult
 nsXULMenubarAccessible::GetNameInternal(nsAString& aName)
 {
   aName.AssignLiteral("Application");
   return NS_OK;
--- a/accessible/src/xul/nsXULMenuAccessible.h
+++ b/accessible/src/xul/nsXULMenuAccessible.h
@@ -90,17 +90,17 @@ public:
   NS_IMETHOD GetNumActions(PRUint8 *_retval);
 
   // nsAccessNode
   virtual PRBool Init();
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual PRInt32 GetLevelInternal();
   virtual void GetPositionAndSizeInternal(PRInt32 *aPosInSet,
                                           PRInt32 *aSetSize);
 
   virtual PRBool GetAllowsAnonChildAccessibles();
 };
 
 /**
@@ -114,41 +114,41 @@ public:
   // nsIAccessible
   NS_IMETHOD DoAction(PRUint8 index);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD GetNumActions(PRUint8 *_retval);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * Used for XUL menupopup and panel.
  */
 class nsXULMenupopupAccessible : public nsXULSelectableAccessible
 {
 public:
   nsXULMenupopupAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 /**
  * Used for XUL menubar element.
  */
 class nsXULMenubarAccessible : public nsAccessibleWrap
 {
 public:
   nsXULMenubarAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 #endif  
--- a/accessible/src/xul/nsXULSliderAccessible.cpp
+++ b/accessible/src/xul/nsXULSliderAccessible.cpp
@@ -34,16 +34,17 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsXULSliderAccessible.h"
 
 #include "nsAccessibilityAtoms.h"
+#include "States.h"
 
 #include "nsIDOMDocument.h"
 #include "nsIDOMDocumentXBL.h"
 #include "nsIFrame.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULSliderAccessible
 ////////////////////////////////////////////////////////////////////////////////
@@ -63,34 +64,32 @@ NS_IMPL_ISUPPORTS_INHERITED1(nsXULSlider
 // nsAccessible
 
 PRUint32
 nsXULSliderAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_SLIDER;
 }
 
-nsresult
-nsXULSliderAccessible::GetStateInternal(PRUint32 *aState,
-                                        PRUint32 *aExtraState)
+PRUint64
+nsXULSliderAccessible::NativeState()
 {
-  nsresult rv = nsAccessibleWrap::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 states = nsAccessibleWrap::NativeState();
 
   nsCOMPtr<nsIContent> sliderContent(GetSliderNode());
   NS_ENSURE_STATE(sliderContent);
 
   nsIFrame *frame = sliderContent->GetPrimaryFrame();
   if (frame && frame->IsFocusable())
-    *aState |= nsIAccessibleStates::STATE_FOCUSABLE;
+    states |= states::FOCUSABLE;
 
   if (gLastFocusedNode == mContent)
-    *aState |= nsIAccessibleStates::STATE_FOCUSED;
+    states |= states::FOCUSED;
 
-  return NS_OK;
+  return states;
 }
 
 // nsIAccessible
 
 NS_IMETHODIMP
 nsXULSliderAccessible::GetValue(nsAString& aValue)
 {
   return GetSliderAttr(nsAccessibilityAtoms::curpos, aValue);
--- a/accessible/src/xul/nsXULSliderAccessible.h
+++ b/accessible/src/xul/nsXULSliderAccessible.h
@@ -60,17 +60,17 @@ public:
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 aIndex);
 
   // nsIAccessibleValue
   NS_DECL_NSIACCESSIBLEVALUE
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual PRBool GetAllowsAnonChildAccessibles();
 
 protected:
   already_AddRefed<nsIContent> GetSliderNode();
 
   nsresult GetSliderAttr(nsIAtom *aName, nsAString& aValue);
   nsresult SetSliderAttr(nsIAtom *aName, const nsAString& aValue);
 
--- a/accessible/src/xul/nsXULTabAccessible.cpp
+++ b/accessible/src/xul/nsXULTabAccessible.cpp
@@ -35,16 +35,17 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsXULTabAccessible.h"
 
 #include "nsAccUtils.h"
 #include "nsRelUtils.h"
+#include "States.h"
 
 // NOTE: alphabetically ordered
 #include "nsIDocument.h"
 #include "nsIFrame.h"
 #include "nsIDOMDocument.h"
 #include "nsIDOMXULSelectCntrlEl.h"
 #include "nsIDOMXULSelectCntrlItemEl.h"
 #include "nsIDOMXULRelatedElement.h"
@@ -97,47 +98,46 @@ NS_IMETHODIMP nsXULTabAccessible::DoActi
 // nsXULTabAccessible: nsAccessible
 
 PRUint32
 nsXULTabAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_PAGETAB;
 }
 
-nsresult
-nsXULTabAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsXULTabAccessible::NativeState()
 {
   // Possible states: focused, focusable, unavailable(disabled), offscreen.
 
   // get focus and disable status from base class
-  nsresult rv = nsAccessibleWrap::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsAccessibleWrap::NativeState();
 
   // In the past, tabs have been focusable in classic theme
   // They may be again in the future
   // Check style for -moz-user-focus: normal to see if it's focusable
-  *aState &= ~nsIAccessibleStates::STATE_FOCUSABLE;
+  state &= ~states::FOCUSABLE;
 
   nsIFrame *frame = mContent->GetPrimaryFrame();
   if (frame) {
     const nsStyleUserInterface* ui = frame->GetStyleUserInterface();
     if (ui->mUserFocus == NS_STYLE_USER_FOCUS_NORMAL)
-      *aState |= nsIAccessibleStates::STATE_FOCUSABLE;
+      state |= states::FOCUSABLE;
   }
 
   // Check whether the tab is selected
-  *aState |= nsIAccessibleStates::STATE_SELECTABLE;
-  *aState &= ~nsIAccessibleStates::STATE_SELECTED;
+  state |= states::SELECTABLE;
+  state &= ~states::SELECTED;
   nsCOMPtr<nsIDOMXULSelectControlItemElement> tab(do_QueryInterface(mContent));
   if (tab) {
     PRBool selected = PR_FALSE;
     if (NS_SUCCEEDED(tab->GetSelected(&selected)) && selected)
-      *aState |= nsIAccessibleStates::STATE_SELECTED;
+      state |= states::SELECTED;
   }
-  return NS_OK;
+  return state;
 }
 
 // nsIAccessible
 NS_IMETHODIMP
 nsXULTabAccessible::GetRelationByType(PRUint32 aRelationType,
                                       nsIAccessibleRelation **aRelation)
 {
   nsresult rv = nsAccessibleWrap::GetRelationByType(aRelationType,
--- a/accessible/src/xul/nsXULTabAccessible.h
+++ b/accessible/src/xul/nsXULTabAccessible.h
@@ -59,17 +59,17 @@ public:
   NS_IMETHOD DoAction(PRUint8 index);
   NS_IMETHOD GetRelationByType(PRUint32 aRelationType,
                                nsIAccessibleRelation **aRelation);
 
   // nsAccessible
   virtual void GetPositionAndSizeInternal(PRInt32 *aPosInSet,
                                           PRInt32 *aSetSize);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 
 /**
  * A container of tab objects, xul:tabs element.
  */
 class nsXULTabsAccessible : public nsXULSelectableAccessible
 {
--- a/accessible/src/xul/nsXULTextAccessible.cpp
+++ b/accessible/src/xul/nsXULTextAccessible.cpp
@@ -41,16 +41,17 @@
 #include "nsXULTextAccessible.h"
 
 #include "nsAccessibilityAtoms.h"
 #include "nsAccUtils.h"
 #include "nsBaseWidgetAccessible.h"
 #include "nsCoreUtils.h"
 #include "nsRelUtils.h"
 #include "nsTextEquivUtils.h"
+#include "States.h"
 
 #include "nsIDOMXULDescriptionElement.h"
 #include "nsINameSpaceManager.h"
 #include "nsString.h"
 #include "nsNetUtil.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULTextAccessible
@@ -72,27 +73,22 @@ nsXULTextAccessible::GetNameInternal(nsA
 }
 
 PRUint32
 nsXULTextAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_LABEL;
 }
 
-nsresult
-nsXULTextAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsXULTextAccessible::NativeState()
 {
-  nsresult rv = nsHyperTextAccessibleWrap::GetStateInternal(aState,
-                                                            aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
   // Labels and description have read only state
   // They are not focusable or selectable
-  *aState |= nsIAccessibleStates::STATE_READONLY;
-  return NS_OK;
+  return nsHyperTextAccessibleWrap::NativeState() | states::READONLY;
 }
 
 NS_IMETHODIMP
 nsXULTextAccessible::GetRelationByType(PRUint32 aRelationType,
                                        nsIAccessibleRelation **aRelation)
 {
   nsresult rv =
     nsHyperTextAccessibleWrap::GetRelationByType(aRelationType, aRelation);
@@ -117,26 +113,24 @@ nsXULTextAccessible::GetRelationByType(P
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXULTooltipAccessible::
   nsXULTooltipAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
   nsLeafAccessible(aContent, aShell)
 {
 }
 
-nsresult
-nsXULTooltipAccessible::GetStateInternal(PRUint32 *aState,
-                                         PRUint32 *aExtraState)
+PRUint64
+nsXULTooltipAccessible::NativeState()
 {
-  nsresult rv = nsLeafAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 states = nsLeafAccessible::NativeState();
 
-  *aState &= ~nsIAccessibleStates::STATE_FOCUSABLE;
-  *aState |= nsIAccessibleStates::STATE_READONLY;
-  return NS_OK;
+  states &= ~states::FOCUSABLE;
+  states |= states::READONLY;
+  return states;
 }
 
 PRUint32
 nsXULTooltipAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_TOOLTIP;
 }
 
@@ -182,25 +176,20 @@ nsXULLinkAccessible::GetNameInternal(nsA
 
 PRUint32
 nsXULLinkAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_LINK;
 }
 
 
-nsresult
-nsXULLinkAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsXULLinkAccessible::NativeState()
 {
-  nsresult rv = nsHyperTextAccessibleWrap::GetStateInternal(aState,
-                                                            aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
-
-  *aState |= nsIAccessibleStates::STATE_LINKED;
-  return NS_OK;
+  return nsHyperTextAccessible::NativeState() | states::LINKED;
 }
 
 NS_IMETHODIMP
 nsXULLinkAccessible::GetNumActions(PRUint8 *aNumActions)
 {
   NS_ENSURE_ARG_POINTER(aNumActions);
   
   *aNumActions = 1;
--- a/accessible/src/xul/nsXULTextAccessible.h
+++ b/accessible/src/xul/nsXULTextAccessible.h
@@ -54,31 +54,31 @@ public:
 
   // nsIAccessible
   NS_IMETHOD GetRelationByType(PRUint32 aRelationType,
                                nsIAccessibleRelation **aRelation);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 /**
  * Used for XUL tooltip element.
  */
 class nsXULTooltipAccessible : public nsLeafAccessible
 {
 
 public:
   nsXULTooltipAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 };
 
 class nsXULLinkAccessible : public nsHyperTextAccessibleWrap
 {
 
 public:
   nsXULLinkAccessible(nsIContent *aContent, nsIWeakReference *aShell);
 
@@ -89,17 +89,17 @@ public:
 
   NS_IMETHOD GetNumActions(PRUint8 *aNumActions);
   NS_IMETHOD GetActionName(PRUint8 aIndex, nsAString& aName);
   NS_IMETHOD DoAction(PRUint8 aIndex);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
 
   // HyperLinkAccessible
   virtual bool IsHyperLink();
   virtual PRUint32 StartOffset();
   virtual PRUint32 EndOffset();
   virtual already_AddRefed<nsIURI> GetAnchorURI(PRUint32 aAnchorIndex);
 
 protected:
--- a/accessible/src/xul/nsXULTreeAccessible.cpp
+++ b/accessible/src/xul/nsXULTreeAccessible.cpp
@@ -38,16 +38,17 @@
 
 #include "nsXULTreeAccessible.h"
 
 #include "nsAccCache.h"
 #include "nsAccUtils.h"
 #include "nsCoreUtils.h"
 #include "nsDocAccessible.h"
 #include "nsRelUtils.h"
+#include "States.h"
 
 #include "nsIDOMXULElement.h"
 #include "nsIDOMXULMultSelectCntrlEl.h"
 #include "nsIDOMXULTreeElement.h"
 #include "nsITreeSelection.h"
 #include "nsIMutableArray.h"
 #include "nsComponentManagerUtils.h"
 
@@ -88,43 +89,41 @@ NS_INTERFACE_MAP_STATIC_AMBIGUOUS(nsXULT
 NS_INTERFACE_MAP_END_INHERITING(nsAccessible)
 
 NS_IMPL_ADDREF_INHERITED(nsXULTreeAccessible, nsAccessible)
 NS_IMPL_RELEASE_INHERITED(nsXULTreeAccessible, nsAccessible)
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULTreeAccessible: nsAccessible implementation
 
-nsresult
-nsXULTreeAccessible::GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState)
+PRUint64
+nsXULTreeAccessible::NativeState()
 {
   // Get focus status from base class.
-  nsresult rv = nsAccessible::GetStateInternal(aState, aExtraState);
-  NS_ENSURE_A11Y_SUCCESS(rv, rv);
+  PRUint64 state = nsAccessible::NativeState();
 
   // readonly state
-  *aState |= nsIAccessibleStates::STATE_READONLY;
+  state |= states::READONLY;
 
   // remove focusable and focused states since tree items are focusable for AT
-  *aState &= ~nsIAccessibleStates::STATE_FOCUSABLE;
-  *aState &= ~nsIAccessibleStates::STATE_FOCUSED;
+  state &= ~(states::FOCUSABLE | states::FOCUSED);
 
   // multiselectable state.
   nsCOMPtr<nsITreeSelection> selection;
   mTreeView->GetSelection(getter_AddRefs(selection));
-  NS_ENSURE_STATE(selection);
+  NS_ENSURE_TRUE(selection, state);
 
   PRBool isSingle = PR_FALSE;
-  rv = selection->GetSingle(&isSingle);
-  NS_ENSURE_SUCCESS(rv, rv);
+  nsresult rv = selection->GetSingle(&isSingle);
+  NS_ENSURE_SUCCESS(rv, state);
 
   if (!isSingle)
-    *aState |= nsIAccessibleStates::STATE_MULTISELECTABLE;
+    state |= states::MULTISELECTABLE;
 
-  return NS_OK;
+  return state;
 }
 
 NS_IMETHODIMP
 nsXULTreeAccessible::GetValue(nsAString& aValue)
 {
   // Return the value is the first selected child.
 
   aValue.Truncate();
@@ -920,74 +919,62 @@ nsXULTreeItemAccessibleBase::GroupPositi
 
   *aGroupLevel = level + 1;
   *aSimilarItemsInGroup = setSize;
   *aPositionInGroup = posInSet;
 
   return NS_OK;
 }
 
-nsresult
-nsXULTreeItemAccessibleBase::GetStateInternal(PRUint32 *aState,
-                                              PRUint32 *aExtraState)
+PRUint64
+nsXULTreeItemAccessibleBase::NativeState()
 {
-  NS_ENSURE_ARG_POINTER(aState);
 
-  *aState = 0;
-  if (aExtraState)
-    *aExtraState = 0;
-
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_DEFUNCT;
-    return NS_OK_DEFUNCT_OBJECT;
-  }
+  if (IsDefunct())
+    return states::DEFUNCT;
 
   // focusable and selectable states
-  *aState = nsIAccessibleStates::STATE_FOCUSABLE |
-    nsIAccessibleStates::STATE_SELECTABLE;
+  PRUint64 state = states::FOCUSABLE | states::SELECTABLE;
 
   // expanded/collapsed state
   if (IsExpandable()) {
     PRBool isContainerOpen;
     mTreeView->IsContainerOpen(mRow, &isContainerOpen);
-    *aState |= isContainerOpen ?
-      static_cast<PRUint32>(nsIAccessibleStates::STATE_EXPANDED) :
-      static_cast<PRUint32>(nsIAccessibleStates::STATE_COLLAPSED);
+    state |= isContainerOpen ? states::EXPANDED : states::COLLAPSED;
   }
 
   // selected state
   nsCOMPtr<nsITreeSelection> selection;
   mTreeView->GetSelection(getter_AddRefs(selection));
   if (selection) {
     PRBool isSelected;
     selection->IsSelected(mRow, &isSelected);
     if (isSelected)
-      *aState |= nsIAccessibleStates::STATE_SELECTED;
+      state |= states::SELECTED;
   }
 
   // focused state
   nsCOMPtr<nsIDOMXULMultiSelectControlElement> multiSelect =
     do_QueryInterface(mContent);
   if (multiSelect) {
     PRInt32 currentIndex;
     multiSelect->GetCurrentIndex(&currentIndex);
     if (currentIndex == mRow) {
-      *aState |= nsIAccessibleStates::STATE_FOCUSED;
+      state |= states::FOCUSED;
     }
   }
 
   // invisible state
   PRInt32 firstVisibleRow, lastVisibleRow;
   mTree->GetFirstVisibleRow(&firstVisibleRow);
   mTree->GetLastVisibleRow(&lastVisibleRow);
   if (mRow < firstVisibleRow || mRow > lastVisibleRow)
-    *aState |= nsIAccessibleStates::STATE_INVISIBLE;
+    state |= states::INVISIBLE;
 
-  return NS_OK;
+  return state;
 }
 
 PRInt32
 nsXULTreeItemAccessibleBase::GetIndexInParent() const
 {
   return mParent ? mParent->GetCachedChildCount() + mRow : -1;
 }
 
--- a/accessible/src/xul/nsXULTreeAccessible.h
+++ b/accessible/src/xul/nsXULTreeAccessible.h
@@ -80,17 +80,17 @@ public:
   NS_IMETHOD GetFocusedChild(nsIAccessible **aFocusedChild);
 
   // nsAccessNode
   virtual PRBool IsDefunct();
   virtual void Shutdown();
 
   // nsAccessible
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual nsAccessible* GetChildAtPoint(PRInt32 aX, PRInt32 aY,
                                         EWhichChildAtPoint aWhichChild);
 
   virtual nsAccessible* GetChildAt(PRUint32 aIndex);
   virtual PRInt32 GetChildCount();
 
   // SelectAccessible
   virtual bool IsSelect();
@@ -201,17 +201,17 @@ public:
   NS_IMETHOD DoAction(PRUint8 aIndex);
 
   // nsAccessNode
   virtual PRBool IsDefunct();
   virtual void Shutdown();
   virtual bool IsPrimaryForNode() const;
 
   // nsAccessible
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual PRInt32 GetIndexInParent() const;
 
   // nsXULTreeItemAccessibleBase
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_XULTREEITEMBASEACCESSIBLE_IMPL_CID)
 
   /**
    * Return row index associated with the accessible.
    */
--- a/accessible/src/xul/nsXULTreeGridAccessible.cpp
+++ b/accessible/src/xul/nsXULTreeGridAccessible.cpp
@@ -38,16 +38,17 @@
 
 #include "nsXULTreeGridAccessibleWrap.h"
 
 #include "nsAccCache.h"
 #include "nsAccessibilityService.h"
 #include "nsAccUtils.h"
 #include "nsDocAccessible.h"
 #include "nsEventShell.h"
+#include "States.h"
 
 #include "nsITreeSelection.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULTreeGridAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXULTreeGridAccessible::
@@ -1156,56 +1157,47 @@ nsXULTreeGridCellAccessible::GetAttribut
 }
 
 PRUint32
 nsXULTreeGridCellAccessible::NativeRole()
 {
   return nsIAccessibleRole::ROLE_GRID_CELL;
 }
 
-nsresult
-nsXULTreeGridCellAccessible::GetStateInternal(PRUint32 *aStates,
-                                              PRUint32 *aExtraStates)
+PRUint64
+nsXULTreeGridCellAccessible::NativeState()
 {
-  NS_ENSURE_ARG_POINTER(aStates);
 
-  *aStates = 0;
-  if (aExtraStates)
-    *aExtraStates = 0;
-
-  if (IsDefunct()) {
-    if (aExtraStates)
-      *aExtraStates = nsIAccessibleStates::EXT_STATE_DEFUNCT;
-    return NS_OK_DEFUNCT_OBJECT;
-  }
+  if (IsDefunct())
+    return states::DEFUNCT;
 
   // selectable/selected state
-  *aStates |= nsIAccessibleStates::STATE_SELECTABLE;
+  PRUint64 states = states::SELECTABLE;
 
   nsCOMPtr<nsITreeSelection> selection;
   mTreeView->GetSelection(getter_AddRefs(selection));
   if (selection) {
     PRBool isSelected = PR_FALSE;
     selection->IsSelected(mRow, &isSelected);
     if (isSelected)
-      *aStates |= nsIAccessibleStates::STATE_SELECTED;
+      states |= states::SELECTED;
   }
 
   // checked state
   PRInt16 type;
   mColumn->GetType(&type);
   if (type == nsITreeColumn::TYPE_CHECKBOX) {
-    *aStates |= nsIAccessibleStates::STATE_CHECKABLE;
+    states |= states::CHECKABLE;
     nsAutoString checked;
     mTreeView->GetCellValue(mRow, mColumn, checked);
     if (checked.EqualsIgnoreCase("true"))
-      *aStates |= nsIAccessibleStates::STATE_CHECKED;
+      states |= states::CHECKED;
   }
 
-  return NS_OK;
+  return states;
 }
 
 PRInt32
 nsXULTreeGridCellAccessible::GetIndexInParent() const
 {
   return GetColumnIndex();
 }
 
@@ -1230,18 +1222,17 @@ nsXULTreeGridCellAccessible::CellInvalid
 
   PRInt16 type;
   mColumn->GetType(&type);
   if (type == nsITreeColumn::TYPE_CHECKBOX) {
     mTreeView->GetCellValue(mRow, mColumn, textEquiv);
     if (mCachedTextEquiv != textEquiv) {
       PRBool isEnabled = textEquiv.EqualsLiteral("true");
       nsRefPtr<AccEvent> accEvent =
-        new AccStateChangeEvent(this, nsIAccessibleStates::STATE_CHECKED,
-                                PR_FALSE, isEnabled);
+        new AccStateChangeEvent(this, states::CHECKED, isEnabled);
       nsEventShell::FireEvent(accEvent);
 
       mCachedTextEquiv = textEquiv;
     }
 
     return;
   }
 
--- a/accessible/src/xul/nsXULTreeGridAccessible.h
+++ b/accessible/src/xul/nsXULTreeGridAccessible.h
@@ -157,17 +157,17 @@ public:
   // nsAccessNode
   virtual PRBool IsDefunct();
   virtual PRBool Init();
   virtual bool IsPrimaryForNode() const;
 
   // nsAccessible
   virtual nsresult GetAttributesInternal(nsIPersistentProperties *aAttributes);
   virtual PRUint32 NativeRole();
-  virtual nsresult GetStateInternal(PRUint32 *aState, PRUint32 *aExtraState);
+  virtual PRUint64 NativeState();
   virtual PRInt32 GetIndexInParent() const;
 
   // nsXULTreeGridCellAccessible
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_XULTREEGRIDCELLACCESSIBLE_IMPL_CID)
 
   /**
    * Return index of the column.
    */