Merge TM -> JM
authorBrian Hackett <bhackett1024@gmail.com>
Tue, 12 Apr 2011 07:04:45 -0700
changeset 74930 c09134c989c8528d88f75221b61943904e923e16
parent 74929 23a746dac3706a1c0b41d9dbf2b675e93dc7b18c (current diff)
parent 68009 5b8812d6950b83d540fa324e870bec4f882356a7 (diff)
child 74931 a4131835b866364816d60729d80f27c294180b1f
push id2
push userbsmedberg@mozilla.com
push dateFri, 19 Aug 2011 14:38:13 +0000
milestone2.2a1pre
Merge TM -> JM
content/mathml/content/src/mathml.dtd
content/xml/content/src/xhtml11.dtd
dom/base/nsDOMClassInfo.cpp
dom/base/nsGlobalWindow.cpp
dom/base/nsJSEnvironment.cpp
dom/tests/mochitest/dom-level2-core/test_nodesetprefix01.html
dom/tests/mochitest/dom-level2-core/test_nodesetprefix02.html
dom/tests/mochitest/dom-level2-core/test_nodesetprefix03.html
dom/tests/mochitest/dom-level2-core/test_nodesetprefix04.html
dom/tests/mochitest/dom-level2-core/test_nodesetprefix05.html
dom/tests/mochitest/dom-level2-core/test_nodesetprefix06.html
dom/tests/mochitest/dom-level2-core/test_nodesetprefix07.html
dom/tests/mochitest/dom-level2-core/test_nodesetprefix08.html
dom/tests/mochitest/dom-level2-core/test_nodesetprefix09.html
dom/tests/mochitest/dom-level2-core/test_prefix05.html
dom/tests/mochitest/dom-level2-core/test_prefix06.html
dom/tests/mochitest/dom-level2-core/test_prefix07.html
dom/tests/mochitest/dom-level2-core/test_prefix08.html
dom/tests/mochitest/dom-level2-core/test_prefix09.html
dom/tests/mochitest/dom-level2-core/test_prefix10.html
dom/tests/mochitest/dom-level2-core/test_prefix11.html
embedding/browser/gtk/Makefile.in
embedding/browser/gtk/src/EmbedCertificates.cpp
embedding/browser/gtk/src/EmbedCertificates.h
embedding/browser/gtk/src/EmbedContentListener.cpp
embedding/browser/gtk/src/EmbedContentListener.h
embedding/browser/gtk/src/EmbedContextMenuInfo.cpp
embedding/browser/gtk/src/EmbedContextMenuInfo.h
embedding/browser/gtk/src/EmbedEventListener.cpp
embedding/browser/gtk/src/EmbedEventListener.h
embedding/browser/gtk/src/EmbedGtkTools.cpp
embedding/browser/gtk/src/EmbedGtkTools.h
embedding/browser/gtk/src/EmbedPrivate.cpp
embedding/browser/gtk/src/EmbedPrivate.h
embedding/browser/gtk/src/EmbedProgress.cpp
embedding/browser/gtk/src/EmbedProgress.h
embedding/browser/gtk/src/EmbedPrompter.cpp
embedding/browser/gtk/src/EmbedPrompter.h
embedding/browser/gtk/src/EmbedWindow.cpp
embedding/browser/gtk/src/EmbedWindow.h
embedding/browser/gtk/src/EmbedWindowCreator.cpp
embedding/browser/gtk/src/EmbedWindowCreator.h
embedding/browser/gtk/src/GtkPromptService.cpp
embedding/browser/gtk/src/GtkPromptService.h
embedding/browser/gtk/src/Makefile.in
embedding/browser/gtk/src/gtkmozembed.h
embedding/browser/gtk/src/gtkmozembed2.cpp
embedding/browser/gtk/src/gtkmozembed_glue.cpp
embedding/browser/gtk/src/gtkmozembed_internal.h
embedding/browser/gtk/src/gtkmozembedmarshal.list
embedding/browser/gtk/src/gtkmozembedprivate.h
embedding/browser/gtk/tests/Makefile.in
embedding/browser/gtk/tests/TestGtkEmbed.cpp
embedding/browser/gtk/tests/TestGtkEmbedChild.cpp
embedding/browser/gtk/tests/TestGtkEmbedMDI.cpp
embedding/browser/gtk/tests/TestGtkEmbedNotebook.cpp
embedding/browser/gtk/tests/TestGtkEmbedSocket.cpp
extensions/java/Makefile.in
extensions/java/xpcom/Makefile.in
extensions/java/xpcom/glue/Makefile.in
extensions/java/xpcom/glue/nsJavaXPCOMGlue.cpp
extensions/java/xpcom/interfaces/Makefile.in
extensions/java/xpcom/interfaces/gen-nsError.pl
extensions/java/xpcom/interfaces/org/mozilla/xpcom/GREVersionRange.java
extensions/java/xpcom/interfaces/org/mozilla/xpcom/IAppFileLocProvider.java
extensions/java/xpcom/interfaces/org/mozilla/xpcom/IGRE.java
extensions/java/xpcom/interfaces/org/mozilla/xpcom/IJavaXPCOMUtils.java
extensions/java/xpcom/interfaces/org/mozilla/xpcom/IMozilla.java
extensions/java/xpcom/interfaces/org/mozilla/xpcom/INIParser.java
extensions/java/xpcom/interfaces/org/mozilla/xpcom/IXPCOM.java
extensions/java/xpcom/interfaces/org/mozilla/xpcom/Mozilla.java
extensions/java/xpcom/interfaces/org/mozilla/xpcom/ProfileLock.java
extensions/java/xpcom/interfaces/org/mozilla/xpcom/VersionComparator.java
extensions/java/xpcom/interfaces/org/mozilla/xpcom/XPCOMException.java
extensions/java/xpcom/interfaces/org/mozilla/xpcom/XPCOMInitializationException.java
extensions/java/xpcom/package/Makefile.in
extensions/java/xpcom/package/javaconnect.jst
extensions/java/xpcom/package/packages-mac
extensions/java/xpcom/package/packages-unix
extensions/java/xpcom/package/packages-win
extensions/java/xpcom/src/MacJawt.mm
extensions/java/xpcom/src/Makefile.in
extensions/java/xpcom/src/dlldeps-javaxpcom.cpp
extensions/java/xpcom/src/nsAppFileLocProviderProxy.cpp
extensions/java/xpcom/src/nsAppFileLocProviderProxy.h
extensions/java/xpcom/src/nsJavaInterfaces.cpp
extensions/java/xpcom/src/nsJavaInterfaces.h
extensions/java/xpcom/src/nsJavaWrapper.cpp
extensions/java/xpcom/src/nsJavaWrapper.h
extensions/java/xpcom/src/nsJavaXPCOMBindingUtils.cpp
extensions/java/xpcom/src/nsJavaXPCOMBindingUtils.h
extensions/java/xpcom/src/nsJavaXPTCStub.cpp
extensions/java/xpcom/src/nsJavaXPTCStub.h
extensions/java/xpcom/src/nsJavaXPTCStubWeakRef.cpp
extensions/java/xpcom/src/nsJavaXPTCStubWeakRef.h
extensions/java/xpcom/src/org/mozilla/xpcom/internal/GREImpl.java
extensions/java/xpcom/src/org/mozilla/xpcom/internal/JavaXPCOMMethods.java
extensions/java/xpcom/src/org/mozilla/xpcom/internal/MozillaImpl.java
extensions/java/xpcom/src/org/mozilla/xpcom/internal/XPCOMImpl.java
extensions/java/xpcom/src/org/mozilla/xpcom/internal/XPCOMJavaProxy.java
extensions/java/xpcom/src/org/mozilla/xpcom/internal/XPCOMJavaProxyBase.java
extensions/java/xpcom/tests/LocationProvider.java
extensions/java/xpcom/tests/Makefile.in
extensions/java/xpcom/tests/TestArray.java
extensions/java/xpcom/tests/TestINIParser.java
extensions/java/xpcom/tests/TestJavaProxy.java
extensions/java/xpcom/tests/TestProps.java
extensions/java/xpcom/tests/TestQI.java
extensions/java/xpcom/tests/TestVersionComparator.java
extensions/java/xpcom/tests/testparams/Makefile.in
extensions/java/xpcom/tests/testparams/TestParams.java
extensions/java/xpcom/tests/testparams/nsIJXTestArrayParams.idl
extensions/java/xpcom/tests/testparams/nsIJXTestParams.idl
extensions/java/xpcom/tests/testparams/nsJXTestParams.js
extensions/java/xpcom/tests/testparams/xpctests.js
extensions/java/xpcom/tools/genifaces/GenerateJavaInterfaces.cpp
extensions/java/xpcom/tools/genifaces/Makefile.in
extensions/java/xpcom/tools/xpidl/Makefile.in
extensions/java/xpcom/tools/xpidl/xpidl.c
extensions/java/xpcom/tools/xpidl/xpidl.h
extensions/java/xpcom/tools/xpidl/xpidl_doc.c
extensions/java/xpcom/tools/xpidl/xpidl_header.c
extensions/java/xpcom/tools/xpidl/xpidl_idl.c
extensions/java/xpcom/tools/xpidl/xpidl_java.c
extensions/java/xpcom/tools/xpidl/xpidl_javastub.c
extensions/java/xpcom/tools/xpidl/xpidl_typelib.c
extensions/java/xpcom/tools/xpidl/xpidl_util.c
gfx/angle/src/compiler/debug.cpp
gfx/angle/src/compiler/debug.h
intl/uconv/native/Makefile.in
intl/uconv/native/nsINativeUConvService.idl
intl/uconv/native/nsNativeUConvService.cpp
intl/uconv/native/nsNativeUConvService.h
intl/uconv/native/nsWinCEUConvService.cpp
intl/uconv/public/nsICharsetAlias.h
intl/uconv/public/nsIPlatformCharset.h
intl/uconv/src/charsetalias.properties
intl/uconv/src/maccharset.properties
intl/uconv/src/nsCharsetAlias.h
intl/uconv/src/nsCharsetAliasImp.cpp
intl/uconv/src/nsMacCharset.cpp
intl/uconv/src/nsOS2Charset.cpp
intl/uconv/src/nsPlatformCharset.h
intl/uconv/src/nsUConvPropertySearch.cpp
intl/uconv/src/nsUConvPropertySearch.h
intl/uconv/src/nsUNIXCharset.cpp
intl/uconv/src/nsWinCharset.cpp
intl/uconv/src/os2charset.properties
intl/uconv/src/props2arrays.py
intl/uconv/src/unixcharset.properties
intl/uconv/src/wincharset.properties
js/src/Makefile.in
js/src/configure.in
js/src/jsapi.cpp
js/src/jsarray.cpp
js/src/jsatom.cpp
js/src/jscntxt.h
js/src/jscompartment.cpp
js/src/jscompartment.h
js/src/jsdate.cpp
js/src/jsfun.cpp
js/src/jsgc.cpp
js/src/jshashtable.h
js/src/jsinfer.cpp
js/src/jsinfer.h
js/src/jsinterp.cpp
js/src/jsinterp.h
js/src/jsiter.cpp
js/src/jsobj.cpp
js/src/jsobj.h
js/src/json.cpp
js/src/jsregexp.cpp
js/src/jsscopeinlines.h
js/src/jsstr.cpp
js/src/jsstrinlines.h
js/src/jstypedarray.cpp
js/src/jsxml.cpp
js/src/methodjit/Compiler.cpp
js/src/methodjit/FastBuiltins.cpp
js/src/methodjit/FastOps.cpp
js/src/methodjit/LoopState.cpp
js/src/xpconnect/shell/xpcshell.cpp
js/src/xpconnect/src/xpcwrappednative.cpp
js/src/xpconnect/wrappers/WrapperFactory.cpp
layout/generic/nsBidiFrames.cpp
layout/generic/nsBidiFrames.h
layout/style/nsCSSRule.h
layout/style/nsICSSGroupRule.h
modules/libpref/src/init/all.js
services/sync/tests/unit/test_utils_file.js
toolkit/mozapps/update/test/unit/data/partial_in_use_win.mar
toolkit/mozapps/update/updater/updater_wince.cpp
toolkit/mozapps/update/updater/updater_wince.h
toolkit/mozapps/update/updater/updater_wince.rc
toolkit/mozapps/update/updater/updater_winmo.rc
xpcom/glue/nsGREGlue.cpp
xulrunner/app/nsRegisterGRE.h
xulrunner/app/nsRegisterGREUnix.cpp
xulrunner/app/nsRegisterGREVoid.cpp
xulrunner/app/nsRegisterGREWin.cpp
--- a/.hgtags
+++ b/.hgtags
@@ -52,8 +52,12 @@ 138f593553b66c9f815e8f57870c19d6347f7702
 0327e126ea245112c0aa7283fee154e084866fb5 bsmedberg-static-xpcom-registration-base
 0327e126ea245112c0aa7283fee154e084866fb5 bsmedberg-static-xpcom-registration-base
 2f83edbbeef0de7dd901411d270da61106c8afae bsmedberg-static-xpcom-registration-base
 138f593553b66c9f815e8f57870c19d6347f7702 UPDATE_PACKAGING_R12
 138f593553b66c9f815e8f57870c19d6347f7702 UPDATE_PACKAGING_R13
 138f593553b66c9f815e8f57870c19d6347f7702 UPDATE_PACKAGING_R11_1_MU
 e56ecd8b3a68c158025207c5fd081d043e28f5ce GECKO_2_0_BASE
 e273946b74c8d631ed86bd74ba9afe0e67b12378 GECKO_2_1_BASE
