--- a/accessible/src/atk/nsAccessibleWrap.cpp
+++ b/accessible/src/atk/nsAccessibleWrap.cpp
@@ -716,17 +716,17 @@ getDescriptionCB(AtkObject *aAtkObj)
 
 AtkRole
 getRoleCB(AtkObject *aAtkObj)
 {
   nsAccessibleWrap* accWrap = GetAccessibleWrap(aAtkObj);
   if (!accWrap)
     return ATK_ROLE_INVALID;
 
-#ifdef DEBUG_A11Y
+#ifdef DEBUG
   NS_ASSERTION(nsAccUtils::IsTextInterfaceSupportCorrect(accWrap),
       "Does not support nsIAccessibleText when it should");
 #endif
 
   if (aAtkObj->role != ATK_ROLE_INVALID)
     return aAtkObj->role;
 
 #define ROLE(geckoRole, stringRole, atkRole, macRole, msaaRole, ia2Role) \

--- a/accessible/src/base/Relation.h
+++ b/accessible/src/base/Relation.h
@@ -69,19 +69,19 @@ public:
     mFirstIter(aRelation.mFirstIter), mLastIter(aRelation.mLastIter) { }
 
   Relation(AccIterable* aIter) : mFirstIter(aIter), mLastIter(aIter) { }
 
   Relation(nsAccessible* aAcc) :
     mFirstIter(nsnull), mLastIter(nsnull)
     { AppendTarget(aAcc); }
 
-  Relation(nsIContent* aContent) :
+  Relation(nsDocAccessible* aDocument, nsIContent* aContent) :
     mFirstIter(nsnull), mLastIter(nsnull)
-    { AppendTarget(aContent); }
+    { AppendTarget(aDocument, aContent); }
 
   Relation& operator = (const RelationCopyHelper& aRH)
   {
     mFirstIter = aRH.mFirstIter;
     mLastIter = aRH.mLastIter;
     return *this;
   }
 
@@ -115,20 +115,20 @@ public:
     if (aAcc)
       AppendIter(new SingleAccIterator(aAcc));
   }
 
   /**
    * Append the one accessible for this content node to the set of related
    * accessibles.
    */
-  inline void AppendTarget(nsIContent* aContent)
+  void AppendTarget(nsDocAccessible* aDocument, nsIContent* aContent)
   {
     if (aContent)
-      AppendTarget(GetAccService()->GetAccessible(aContent, nsnull));
+      AppendTarget(aDocument->GetAccessible(aContent));
   }
 
   /**
    * compute and return the next related accessible.
    */
   inline nsAccessible* Next()
   {
     nsAccessible* target = nsnull;

--- a/accessible/src/base/nsAccUtils.cpp
+++ b/accessible/src/base/nsAccUtils.cpp
@@ -438,44 +438,44 @@ nsAccUtils::GetLiveAttrValue(PRUint32 aR
     case ePoliteLiveAttr:
       aValue = NS_LITERAL_STRING("polite");
       return true;
   }
 
   return false;
 }
 
-#ifdef DEBUG_A11Y
+#ifdef DEBUG
 
 bool
-nsAccUtils::IsTextInterfaceSupportCorrect(nsAccessible *aAccessible)
+nsAccUtils::IsTextInterfaceSupportCorrect(nsAccessible* aAccessible)
 {
   // Don't test for accessible docs, it makes us create accessibles too
   // early and fire mutation events before we need to
   if (aAccessible->IsDoc())
     return true;
 
   bool foundText = false;
   PRInt32 childCount = aAccessible->GetChildCount();
-  for (PRint32 childIdx = 0; childIdx < childCount; childIdx++) {
-    nsAccessible *child = GetChildAt(childIdx);
+  for (PRInt32 childIdx = 0; childIdx < childCount; childIdx++) {
+    nsAccessible* child = aAccessible->GetChildAt(childIdx);
     if (IsText(child)) {
       foundText = true;
       break;
     }
   }
 
   if (foundText) {
     // found text child node
     nsCOMPtr<nsIAccessibleText> text = do_QueryObject(aAccessible);
     if (!text)
       return false;
   }
 
-  return true; 
+  return true;
 }
 #endif
 
 PRUint32
 nsAccUtils::TextLength(nsAccessible *aAccessible)
 {
   if (!IsText(aAccessible))
     return 1;

--- a/accessible/src/base/nsAccUtils.h
+++ b/accessible/src/base/nsAccUtils.h
@@ -265,17 +265,17 @@ public:
    *
    * @param  aRule   [in] rule constant (see ELiveAttrRule in nsAccMap.h)
    * @param  aValue  [out] object attribute value
    *
    * @return         true if object attribute should be exposed
    */
   static bool GetLiveAttrValue(PRUint32 aRule, nsAString& aValue);
 
-#ifdef DEBUG_A11Y
+#ifdef DEBUG
   /**
    * Detect whether the given accessible object implements nsIAccessibleText,
    * when it is text or has text child node.
    */
   static bool IsTextInterfaceSupportCorrect(nsAccessible *aAccessible);
 #endif
 
   /**

--- a/accessible/src/base/nsAccessNode.cpp
+++ b/accessible/src/base/nsAccessNode.cpp
@@ -44,36 +44,31 @@
 #include "nsCoreUtils.h"
 #include "RootAccessible.h"
 
 #include "nsIDocShell.h"
 #include "nsIDocShellTreeItem.h"
 #include "nsIDOMWindow.h"
 #include "nsIFrame.h"
 #include "nsIInterfaceRequestorUtils.h"
-#include "nsIObserverService.h"
-#include "nsIPrefBranch.h"
-#include "nsIPrefService.h"
 #include "nsIPresShell.h"
 #include "nsIServiceManager.h"
 #include "nsIStringBundle.h"
 #include "nsFocusManager.h"
 #include "nsPresContext.h"
 #include "mozilla/Services.h"
 
 using namespace mozilla::a11y;
 
 /* For documentation of the accessibility architecture, 
  * see http://lxr.mozilla.org/seamonkey/source/accessible/accessible-docs.html
  */
 
 nsIStringBundle *nsAccessNode::gStringBundle = 0;
 
-bool nsAccessNode::gIsFormFillEnabled = false;
-
 ApplicationAccessible* nsAccessNode::gApplicationAccessible = nsnull;
 
 /*
  * Class nsAccessNode
  */
  
 ////////////////////////////////////////////////////////////////////////////////
 // nsAccessible. nsISupports
@@ -158,38 +153,16 @@ void nsAccessNode::InitXPAccessibility()
 {
   nsCOMPtr<nsIStringBundleService> stringBundleService =
     mozilla::services::GetStringBundleService();
   if (stringBundleService) {
     // Static variables are released in ShutdownAllXPAccessibility();
     stringBundleService->CreateBundle(ACCESSIBLE_BUNDLE_URL, 
                                       &gStringBundle);
   }
-
-  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
-  if (prefBranch) {
-    prefBranch->GetBoolPref("browser.formfill.enable", &gIsFormFillEnabled);
-  }
-
-  NotifyA11yInitOrShutdown(true);
-}
-
-// nsAccessNode protected static
-void nsAccessNode::NotifyA11yInitOrShutdown(bool aIsInit)
-{
-  nsCOMPtr<nsIObserverService> obsService =
-    mozilla::services::GetObserverService();
-  NS_ASSERTION(obsService, "No observer service to notify of a11y init/shutdown");
-  if (!obsService)
-    return;
-
-  static const PRUnichar kInitIndicator[] = { '1', 0 };
-  static const PRUnichar kShutdownIndicator[] = { '0', 0 }; 
-  obsService->NotifyObservers(nsnull, "a11y-init-or-shutdown",
-                              aIsInit ? kInitIndicator  : kShutdownIndicator);
 }
 
 void nsAccessNode::ShutdownXPAccessibility()
 {
   // Called by nsAccessibilityService::Shutdown()
   // which happens when xpcom is shutting down
   // at exit of program
 
@@ -197,18 +170,16 @@ void nsAccessNode::ShutdownXPAccessibili
 
   // Release gApplicationAccessible after everything else is shutdown
   // so we don't accidently create it again while tearing down root accessibles
   ApplicationAccessibleWrap::Unload();
   if (gApplicationAccessible) {
     gApplicationAccessible->Shutdown();
     NS_RELEASE(gApplicationAccessible);
   }
-
-  NotifyA11yInitOrShutdown(false);
 }
 
 RootAccessible*
 nsAccessNode::RootAccessible() const
 {
   nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem =
     nsCoreUtils::GetDocShellTreeItemFor(mContent);
   NS_ASSERTION(docShellTreeItem, "No docshell tree item for mContent");

--- a/accessible/src/base/nsAccessNode.h
+++ b/accessible/src/base/nsAccessNode.h
@@ -159,26 +159,19 @@ public:
   void Language(nsAString& aLocale);
 
 protected:
   void LastRelease();
 
   nsCOMPtr<nsIContent> mContent;
   nsDocAccessible* mDoc;
 
-  /**
-   * Notify global nsIObserver's that a11y is getting init'd or shutdown.
-   */
-  static void NotifyA11yInitOrShutdown(bool aIsInit);
-
   // Static data, we do our own refcounting for our static data.
   static nsIStringBundle* gStringBundle;
 
-  static bool gIsFormFillEnabled;
-
 private:
   nsAccessNode() MOZ_DELETE;
   nsAccessNode(const nsAccessNode&) MOZ_DELETE;
   nsAccessNode& operator =(const nsAccessNode&) MOZ_DELETE;
   
   static ApplicationAccessible* gApplicationAccessible;
 };
 

--- a/accessible/src/base/nsAccessibilityService.cpp
+++ b/accessible/src/base/nsAccessibilityService.cpp
@@ -41,16 +41,17 @@
 // NOTE: alphabetically ordered
 #include "Accessible-inl.h"
 #include "ApplicationAccessibleWrap.h"
 #include "ARIAGridAccessibleWrap.h"
 #ifdef MOZ_ACCESSIBILITY_ATK
 #include "AtkSocketAccessible.h"
 #endif
 #include "FocusManager.h"
+#include "HTMLListAccessible.h"
 #include "nsAccessiblePivot.h"
 #include "nsAccUtils.h"
 #include "nsARIAMap.h"
 #include "nsIAccessibleProvider.h"
 #include "nsHTMLCanvasAccessible.h"
 #include "nsHTMLImageMapAccessible.h"
 #include "nsHTMLLinkAccessible.h"
 #include "nsHTMLSelectAccessible.h"
@@ -217,17 +218,17 @@ nsAccessibilityService::CreateHTMLButton
   return accessible;
 }
 
 already_AddRefed<nsAccessible>
 nsAccessibilityService::CreateHTMLLIAccessible(nsIContent* aContent,
                                                nsIPresShell* aPresShell)
 {
   nsAccessible* accessible = 
-    new nsHTMLLIAccessible(aContent, GetDocAccessible(aPresShell));
+    new HTMLLIAccessible(aContent, GetDocAccessible(aPresShell));
   NS_ADDREF(accessible);
   return accessible;
 }
 
 already_AddRefed<nsAccessible>
 nsAccessibilityService::CreateHyperTextAccessible(nsIContent* aContent,
                                                   nsIPresShell* aPresShell)
 {
@@ -594,17 +595,17 @@ void
 nsAccessibilityService::UpdateListBullet(nsIPresShell* aPresShell,
                                          nsIContent* aHTMLListItemContent,
                                          bool aHasBullet)
 {
   nsDocAccessible* document = GetDocAccessible(aPresShell);
   if (document) {
     nsAccessible* accessible = document->GetAccessible(aHTMLListItemContent);
     if (accessible) {
-      nsHTMLLIAccessible* listItem = accessible->AsHTMLListItem();
+      HTMLLIAccessible* listItem = accessible->AsHTMLListItem();
       if (listItem)
         listItem->UpdateBullet(aHasBullet);
     }
   }
 }
 
 void
 nsAccessibilityService::UpdateImageMap(nsImageFrame* aImageFrame)
@@ -1266,32 +1267,39 @@ nsAccessibilityService::Init()
   // Add observers.
   nsCOMPtr<nsIObserverService> observerService =
     mozilla::services::GetObserverService();
   if (!observerService)
     return false;
 
   observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
 
+  static const PRUnichar kInitIndicator[] = { '1', 0 };
+  observerService->NotifyObservers(nsnull, "a11y-init-or-shutdown", kInitIndicator);
+
   // Initialize accessibility.
   nsAccessNodeWrap::InitAccessibility();
 
   gIsShutdown = false;
   return true;
 }
 
 void
 nsAccessibilityService::Shutdown()
 {
   // Remove observers.
   nsCOMPtr<nsIObserverService> observerService =
       mozilla::services::GetObserverService();
-  if (observerService)
+  if (observerService) {
     observerService->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
 
+    static const PRUnichar kShutdownIndicator[] = { '0', 0 };
+    observerService->NotifyObservers(nsnull, "a11y-init-or-shutdown", kShutdownIndicator);
+  }
+
   // Stop accessible document loader.
   nsAccDocManager::Shutdown();
 
   // Application is going to be closed, shutdown accessibility and mark
   // accessibility service as shutdown to prevent calls of its methods.
   // Don't null accessibility service static member at this point to be safe
   // if someone will try to operate with it.
 
@@ -1646,17 +1654,17 @@ nsAccessibilityService::CreateHTMLAccess
     nsAccessible* accessible = new nsHTMLSelectOptGroupAccessible(aContent,
                                                                   aDoc);
     NS_IF_ADDREF(accessible);
     return accessible;
   }
 
   if (tag == nsGkAtoms::ul || tag == nsGkAtoms::ol ||
       tag == nsGkAtoms::dl) {
-    nsAccessible* accessible = new nsHTMLListAccessible(aContent, aDoc);
+    nsAccessible* accessible = new HTMLListAccessible(aContent, aDoc);
     NS_IF_ADDREF(accessible);
     return accessible;
   }
 
   if (tag == nsGkAtoms::a) {
     // Only some roles truly enjoy life as nsHTMLLinkAccessibles, for details
     // see closed bug 494807.
     nsRoleMapEntry* roleMapEntry = aria::GetRoleMap(aContent);
@@ -1673,17 +1681,17 @@ nsAccessibilityService::CreateHTMLAccess
   }
 
   if (tag == nsGkAtoms::dt ||
       (tag == nsGkAtoms::li &&
        aFrame->GetType() != nsGkAtoms::blockFrame)) {
     // Normally for li, it is created by the list item frame (in nsBlockFrame)
     // which knows about the bullet frame; however, in this case the list item
     // must have been styled using display: foo
-    nsAccessible* accessible = new nsHTMLLIAccessible(aContent, aDoc);
+    nsAccessible* accessible = new HTMLLIAccessible(aContent, aDoc);
     NS_IF_ADDREF(accessible);
     return accessible;
   }
 
   if (tag == nsGkAtoms::abbr ||
       tag == nsGkAtoms::acronym ||
       tag == nsGkAtoms::blockquote ||
       tag == nsGkAtoms::dd ||

--- a/accessible/src/base/nsAccessible.cpp
+++ b/accessible/src/base/nsAccessible.cpp
@@ -909,17 +909,17 @@ void nsAccessible::GetBoundsRect(nsRect&
  * 1) Start with an empty rectangle
  * 2) Add the rect for the primary frame from for the DOM node.
  * 3) For each next frame at the same depth with the same DOM node, add that rect to total
  * 4) If that frame is an inline frame, search deeper at that point in the tree, adding all rects
  */
 
   // Initialization area
   *aBoundingFrame = nsnull;