+b70744835d94e54eec97b8fd186c96da5708a506 PRE_MOBILE_MERGE
+b70744835d94e54eec97b8fd186c96da5708a506 PRE_MOBILE_MERGE_20110406
+a71bd564ebf5bf4f93d13e84114f759c263130b0 MOBILE_MERGE_DONE
+a71bd564ebf5bf4f93d13e84114f759c263130b0 MOBILE_MERGE_DONE_20110406
--- a/Makefile.in
+++ b/Makefile.in
@@ -89,22 +89,22 @@ DIST_GARBAGE = config.cache config.log c
    $(topsrcdir)/.mozconfig.mk $(topsrcdir)/.mozconfig.out
 
 ifdef WINCE
 check::
 	$(PYTHON) $(topsrcdir)/build/mobile/devicemanager-utils.py copy $(DIST)/bin
 endif
 
 default alldep all:: $(topsrcdir)/configure config.status
-	$(RM) -rf $(DIST)/sdk
-	$(RM) -rf $(DIST)/include
-	$(RM) -rf $(DIST)/private
-	$(RM) -rf $(DIST)/public
-	$(RM) -rf $(DIST)/bin/components
-	$(RM) -rf _tests
+	$(RM) -r $(DIST)/sdk
+	$(RM) -r $(DIST)/include
+	$(RM) -r $(DIST)/private
+	$(RM) -r $(DIST)/public
+	$(RM) -r $(DIST)/bin/components
+	$(RM) -r _tests
 
 $(topsrcdir)/configure: $(topsrcdir)/configure.in
 	@echo "STOP!  configure.in has changed, and your configure is out of date."
 	@echo "Please rerun autoconf and re-configure your build directory."
 	@echo "To ignore this message, touch 'configure' in the source directory,"
 	@echo "but your build might not succeed."
 	@exit 1
 
@@ -112,30 +112,30 @@ config.status: $(topsrcdir)/configure
 	@echo "STOP!  configure has changed and needs to be run in this build directory."
 	@echo "Please rerun configure."
 	@echo "To ignore this message, touch 'config.status' in the build directory,"
 	@echo "but your build might not succeed."
 	@exit 1
 
 # Build pseudo-external modules first when export is explicitly called
 export::
-	$(RM) -rf $(DIST)/sdk
+	$(RM) -r $(DIST)/sdk
 	$(MAKE) -C config export
 	$(MAKE) tier_nspr
 
 ifdef ENABLE_TESTS
 # Additional makefile targets to call automated test suites
 include $(topsrcdir)/testing/testsuite-targets.mk
 endif
 
 include $(topsrcdir)/config/rules.mk
 
 distclean::
 	cat unallmakefiles | $(XARGS) rm -f
-	rm -f unallmakefiles $(DIST_GARBAGE)
+	$(RM) unallmakefiles $(DIST_GARBAGE)
 
 ifeq ($(OS_ARCH),WINNT)
 # we want to copy PDB files on Windows
 MAKE_SYM_STORE_ARGS := -c --vcs-info
 ifdef PDBSTR_PATH
 MAKE_SYM_STORE_ARGS += -i
 endif
 DUMP_SYMS_BIN ?= $(topsrcdir)/toolkit/crashreporter/tools/win32/dump_syms_vc$(_MSC_VER).exe
@@ -171,18 +171,18 @@ export SYMBOL_INDEX_NAME = \
   $(MOZ_APP_NAME)-$(MOZ_APP_VERSION)-$(OS_TARGET)-$(BUILDID)$(EXTRA_BUILDID)-symbols.txt
 
 buildsymbols:
 ifdef MOZ_CRASHREPORTER
 ifdef USE_ELF_HACK
 	$(MAKE) -C $(MOZ_BUILD_APP)/installer elfhack
 endif
 	echo building symbol store
-	$(RM) -rf $(DIST)/crashreporter-symbols
-	$(RM) -f "$(DIST)/$(SYMBOL_ARCHIVE_BASENAME).zip"
+	$(RM) -r $(DIST)/crashreporter-symbols
+	$(RM) "$(DIST)/$(SYMBOL_ARCHIVE_BASENAME).zip"
 	$(NSINSTALL) -D $(DIST)/crashreporter-symbols
 	$(PYTHON) $(topsrcdir)/toolkit/crashreporter/tools/symbolstore.py \
 	  $(MAKE_SYM_STORE_ARGS)                                          \
 	  $(foreach dir,$(SYM_STORE_SOURCE_DIRS),-s $(dir))               \
 	  $(DUMP_SYMS_BIN)                                                \
 	  $(DIST)/crashreporter-symbols                                   \
 	  $(MAKE_SYM_STORE_PATH) >                                        \
 	  $(DIST)/crashreporter-symbols/$(SYMBOL_INDEX_NAME)
@@ -194,18 +194,18 @@ endif
 	grep "sym" $(SYMBOL_INDEX_NAME) > $(SYMBOL_INDEX_NAME).tmp && \
 	  mv $(SYMBOL_INDEX_NAME).tmp $(SYMBOL_INDEX_NAME)
 	cd $(DIST)/crashreporter-symbols && \
           zip -r9D "../$(PKG_PATH)$(SYMBOL_ARCHIVE_BASENAME).zip" . -i "*.sym" -i "*.txt"
 else
 ifdef WINCE
 ifdef SYMBOLSTORE_PATH
 	echo building symbol store with symstore.exe
-	$(RM) -rf $(DIST)/symbols
-	$(RM) -f "$(DIST)/$(SYMBOL_ARCHIVE_BASENAME).zip"
+	$(RM) -r $(DIST)/symbols
+	$(RM) "$(DIST)/$(SYMBOL_ARCHIVE_BASENAME).zip"
 	$(NSINSTALL) -D $(DIST)/symbols
 	$(SYMBOLSTORE_PATH) add -r -f "$(subst /,\,$(shell pwd -W))\*.PDB" \
 	  -s $(DIST)/symbols/ -t "$(MOZ_PKG_APPNAME)" -v "$(MOZ_PKG_VERSION)"
 	echo packing symbols
 	$(NSINSTALL) -D $(DIST)/$(PKG_PATH)
 	cd $(DIST)/symbols && \
 	  zip -r9D "../$(PKG_PATH)$(SYMBOL_ARCHIVE_BASENAME).zip" .
 endif # SYMBOLSTORE_PATH