-  nsIFrame *firstFrame = GetBoundsFrame();
+  nsIFrame* firstFrame = GetFrame();
   if (!firstFrame)
     return;
 
   // Find common relative parent
   // This is an ancestor frame that will incompass all frames for this content node.
   // We need the relative parent so we can get absolute screen coordinates
   nsIFrame *ancestorFrame = firstFrame;
 
@@ -1024,23 +1024,16 @@ nsAccessible::GetBounds(PRInt32* aX, PRI
   nsIntRect orgRectPixels = boundingFrame->GetScreenRectInAppUnits().
     ToNearestPixels(presContext->AppUnitsPerDevPixel());
   *aX += orgRectPixels.x;
   *aY += orgRectPixels.y;
 
   return NS_OK;
 }
 
-// helpers
-
-nsIFrame* nsAccessible::GetBoundsFrame()
-{
-  return GetFrame();
-}
-
 NS_IMETHODIMP nsAccessible::SetSelected(bool aSelect)
 {
   if (IsDefunct())
     return NS_ERROR_FAILURE;
 
   nsAccessible* select = nsAccUtils::GetSelectableContainer(this, State());
   if (select) {
     if (select->State() & states::MULTISELECTABLE) {
@@ -2104,17 +2097,17 @@ nsAccessible::RelationByType(PRUint32 aT
       if (mContent->IsHTML()) {
         // HTML form controls implements nsIFormControl interface.
         nsCOMPtr<nsIFormControl> control(do_QueryInterface(mContent));
         if (control) {
           nsCOMPtr<nsIForm> form(do_QueryInterface(control->GetFormElement()));
           if (form) {
             nsCOMPtr<nsIContent> formContent =
               do_QueryInterface(form->GetDefaultSubmitElement());
-            return Relation(formContent);
+            return Relation(mDoc, formContent);
           }
         }
       } else {
         // In XUL, use first <button default="true" .../> in the document
         nsCOMPtr<nsIDOMXULDocument> xulDoc =
           do_QueryInterface(mContent->OwnerDoc());
         nsCOMPtr<nsIDOMXULButtonElement> buttonEl;
         if (xulDoc) {
@@ -2145,23 +2138,23 @@ nsAccessible::RelationByType(PRUint32 aT
                                                       NS_LITERAL_STRING("default"),
                                                       NS_LITERAL_STRING("true"),
                                                       getter_AddRefs(possibleButtonEl));
                 buttonEl = do_QueryInterface(possibleButtonEl);
               }
             }
           }
           nsCOMPtr<nsIContent> relatedContent(do_QueryInterface(buttonEl));
-          return Relation(relatedContent);
+          return Relation(mDoc, relatedContent);
         }
       }
       return Relation();
     }
     case nsIAccessibleRelation::RELATION_MEMBER_OF:
-      return Relation(GetAtomicRegion());
+      return Relation(mDoc, GetAtomicRegion());
     case nsIAccessibleRelation::RELATION_SUBWINDOW_OF:
     case nsIAccessibleRelation::RELATION_EMBEDS:
     case nsIAccessibleRelation::RELATION_EMBEDDED_BY:
     case nsIAccessibleRelation::RELATION_POPUP_FOR:
     case nsIAccessibleRelation::RELATION_PARENT_WINDOW_OF:
     default:
     return Relation();
   }

--- a/accessible/src/base/nsAccessible.h
+++ b/accessible/src/base/nsAccessible.h
@@ -57,22 +57,23 @@
 class AccEvent;
 class AccGroupInfo;
 class EmbeddedObjCollector;
 class KeyBinding;
 class nsAccessible;
 class nsHyperTextAccessible;
 class nsHTMLImageAccessible;
 class nsHTMLImageMapAccessible;