--- 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.
--- a/accessible/src/base/NotificationController.cpp
+++ b/accessible/src/base/NotificationController.cpp
@@ -152,21 +152,22 @@ void
 NotificationController::ScheduleContentInsertion(nsAccessible* aContainer,
                                                  nsIContent* aStartChildNode,
                                                  nsIContent* aEndChildNode)
 {
   // Ignore content insertions until we constructed accessible tree.
   if (mTreeConstructedState == eTreeConstructionPending)
     return;
 
-  nsRefPtr<ContentInsertion> insertion =
-    new ContentInsertion(mDocument, aContainer, aStartChildNode, aEndChildNode);
-
-  if (insertion && mContentInsertions.AppendElement(insertion))
+  nsRefPtr<ContentInsertion> insertion = new ContentInsertion(mDocument,
+                                                              aContainer);
+  if (insertion && insertion->InitChildList(aStartChildNode, aEndChildNode) &&
+      mContentInsertions.AppendElement(insertion)) {
     ScheduleProcessing();
+  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // NotificationCollector: protected
 
 void
 NotificationController::ScheduleProcessing()
 {
@@ -676,25 +677,41 @@ NotificationController::TextEnumerator(n
   return PL_DHASH_NEXT;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // NotificationController: content inserted notification
 
 NotificationController::ContentInsertion::
-  ContentInsertion(nsDocAccessible* aDocument, nsAccessible* aContainer,
-                   nsIContent* aStartChildNode, nsIContent* aEndChildNode) :
+  ContentInsertion(nsDocAccessible* aDocument, nsAccessible* aContainer) :
   mDocument(aDocument), mContainer(aContainer)
 {
+}
+
+bool
+NotificationController::ContentInsertion::
+  InitChildList(nsIContent* aStartChildNode, nsIContent* aEndChildNode)
+{
+  bool haveToUpdate = false;
+
   nsIContent* node = aStartChildNode;
   while (node != aEndChildNode) {
-    mInsertedContent.AppendElement(node);
+    // Notification triggers for content insertion even if no content was
+    // actually inserted, check if the given content has a frame to discard
+    // this case early.
+    if (node->GetPrimaryFrame()) {
+      if (mInsertedContent.AppendElement(node))
+        haveToUpdate = true;
+    }
+
     node = node->GetNextSibling();
   }
+
+  return haveToUpdate;
 }
 
 NS_IMPL_CYCLE_COLLECTION_CLASS(NotificationController::ContentInsertion)
 
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_NATIVE(NotificationController::ContentInsertion)
   NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mContainer)
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
--- a/accessible/src/base/NotificationController.h
+++ b/accessible/src/base/NotificationController.h
@@ -316,23 +316,23 @@ private:
   nsTArray<nsRefPtr<nsDocAccessible> > mHangingChildDocuments;
 
   /**
    * Storage for content inserted notification information.
    */
   class ContentInsertion
   {
   public:
-    ContentInsertion(nsDocAccessible* aDocument, nsAccessible* aContainer,
-                     nsIContent* aStartChildNode, nsIContent* aEndChildNode);
+    ContentInsertion(nsDocAccessible* aDocument, nsAccessible* aContainer);
     virtual ~ContentInsertion() { mDocument = nsnull; }
 
     NS_INLINE_DECL_REFCOUNTING(ContentInsertion)
     NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(ContentInsertion)
 
+    bool InitChildList(nsIContent* aStartChildNode, nsIContent* aEndChildNode);
     void Process();
 
   private:
     ContentInsertion();
     ContentInsertion(const ContentInsertion&);
     ContentInsertion& operator = (const ContentInsertion&);
 
     // The document used to process content insertion, matched to document of
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/nsAccTreeWalker.cpp
+++ b/accessible/src/base/nsAccTreeWalker.cpp
@@ -61,18 +61,18 @@ struct WalkState
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsAccTreeWalker
 ////////////////////////////////////////////////////////////////////////////////
 
 nsAccTreeWalker::
   nsAccTreeWalker(nsIWeakReference* aShell, nsIContent* aContent,
-                  PRBool aWalkAnonContent) :
-  mWeakShell(aShell), mState(nsnull)
+                  PRBool aWalkAnonContent, bool aWalkCache) :
+  mWeakShell(aShell), mState(nsnull), mWalkCache(aWalkCache)
 {
   NS_ASSERTION(aContent, "No node for the accessible tree walker!");
 
   if (aContent)
     mState = new WalkState(aContent);
 
   mChildFilter = aWalkAnonContent ? nsIContent::eAllChildren :
                                   nsIContent::eAllButXBL;
@@ -109,17 +109,18 @@ nsAccTreeWalker::NextChildInternal(bool 
   if (mState->childList)
     mState->childList->GetLength(&length);
 
   while (mState->childIdx < length) {
     nsIContent* childNode = mState->childList->GetNodeAt(mState->childIdx);
     mState->childIdx++;
 
     bool isSubtreeHidden = false;
-    nsAccessible* accessible =
+    nsAccessible* accessible = mWalkCache ?
+      GetAccService()->GetAccessibleInWeakShell(childNode, mWeakShell) :
       GetAccService()->GetOrCreateAccessible(childNode, presShell, mWeakShell,
                                              &isSubtreeHidden);
 
     if (accessible)
       return accessible;
 
     // Walk down into subtree to find accessibles.
     if (!isSubtreeHidden) {
--- a/accessible/src/base/nsAccTreeWalker.h
+++ b/accessible/src/base/nsAccTreeWalker.h
@@ -49,17 +49,17 @@ struct WalkState;
 
 /**
  * This class is used to walk the DOM tree to create accessible tree.
  */
 class nsAccTreeWalker
 {
 public:
   nsAccTreeWalker(nsIWeakReference *aShell, nsIContent *aNode, 
-                  PRBool aWalkAnonymousContent);
+                  PRBool aWalkAnonymousContent, bool aWalkCache = false);
   virtual ~nsAccTreeWalker();
 
   /**
    * Return the next child accessible.
    *
    * @note Returned accessible is bound to the document, if the accessible is
    *       rejected during tree creation then the caller should be unbind it
    *       from the document.
@@ -90,12 +90,13 @@ private:
 
   /**
    * Pop state from stack.
    */
   void PopState();
 
   nsCOMPtr<nsIWeakReference> mWeakShell;
   PRInt32 mChildFilter;
+  bool mWalkCache;
   WalkState* mState;
 };
 
 #endif 
--- 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/nsAccessNode.cpp
+++ b/accessible/src/base/nsAccessNode.cpp
@@ -96,19 +96,18 @@ nsApplicationAccessible *nsAccessNode::g
 NS_IMPL_CYCLE_COLLECTION_0(nsAccessNode)
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsAccessNode)
   NS_INTERFACE_MAP_ENTRY(nsIAccessNode)
   NS_INTERFACE_MAP_ENTRY(nsAccessNode)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIAccessNode)
 NS_INTERFACE_MAP_END
  
-NS_IMPL_CYCLE_COLLECTING_ADDREF_AMBIGUOUS(nsAccessNode, nsIAccessNode)
-NS_IMPL_CYCLE_COLLECTING_RELEASE_FULL(nsAccessNode, nsIAccessNode,
-                                      LastRelease())
+NS_IMPL_CYCLE_COLLECTING_ADDREF(nsAccessNode)
+NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_DESTROY(nsAccessNode, LastRelease())
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsAccessNode construction/desctruction
 
 nsAccessNode::
   nsAccessNode(nsIContent *aContent, nsIWeakReference *aShell) :
   mContent(aContent), mWeakShell(aShell)
 {
--- 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"
@@ -469,45 +470,54 @@ nsAccessible::GetPreviousSibling(nsIAcce
 
   /* readonly attribute nsIAccessible firstChild; */
 NS_IMETHODIMP
 nsAccessible::GetFirstChild(nsIAccessible **aFirstChild) 
 {
   NS_ENSURE_ARG_POINTER(aFirstChild);
   *aFirstChild = nsnull;
 
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
   PRInt32 childCount = GetChildCount();
   NS_ENSURE_TRUE(childCount != -1, NS_ERROR_FAILURE);
 
   if (childCount > 0)
     NS_ADDREF(*aFirstChild = GetChildAt(0));
 
   return NS_OK;
 }
 
   /* readonly attribute nsIAccessible lastChild; */
 NS_IMETHODIMP
 nsAccessible::GetLastChild(nsIAccessible **aLastChild)
 {
   NS_ENSURE_ARG_POINTER(aLastChild);
   *aLastChild = nsnull;
 
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
   PRInt32 childCount = GetChildCount();
   NS_ENSURE_TRUE(childCount != -1, NS_ERROR_FAILURE);
 
   NS_IF_ADDREF(*aLastChild = GetChildAt(childCount - 1));
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsAccessible::GetChildAt(PRInt32 aChildIndex, nsIAccessible **aChild)
 {
   NS_ENSURE_ARG_POINTER(aChild);
   *aChild = nsnull;
 
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
   PRInt32 childCount = GetChildCount();
   NS_ENSURE_TRUE(childCount != -1, NS_ERROR_FAILURE);
 
   // If child index is negative, then return last child.
   // XXX: do we really need this?
   if (aChildIndex < 0)
     aChildIndex = childCount - 1;
 
@@ -521,16 +531,19 @@ nsAccessible::GetChildAt(PRInt32 aChildI
 
 // readonly attribute nsIArray children;
 NS_IMETHODIMP
 nsAccessible::GetChildren(nsIArray **aOutChildren)
 {
   NS_ENSURE_ARG_POINTER(aOutChildren);
   *aOutChildren = nsnull;
 
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
   PRInt32 childCount = GetChildCount();
   NS_ENSURE_TRUE(childCount != -1, NS_ERROR_FAILURE);
 
   nsresult rv = NS_OK;
   nsCOMPtr<nsIMutableArray> children =
     do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
   NS_ENSURE_SUCCESS(rv, rv);
 
@@ -550,16 +563,19 @@ nsAccessible::GetAllowsAnonChildAccessib
 }
 
 /* readonly attribute long childCount; */
 NS_IMETHODIMP
 nsAccessible::GetChildCount(PRInt32 *aChildCount) 
 {
   NS_ENSURE_ARG_POINTER(aChildCount);
 
+  if (IsDefunct())
+    return NS_ERROR_FAILURE;
+
   *aChildCount = GetChildCount();
   return *aChildCount != -1 ? NS_OK : NS_ERROR_FAILURE;  
 }
 
 /* readonly attribute long indexInParent; */
 NS_IMETHODIMP
 nsAccessible::GetIndexInParent(PRInt32 *aIndexInParent)
 {
@@ -592,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) 
@@ -670,85 +687,74 @@ 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;
-
+  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) {
@@ -823,17 +829,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;
       }
     }
 
@@ -1033,18 +1039,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) {
@@ -1062,18 +1067,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);
   }
@@ -1311,17 +1315,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);
 
@@ -1477,17 +1481,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;
   }
@@ -1504,176 +1508,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()
+{
+  if (IsDefunct())
+    return states::DEFUNCT;
+
+  PRUint64 state = NativeState();
   // 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)
 {
@@ -1742,20 +1746,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)
@@ -1859,17 +1862,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); */
@@ -1879,43 +1882,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;
@@ -1924,17 +1927,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;
 }
@@ -1956,17 +1959,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 (); */
@@ -2782,20 +2785,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");
@@ -2807,88 +2810,75 @@ nsAccessible::RemoveChild(nsAccessible* 
   mEmbeddedObjCollector = nsnull;
 
   return PR_TRUE;
 }
 
 nsAccessible*
 nsAccessible::GetChildAt(PRUint32 aIndex)
 {
-  if (EnsureChildren())
-    return nsnull;
-
   nsAccessible *child = mChildren.SafeElementAt(aIndex, nsnull);
   if (!child)
     return nsnull;
 
 #ifdef DEBUG
   nsAccessible* realParent = child->mParent;
   NS_ASSERTION(!realParent || realParent == this,
                "Two accessibles have the same first child accessible!");
 #endif
 
   return child;
 }
 
 PRInt32
 nsAccessible::GetChildCount()
 {
-  return EnsureChildren() ? -1 : mChildren.Length();
+  return mChildren.Length();
 }
 
 PRInt32
 nsAccessible::GetIndexOf(nsAccessible* aChild)
 {
-  return EnsureChildren() || (aChild->mParent != this) ?
-    -1 : aChild->GetIndexInParent();
+  return (aChild->mParent != this) ? -1 : aChild->GetIndexInParent();
 }
 
 PRInt32
 nsAccessible::GetIndexInParent() const
 {
   return mIndexInParent;
 }
 
 PRInt32
 nsAccessible::GetEmbeddedChildCount()
 {
-  if (EnsureChildren())
-    return -1;
-
   if (IsChildrenFlag(eMixedChildren)) {
     if (!mEmbeddedObjCollector)
       mEmbeddedObjCollector = new EmbeddedObjCollector(this);
     return mEmbeddedObjCollector ? mEmbeddedObjCollector->Count() : -1;
   }
 
   return GetChildCount();
 }
 
 nsAccessible*
 nsAccessible::GetEmbeddedChildAt(PRUint32 aIndex)
 {
-  if (EnsureChildren())
-    return nsnull;
-
   if (IsChildrenFlag(eMixedChildren)) {
     if (!mEmbeddedObjCollector)
       mEmbeddedObjCollector = new EmbeddedObjCollector(this);
     return mEmbeddedObjCollector ?
       mEmbeddedObjCollector->GetAccessibleAt(aIndex) : nsnull;
   }
 
   return GetChildAt(aIndex);
 }
 
 PRInt32
 nsAccessible::GetIndexOfEmbeddedChild(nsAccessible* aChild)
 {
-  if (EnsureChildren())
-    return -1;
-
   if (IsChildrenFlag(eMixedChildren)) {
     if (!mEmbeddedObjCollector)
       mEmbeddedObjCollector = new EmbeddedObjCollector(this);
     return mEmbeddedObjCollector ?
       mEmbeddedObjCollector->GetIndexAt(aChild) : -1;
   }
 
   return GetIndexOf(aChild);
@@ -2923,18 +2913,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()
@@ -3047,17 +3036,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;
@@ -3314,19 +3303,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 IsDefunct() ? states::DEFUNCT : 0;
 }
 
 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 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,71 @@ 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 (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 +372,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 +889,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 +970,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 +1006,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 +1069,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 +1122,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 +1202,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)
 {
 }
@@ -1422,36 +1387,36 @@ void
 nsDocAccessible::ContentRemoved(nsIContent* aContainerNode,
                                 nsIContent* aChildNode)
 {
   // Update the whole tree of this document accessible when the container is
   // null (document element is removed).
   nsAccessible* container = aContainerNode ?
     GetAccessibleOrContainer(aContainerNode) : this;
 
-  UpdateTree(container, aChildNode, PR_FALSE);
+  UpdateTree(container, aChildNode, false);
 }
 
 void
 nsDocAccessible::RecreateAccessible(nsIContent* aContent)
 {
   // XXX: we shouldn't recreate whole accessible subtree, instead we should
   // subclass hide and show events to handle them separately and implement their
   // coalescence with normal hide and show events. Note, in this case they
   // should be coalesced with normal show/hide events.
 
   // Check if the node is in DOM still.
   nsIContent* parentContent = aContent->GetParent();
   if (parentContent && parentContent->IsInDoc()) {
     nsAccessible* container = GetAccessibleOrContainer(parentContent);
 
     // Remove and reinsert.
-    UpdateTree(container, aContent, PR_FALSE);
+    UpdateTree(container, aContent, false);
     container->UpdateChildren();
-    UpdateTree(container, aContent, PR_TRUE);
+    UpdateTree(container, aContent, true);
   }
 }
 
 void
 nsDocAccessible::NotifyOfCachingStart(nsAccessible* aAccessible)
 {
   if (!mCacheRoot)
     mCacheRoot = aAccessible;
@@ -1463,25 +1428,30 @@ nsDocAccessible::NotifyOfCachingEnd(nsAc
   if (mCacheRoot == aAccessible && !mIsPostCacheProcessing) {
     // Allow invalidation list insertions while container children are recached.
     mIsPostCacheProcessing = PR_TRUE;
 
     // Invalidate children of container accessible for each element in
     // invalidation list.
     for (PRUint32 idx = 0; idx < mInvalidationList.Length(); idx++) {
       nsIContent* content = mInvalidationList[idx];
-      if (!HasAccessible(content)) {
-        // Make sure we keep children updated. While we're inside of caching
-        // loop then we must exist it with cached children.
+      nsAccessible* accessible = GetAccessible(content);
+      if (!accessible) {
         nsAccessible* container = GetContainerAccessible(content);
         NS_ASSERTION(container,
                      "Got a referenced element that is not in document!");
-        if (container)
+        if (container) {
           container->UpdateChildren();
+          accessible = GetAccessible(content);
+        }
       }
+
+      // Make sure the subtree is created.
+      if (accessible)
+        CacheChildrenInSubtree(accessible);
     }
     mInvalidationList.Clear();
 
     mCacheRoot = nsnull;
     mIsPostCacheProcessing = PR_FALSE;
   }
 }
 
@@ -1792,26 +1762,38 @@ nsDocAccessible::ProcessContentInserted(
   // double processing, however generated events are coalesced and we don't
   // harm an AT.
   // Theoretically the element might be not in tree at all at this point what
   // means there's no container.
   for (PRUint32 idx = 0; idx < aInsertedContent->Length(); idx++) {
     nsAccessible* directContainer =
       GetContainerAccessible(aInsertedContent->ElementAt(idx));
     if (directContainer)
-      UpdateTree(directContainer, aInsertedContent->ElementAt(idx), PR_TRUE);
+      UpdateTree(directContainer, aInsertedContent->ElementAt(idx), true);
   }
 }
 
 void
 nsDocAccessible::UpdateTree(nsAccessible* aContainer, nsIContent* aChildNode,
-                            PRBool aIsInsert)
+                            bool aIsInsert)
 {
-  PRUint32 updateFlags =
-    UpdateTreeInternal(aChildNode, aChildNode->GetNextSibling(), aIsInsert);
+  PRUint32 updateFlags = eNoAccessible;
+
+  // If child node is not accessible then look for its accessible children.
+  nsAccessible* child = GetAccessible(aChildNode);
+  if (child) {
+    updateFlags |= UpdateTreeInternal(child, aIsInsert);
+
+  } else {
+    nsAccTreeWalker walker(mWeakShell, aChildNode,
+                           aContainer->GetAllowsAnonChildAccessibles(), true);
+
+    while ((child = walker.NextChild()))
+      updateFlags |= UpdateTreeInternal(child, aIsInsert);
+  }
 
   // Content insertion/removal is not cause of accessible tree change.
   if (updateFlags == eNoAccessible)
     return;
 
   // Check to see if change occurred inside an alert, and fire an EVENT_ALERT
   // if it did.
   if (aIsInsert && !(updateFlags & eAlertAccessible)) {
@@ -1844,107 +1826,87 @@ nsDocAccessible::UpdateTree(nsAccessible
   nsRefPtr<AccEvent> reorderEvent =
     new AccEvent(nsIAccessibleEvent::EVENT_REORDER, aContainer->GetNode(),
                  eAutoDetect, AccEvent::eCoalesceFromSameSubtree);
   if (reorderEvent)
     FireDelayedAccessibleEvent(reorderEvent);
 }
 
 PRUint32
-nsDocAccessible::UpdateTreeInternal(nsIContent* aStartNode,
-                                    nsIContent* aEndNode,
-                                    PRBool aIsInsert)
+nsDocAccessible::UpdateTreeInternal(nsAccessible* aChild, bool aIsInsert)
 {
-  PRUint32 updateFlags = eNoAccessible;
-  for (nsIContent* node = aStartNode; node != aEndNode;
-       node = node->GetNextSibling()) {
+  PRUint32 updateFlags = eAccessible;
+
+  nsINode* node = aChild->GetNode();
+  if (aIsInsert) {
+    // Create accessible tree for shown accessible.
+    CacheChildrenInSubtree(aChild);
+
+  } else {
+    // Fire menupopup end event before hide event if a menu goes away.
+
+    // XXX: We don't look into children of hidden subtree to find hiding
+    // menupopup (as we did prior bug 570275) because we don't do that when
+    // menu is showing (and that's impossible until bug 606924 is fixed).
+    // Nevertheless we should do this at least because layout coalesces
+    // the changes before our processing and we may miss some menupopup
+    // events. Now we just want to be consistent in content insertion/removal
+    // handling.
+    if (aChild->ARIARole() == nsIAccessibleRole::ROLE_MENUPOPUP) {
+      nsRefPtr<AccEvent> event =
+        new AccEvent(nsIAccessibleEvent::EVENT_MENUPOPUP_END, aChild);
 
-    // Tree update triggers for content insertion even if no content was
-    // inserted actually, check if the given content has a frame to discard
-    // this case early.
-    if (aIsInsert && !node->GetPrimaryFrame())
-      continue;
+      if (event)
+        FireDelayedAccessibleEvent(event);
+    }
+  }
+
+  // Fire show/hide event.
+  nsRefPtr<AccEvent> event;
+  if (aIsInsert)
+    event = new AccShowEvent(aChild, node);
+  else
+    event = new AccHideEvent(aChild, node);
 
-    nsAccessible* accessible = GetAccessible(node);
+  if (event)
+    FireDelayedAccessibleEvent(event);
 
-    if (!accessible) {
-      updateFlags |= UpdateTreeInternal(node->GetFirstChild(), nsnull,
-                                        aIsInsert);
-      continue;
+  if (aIsInsert) {
+    PRUint32 ariaRole = aChild->ARIARole();
+    if (ariaRole == nsIAccessibleRole::ROLE_MENUPOPUP) {
+      // Fire EVENT_MENUPOPUP_START if ARIA menu appears.
+      FireDelayedAccessibleEvent(nsIAccessibleEvent::EVENT_MENUPOPUP_START,
+                                 node, AccEvent::eRemoveDupes);
+
+    } else if (ariaRole == nsIAccessibleRole::ROLE_ALERT) {
+      // Fire EVENT_ALERT if ARIA alert appears.
+      updateFlags = eAlertAccessible;
+      FireDelayedAccessibleEvent(nsIAccessibleEvent::EVENT_ALERT, node,
+                                 AccEvent::eRemoveDupes);
     }
 
-    updateFlags |= eAccessible;
-
-    if (aIsInsert) {
-      // Create accessible tree for shown accessible.
-      CacheChildrenInSubtree(accessible);
-
-    } else {
-      // Fire menupopup end event before hide event if a menu goes away.
-
-      // XXX: We don't look into children of hidden subtree to find hiding
-      // menupopup (as we did prior bug 570275) because we don't do that when
-      // menu is showing (and that's impossible until bug 606924 is fixed).
-      // Nevertheless we should do this at least because layout coalesces
-      // the changes before our processing and we may miss some menupopup
-      // events. Now we just want to be consistent in content insertion/removal
-      // handling.
-      if (accessible->ARIARole() == nsIAccessibleRole::ROLE_MENUPOPUP) {
-        nsRefPtr<AccEvent> event =
-          new AccEvent(nsIAccessibleEvent::EVENT_MENUPOPUP_END, accessible);
-
-        if (event)
-          FireDelayedAccessibleEvent(event);
-      }
+    // If focused node has been shown then it means its frame was recreated
+    // while it's focused. Fire focus event on new focused accessible. If
+    // the queue contains focus event for this node then it's suppressed by
+    // this one.
+    if (node == gLastFocusedNode) {
+      FireDelayedAccessibleEvent(nsIAccessibleEvent::EVENT_FOCUS,
+                                 node, AccEvent::eCoalesceFromSameDocument);
     }
-
-    // Fire show/hide event.
-    nsRefPtr<AccEvent> event;
-    if (aIsInsert)
-      event = new AccShowEvent(accessible, node);
-    else
-      event = new AccHideEvent(accessible, node);
-
-    if (event)
-      FireDelayedAccessibleEvent(event);
+  } else {
+    // Update the tree for content removal.
+    // The accessible parent may differ from container accessible if
+    // the parent doesn't have own DOM node like list accessible for HTML
+    // selects.
+    nsAccessible* parent = aChild->GetParent();
+    NS_ASSERTION(parent, "No accessible parent?!");
+    if (parent)
+      parent->RemoveChild(aChild);
 
-    if (aIsInsert) {
-      PRUint32 ariaRole = accessible->ARIARole();
-      if (ariaRole == nsIAccessibleRole::ROLE_MENUPOPUP) {
-        // Fire EVENT_MENUPOPUP_START if ARIA menu appears.
-        FireDelayedAccessibleEvent(nsIAccessibleEvent::EVENT_MENUPOPUP_START,
-                                   node, AccEvent::eRemoveDupes);
-
-      } else if (ariaRole == nsIAccessibleRole::ROLE_ALERT) {
-        // Fire EVENT_ALERT if ARIA alert appears.
-        updateFlags = eAlertAccessible;
-        FireDelayedAccessibleEvent(nsIAccessibleEvent::EVENT_ALERT, node,
-                                   AccEvent::eRemoveDupes);
-      }
-
-      // If focused node has been shown then it means its frame was recreated
-      // while it's focused. Fire focus event on new focused accessible. If
-      // the queue contains focus event for this node then it's suppressed by
-      // this one.
-      if (node == gLastFocusedNode) {
-        FireDelayedAccessibleEvent(nsIAccessibleEvent::EVENT_FOCUS,
-                                   node, AccEvent::eCoalesceFromSameDocument);
-      }
-    } else {
-      // Update the tree for content removal.
-      // The accessible parent may differ from container accessible if
-      // the parent doesn't have own DOM node like list accessible for HTML
-      // selects.
-      nsAccessible* parent = accessible->GetParent();
-      NS_ASSERTION(parent, "No accessible parent?!");
-      if (parent)
-        parent->RemoveChild(accessible);
-
-      UncacheChildrenInSubtree(accessible);
-    }
+    UncacheChildrenInSubtree(aChild);
   }
 
   return updateFlags;
 }
 
 void
 nsDocAccessible::CacheChildrenInSubtree(nsAccessible* aRoot)
 {
--- 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
@@ -438,31 +438,29 @@ protected:
    */
   void ProcessContentInserted(nsAccessible* aContainer,
                               const nsTArray<nsCOMPtr<nsIContent> >* aInsertedContent);
 
   /**
    * Update the accessible tree for content insertion or removal.
    */
   void UpdateTree(nsAccessible* aContainer, nsIContent* aChildNode,
-                  PRBool aIsInsert);
+                  bool aIsInsert);
 
   /**
    * Helper for UpdateTree() method. Go down to DOM subtree and updates
    * accessible tree. Return one of these flags.
    */
   enum EUpdateTreeFlags {
     eNoAccessible = 0,
     eAccessible = 1,
     eAlertAccessible = 2
   };
 
-  PRUint32 UpdateTreeInternal(nsIContent* aStartNode,
-                              nsIContent* aEndNode,
-                              PRBool aIsInsert);
+  PRUint32 UpdateTreeInternal(nsAccessible* aChild, bool aIsInsert);
 
   /**
    * Create accessible tree.
    */
   void CacheChildrenInSubtree(nsAccessible* aRoot);
 
   /**
    * Remove accessibles in subtree from node to accessible map.
@@ -498,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,86 +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) &&
-      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;
-  } else if (gIsFormFillEnabled && htmlInput &&
-             !(*aState & nsIAccessibleStates::STATE_PROTECTED)) {
+                                         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.
+       state |= states::SUPPORTS_AUTOCOMPLETION;
+     }
+  } 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);
@@ -518,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;;
 }
 
@@ -543,17 +521,17 @@ NS_IMETHODIMP nsHTMLTextFieldAccessible:
     return NS_OK;
   }
   return NS_ERROR_INVALID_ARG;
 }
 
 NS_IMETHODIMP nsHTMLTextFieldAccessible::DoAction(PRUint8 index)
 {
   if (index == 0) {
-    nsCOMPtr<nsIDOMNSHTMLElement> element(do_QueryInterface(mContent));
+    nsCOMPtr<nsIDOMHTMLElement> element(do_QueryInterface(mContent));
     if ( element ) {
       return element->Focus();
     }
     return NS_ERROR_FAILURE;
   }
   return NS_ERROR_INVALID_ARG;
 }
 
--- 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 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);
@@ -2207,17 +2204,16 @@ nsHyperTextAccessible::GetChildOffset(PR
       mOffsets.RemoveElementsAt(aChildIndex, count);
 
     return mOffsets[aChildIndex - 1];
   }
 
   PRUint32 lastOffset = mOffsets.IsEmpty() ?
     0 : mOffsets[mOffsets.Length() - 1];
 
-  EnsureChildren();
   while (mOffsets.Length() < aChildIndex) {
     nsAccessible* child = mChildren[mOffsets.Length()];
     lastOffset += nsAccUtils::TextLength(child);
     mOffsets.AppendElement(lastOffset);
   }
 
   return mOffsets[aChildIndex - 1];
 }
--- 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 (mGeckoAccessible->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
@@ -40,16 +40,17 @@
  * see http://lxr.mozilla.org/seamonkey/source/accessible/accessible-docs.html
  */
 
 #ifndef _nsAccessibleWrap_H_
 #define _nsAccessibleWrap_H_
 
 #include "nsAccessible.h"
 #include "nsAccUtils.h"
+#include "States.h"
 
 #include "nsCOMPtr.h"
 #include "nsRect.h"
 
 #include "nsTArray.h"
 #include "nsAutoPtr.h"
 
 struct AccessibleWrapper;
@@ -79,19 +80,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,22 @@ 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;
-
-  return rv;
+  return mHwnd ? nsAccessibleWrap::NativeState() : 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/msaa/nsTextAccessibleWrap.cpp
+++ b/accessible/src/msaa/nsTextAccessibleWrap.cpp
@@ -38,23 +38,25 @@
 
 // NOTE: alphabetically ordered
 #include "nsTextAccessibleWrap.h"
 #include "ISimpleDOMText_i.c"
 
 #include "nsCoreUtils.h"
 #include "nsDocAccessible.h"
 
-#include "nsIFontMetrics.h"
+#include "nsIThebesFontMetrics.h"
 #include "nsIFrame.h"
 #include "nsPresContext.h"
 #include "nsIPresShell.h"
 #include "nsIRenderingContext.h"
 #include "nsIComponentManager.h"
 
+#include "gfxFont.h"
+
 ////////////////////////////////////////////////////////////////////////////////
 // nsTextAccessibleWrap Accessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsTextAccessibleWrap::
   nsTextAccessibleWrap(nsIContent *aContent, nsIWeakReference *aShell) :
   nsTextAccessible(aContent, aShell)
 {
@@ -248,53 +250,35 @@ nsresult nsTextAccessibleWrap::GetCharac
 }
 
 STDMETHODIMP nsTextAccessibleWrap::get_fontFamily(
     /* [retval][out] */ BSTR __RPC_FAR *aFontFamily)
 {
 __try {
   *aFontFamily = NULL;
 
-  nsIFrame *frame = GetFrame();
-  nsCOMPtr<nsIPresShell> presShell = GetPresShell();
-  if (!frame || !presShell || !presShell->GetPresContext()) {
-    return E_FAIL;
-  }
-
-  nsCOMPtr<nsIRenderingContext> rc = presShell->GetReferenceRenderingContext();
-  if (!rc) {
-    return E_FAIL;
-  }
-
-  const nsStyleFont *font = frame->GetStyleFont();
-
-  const nsStyleVisibility *visibility = frame->GetStyleVisibility();
-
-  if (NS_FAILED(rc->SetFont(font->mFont, visibility->mLanguage,
-                            presShell->GetPresContext()->GetUserFontSet()))) {
-    return E_FAIL;
-  }
-
-  nsCOMPtr<nsIDeviceContext> deviceContext;
-  rc->GetDeviceContext(*getter_AddRefs(deviceContext));
-  if (!deviceContext) {
+  nsIFrame* frame = GetFrame();
+  if (!frame) {
     return E_FAIL;
   }
 
   nsCOMPtr<nsIFontMetrics> fm;
-  rc->GetFontMetrics(*getter_AddRefs(fm));
-  if (!fm) {
-    return E_FAIL;
-  }
+  frame->PresContext()->DeviceContext()->
+    GetMetricsFor(frame->GetStyleFont()->mFont,
+                  frame->GetStyleVisibility()->mLanguage,
+                  frame->PresContext()->GetUserFontSet(),
+                  *getter_AddRefs(fm));
 
-  nsAutoString fontFamily;
-  deviceContext->FirstExistingFont(fm->Font(), fontFamily);
-  if (fontFamily.IsEmpty())
+  nsCOMPtr<nsIThebesFontMetrics> tfm = do_QueryInterface(fm);
+  const nsString& name = tfm->GetThebesFontGroup()->GetFontAt(0)->GetName();
+
+  if (name.IsEmpty())
     return S_FALSE;
 
-  *aFontFamily = ::SysAllocStringLen(fontFamily.get(), fontFamily.Length());
+  *aFontFamily = ::SysAllocStringLen(name.get(), name.Length());
   if (!*aFontFamily)
     return E_OUTOFMEMORY;
 
-} __except(FilterA11yExceptions(::GetExceptionCode(), GetExceptionInformation())) { }
+} __except(FilterA11yExceptions(::GetExceptionCode(),
+                                GetExceptionInformation())) { }
 
   return S_OK;
 }
--- 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,54 @@ 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;
-
-    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 +249,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 +409,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 +463,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,25 @@ 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;
-
   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 +137,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,20 @@ 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 (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 +358,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 +382,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 +617,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 +672,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 +803,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 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsXULTextFieldAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsXULTextFieldAccessible::
  nsXULTextFieldAccessible(nsIContent *aContent, nsIWeakReference *aShell) :
@@ -871,105 +826,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.
-  nsHTMLTextFieldAccessible* tempAccessible =
+  // 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;
-  nsCOMPtr<nsIAccessible> kungFuDeathGrip = tempAccessible;
-  rv = tempAccessible->GetStateInternal(aState, nsnull);
-  NS_ENSURE_SUCCESS(rv, rv);
+    return state;
+
+  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;
-    }
-  }
-  else {
-    // <xul:textbox>
-    if (mContent->AttrValueIs(kNameSpaceID_None, nsAccessibilityAtoms::type,
-                              nsAccessibilityAtoms::password, eIgnoreCase)) {
-      *aState |= nsIAccessibleStates::STATE_PROTECTED;
-    }
-    if (mContent->AttrValueIs(kNameSpaceID_None, nsAccessibilityAtoms::readonly,
-                              nsAccessibilityAtoms::_true, eIgnoreCase)) {
-      *aState |= nsIAccessibleStates::STATE_READONLY;
+      state |= states::READONLY;
     }
   }
 
-  if (!aExtraState)
-    return NS_OK;
-
-  PRBool isMultiLine = mContent->HasAttr(kNameSpaceID_None,
-                                         nsAccessibilityAtoms::multiline);
-
-  if (isMultiLine) {
-    *aExtraState |= nsIAccessibleStates::EXT_STATE_MULTI_LINE;
-  }
-  else {
-    *aExtraState |= nsIAccessibleStates::EXT_STATE_SINGLE_LINE;
-  }
-
-  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 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 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,48 @@ 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);
-  }
-
-  *aState = 0;
+  if (mIsCheckbox)
+    return nsXULMenuitemAccessible::NativeState();
 
-  if (IsDefunct()) {
-    if (aExtraState)
-      *aExtraState = nsIAccessibleStates::EXT_STATE_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,58 @@ 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;
-  }
-
   // 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_EXP