-class nsHTMLLIAccessible;
 struct nsRoleMapEntry;
 class Relation;
 
 namespace mozilla {
 namespace a11y {
+
+class HTMLLIAccessible;
 class TableAccessible;
 
 /**
  * Name type flags.
  */
 enum ENameValueFlag {
   /**
    * Name either
@@ -440,16 +441,21 @@ public:
                             PRUint32 aLength = PR_UINT32_MAX);
 
   /**
    * Assert if child not in parent's cache if the cache was initialized at this
    * point.
    */
   void TestChildCache(nsAccessible* aCachedChild) const;
 
+  /**
+   * Return boundaries rect relative the bounding frame.
+   */
+  virtual void GetBoundsRect(nsRect& aRect, nsIFrame** aRelativeFrame);
+
   //////////////////////////////////////////////////////////////////////////////
   // Downcasting and types
 
   inline bool IsAbbreviation() const
   {
     return mContent->IsHTML() &&
       (mContent->Tag() == nsGkAtoms::abbr || mContent->Tag() == nsGkAtoms::acronym);
   }
@@ -466,17 +472,17 @@ public:
   nsDocAccessible* AsDoc();
 
   inline bool IsHyperText() const { return mFlags & eHyperTextAccessible; }
   nsHyperTextAccessible* AsHyperText();
 
   inline bool IsHTMLFileInput() const { return mFlags & eHTMLFileInputAccessible; }
 
   inline bool IsHTMLListItem() const { return mFlags & eHTMLListItemAccessible; }
-  nsHTMLLIAccessible* AsHTMLListItem();
+  mozilla::a11y::HTMLLIAccessible* AsHTMLListItem();
 
   inline bool IsImageAccessible() const { return mFlags & eImageAccessible; }
   nsHTMLImageAccessible* AsImage();
 
   bool IsImageMapAccessible() const { return mFlags & eImageMapAccessible; }
   nsHTMLImageMapAccessible* AsImageMap();
 
   inline bool IsXULTree() const { return mFlags & eXULTreeAccessible; }
@@ -740,19 +746,16 @@ protected:
   //////////////////////////////////////////////////////////////////////////////
   // Miscellaneous helpers
 
   /**
    * Return ARIA role (helper method).
    */
   mozilla::a11y::role ARIATransformRole(mozilla::a11y::role aRole);
 
-  virtual nsIFrame* GetBoundsFrame();
-  virtual void GetBoundsRect(nsRect& aRect, nsIFrame** aRelativeFrame);
-
   //////////////////////////////////////////////////////////////////////////////
   // Name helpers
 
   /**
    * Compute the name of HTML node.
    */
   nsresult GetHTMLName(nsAString& aName);
 

--- a/accessible/src/base/nsDocAccessible.h
+++ b/accessible/src/base/nsDocAccessible.h
@@ -118,16 +118,18 @@ public:
   virtual void ApplyARIAState(PRUint64* aState);
 
   virtual void SetRoleMapEntry(nsRoleMapEntry* aRoleMapEntry);
 
 #ifdef DEBUG_ACCDOCMGR
   virtual nsresult HandleAccEvent(AccEvent* aAccEvent);
 #endif
 
+  virtual void GetBoundsRect(nsRect& aRect, nsIFrame** aRelativeFrame);
+
   // nsHyperTextAccessible
   virtual already_AddRefed<nsIEditor> GetEditor() const;
 
   // nsDocAccessible
 
   /**
    * Return presentation shell for this document accessible.
    */
@@ -379,17 +381,16 @@ public:
 protected:
 
   void LastRelease();
 
   // nsAccessible
   virtual void CacheChildren();
 
   // nsDocAccessible
-    virtual void GetBoundsRect(nsRect& aRect, nsIFrame** aRelativeFrame);
     virtual nsresult AddEventListeners();
     virtual nsresult RemoveEventListeners();
 
   /**
    * Marks this document as loaded or loading.
    */
   inline void NotifyOfLoad(PRUint32 aLoadEventType)
   {

--- a/accessible/src/html/HTMLFormControlAccessible.cpp
+++ b/accessible/src/html/HTMLFormControlAccessible.cpp
@@ -58,16 +58,19 @@
 #include "nsIFrame.h"
 #include "nsINameSpaceManager.h"
 #include "nsISelectionController.h"
 #include "jsapi.h"
 #include "nsIJSContextStack.h"
 #include "nsIServiceManager.h"
 #include "nsITextControlFrame.h"
 
+#include "mozilla/Preferences.h"
+
+using namespace mozilla;
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLCheckboxAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 HTMLCheckboxAccessible::
   HTMLCheckboxAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
@@ -491,17 +494,17 @@ HTMLTextFieldAccessible::NativeState()
   }
 
   // Expose autocomplete state if it has associated autocomplete list.
   if (mContent->HasAttr(kNameSpaceID_None, nsGkAtoms::list))
     return state | states::SUPPORTS_AUTOCOMPLETION;
 
   // No parent can mean a fake widget created for XUL textbox. If accessible
   // is unattached from tree then we don't care.
-  if (mParent && gIsFormFillEnabled) {
+  if (mParent && Preferences::GetBool("browser.formfill.enable")) {
     // 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, nsGkAtoms::autocomplete,
                       autocomplete);
@@ -699,17 +702,17 @@ HTMLGroupboxAccessible::GetNameInternal(
 }
 
 Relation
 HTMLGroupboxAccessible::RelationByType(PRUint32 aType)
 {
   Relation rel = nsHyperTextAccessibleWrap::RelationByType(aType);
     // No override for label, so use <legend> for this <fieldset>
   if (aType == nsIAccessibleRelation::RELATION_LABELLED_BY)
-    rel.AppendTarget(GetLegend());
+    rel.AppendTarget(mDoc, GetLegend());
 
   return rel;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLLegendAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -785,17 +788,17 @@ HTMLFigureAccessible::GetNameInternal(ns
   return NS_OK;
 }
 
 Relation
 HTMLFigureAccessible::RelationByType(PRUint32 aType)
 {
   Relation rel = nsHyperTextAccessibleWrap::RelationByType(aType);
   if (aType == nsIAccessibleRelation::RELATION_LABELLED_BY)
-    rel.AppendTarget(Caption());
+    rel.AppendTarget(mDoc, Caption());
 
   return rel;
 }
 
 nsIContent*
 HTMLFigureAccessible::Caption() const
 {
   for (nsIContent* childContent = mContent->GetFirstChild(); childContent;

copy from accessible/src/html/nsHTMLTextAccessible.cpp
copy to accessible/src/html/HTMLListAccessible.cpp
--- a/accessible/src/html/nsHTMLTextAccessible.cpp
+++ b/accessible/src/html/HTMLListAccessible.cpp
@@ -1,360 +1,165 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Aaron Leventhal (aaronl@netscape.com)
- *   Kyle Yuan (kyle.yuan@sun.com)
- *
- * 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 ***** */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#include "nsHTMLTextAccessible.h"
+#include "HTMLListAccessible.h"
 
 #include "nsDocAccessible.h"
-#include "nsAccUtils.h"
-#include "nsTextEquivUtils.h"
-#include "Relation.h"
 #include "Role.h"
 #include "States.h"
 
-#include "nsIAccessibleRelation.h"
-#include "nsIFrame.h"
-#include "nsPresContext.h"
 #include "nsBlockFrame.h"
-#include "nsISelection.h"
-#include "nsISelectionController.h"
-#include "nsComponentManagerUtils.h"
 
+using namespace mozilla;
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
-// nsHTMLTextAccessible
+// HTMLListAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
-nsHTMLTextAccessible::
-  nsHTMLTextAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
-  nsTextAccessibleWrap(aContent, aDoc)
-{
-}
-
-NS_IMPL_ISUPPORTS_INHERITED0(nsHTMLTextAccessible, nsTextAccessible)
-
-ENameValueFlag
-nsHTMLTextAccessible::Name(nsString& aName)
-{
-  // Text node, ARIA can't be used.
-  aName = mText;
-  return eNameOK;
-}
+NS_IMPL_ISUPPORTS_INHERITED0(HTMLListAccessible, nsHyperTextAccessible)
 
 role
-nsHTMLTextAccessible::NativeRole()
+HTMLListAccessible::NativeRole()
 {
-  nsIFrame *frame = GetFrame();
-  // Don't return on null frame -- we still return a role
-  // after accessible is shutdown/DEFUNCT
-  if (frame && frame->IsGeneratedContentFrame()) 
-    return roles::STATICTEXT;
+  if (mContent->Tag() == nsGkAtoms::dl)
+    return roles::DEFINITION_LIST;
 
-  return nsTextAccessible::NativeRole();
+  return roles::LIST;
 }
 
 PRUint64
-nsHTMLTextAccessible::NativeState()
+HTMLListAccessible::NativeState()
 {
-  PRUint64 state = nsTextAccessible::NativeState();
-
-  nsDocAccessible* docAccessible = Document();
-  if (docAccessible) {
-     PRUint64 docState = docAccessible->State();
-     if (0 == (docState & states::EDITABLE)) {
-       state |= states::READONLY; // Links not focusable in editor
-     }
-  }
-
-  return state;
-}
-
-nsresult
-nsHTMLTextAccessible::GetAttributesInternal(nsIPersistentProperties *aAttributes)
-{
-  if (NativeRole() == roles::STATICTEXT) {
-    nsAutoString oldValueUnused;
-    aAttributes->SetStringProperty(NS_LITERAL_CSTRING("auto-generated"),
-                                  NS_LITERAL_STRING("true"), oldValueUnused);
-  }
-
-  return NS_OK;
+  return nsHyperTextAccessibleWrap::NativeState() | states::READONLY;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
-// nsHTMLHRAccessible
-////////////////////////////////////////////////////////////////////////////////
-
-nsHTMLHRAccessible::
-  nsHTMLHRAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
-  nsLeafAccessible(aContent, aDoc)
-{
-}
-
-role
-nsHTMLHRAccessible::NativeRole()
-{
-  return roles::SEPARATOR;
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLBRAccessible
-////////////////////////////////////////////////////////////////////////////////
-
-nsHTMLBRAccessible::
-  nsHTMLBRAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
-  nsLeafAccessible(aContent, aDoc)
-{
-}
-
-role
-nsHTMLBRAccessible::NativeRole()
-{
-  return roles::WHITESPACE;
-}
-
-PRUint64
-nsHTMLBRAccessible::NativeState()
-{
-  return states::READONLY;
-}
-
-nsresult
-nsHTMLBRAccessible::GetNameInternal(nsAString& aName)
-{
-  aName = static_cast<PRUnichar>('\n');    // Newline char
-  return NS_OK;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLLabelAccessible
+// HTMLLIAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
-nsHTMLLabelAccessible::
-  nsHTMLLabelAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
-  nsHyperTextAccessibleWrap(aContent, aDoc)
-{
-}
-
-NS_IMPL_ISUPPORTS_INHERITED0(nsHTMLLabelAccessible, nsHyperTextAccessible)
-
-nsresult
-nsHTMLLabelAccessible::GetNameInternal(nsAString& aName)
-{
-  return nsTextEquivUtils::GetNameFromSubtree(this, aName);
-}
-
-role
-nsHTMLLabelAccessible::NativeRole()
-{
-  return roles::LABEL;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLOuputAccessible
-////////////////////////////////////////////////////////////////////////////////
-
-nsHTMLOutputAccessible::
-  nsHTMLOutputAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
-  nsHyperTextAccessibleWrap(aContent, aDoc)
-{
-}
-
-NS_IMPL_ISUPPORTS_INHERITED0(nsHTMLOutputAccessible, nsHyperTextAccessible)
-
-Relation
-nsHTMLOutputAccessible::RelationByType(PRUint32 aType)
-{
-  Relation rel = nsAccessibleWrap::RelationByType(aType);
-  if (aType == nsIAccessibleRelation::RELATION_CONTROLLED_BY)
-    rel.AppendIter(new IDRefsIterator(mDoc, mContent, nsGkAtoms::_for));
-
-  return rel;
-}
-
-role
-nsHTMLOutputAccessible::NativeRole()
-{
-  return roles::SECTION;
-}
-
-nsresult
-nsHTMLOutputAccessible::GetAttributesInternal(nsIPersistentProperties* aAttributes)
-{
-  nsresult rv = nsAccessibleWrap::GetAttributesInternal(aAttributes);
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::live,
-                         NS_LITERAL_STRING("polite"));
-  
-  return NS_OK;
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLLIAccessible
-////////////////////////////////////////////////////////////////////////////////
-
-nsHTMLLIAccessible::
-  nsHTMLLIAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
+HTMLLIAccessible::
+  HTMLLIAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
   nsHyperTextAccessibleWrap(aContent, aDoc), mBullet(nsnull)
 {
   mFlags |= eHTMLListItemAccessible;
 
   nsBlockFrame* blockFrame = do_QueryFrame(GetFrame());
   if (blockFrame && blockFrame->HasBullet()) {
-    mBullet = new nsHTMLListBulletAccessible(mContent, mDoc);
+    mBullet = new HTMLListBulletAccessible(mContent, mDoc);
     if (!Document()->BindToDocument(mBullet, nsnull))
       mBullet = nsnull;
   }
 }
 
-NS_IMPL_ISUPPORTS_INHERITED0(nsHTMLLIAccessible, nsHyperTextAccessible)
+NS_IMPL_ISUPPORTS_INHERITED0(HTMLLIAccessible, nsHyperTextAccessible)
 
 void
-nsHTMLLIAccessible::Shutdown()
+HTMLLIAccessible::Shutdown()
 {
   mBullet = nsnull;
 
   nsHyperTextAccessibleWrap::Shutdown();
 }
 
 role
-nsHTMLLIAccessible::NativeRole()
+HTMLLIAccessible::NativeRole()
 {
   if (mContent->Tag() == nsGkAtoms::dt)
     return roles::TERM;
 
   return roles::LISTITEM;
 }
 
 PRUint64
-nsHTMLLIAccessible::NativeState()
+HTMLLIAccessible::NativeState()
 {
   return nsHyperTextAccessibleWrap::NativeState() | states::READONLY;
 }
 
-NS_IMETHODIMP nsHTMLLIAccessible::GetBounds(PRInt32 *x, PRInt32 *y, PRInt32 *width, PRInt32 *height)
+NS_IMETHODIMP
+HTMLLIAccessible::GetBounds(PRInt32* aX, PRInt32* aY,
+                            PRInt32* aWidth, PRInt32* aHeight)
 {
-  nsresult rv = nsAccessibleWrap::GetBounds(x, y, width, height);
+  nsresult rv = nsAccessibleWrap::GetBounds(aX, aY, aWidth, aHeight);
   if (NS_FAILED(rv) || !mBullet)
     return rv;
 
-  PRInt32 bulletX, bulletY, bulletWidth, bulletHeight;
+  PRInt32 bulletX = 0, bulletY = 0, bulletWidth = 0, bulletHeight = 0;
   rv = mBullet->GetBounds(&bulletX, &bulletY, &bulletWidth, &bulletHeight);
   NS_ENSURE_SUCCESS(rv, rv);
 
-  *x = bulletX; // Move x coordinate of list item over to cover bullet as well
-  *width += bulletWidth;
+  *aX = bulletX; // Move x coordinate of list item over to cover bullet as well
+  *aWidth += bulletWidth;
   return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// nsHTMLLIAccessible: public
+// HTMLLIAccessible: public
 
 void
-nsHTMLLIAccessible::UpdateBullet(bool aHasBullet)
+HTMLLIAccessible::UpdateBullet(bool aHasBullet)
 {
   if (aHasBullet == !!mBullet) {
     NS_NOTREACHED("Bullet and accessible are in sync already!");
     return;
   }
 
   nsDocAccessible* document = Document();
   if (aHasBullet) {
-    mBullet = new nsHTMLListBulletAccessible(mContent, mDoc);
+    mBullet = new HTMLListBulletAccessible(mContent, mDoc);
     if (document->BindToDocument(mBullet, nsnull)) {
       InsertChildAt(0, mBullet);
     }
   } else {
     RemoveChild(mBullet);
     document->UnbindFromDocument(mBullet);
     mBullet = nsnull;
   }
 
   // XXXtodo: fire show/hide and reorder events. That's hard to make it
   // right now because coalescence happens by DOM node.
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// nsHTMLLIAccessible: nsAccessible protected
+// HTMLLIAccessible: nsAccessible protected
 
 void
-nsHTMLLIAccessible::CacheChildren()
+HTMLLIAccessible::CacheChildren()
 {
   if (mBullet)
     AppendChild(mBullet);
 
   // Cache children from subtree.
   nsAccessibleWrap::CacheChildren();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// nsHTMLListBulletAccessible
+// HTMLListBulletAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
-nsHTMLListBulletAccessible::
-  nsHTMLListBulletAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
-    nsLeafAccessible(aContent, aDoc)
-{
-}
-
 ////////////////////////////////////////////////////////////////////////////////
-// nsHTMLListBulletAccessible: nsAccessNode
+// HTMLListBulletAccessible: nsAccessNode
 
 bool
-nsHTMLListBulletAccessible::IsPrimaryForNode() const
+HTMLListBulletAccessible::IsPrimaryForNode() const
 {
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// nsHTMLListBulletAccessible: nsAccessible
+// HTMLListBulletAccessible: nsAccessible
 
 ENameValueFlag
-nsHTMLListBulletAccessible::Name(nsString &aName)
+HTMLListBulletAccessible::Name(nsString &aName)
 {
   aName.Truncate();
 
   // Native anonymous content, ARIA can't be used. Get list bullet text.
   nsBlockFrame* blockFrame = do_QueryFrame(mContent->GetPrimaryFrame());
   NS_ASSERTION(blockFrame, "No frame for list item!");
   if (blockFrame) {
     blockFrame->GetBulletText(aName);
@@ -362,63 +167,35 @@ nsHTMLListBulletAccessible::Name(nsStrin
     // Append space otherwise bullets are jammed up against list text.
     aName.Append(' ');
   }
 
   return eNameOK;
 }
 
 role
-nsHTMLListBulletAccessible::NativeRole()
+HTMLListBulletAccessible::NativeRole()
 {
   return roles::STATICTEXT;
 }
 
 PRUint64
-nsHTMLListBulletAccessible::NativeState()
+HTMLListBulletAccessible::NativeState()
 {
   PRUint64 state = nsLeafAccessible::NativeState();
 
   state &= ~states::FOCUSABLE;
   state |= states::READONLY;
   return state;
 }
 
 void
-nsHTMLListBulletAccessible::AppendTextTo(nsAString& aText, PRUint32 aStartOffset,
-                                         PRUint32 aLength)
+HTMLListBulletAccessible::AppendTextTo(nsAString& aText, PRUint32 aStartOffset,
+                                       PRUint32 aLength)
 {
   nsAutoString bulletText;
   nsBlockFrame* blockFrame = do_QueryFrame(mContent->GetPrimaryFrame());
   NS_ASSERTION(blockFrame, "No frame for list item!");
   if (blockFrame)
     blockFrame->GetBulletText(bulletText);
 
   aText.Append(Substring(bulletText, aStartOffset, aLength));
 }
-
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLListAccessible
-////////////////////////////////////////////////////////////////////////////////
-
-nsHTMLListAccessible::
-  nsHTMLListAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
-  nsHyperTextAccessibleWrap(aContent, aDoc)
-{
-}
-
-NS_IMPL_ISUPPORTS_INHERITED0(nsHTMLListAccessible, nsHyperTextAccessible)
-
-role
-nsHTMLListAccessible::NativeRole()
-{
-  if (mContent->Tag() == nsGkAtoms::dl)
-    return roles::DEFINITION_LIST;
-
-  return roles::LIST;
-}
-
-PRUint64
-nsHTMLListAccessible::NativeState()
-{
-  return nsHyperTextAccessibleWrap::NativeState() | states::READONLY;
-}
-

copy from accessible/src/html/nsHTMLTextAccessible.h
copy to accessible/src/html/HTMLListAccessible.h
--- a/accessible/src/html/nsHTMLTextAccessible.h
+++ b/accessible/src/html/HTMLListAccessible.h
@@ -1,196 +1,104 @@
 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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
- * Netscape Communications Corporation.
- * Portions created by the Initial Developer are Copyright (C) 1998
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *   Aaron Leventhal (aaronl@netscape.com)
- *   Kyle Yuan (kyle.yuan@sun.com)
- *
- * 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 ***** */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-#ifndef _nsHTMLTextAccessible_H_
-#define _nsHTMLTextAccessible_H_
+#ifndef mozilla_a11y_HTMLListAccessible_h__
+#define mozilla_a11y_HTMLListAccessible_h__
 
-#include "nsTextAccessibleWrap.h"
-#include "nsAutoPtr.h"
+#include "nsHyperTextAccessibleWrap.h"
 #include "nsBaseWidgetAccessible.h"
 
+namespace mozilla {
+namespace a11y {
+
+class HTMLListBulletAccessible;
+
 /**
- * Used for text nodes within HTML document.
+ * Used for HTML list (like HTML ul).
  */
-class nsHTMLTextAccessible : public nsTextAccessibleWrap
+class HTMLListAccessible : public nsHyperTextAccessibleWrap
 {
 public:
-  nsHTMLTextAccessible(nsIContent* aContent, nsDocAccessible* aDoc);
+  HTMLListAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
+    nsHyperTextAccessibleWrap(aContent, aDoc) { }
+  virtual ~HTMLListAccessible() { }
 
   // nsISupports
   NS_DECL_ISUPPORTS_INHERITED
 
   // nsAccessible
-  virtual mozilla::a11y::ENameValueFlag Name(nsString& aName);
-  virtual nsresult GetAttributesInternal(nsIPersistentProperties *aAttributes);
-  virtual mozilla::a11y::role NativeRole();
-  virtual PRUint64 NativeState();
-};
-
-/**
- * Used for HTML hr element.
- */
-class nsHTMLHRAccessible : public nsLeafAccessible
-{
-public:
-  nsHTMLHRAccessible(nsIContent* aContent, nsDocAccessible* aDoc);
-
-  // nsAccessible
-  virtual mozilla::a11y::role NativeRole();
-};
-
-/**
- * Used for HTML br element.
- */
-class nsHTMLBRAccessible : public nsLeafAccessible
-{
-public:
-  nsHTMLBRAccessible(nsIContent* aContent, nsDocAccessible* aDoc);
-
-  // nsAccessible
-  virtual nsresult GetNameInternal(nsAString& aName);
-  virtual mozilla::a11y::role NativeRole();
+  virtual a11y::role NativeRole();
   virtual PRUint64 NativeState();
 };
 
-/**
- * Used for HTML label element.
- */
-class nsHTMLLabelAccessible : public nsHyperTextAccessibleWrap
-{
-public:
-  nsHTMLLabelAccessible(nsIContent* aContent, nsDocAccessible* aDoc);
-
-  NS_DECL_ISUPPORTS_INHERITED
-
-  // nsAccessible
-  virtual nsresult GetNameInternal(nsAString& aName);
-  virtual mozilla::a11y::role NativeRole();
-};
-
-/**
- * Used for HTML output element.
- */
-class nsHTMLOutputAccessible : public nsHyperTextAccessibleWrap
-{
-public:
-  nsHTMLOutputAccessible(nsIContent* aContent, nsDocAccessible* aDoc);
-
-  NS_DECL_ISUPPORTS_INHERITED
-
-  // nsAccessible
-  virtual mozilla::a11y::role NativeRole();
-  virtual nsresult GetAttributesInternal(nsIPersistentProperties* aAttributes);
-  virtual Relation RelationByType(PRUint32 aType);
-};
-
-/**
- * Used for bullet of HTML list item element (for example, HTML li).
- */
-class nsHTMLListBulletAccessible : public nsLeafAccessible
-{
-public:
-  nsHTMLListBulletAccessible(nsIContent* aContent, nsDocAccessible* aDoc);
-
-  // nsAccessNode
-  virtual bool IsPrimaryForNode() const;
-
-  // nsAccessible
-  virtual mozilla::a11y::ENameValueFlag Name(nsString& aName);
-  virtual mozilla::a11y::role NativeRole();
-  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
-{
-public:
-  nsHTMLListAccessible(nsIContent* aContent, nsDocAccessible* aDoc);
-
-  // nsISupports
-  NS_DECL_ISUPPORTS_INHERITED
-
-  // nsAccessible
-  virtual mozilla::a11y::role NativeRole();
-  virtual PRUint64 NativeState();
-};
 
 /**
  * Used for HTML list item (e.g. HTML li).
  */
-class nsHTMLLIAccessible : public nsHyperTextAccessibleWrap
+class HTMLLIAccessible : public nsHyperTextAccessibleWrap
 {
 public:
-  nsHTMLLIAccessible(nsIContent* aContent, nsDocAccessible* aDoc);
+  HTMLLIAccessible(nsIContent* aContent, nsDocAccessible* aDoc);
+  virtual ~HTMLLIAccessible() { }
 
   // nsISupports
   NS_DECL_ISUPPORTS_INHERITED
 
   // nsAccessNode
   virtual void Shutdown();
 
   // nsIAccessible
-  NS_IMETHOD GetBounds(PRInt32 *x, PRInt32 *y, PRInt32 *width, PRInt32 *height);
+  NS_IMETHOD GetBounds(PRInt32* aX, PRInt32* aY,
+                       PRInt32* aWidth, PRInt32* aHeight);
 
   // nsAccessible
-  virtual mozilla::a11y::role NativeRole();
+  virtual a11y::role NativeRole();
   virtual PRUint64 NativeState();
 
   // nsHTMLLIAccessible
   void UpdateBullet(bool aHasBullet);
 
 protected:
   // nsAccessible
   virtual void CacheChildren();
 
 private:
-  nsRefPtr<nsHTMLListBulletAccessible> mBullet;
+  nsRefPtr<HTMLListBulletAccessible> mBullet;
 };
 
-inline nsHTMLLIAccessible*
+
+/**
+ * Used for bullet of HTML list item element (for example, HTML li).
+ */
+class HTMLListBulletAccessible : public nsLeafAccessible
+{
+public:
+  HTMLListBulletAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
+    nsLeafAccessible(aContent, aDoc) { }
+  virtual ~HTMLListBulletAccessible() { }
+
+  // nsAccessNode
+  virtual bool IsPrimaryForNode() const;
+
+  // nsAccessible
+  virtual ENameValueFlag Name(nsString& aName);
+  virtual a11y::role NativeRole();
+  virtual PRUint64 NativeState();
+  virtual void AppendTextTo(nsAString& aText, PRUint32 aStartOffset = 0,
+                            PRUint32 aLength = PR_UINT32_MAX);
+};
+
+} // namespace a11y
+} // namespace mozilla
+
+
+inline mozilla::a11y::HTMLLIAccessible*
 nsAccessible::AsHTMLListItem()
 {
   return mFlags & eHTMLListItemAccessible ?
-    static_cast<nsHTMLLIAccessible*>(this) : nsnull;
+    static_cast<mozilla::a11y::HTMLLIAccessible*>(this) : nsnull;
 }
 
 #endif

--- a/accessible/src/html/Makefile.in
+++ b/accessible/src/html/Makefile.in
@@ -47,16 +47,17 @@ MODULE = accessibility
 LIBRARY_NAME = accessibility_html_s
 LIBXUL_LIBRARY = 1
 
 
 
 CPPSRCS = \
   nsHTMLCanvasAccessible.cpp \
   HTMLFormControlAccessible.cpp \
+  HTMLListAccessible.cpp \
   nsHTMLImageAccessible.cpp \
   nsHTMLImageMapAccessible.cpp \
   nsHTMLLinkAccessible.cpp \
   nsHTMLSelectAccessible.cpp \
   nsHTMLTableAccessible.cpp \
   nsHTMLTextAccessible.cpp \
   nsHyperTextAccessible.cpp \
   $(NULL)

--- a/accessible/src/html/nsHTMLImageMapAccessible.h
+++ b/accessible/src/html/nsHTMLImageMapAccessible.h
@@ -100,21 +100,21 @@ public:
   virtual bool IsPrimaryForNode() const;
 
   // nsAccessible
   virtual void Description(nsString& aDescription);
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual PRUint64 NativeState();
   virtual nsAccessible* ChildAtPoint(PRInt32 aX, PRInt32 aY,
                                      EWhichChildAtPoint aWhichChild);
+  virtual void GetBoundsRect(nsRect& aBounds, nsIFrame** aBoundingFrame);
 
   // HyperLinkAccessible
   virtual PRUint32 StartOffset();
   virtual PRUint32 EndOffset();
 
 protected:
 
   // nsAccessible
   virtual void CacheChildren();
-  virtual void GetBoundsRect(nsRect& aBounds, nsIFrame** aBoundingFrame);
 };
 
 #endif  

--- a/accessible/src/html/nsHTMLSelectAccessible.cpp
+++ b/accessible/src/html/nsHTMLSelectAccessible.cpp
@@ -251,32 +251,16 @@ nsHTMLSelectOptionAccessible::GetNameInt
     txtValue.CompressWhitespace();
     aName.Assign(txtValue);
     return NS_OK;
   }
 
   return NS_OK;
 }
 
-// nsAccessible protected
-nsIFrame* nsHTMLSelectOptionAccessible::GetBoundsFrame()
-{
-  PRUint64 state = 0;
-  nsIContent* content = GetSelectState(&state);
-  if (state & states::COLLAPSED) {
-    if (content) {
-      return content->GetPrimaryFrame();
-    }
-
-    return nsnull;
-  }
-
-  return nsAccessible::GetBoundsFrame();
-}
-
 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 EDITABLE or SELECTABLE_TEXT
   PRUint64 state = nsAccessible::NativeState();
@@ -343,18 +327,26 @@ nsHTMLSelectOptionAccessible::GetLevelIn
     parentContent->NodeInfo()->Equals(nsGkAtoms::optgroup) ? 2 : 1;
 
   if (level == 1 && Role() != roles::HEADING)
     level = 0; // In a single level list, the level is irrelevant
 
   return level;
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLSelectOptionAccessible: nsIAccessible
+void
+nsHTMLSelectOptionAccessible::GetBoundsRect(nsRect& aTotalBounds,
+                                            nsIFrame** aBoundingFrame)
+{
+  nsAccessible* combobox = GetCombobox();
+  if (combobox && (combobox->State() & states::COLLAPSED))
+    combobox->GetBoundsRect(aTotalBounds, aBoundingFrame);
+  else
+    nsHyperTextAccessibleWrap::GetBoundsRect(aTotalBounds, aBoundingFrame);
+}
 
 /** select us! close combo box if necessary*/
 NS_IMETHODIMP nsHTMLSelectOptionAccessible::GetActionName(PRUint8 aIndex, nsAString& aName)
 {
   if (aIndex == eAction_Select) {
     aName.AssignLiteral("select"); 
     return NS_OK;
   }
@@ -546,28 +538,25 @@ nsHTMLComboboxAccessible::Shutdown()
   nsAccessibleWrap::Shutdown();
 
   if (mListAccessible) {
     mListAccessible->Shutdown();
     mListAccessible = nsnull;
   }
 }
 
-/**
-  */
 PRUint64
 nsHTMLComboboxAccessible::NativeState()
 {
   // As a nsHTMLComboboxAccessible we can have the following states:
   // FOCUSED, FOCUSABLE, HASPOPUP, EXPANDED, COLLAPSED
   // Get focus status from base class
   PRUint64 state = nsAccessible::NativeState();
 
-  nsIFrame *frame = GetBoundsFrame();
-  nsIComboboxControlFrame *comboFrame = do_QueryFrame(frame);
+  nsIComboboxControlFrame* comboFrame = do_QueryFrame(GetFrame());
   if (comboFrame && comboFrame->IsDroppedDown())
     state |= states::EXPANDED;
   else
     state |= states::COLLAPSED;
 
   state |= states::HASPOPUP;
   return state;
 }
@@ -745,18 +734,17 @@ nsHTMLComboboxListAccessible::IsPrimaryF
 PRUint64
 nsHTMLComboboxListAccessible::NativeState()
 {
   // As a nsHTMLComboboxListAccessible we can have the following states:
   // FOCUSED, FOCUSABLE, FLOATING, INVISIBLE
   // Get focus status from base class
   PRUint64 state = nsAccessible::NativeState();
 
-  nsIFrame *boundsFrame = GetBoundsFrame();
-  nsIComboboxControlFrame* comboFrame = do_QueryFrame(boundsFrame);
+  nsIComboboxControlFrame* comboFrame = do_QueryFrame(mParent->GetFrame());
   if (comboFrame && comboFrame->IsDroppedDown())
     state |= states::FLOATING;
   else
     state |= states::INVISIBLE;
 
   return state;
 }
 

--- a/accessible/src/html/nsHTMLSelectAccessible.h
+++ b/accessible/src/html/nsHTMLSelectAccessible.h
@@ -117,35 +117,45 @@ public:
   NS_IMETHOD SetSelected(bool aSelect);
 
   // nsAccessible
   virtual nsresult GetNameInternal(nsAString& aName);
   virtual mozilla::a11y::role NativeRole();
   virtual PRUint64 NativeState();
 
   virtual PRInt32 GetLevelInternal();
+  virtual void GetBoundsRect(nsRect& aTotalBounds, nsIFrame** aBoundingFrame);
 
   // ActionAccessible
   virtual PRUint8 ActionCount();
 
   // Widgets
   virtual nsAccessible* ContainerWidget() const;
 
-protected:
-  // nsAccessible
-  virtual nsIFrame* GetBoundsFrame();
-
 private:
   
   /**
    * Get Select element's accessible state
    * @param aState, Select element state
    * @return Select element content, returns null if not avaliable
    */ 
   nsIContent* GetSelectState(PRUint64* aState);
+
+  /**
+   * Return a combobox accessible the option belongs to if any.
+   */
+  nsAccessible* GetCombobox() const
+  {
+    if (mParent && mParent->IsListControl()) {
+      nsAccessible* combobox = mParent->Parent();
+      return combobox->IsCombobox() ? combobox : nsnull;
+    }
+
+    return nsnull;
+  }
 };
 
 /*
  * Opt Groups inside the select, contained within the list
  */
 class nsHTMLSelectOptGroupAccessible : public nsHTMLSelectOptionAccessible
 {
 public:

--- a/accessible/src/html/nsHTMLTextAccessible.cpp
+++ b/accessible/src/html/nsHTMLTextAccessible.cpp
@@ -36,29 +36,22 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #include "nsHTMLTextAccessible.h"
 
 #include "nsDocAccessible.h"
 #include "nsAccUtils.h"
+#include "nsIAccessibleRelation.h"
 #include "nsTextEquivUtils.h"
 #include "Relation.h"
 #include "Role.h"
 #include "States.h"
 
-#include "nsIAccessibleRelation.h"
-#include "nsIFrame.h"
-#include "nsPresContext.h"
-#include "nsBlockFrame.h"
-#include "nsISelection.h"
-#include "nsISelectionController.h"
-#include "nsComponentManagerUtils.h"
-
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsHTMLTextAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 nsHTMLTextAccessible::
   nsHTMLTextAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
@@ -222,203 +215,8 @@ nsHTMLOutputAccessible::GetAttributesInt
   NS_ENSURE_SUCCESS(rv, rv);
 
   nsAccUtils::SetAccAttr(aAttributes, nsGkAtoms::live,
                          NS_LITERAL_STRING("polite"));
   
   return NS_OK;
 }
 
-
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLLIAccessible
-////////////////////////////////////////////////////////////////////////////////
-
-nsHTMLLIAccessible::
-  nsHTMLLIAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
-  nsHyperTextAccessibleWrap(aContent, aDoc), mBullet(nsnull)
-{
-  mFlags |= eHTMLListItemAccessible;
-
-  nsBlockFrame* blockFrame = do_QueryFrame(GetFrame());
-  if (blockFrame && blockFrame->HasBullet()) {
-    mBullet = new nsHTMLListBulletAccessible(mContent, mDoc);
-    if (!Document()->BindToDocument(mBullet, nsnull))
-      mBullet = nsnull;
-  }
-}
-
-NS_IMPL_ISUPPORTS_INHERITED0(nsHTMLLIAccessible, nsHyperTextAccessible)
-
-void
-nsHTMLLIAccessible::Shutdown()
-{
-  mBullet = nsnull;
-
-  nsHyperTextAccessibleWrap::Shutdown();
-}
-
-role
-nsHTMLLIAccessible::NativeRole()
-{
-  if (mContent->Tag() == nsGkAtoms::dt)
-    return roles::TERM;
-
-  return roles::LISTITEM;
-}
-
-PRUint64
-nsHTMLLIAccessible::NativeState()
-{
-  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;
-
-  PRInt32 bulletX, bulletY, bulletWidth, bulletHeight;
-  rv = mBullet->GetBounds(&bulletX, &bulletY, &bulletWidth, &bulletHeight);
-  NS_ENSURE_SUCCESS(rv, rv);
-
-  *x = bulletX; // Move x coordinate of list item over to cover bullet as well
-  *width += bulletWidth;
-  return NS_OK;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLLIAccessible: public
-
-void
-nsHTMLLIAccessible::UpdateBullet(bool aHasBullet)
-{
-  if (aHasBullet == !!mBullet) {
-    NS_NOTREACHED("Bullet and accessible are in sync already!");
-    return;
-  }
-
-  nsDocAccessible* document = Document();
-  if (aHasBullet) {
-    mBullet = new nsHTMLListBulletAccessible(mContent, mDoc);
-    if (document->BindToDocument(mBullet, nsnull)) {
-      InsertChildAt(0, mBullet);
-    }
-  } else {
-    RemoveChild(mBullet);
-    document->UnbindFromDocument(mBullet);
-    mBullet = nsnull;
-  }
-
-  // XXXtodo: fire show/hide and reorder events. That's hard to make it
-  // right now because coalescence happens by DOM node.
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLLIAccessible: nsAccessible protected
-
-void
-nsHTMLLIAccessible::CacheChildren()
-{
-  if (mBullet)
-    AppendChild(mBullet);
-
-  // Cache children from subtree.
-  nsAccessibleWrap::CacheChildren();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLListBulletAccessible
-////////////////////////////////////////////////////////////////////////////////
-
-nsHTMLListBulletAccessible::
-  nsHTMLListBulletAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
-    nsLeafAccessible(aContent, aDoc)
-{
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLListBulletAccessible: nsAccessNode
-
-bool
-nsHTMLListBulletAccessible::IsPrimaryForNode() const
-{
-  return false;
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLListBulletAccessible: nsAccessible
-
-ENameValueFlag
-nsHTMLListBulletAccessible::Name(nsString &aName)
-{
-  aName.Truncate();
-
-  // Native anonymous content, ARIA can't be used. Get list bullet text.
-  nsBlockFrame* blockFrame = do_QueryFrame(mContent->GetPrimaryFrame());
-  NS_ASSERTION(blockFrame, "No frame for list item!");
-  if (blockFrame) {
-    blockFrame->GetBulletText(aName);
-
-    // Append space otherwise bullets are jammed up against list text.
-    aName.Append(' ');
-  }
-
-  return eNameOK;
-}
-
-role
-nsHTMLListBulletAccessible::NativeRole()
-{
-  return roles::STATICTEXT;
-}
-
-PRUint64
-nsHTMLListBulletAccessible::NativeState()
-{
-  PRUint64 state = nsLeafAccessible::NativeState();
-
-  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());
-  NS_ASSERTION(blockFrame, "No frame for list item!");
-  if (blockFrame)
-    blockFrame->GetBulletText(bulletText);
-
-  aText.Append(Substring(bulletText, aStartOffset, aLength));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// nsHTMLListAccessible
-////////////////////////////////////////////////////////////////////////////////
-
-nsHTMLListAccessible::
-  nsHTMLListAccessible(nsIContent* aContent, nsDocAccessible* aDoc) :
-  nsHyperTextAccessibleWrap(aContent, aDoc)
-{
-}
-
-NS_IMPL_ISUPPORTS_INHERITED0(nsHTMLListAccessible, nsHyperTextAccessible)
-
-role
-nsHTMLListAccessible::NativeRole()
-{
-  if (mContent->Tag() == nsGkAtoms::dl)
-    return roles::DEFINITION_LIST;
-
-  return roles::LIST;
-}
-
-PRUint64
-nsHTMLListAccessible::NativeState()
-{
-  return nsHyperTextAccessibleWrap::NativeState() | states::READONLY;
-}
-

--- a/accessible/src/html/nsHTMLTextAccessible.h
+++ b/accessible/src/html/nsHTMLTextAccessible.h
@@ -114,83 +114,9 @@ public:
   NS_DECL_ISUPPORTS_INHERITED
 
   // nsAccessible
   virtual mozilla::a11y::role NativeRole();
   virtual nsresult GetAttributesInternal(nsIPersistentProperties* aAttributes);
   virtual Relation RelationByType(PRUint32 aType);
 };
 
-/**
- * Used for bullet of HTML list item element (for example, HTML li).
- */
-class nsHTMLListBulletAccessible : public nsLeafAccessible
-{
-public:
-  nsHTMLListBulletAccessible(nsIContent* aContent, nsDocAccessible* aDoc);
-
-  // nsAccessNode
-  virtual bool IsPrimaryForNode() const;
-
-  // nsAccessible
-  virtual mozilla::a11y::ENameValueFlag Name(nsString& aName);
-  virtual mozilla::a11y::role NativeRole();
-  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
-{
-public:
-  nsHTMLListAccessible(nsIContent* aContent, nsDocAccessible* aDoc);
-
-  // nsISupports
-  NS_DECL_ISUPPORTS_INHERITED
-
-  // nsAccessible
-  virtual mozilla::a11y::role NativeRole();
-  virtual PRUint64 NativeState();
-};
-
-/**
- * Used for HTML list item (e.g. HTML li).
- */
-class nsHTMLLIAccessible : public nsHyperTextAccessibleWrap
-{
-public:
-  nsHTMLLIAccessible(nsIContent* aContent, nsDocAccessible* aDoc);
-
-  // nsISupports
-  NS_DECL_ISUPPORTS_INHERITED
-
-  // nsAccessNode
-  virtual void Shutdown();
-
-  // nsIAccessible
-  NS_IMETHOD GetBounds(PRInt32 *x, PRInt32 *y, PRInt32 *width, PRInt32 *height);
-
-  // nsAccessible
-  virtual mozilla::a11y::role NativeRole();
-  virtual PRUint64 NativeState();
-
-  // nsHTMLLIAccessible
-  void UpdateBullet(bool aHasBullet);
-
-protected:
-  // nsAccessible
-  virtual void CacheChildren();
-
-private:
-  nsRefPtr<nsHTMLListBulletAccessible> mBullet;
-};
-
-inline nsHTMLLIAccessible*
-nsAccessible::AsHTMLListItem()
-{
-  return mFlags & eHTMLListItemAccessible ?
-    static_cast<nsHTMLLIAccessible*>(this) : nsnull;
-}
-
 #endif

--- a/accessible/src/jsat/AccessFu.jsm
+++ b/accessible/src/jsat/AccessFu.jsm
@@ -48,57 +48,52 @@ var AccessFu = {
     } catch (x) {
     }
 
     if (this.amINeeded(accessPref))
       this.enable();
   },
 
   /**
-   * Start the special AccessFu mode, this primarily means controlling the virtual
-   * cursor with arrow keys. Currently, on platforms other than Android this needs
-   * to be called explicitly.
+   * Start AccessFu mode, this primarily means controlling the virtual cursor
+   * with arrow keys.
    */
   enable: function enable() {
     dump('AccessFu enable');
     this.addPresenter(new VisualPresenter());
 
     // Implicitly add the Android presenter on Android.
     if (Services.appinfo.OS == 'Android')
       this.addPresenter(new AndroidPresenter());
 
     VirtualCursorController.attach(this.chromeWin);
 
     Services.obs.addObserver(this, 'accessible-event', false);
     this.chromeWin.addEventListener('DOMActivate', this, true);
     this.chromeWin.addEventListener('resize', this, true);
     this.chromeWin.addEventListener('scroll', this, true);
     this.chromeWin.addEventListener('TabOpen', this, true);
-    this.chromeWin.addEventListener('TabSelect', this, true);
-    this.chromeWin.addEventListener('TabClosed', this, true);
   },
 
   /**
    * Disable AccessFu and return to default interaction mode.
    */
   disable: function disable() {
     dump('AccessFu disable');
 
-    this.presenters.forEach(function(p) {p.detach();});
+    this.presenters.forEach(function(p) { p.detach(); });
     this.presenters = [];
 
     VirtualCursorController.detach();
 
-    Services.obs.addObserver(this, 'accessible-event', false);
-    this.chromeWin.removeEventListener('DOMActivate', this);
-    this.chromeWin.removeEventListener('resize', this);
-    this.chromeWin.removeEventListener('scroll', this);
-    this.chromeWin.removeEventListener('TabOpen', this);
-    this.chromeWin.removeEventListener('TabSelect', this);
-    this.chromeWin.removeEventListener('TabClose', this);
+    Services.obs.removeObserver(this, 'accessible-event');
+    this.chromeWin.removeEventListener('DOMActivate', this, true);
+    this.chromeWin.removeEventListener('resize', this, true);
+    this.chromeWin.removeEventListener('scroll', this, true);
+    this.chromeWin.removeEventListener('TabOpen', this, true);
   },
 
   amINeeded: function(aPref) {
     switch (aPref) {
       case ACCESSFU_ENABLE:
         return true;
       case ACCESSFU_AUTO:
         if (Services.appinfo.OS == 'Android') {
@@ -120,24 +115,27 @@ var AccessFu = {
 
   addPresenter: function addPresenter(presenter) {
     this.presenters.push(presenter);
     presenter.attach(this.chromeWin);
   },
 
   handleEvent: function handleEvent(aEvent) {
     switch (aEvent.type) {
-      case 'TabSelect':
-        {
-          this.getDocAccessible(
-              function(docAcc) {
-                this.presenters.forEach(function(p) {p.tabSelected(docAcc);});
-              });
-          break;
-        }
+      case 'TabOpen':
+      {
+        let browser = aEvent.target.linkedBrowser || aEvent.target;
+        // Store the new browser node. We will need to check later when a new
+        // content document is attached if it has been attached to this new tab.
+        // If it has, than we will need to send a 'loading' message along with
+        // the usual 'newdoc' to presenters.
+        this._pendingDocuments[browser] = true;
+        this.presenters.forEach(function(p) { p.tabStateChanged(null, 'newtab'); });
+        break;
+      }
       case 'DOMActivate':
       {
         let activatedAcc = getAccessible(aEvent.originalTarget);
         let state = {};
         activatedAcc.getState(state, {});
 
         // Checkable objects will have a state changed event that we will use
         // instead of this hackish DOMActivate. We will also know the true
@@ -148,35 +146,22 @@ var AccessFu = {
         this.presenters.forEach(function(p) {
                                   p.actionInvoked(activatedAcc, 'click');
                                 });
         break;
       }
       case 'scroll':
       case 'resize':
       {
-        this.presenters.forEach(function(p) {p.viewportChanged();});
+        this.presenters.forEach(function(p) { p.viewportChanged(); });
         break;
       }
     }
   },
 
-  getDocAccessible: function getDocAccessible(aCallback) {
-    let browserApp = (Services.appinfo.OS == 'Android') ?
-      this.chromeWin.BrowserApp : this.chromeWin.gBrowser;
-
-    let docAcc = getAccessible(browserApp.selectedBrowser.contentDocument);
-    if (!docAcc) {
-      // Wait for a reorder event fired by the parent of the new doc.
-      this._pendingDocuments[browserApp.selectedBrowser] = aCallback;
-    } else {
-      aCallback.apply(this, [docAcc]);
-    }
-  },
-
   observe: function observe(aSubject, aTopic, aData) {
     switch (aTopic) {
       case 'nsPref:changed':
         if (aData == 'accessfu') {
           if (this.amINeeded(this.prefsBranch.getIntPref('accessfu')))
             this.enable();
           else
             this.disable();
@@ -218,26 +203,96 @@ var AccessFu = {
               !(event.isExtraState())) {
             this.presenters.forEach(
               function(p) {
                 p.actionInvoked(aEvent.accessible,
                                 event.isEnabled() ? 'check' : 'uncheck');
               }
             );
           }
+          else if (event.state == Ci.nsIAccessibleStates.STATE_BUSY &&
+                   !(event.isExtraState()) && event.isEnabled()) {
+            let role = event.accessible.role;
+            if ((role == Ci.nsIAccessibleRole.ROLE_DOCUMENT ||
+                 role == Ci.nsIAccessibleRole.ROLE_APPLICATION)) {
+              // An existing document has changed to state "busy", this means
+              // something is loading. Send a 'loading' message to presenters.
+              this.presenters.forEach(
+                function(p) {
+                  p.tabStateChanged(event.accessible, 'loading');
+                }
+              );
+            }
+          }
           break;
         }
       case Ci.nsIAccessibleEvent.EVENT_REORDER:
         {
-          let node = aEvent.accessible.DOMNode;
-          let callback = this._pendingDocuments[node];
-          if (callback && aEvent.accessible.childCount) {
-            // We have a callback associated with a document.
-            callback.apply(this, [aEvent.accessible.getChildAt(0)]);
-            delete this._pendingDocuments[node];
+          let acc = aEvent.accessible;
+          if (acc.childCount) {
+            let docAcc = acc.getChildAt(0);
+            if (this._pendingDocuments[aEvent.DOMNode]) {
+              // This is a document in a new tab. Check if it is
+              // in a BUSY state (i.e. loading), and inform presenters.
+              // We need to do this because a state change event will not be
+              // fired when an object is created with the BUSY state.
+              // If this is not a new tab, don't bother because we sent 'loading'
+              // when the previous doc changed its state to BUSY.
+              let state = {};
+              docAcc.getState(state, {});
+              if (state.value & Ci.nsIAccessibleStates.STATE_BUSY &&
+                  this.isNotChromeDoc(docAcc))
+                this.presenters.forEach(
+                  function(p) { p.tabStateChanged(docAcc, 'loading'); }
+                );
+              delete this._pendingDocuments[aEvent.DOMNode];
+            }
+            if (this.isBrowserDoc(docAcc))
+              // A new top-level content document has been attached
+              this.presenters.forEach(
+                function(p) { p.tabStateChanged(docAcc, 'newdoc'); }
+              );
+          }
+          break;
+        }
+      case Ci.nsIAccessibleEvent.EVENT_DOCUMENT_LOAD_COMPLETE:
+        {
+          if (this.isNotChromeDoc(aEvent.accessible)) {
+            this.presenters.forEach(
+              function(p) {
+                p.tabStateChanged(aEvent.accessible, 'loaded');
+              }
+            );
+          }
+          break;
+        }
+      case Ci.nsIAccessibleEvent.EVENT_DOCUMENT_LOAD_STOPPED:
+        {
+          this.presenters.forEach(
+            function(p) {
+              p.tabStateChanged(aEvent.accessible, 'loadstopped');
+            }
+          );
+          break;
+        }
+      case Ci.nsIAccessibleEvent.EVENT_DOCUMENT_RELOAD:
+        {
+          this.presenters.forEach(
+            function(p) {
+              p.tabStateChanged(aEvent.accessible, 'reload');
+            }
+          );
+          break;
+        }
+      case Ci.nsIAccessibleEvent.EVENT_FOCUS:
+        {
+          if (this.isBrowserDoc(aEvent.accessible)) {
+            // The document recieved focus, call tabSelected to present current tab.
+            this.presenters.forEach(
+              function(p) { p.tabSelected(aEvent.accessible); });
           }
           break;
         }
       case Ci.nsIAccessibleEvent.EVENT_TEXT_INSERTED:
       case Ci.nsIAccessibleEvent.EVENT_TEXT_REMOVED:
       {
         if (aEvent.isFromUserInput) {
           // XXX support live regions as well.
@@ -264,16 +319,48 @@ var AccessFu = {
         }
         break;
       }
       default:
         break;
     }
   },
 
+  /**
+   * Check if accessible is a top-level content document (i.e. a child of a XUL
+   * browser node).
+   * @param {nsIAccessible} aDocAcc the accessible to check.
+   * @return {boolean} true if this is a top-level content document.
+   */
+  isBrowserDoc: function isBrowserDoc(aDocAcc) {
+    let parent = aDocAcc.parent;
+    if (!parent)
+      return false;
+
+    let domNode = parent.DOMNode;
+    if (!domNode)
+      return false;
+
+    const ns = 'http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul';
+    return (domNode.localName == 'browser' && domNode.namespaceURI == ns);
+  },
+
+  /**
+   * Check if document is not a local "chrome" document, like about:home.
+   * @param {nsIDOMDocument} aDocument the document to check.
+   * @return {boolean} true if this is not a chrome document.
+   */
+  isNotChromeDoc: function isNotChromeDoc(aDocument) {
+    let location = aDocument.DOMNode.location;
+    if (!location)
+      return false;
+
+    return location.protocol != "about:";
+  },
+
   getNewContext: function getNewContext(aOldObject, aNewObject) {
     let newLineage = [];
     let oldLineage = [];
 
     let parent = aNewObject;
     while ((parent = parent.parent))
       newLineage.push(parent);
 

--- a/accessible/src/jsat/Presenters.jsm
+++ b/accessible/src/jsat/Presenters.jsm
@@ -61,25 +61,31 @@ Presenter.prototype = {
 
   /**
    * Selection has changed. TODO.
    * @param {nsIAccessible} aObject the object that has been selected.
    */
   selectionChanged: function selectionChanged(aObject) {},
 
   /**
-   * The page state has changed, loading, stopped loading, etc. TODO.
+   * The tab, or the tab's document state has changed.
+   * @param {nsIAccessible} aDocObj the tab document accessible that has had its
+   *    state changed, or null if the tab has no associated document yet.
+   * @param {string} aPageState the state name for the tab, valid states are:
+   *    'newtab', 'loading', 'newdoc', 'loaded', 'stopped', and 'reload'.
    */
-  pageStateChanged: function pageStateChanged() {},
+  tabStateChanged: function tabStateChanged(aDocObj, aPageState) {},
 
   /**
-   * The tab has changed.
-   * @param {nsIAccessible} aObject the document contained in the tab.
+   * The current tab has changed.
+   * @param {nsIAccessible} aObject the document contained by the tab
+   *    accessible, or null if it is a new tab with no attached
+   *    document yet.
    */
-  tabSelected: function tabSelected(aObject) {},
+  tabSelected: function tabSelected(aDocObj) {},
 
   /**
    * The viewport has changed, either a scroll, pan, zoom, or
    *    landscape/portrait toggle.
    */
   viewportChanged: function viewportChanged() {}
 };
 
@@ -142,19 +148,27 @@ VisualPresenter.prototype.pivotChanged =
     aObject.scrollTo(Ci.nsIAccessibleScrollType.SCROLL_TYPE_ANYWHERE);
     this.highlight(aObject);
   } catch (e) {
     dump('Error getting bounds: ' + e);
     return;
   }
 };
 
-VisualPresenter.prototype.tabSelected = function(aObject) {
-  let vcDoc = aObject.QueryInterface(Ci.nsIAccessibleCursorable);
-  this.pivotChanged(vcDoc.virtualCursor.position);
+VisualPresenter.prototype.tabSelected = function(aDocObj) {
+  let vcPos = aDocObj ?
+    aDocObj.QueryInterface(Ci.nsIAccessibleCursorable).virtualCursor.position :
+    null;
+
+  this.pivotChanged(vcPos);
+};
+
+VisualPresenter.prototype.tabStateChanged = function(aDocObj, aPageState) {
+  if (aPageState == "newdoc")
+    this.pivotChanged(null);
 };
 
 // Internals
 
 VisualPresenter.prototype.hide = function hide() {
   this.highlightBox.style.display = 'none';
 };
 
@@ -237,26 +251,50 @@ AndroidPresenter.prototype.actionInvoked
     gecko: {
       type: 'Accessibility:Event',
       eventType: ANDROID_TYPE_VIEW_CLICKED,
       text: UtteranceGenerator.genForAction(aObject, aActionName)
     }
   });
 };
 
-AndroidPresenter.prototype.tabSelected = function(aObject) {
-  let vcDoc = aObject.QueryInterface(Ci.nsIAccessibleCursorable);
+AndroidPresenter.prototype.tabSelected = function(aDocObj) {
+  // Send a pivot change message with the full context utterance for this doc.
+  let vcDoc = aDocObj.QueryInterface(Ci.nsIAccessibleCursorable);
   let context = [];
 
-  let parent = vcDoc.virtualCursor.position || aObject;
-  while ((parent = parent.parent))
+  let parent = vcDoc.virtualCursor.position || aDocObj;
+  while ((parent = parent.parent)) {
     context.push(parent);
+    if (parent == aDocObj)
+      break;
+  }
+
   context.reverse();
 
-  this.pivotChanged(vcDoc.virtualCursor.position || aObject, context);
+  this.pivotChanged(vcDoc.virtualCursor.position || aDocObj, context);
+};
+
+AndroidPresenter.prototype.tabStateChanged = function(aDocObj, aPageState) {
+  let stateUtterance = UtteranceGenerator.
+    genForTabStateChange(aDocObj, aPageState);
+
+  if (!stateUtterance.length)
+    return;
+
+  this.sendMessageToJava({
+    gecko: {
+      type: 'Accessibility:Event',
+      eventType: ANDROID_TYPE_VIEW_TEXT_CHANGED,
+      text: stateUtterance,
+      addedCount: stateUtterance.join(' ').length,
+      removedCount: 0,
+      fromIndex: 0
+    }
+  });
 };
 
 AndroidPresenter.prototype.textChanged = function(aIsInserted, aStart, aLength, aText, aModifiedText) {
   let androidEvent = {
     type: 'Accessibility:Event',
     eventType: ANDROID_TYPE_VIEW_TEXT_CHANGED,
     text: [aText],
     fromIndex: aStart