michael@0: /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: #include "mozilla/dom/TabParent.h"
michael@0: 
michael@0: #include "nsFocusManager.h"
michael@0: 
michael@0: #include "nsIInterfaceRequestorUtils.h"
michael@0: #include "nsGkAtoms.h"
michael@0: #include "nsContentUtils.h"
michael@0: #include "nsIDocument.h"
michael@0: #include "nsIDOMWindow.h"
michael@0: #include "nsPIDOMWindow.h"
michael@0: #include "nsIDOMElement.h"
michael@0: #include "nsIDOMDocument.h"
michael@0: #include "nsIDOMRange.h"
michael@0: #include "nsIHTMLDocument.h"
michael@0: #include "nsIDocShell.h"
michael@0: #include "nsIDocShellTreeOwner.h"
michael@0: #include "nsLayoutUtils.h"
michael@0: #include "nsIPresShell.h"
michael@0: #include "nsFrameTraversal.h"
michael@0: #include "nsIWebNavigation.h"
michael@0: #include "nsCaret.h"
michael@0: #include "nsIBaseWindow.h"
michael@0: #include "nsViewManager.h"
michael@0: #include "nsFrameSelection.h"
michael@0: #include "mozilla/dom/Selection.h"
michael@0: #include "nsXULPopupManager.h"
michael@0: #include "nsIScriptObjectPrincipal.h"
michael@0: #include "nsIPrincipal.h"
michael@0: #include "nsIObserverService.h"
michael@0: #include "nsIObjectFrame.h"
michael@0: #include "nsBindingManager.h"
michael@0: #include "nsStyleCoord.h"
michael@0: 
michael@0: #include "mozilla/ContentEvents.h"
michael@0: #include "mozilla/dom/Element.h"
michael@0: #include "mozilla/EventDispatcher.h"
michael@0: #include "mozilla/EventStateManager.h"
michael@0: #include "mozilla/EventStates.h"
michael@0: #include "mozilla/IMEStateManager.h"
michael@0: #include "mozilla/LookAndFeel.h"
michael@0: #include "mozilla/Preferences.h"
michael@0: #include "mozilla/Services.h"
michael@0: #include <algorithm>
michael@0: 
michael@0: #ifdef MOZ_XUL
michael@0: #include "nsIDOMXULTextboxElement.h"
michael@0: #include "nsIDOMXULMenuListElement.h"
michael@0: #endif
michael@0: 
michael@0: #ifdef ACCESSIBILITY
michael@0: #include "nsAccessibilityService.h"
michael@0: #endif
michael@0: 
michael@0: #ifndef XP_MACOSX
michael@0: #include "nsIScriptError.h"
michael@0: #endif
michael@0: 
michael@0: using namespace mozilla;
michael@0: using namespace mozilla::dom;
michael@0: using namespace mozilla::widget;
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0: 
michael@0: // Two types of focus pr logging are available:
michael@0: //   'Focus' for normal focus manager calls
michael@0: //   'FocusNavigation' for tab and document navigation
michael@0: PRLogModuleInfo* gFocusLog;
michael@0: PRLogModuleInfo* gFocusNavigationLog;
michael@0: 
michael@0: #define LOGFOCUS(args) PR_LOG(gFocusLog, 4, args)
michael@0: #define LOGFOCUSNAVIGATION(args) PR_LOG(gFocusNavigationLog, 4, args)
michael@0: 
michael@0: #define LOGTAG(log, format, content)                            \
michael@0:   {                                                             \
michael@0:     nsAutoCString tag(NS_LITERAL_CSTRING("(none)"));            \
michael@0:     if (content) {                                              \
michael@0:       content->Tag()->ToUTF8String(tag);                        \
michael@0:     }                                                           \
michael@0:     PR_LOG(log, 4, (format, tag.get()));                        \
michael@0:   }
michael@0: 
michael@0: #define LOGCONTENT(format, content) LOGTAG(gFocusLog, format, content)
michael@0: #define LOGCONTENTNAVIGATION(format, content) LOGTAG(gFocusNavigationLog, format, content)
michael@0: 
michael@0: #else
michael@0: 
michael@0: #define LOGFOCUS(args)
michael@0: #define LOGFOCUSNAVIGATION(args)
michael@0: #define LOGCONTENT(format, content)
michael@0: #define LOGCONTENTNAVIGATION(format, content)
michael@0: 
michael@0: #endif
michael@0: 
michael@0: struct nsDelayedBlurOrFocusEvent
michael@0: {
michael@0:   nsDelayedBlurOrFocusEvent(uint32_t aType,
michael@0:                             nsIPresShell* aPresShell,
michael@0:                             nsIDocument* aDocument,
michael@0:                             EventTarget* aTarget)
michael@0:    : mType(aType),
michael@0:      mPresShell(aPresShell),
michael@0:      mDocument(aDocument),
michael@0:      mTarget(aTarget) { }
michael@0: 
michael@0:   nsDelayedBlurOrFocusEvent(const nsDelayedBlurOrFocusEvent& aOther)
michael@0:    : mType(aOther.mType),
michael@0:      mPresShell(aOther.mPresShell),
michael@0:      mDocument(aOther.mDocument),
michael@0:      mTarget(aOther.mTarget) { }
michael@0: 
michael@0:   uint32_t mType;
michael@0:   nsCOMPtr<nsIPresShell> mPresShell;
michael@0:   nsCOMPtr<nsIDocument> mDocument;
michael@0:   nsCOMPtr<EventTarget> mTarget;
michael@0: };
michael@0: 
michael@0: NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsFocusManager)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsIFocusManager)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsIObserver)
michael@0:   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
michael@0:   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIFocusManager)
michael@0: NS_INTERFACE_MAP_END
michael@0: 
michael@0: NS_IMPL_CYCLE_COLLECTING_ADDREF(nsFocusManager)
michael@0: NS_IMPL_CYCLE_COLLECTING_RELEASE(nsFocusManager)
michael@0: 
michael@0: NS_IMPL_CYCLE_COLLECTION(nsFocusManager,
michael@0:                          mActiveWindow,
michael@0:                          mFocusedWindow,
michael@0:                          mFocusedContent,
michael@0:                          mFirstBlurEvent,
michael@0:                          mFirstFocusEvent,
michael@0:                          mWindowBeingLowered)
michael@0: 
michael@0: nsFocusManager* nsFocusManager::sInstance = nullptr;
michael@0: bool nsFocusManager::sMouseFocusesFormControl = false;
michael@0: bool nsFocusManager::sTestMode = false;
michael@0: 
michael@0: static const char* kObservedPrefs[] = {
michael@0:   "accessibility.browsewithcaret",
michael@0:   "accessibility.tabfocus_applies_to_xul",
michael@0:   "accessibility.mouse_focuses_formcontrol",
michael@0:   "focusmanager.testmode",
michael@0:   nullptr
michael@0: };
michael@0: 
michael@0: nsFocusManager::nsFocusManager()
michael@0: { }
michael@0: 
michael@0: nsFocusManager::~nsFocusManager()
michael@0: {
michael@0:   Preferences::RemoveObservers(this, kObservedPrefs);
michael@0: 
michael@0:   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
michael@0:   if (obs) {
michael@0:     obs->RemoveObserver(this, "xpcom-shutdown");
michael@0:   }
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsresult
michael@0: nsFocusManager::Init()
michael@0: {
michael@0:   nsFocusManager* fm = new nsFocusManager();
michael@0:   NS_ENSURE_TRUE(fm, NS_ERROR_OUT_OF_MEMORY);
michael@0:   NS_ADDREF(fm);
michael@0:   sInstance = fm;
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0:   gFocusLog = PR_NewLogModule("Focus");
michael@0:   gFocusNavigationLog = PR_NewLogModule("FocusNavigation");
michael@0: #endif
michael@0: 
michael@0:   nsIContent::sTabFocusModelAppliesToXUL =
michael@0:     Preferences::GetBool("accessibility.tabfocus_applies_to_xul",
michael@0:                          nsIContent::sTabFocusModelAppliesToXUL);
michael@0: 
michael@0:   sMouseFocusesFormControl =
michael@0:     Preferences::GetBool("accessibility.mouse_focuses_formcontrol", false);
michael@0: 
michael@0:   sTestMode = Preferences::GetBool("focusmanager.testmode", false);
michael@0: 
michael@0:   Preferences::AddWeakObservers(fm, kObservedPrefs);
michael@0: 
michael@0:   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
michael@0:   if (obs) {
michael@0:     obs->AddObserver(fm, "xpcom-shutdown", true);
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // static
michael@0: void
michael@0: nsFocusManager::Shutdown()
michael@0: {
michael@0:   NS_IF_RELEASE(sInstance);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::Observe(nsISupports *aSubject,
michael@0:                         const char *aTopic,
michael@0:                         const char16_t *aData)
michael@0: {
michael@0:   if (!nsCRT::strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
michael@0:     nsDependentString data(aData);
michael@0:     if (data.EqualsLiteral("accessibility.browsewithcaret")) {
michael@0:       UpdateCaretForCaretBrowsingMode();
michael@0:     }
michael@0:     else if (data.EqualsLiteral("accessibility.tabfocus_applies_to_xul")) {
michael@0:       nsIContent::sTabFocusModelAppliesToXUL =
michael@0:         Preferences::GetBool("accessibility.tabfocus_applies_to_xul",
michael@0:                              nsIContent::sTabFocusModelAppliesToXUL);
michael@0:     }
michael@0:     else if (data.EqualsLiteral("accessibility.mouse_focuses_formcontrol")) {
michael@0:       sMouseFocusesFormControl =
michael@0:         Preferences::GetBool("accessibility.mouse_focuses_formcontrol",
michael@0:                              false);
michael@0:     }
michael@0:     else if (data.EqualsLiteral("focusmanager.testmode")) {
michael@0:       sTestMode = Preferences::GetBool("focusmanager.testmode", false);
michael@0:     }
michael@0:   } else if (!nsCRT::strcmp(aTopic, "xpcom-shutdown")) {
michael@0:     mActiveWindow = nullptr;
michael@0:     mFocusedWindow = nullptr;
michael@0:     mFocusedContent = nullptr;
michael@0:     mFirstBlurEvent = nullptr;
michael@0:     mFirstFocusEvent = nullptr;
michael@0:     mWindowBeingLowered = nullptr;
michael@0:     mDelayedBlurFocusEvents.Clear();
michael@0:     mMouseDownEventHandlingDocument = nullptr;
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: // given a frame content node, retrieve the nsIDOMWindow displayed in it 
michael@0: static nsPIDOMWindow*
michael@0: GetContentWindow(nsIContent* aContent)
michael@0: {
michael@0:   nsIDocument* doc = aContent->GetCurrentDoc();
michael@0:   if (doc) {
michael@0:     nsIDocument* subdoc = doc->GetSubDocumentFor(aContent);
michael@0:     if (subdoc)
michael@0:       return subdoc->GetWindow();
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: // get the current window for the given content node 
michael@0: static nsPIDOMWindow*
michael@0: GetCurrentWindow(nsIContent* aContent)
michael@0: {
michael@0:   nsIDocument *doc = aContent->GetCurrentDoc();
michael@0:   return doc ? doc->GetWindow() : nullptr;
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsIContent*
michael@0: nsFocusManager::GetFocusedDescendant(nsPIDOMWindow* aWindow, bool aDeep,
michael@0:                                      nsPIDOMWindow** aFocusedWindow)
michael@0: {
michael@0:   NS_ENSURE_TRUE(aWindow, nullptr);
michael@0: 
michael@0:   *aFocusedWindow = nullptr;
michael@0: 
michael@0:   nsIContent* currentContent = nullptr;
michael@0:   nsPIDOMWindow* window = aWindow->GetOuterWindow();
michael@0:   while (window) {
michael@0:     *aFocusedWindow = window;
michael@0:     currentContent = window->GetFocusedNode();
michael@0:     if (!currentContent || !aDeep)
michael@0:       break;
michael@0: 
michael@0:     window = GetContentWindow(currentContent);
michael@0:   }
michael@0: 
michael@0:   NS_IF_ADDREF(*aFocusedWindow);
michael@0: 
michael@0:   return currentContent;
michael@0: }
michael@0: 
michael@0: // static
michael@0: nsIContent*
michael@0: nsFocusManager::GetRedirectedFocus(nsIContent* aContent)
michael@0: {
michael@0: #ifdef MOZ_XUL
michael@0:   if (aContent->IsXUL()) {
michael@0:     nsCOMPtr<nsIDOMNode> inputField;
michael@0: 
michael@0:     nsCOMPtr<nsIDOMXULTextBoxElement> textbox = do_QueryInterface(aContent);
michael@0:     if (textbox) {
michael@0:       textbox->GetInputField(getter_AddRefs(inputField));
michael@0:     }
michael@0:     else {
michael@0:       nsCOMPtr<nsIDOMXULMenuListElement> menulist = do_QueryInterface(aContent);
michael@0:       if (menulist) {
michael@0:         menulist->GetInputField(getter_AddRefs(inputField));
michael@0:       }
michael@0:       else if (aContent->Tag() == nsGkAtoms::scale) {
michael@0:         nsCOMPtr<nsIDocument> doc = aContent->GetCurrentDoc();
michael@0:         if (!doc)
michael@0:           return nullptr;
michael@0: 
michael@0:         nsINodeList* children = doc->BindingManager()->GetAnonymousNodesFor(aContent);
michael@0:         if (children) {
michael@0:           nsIContent* child = children->Item(0);
michael@0:           if (child && child->Tag() == nsGkAtoms::slider)
michael@0:             return child;
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     if (inputField) {
michael@0:       nsCOMPtr<nsIContent> retval = do_QueryInterface(inputField);
michael@0:       return retval;
michael@0:     }
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: // static
michael@0: InputContextAction::Cause
michael@0: nsFocusManager::GetFocusMoveActionCause(uint32_t aFlags)
michael@0: {
michael@0:   if (aFlags & nsIFocusManager::FLAG_BYMOUSE) {
michael@0:     return InputContextAction::CAUSE_MOUSE;
michael@0:   } else if (aFlags & nsIFocusManager::FLAG_BYKEY) {
michael@0:     return InputContextAction::CAUSE_KEY;
michael@0:   }
michael@0:   return InputContextAction::CAUSE_UNKNOWN;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::GetActiveWindow(nsIDOMWindow** aWindow)
michael@0: {
michael@0:   NS_IF_ADDREF(*aWindow = mActiveWindow);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::SetActiveWindow(nsIDOMWindow* aWindow)
michael@0: {
michael@0:   // only top-level windows can be made active
michael@0:   nsCOMPtr<nsPIDOMWindow> piWindow = do_QueryInterface(aWindow);
michael@0:   if (piWindow)
michael@0:       piWindow = piWindow->GetOuterWindow();
michael@0: 
michael@0:   NS_ENSURE_TRUE(piWindow && (piWindow == piWindow->GetPrivateRoot()),
michael@0:                  NS_ERROR_INVALID_ARG);
michael@0: 
michael@0:   RaiseWindow(piWindow);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::GetFocusedWindow(nsIDOMWindow** aFocusedWindow)
michael@0: {
michael@0:   NS_IF_ADDREF(*aFocusedWindow = mFocusedWindow);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsFocusManager::SetFocusedWindow(nsIDOMWindow* aWindowToFocus)
michael@0: {
michael@0:   LOGFOCUS(("<<SetFocusedWindow begin>>"));
michael@0: 
michael@0:   nsCOMPtr<nsPIDOMWindow> windowToFocus(do_QueryInterface(aWindowToFocus));
michael@0:   NS_ENSURE_TRUE(windowToFocus, NS_ERROR_FAILURE);
michael@0: 
michael@0:   windowToFocus = windowToFocus->GetOuterWindow();
michael@0: 
michael@0:   nsCOMPtr<nsIContent> frameContent =
michael@0:     do_QueryInterface(windowToFocus->GetFrameElementInternal());
michael@0:   if (frameContent) {
michael@0:     // pass false for aFocusChanged so that the caret does not get updated
michael@0:     // and scrolling does not occur.
michael@0:     SetFocusInner(frameContent, 0, false, true);
michael@0:   }
michael@0:   else {
michael@0:     // this is a top-level window. If the window has a child frame focused,
michael@0:     // clear the focus. Otherwise, focus should already be in this frame, or
michael@0:     // already cleared. This ensures that focus will be in this frame and not
michael@0:     // in a child.
michael@0:     nsIContent* content = windowToFocus->GetFocusedNode();
michael@0:     if (content) {
michael@0:       nsCOMPtr<nsIDOMWindow> childWindow = GetContentWindow(content);
michael@0:       if (childWindow)
michael@0:         ClearFocus(windowToFocus);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsPIDOMWindow> rootWindow = windowToFocus->GetPrivateRoot();
michael@0:   if (rootWindow)
michael@0:     RaiseWindow(rootWindow);
michael@0: 
michael@0:   LOGFOCUS(("<<SetFocusedWindow end>>"));
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::GetFocusedElement(nsIDOMElement** aFocusedElement)
michael@0: {
michael@0:   if (mFocusedContent)
michael@0:     CallQueryInterface(mFocusedContent, aFocusedElement);
michael@0:   else
michael@0:     *aFocusedElement = nullptr;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::GetLastFocusMethod(nsIDOMWindow* aWindow, uint32_t* aLastFocusMethod)
michael@0: {
michael@0:   // the focus method is stored on the inner window
michael@0:   nsCOMPtr<nsPIDOMWindow> window(do_QueryInterface(aWindow));
michael@0:   if (window)
michael@0:     window = window->GetCurrentInnerWindow();
michael@0:   if (!window)
michael@0:     window = mFocusedWindow;
michael@0: 
michael@0:   *aLastFocusMethod = window ? window->GetFocusMethod() : 0;
michael@0: 
michael@0:   NS_ASSERTION((*aLastFocusMethod & FOCUSMETHOD_MASK) == *aLastFocusMethod,
michael@0:                "invalid focus method");
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::SetFocus(nsIDOMElement* aElement, uint32_t aFlags)
michael@0: {
michael@0:   LOGFOCUS(("<<SetFocus begin>>"));
michael@0: 
michael@0:   nsCOMPtr<nsIContent> newFocus = do_QueryInterface(aElement);
michael@0:   NS_ENSURE_ARG(newFocus);
michael@0: 
michael@0:   SetFocusInner(newFocus, aFlags, true, true);
michael@0: 
michael@0:   LOGFOCUS(("<<SetFocus end>>"));
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::ElementIsFocusable(nsIDOMElement* aElement, uint32_t aFlags,
michael@0:                                    bool* aIsFocusable)
michael@0: {
michael@0:   NS_ENSURE_TRUE(aElement, NS_ERROR_INVALID_ARG);
michael@0: 
michael@0:   nsCOMPtr<nsIContent> aContent = do_QueryInterface(aElement);
michael@0: 
michael@0:   *aIsFocusable = CheckIfFocusable(aContent, aFlags) != nullptr;
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::MoveFocus(nsIDOMWindow* aWindow, nsIDOMElement* aStartElement,
michael@0:                           uint32_t aType, uint32_t aFlags, nsIDOMElement** aElement)
michael@0: {
michael@0:   *aElement = nullptr;
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0:   LOGFOCUS(("<<MoveFocus begin Type: %d Flags: %x>>", aType, aFlags));
michael@0: 
michael@0:   if (PR_LOG_TEST(gFocusLog, PR_LOG_DEBUG) && mFocusedWindow) {
michael@0:     nsIDocument* doc = mFocusedWindow->GetExtantDoc();
michael@0:     if (doc && doc->GetDocumentURI()) {
michael@0:       nsAutoCString spec;
michael@0:       doc->GetDocumentURI()->GetSpec(spec);
michael@0:       LOGFOCUS((" Focused Window: %p %s", mFocusedWindow.get(), spec.get()));
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   LOGCONTENT("  Current Focus: %s", mFocusedContent.get());
michael@0: #endif
michael@0: 
michael@0:   // use FLAG_BYMOVEFOCUS when switching focus with MoveFocus unless one of
michael@0:   // the other focus methods is already set, or we're just moving to the root
michael@0:   // or caret position.
michael@0:   if (aType != MOVEFOCUS_ROOT && aType != MOVEFOCUS_CARET &&
michael@0:       (aFlags & FOCUSMETHOD_MASK) == 0) {
michael@0:     aFlags |= FLAG_BYMOVEFOCUS;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsPIDOMWindow> window;
michael@0:   nsCOMPtr<nsIContent> startContent;
michael@0:   if (aStartElement) {
michael@0:     startContent = do_QueryInterface(aStartElement);
michael@0:     NS_ENSURE_TRUE(startContent, NS_ERROR_INVALID_ARG);
michael@0: 
michael@0:     window = GetCurrentWindow(startContent);
michael@0:   }
michael@0:   else {
michael@0:     window = aWindow ? do_QueryInterface(aWindow) : mFocusedWindow;
michael@0:     NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
michael@0:     window = window->GetOuterWindow();
michael@0:   }
michael@0: 
michael@0:   NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
michael@0: 
michael@0:   bool noParentTraversal = aFlags & FLAG_NOPARENTFRAME;
michael@0:   nsCOMPtr<nsIContent> newFocus;
michael@0:   nsresult rv = DetermineElementToMoveFocus(window, startContent, aType, noParentTraversal,
michael@0:                                             getter_AddRefs(newFocus));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   LOGCONTENTNAVIGATION("Element to be focused: %s", newFocus.get());
michael@0: 
michael@0:   if (newFocus) {
michael@0:     // for caret movement, pass false for the aFocusChanged argument,
michael@0:     // otherwise the caret will end up moving to the focus position. This
michael@0:     // would be a problem because the caret would move to the beginning of the
michael@0:     // focused link making it impossible to navigate the caret over a link.
michael@0:     SetFocusInner(newFocus, aFlags, aType != MOVEFOCUS_CARET, true);
michael@0:     CallQueryInterface(newFocus, aElement);
michael@0:   }
michael@0:   else if (aType == MOVEFOCUS_ROOT || aType == MOVEFOCUS_CARET) {
michael@0:     // no content was found, so clear the focus for these two types.
michael@0:     ClearFocus(window);
michael@0:   }
michael@0: 
michael@0:   LOGFOCUS(("<<MoveFocus end>>"));
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::ClearFocus(nsIDOMWindow* aWindow)
michael@0: {
michael@0:   LOGFOCUS(("<<ClearFocus begin>>"));
michael@0: 
michael@0:   // if the window to clear is the focused window or an ancestor of the
michael@0:   // focused window, then blur the existing focused content. Otherwise, the
michael@0:   // focus is somewhere else so just update the current node.
michael@0:   nsCOMPtr<nsPIDOMWindow> window(do_QueryInterface(aWindow));
michael@0:   NS_ENSURE_TRUE(window, NS_ERROR_INVALID_ARG);
michael@0: 
michael@0:   window = window->GetOuterWindow();
michael@0:   NS_ENSURE_TRUE(window, NS_ERROR_INVALID_ARG);
michael@0: 
michael@0:   if (IsSameOrAncestor(window, mFocusedWindow)) {
michael@0:     bool isAncestor = (window != mFocusedWindow);
michael@0:     if (Blur(window, nullptr, isAncestor, true)) {
michael@0:       // if we are clearing the focus on an ancestor of the focused window,
michael@0:       // the ancestor will become the new focused window, so focus it
michael@0:       if (isAncestor)
michael@0:         Focus(window, nullptr, 0, true, false, false, true);
michael@0:     }
michael@0:   }
michael@0:   else {
michael@0:     window->SetFocusedNode(nullptr);
michael@0:   }
michael@0: 
michael@0:   LOGFOCUS(("<<ClearFocus end>>"));
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::GetFocusedElementForWindow(nsIDOMWindow* aWindow,
michael@0:                                            bool aDeep,
michael@0:                                            nsIDOMWindow** aFocusedWindow,
michael@0:                                            nsIDOMElement** aElement)
michael@0: {
michael@0:   *aElement = nullptr;
michael@0:   if (aFocusedWindow)
michael@0:     *aFocusedWindow = nullptr;
michael@0: 
michael@0:   nsCOMPtr<nsPIDOMWindow> window(do_QueryInterface(aWindow));
michael@0:   NS_ENSURE_TRUE(window, NS_ERROR_INVALID_ARG);
michael@0: 
michael@0:   window = window->GetOuterWindow();
michael@0:   NS_ENSURE_TRUE(window, NS_ERROR_INVALID_ARG);
michael@0: 
michael@0:   nsCOMPtr<nsPIDOMWindow> focusedWindow;
michael@0:   nsCOMPtr<nsIContent> focusedContent =
michael@0:     GetFocusedDescendant(window, aDeep, getter_AddRefs(focusedWindow));
michael@0:   if (focusedContent)
michael@0:     CallQueryInterface(focusedContent, aElement);
michael@0: 
michael@0:   if (aFocusedWindow)
michael@0:     NS_IF_ADDREF(*aFocusedWindow = focusedWindow);
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::MoveCaretToFocus(nsIDOMWindow* aWindow)
michael@0: {
michael@0:   nsCOMPtr<nsIWebNavigation> webnav = do_GetInterface(aWindow);
michael@0:   nsCOMPtr<nsIDocShellTreeItem> dsti = do_QueryInterface(webnav);
michael@0:   if (dsti) {
michael@0:     if (dsti->ItemType() != nsIDocShellTreeItem::typeChrome) {
michael@0:       nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(dsti);
michael@0:       NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
michael@0: 
michael@0:       // don't move the caret for editable documents
michael@0:       bool isEditable;
michael@0:       docShell->GetEditable(&isEditable);
michael@0:       if (isEditable)
michael@0:         return NS_OK;
michael@0: 
michael@0:       nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
michael@0:       NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
michael@0: 
michael@0:       nsCOMPtr<nsPIDOMWindow> window(do_QueryInterface(aWindow));
michael@0:       nsCOMPtr<nsIContent> content = window->GetFocusedNode();
michael@0:       if (content)
michael@0:         MoveCaretToFocus(presShell, content);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::WindowRaised(nsIDOMWindow* aWindow)
michael@0: {
michael@0:   nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(aWindow);
michael@0:   NS_ENSURE_TRUE(window && window->IsOuterWindow(), NS_ERROR_INVALID_ARG);
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0:   if (PR_LOG_TEST(gFocusLog, PR_LOG_DEBUG)) {
michael@0:     LOGFOCUS(("Window %p Raised [Currently: %p %p]", aWindow, mActiveWindow.get(), mFocusedWindow.get()));
michael@0:     nsAutoCString spec;
michael@0:     nsIDocument* doc = window->GetExtantDoc();
michael@0:     if (doc && doc->GetDocumentURI()) {
michael@0:       doc->GetDocumentURI()->GetSpec(spec);
michael@0:       LOGFOCUS(("  Raised Window: %p %s", aWindow, spec.get()));
michael@0:     }
michael@0:     if (mActiveWindow) {
michael@0:       doc = mActiveWindow->GetExtantDoc();
michael@0:       if (doc && doc->GetDocumentURI()) {
michael@0:         doc->GetDocumentURI()->GetSpec(spec);
michael@0:         LOGFOCUS(("  Active Window: %p %s", mActiveWindow.get(), spec.get()));
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   if (mActiveWindow == window) {
michael@0:     // The window is already active, so there is no need to focus anything,
michael@0:     // but make sure that the right widget is focused. This is a special case
michael@0:     // for Windows because when restoring a minimized window, a second
michael@0:     // activation will occur and the top-level widget could be focused instead
michael@0:     // of the child we want. We solve this by calling SetFocus to ensure that
michael@0:     // what the focus manager thinks should be the current widget is actually
michael@0:     // focused.
michael@0:     EnsureCurrentWidgetFocused();
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // lower the existing window, if any. This shouldn't happen usually.
michael@0:   if (mActiveWindow)
michael@0:     WindowLowered(mActiveWindow);
michael@0: 
michael@0:   nsCOMPtr<nsIWebNavigation> webnav(do_GetInterface(aWindow));
michael@0:   nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(do_QueryInterface(webnav));
michael@0:   // If there's no docShellAsItem, this window must have been closed,
michael@0:   // in that case there is no tree owner.
michael@0:   NS_ENSURE_TRUE(docShellAsItem, NS_OK);
michael@0: 
michael@0:   // set this as the active window
michael@0:   mActiveWindow = window;
michael@0: 
michael@0:   // ensure that the window is enabled and visible
michael@0:   nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
michael@0:   docShellAsItem->GetTreeOwner(getter_AddRefs(treeOwner));
michael@0:   nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(treeOwner);
michael@0:   if (baseWindow) {
michael@0:     bool isEnabled = true;
michael@0:     if (NS_SUCCEEDED(baseWindow->GetEnabled(&isEnabled)) && !isEnabled) {
michael@0:       return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     if (!sTestMode) {
michael@0:       baseWindow->SetVisibility(true);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // inform the DOM window that it has activated, so that the active attribute
michael@0:   // is updated on the window
michael@0:   window->ActivateOrDeactivate(true);
michael@0: 
michael@0:   // send activate event
michael@0:   nsContentUtils::DispatchTrustedEvent(window->GetExtantDoc(),
michael@0:                                        window,
michael@0:                                        NS_LITERAL_STRING("activate"),
michael@0:                                        true, true, nullptr);
michael@0: 
michael@0:   // retrieve the last focused element within the window that was raised
michael@0:   nsCOMPtr<nsPIDOMWindow> currentWindow;
michael@0:   nsCOMPtr<nsIContent> currentFocus =
michael@0:     GetFocusedDescendant(window, true, getter_AddRefs(currentWindow));
michael@0: 
michael@0:   NS_ASSERTION(currentWindow, "window raised with no window current");
michael@0:   if (!currentWindow)
michael@0:     return NS_OK;
michael@0: 
michael@0:   nsCOMPtr<nsIDocShell> currentDocShell = currentWindow->GetDocShell();
michael@0: 
michael@0:   nsCOMPtr<nsIPresShell> presShell = currentDocShell->GetPresShell();
michael@0:   if (presShell) {
michael@0:     // disable selection mousedown state on activation
michael@0:     // XXXndeakin P3 not sure if this is necessary, but it doesn't hurt
michael@0:     nsRefPtr<nsFrameSelection> frameSelection = presShell->FrameSelection();
michael@0:     frameSelection->SetMouseDownState(false);
michael@0:   }
michael@0: 
michael@0:   Focus(currentWindow, currentFocus, 0, true, false, true, true);
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::WindowLowered(nsIDOMWindow* aWindow)
michael@0: {
michael@0:   nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(aWindow);
michael@0:   NS_ENSURE_TRUE(window && window->IsOuterWindow(), NS_ERROR_INVALID_ARG);
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0:   if (PR_LOG_TEST(gFocusLog, PR_LOG_DEBUG)) {
michael@0:     LOGFOCUS(("Window %p Lowered [Currently: %p %p]", aWindow, mActiveWindow.get(), mFocusedWindow.get()));
michael@0:     nsAutoCString spec;
michael@0:     nsIDocument* doc = window->GetExtantDoc();
michael@0:     if (doc && doc->GetDocumentURI()) {
michael@0:       doc->GetDocumentURI()->GetSpec(spec);
michael@0:       LOGFOCUS(("  Lowered Window: %s", spec.get()));
michael@0:     }
michael@0:     if (mActiveWindow) {
michael@0:       doc = mActiveWindow->GetExtantDoc();
michael@0:       if (doc && doc->GetDocumentURI()) {
michael@0:         doc->GetDocumentURI()->GetSpec(spec);
michael@0:         LOGFOCUS(("  Active Window: %s", spec.get()));
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   if (mActiveWindow != window)
michael@0:     return NS_OK;
michael@0: 
michael@0:   // clear the mouse capture as the active window has changed
michael@0:   nsIPresShell::SetCapturingContent(nullptr, 0);
michael@0: 
michael@0:   // inform the DOM window that it has deactivated, so that the active
michael@0:   // attribute is updated on the window
michael@0:   window->ActivateOrDeactivate(false);
michael@0: 
michael@0:   // send deactivate event
michael@0:   nsContentUtils::DispatchTrustedEvent(window->GetExtantDoc(),
michael@0:                                        window,
michael@0:                                        NS_LITERAL_STRING("deactivate"),
michael@0:                                        true, true, nullptr);
michael@0: 
michael@0:   // keep track of the window being lowered, so that attempts to raise the
michael@0:   // window can be prevented until we return. Otherwise, focus can get into
michael@0:   // an unusual state.
michael@0:   mWindowBeingLowered = mActiveWindow;
michael@0:   mActiveWindow = nullptr;
michael@0: 
michael@0:   if (mFocusedWindow)
michael@0:     Blur(nullptr, nullptr, true, true);
michael@0: 
michael@0:   mWindowBeingLowered = nullptr;
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsFocusManager::ContentRemoved(nsIDocument* aDocument, nsIContent* aContent)
michael@0: {
michael@0:   NS_ENSURE_ARG(aDocument);
michael@0:   NS_ENSURE_ARG(aContent);
michael@0: 
michael@0:   nsPIDOMWindow *window = aDocument->GetWindow();
michael@0:   if (!window)
michael@0:     return NS_OK;
michael@0: 
michael@0:   // if the content is currently focused in the window, or is an ancestor
michael@0:   // of the currently focused element, reset the focus within that window.
michael@0:   nsIContent* content = window->GetFocusedNode();
michael@0:   if (content && nsContentUtils::ContentIsDescendantOf(content, aContent)) {
michael@0:     bool shouldShowFocusRing = window->ShouldShowFocusRing();
michael@0:     window->SetFocusedNode(nullptr);
michael@0: 
michael@0:     // if this window is currently focused, clear the global focused
michael@0:     // element as well, but don't fire any events.
michael@0:     if (window == mFocusedWindow) {
michael@0:       mFocusedContent = nullptr;
michael@0:     }
michael@0:     else {
michael@0:       // Check if the node that was focused is an iframe or similar by looking
michael@0:       // if it has a subdocument. This would indicate that this focused iframe
michael@0:       // and its descendants will be going away. We will need to move the
michael@0:       // focus somewhere else, so just clear the focus in the toplevel window
michael@0:       // so that no element is focused.
michael@0:       nsIDocument* subdoc = aDocument->GetSubDocumentFor(content);
michael@0:       if (subdoc) {
michael@0:         nsCOMPtr<nsISupports> container = subdoc->GetContainer();
michael@0:         nsCOMPtr<nsPIDOMWindow> childWindow = do_GetInterface(container);
michael@0:         if (childWindow && IsSameOrAncestor(childWindow, mFocusedWindow)) {
michael@0:           ClearFocus(mActiveWindow);
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     NotifyFocusStateChange(content, shouldShowFocusRing, false);
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::WindowShown(nsIDOMWindow* aWindow, bool aNeedsFocus)
michael@0: {
michael@0:   nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(aWindow);
michael@0:   NS_ENSURE_TRUE(window, NS_ERROR_INVALID_ARG);
michael@0: 
michael@0:   window = window->GetOuterWindow();
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0:   if (PR_LOG_TEST(gFocusLog, PR_LOG_DEBUG)) {
michael@0:     LOGFOCUS(("Window %p Shown [Currently: %p %p]", window.get(), mActiveWindow.get(), mFocusedWindow.get()));
michael@0:     nsAutoCString spec;
michael@0:     nsIDocument* doc = window->GetExtantDoc();
michael@0:     if (doc && doc->GetDocumentURI()) {
michael@0:       doc->GetDocumentURI()->GetSpec(spec);
michael@0:       LOGFOCUS(("Shown Window: %s", spec.get()));
michael@0:     }
michael@0: 
michael@0:     if (mFocusedWindow) {
michael@0:       doc = mFocusedWindow->GetExtantDoc();
michael@0:       if (doc && doc->GetDocumentURI()) {
michael@0:         doc->GetDocumentURI()->GetSpec(spec);
michael@0:         LOGFOCUS((" Focused Window: %s", spec.get()));
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   if (mFocusedWindow != window)
michael@0:     return NS_OK;
michael@0: 
michael@0:   if (aNeedsFocus) {
michael@0:     nsCOMPtr<nsPIDOMWindow> currentWindow;
michael@0:     nsCOMPtr<nsIContent> currentFocus =
michael@0:       GetFocusedDescendant(window, true, getter_AddRefs(currentWindow));
michael@0:     if (currentWindow)
michael@0:       Focus(currentWindow, currentFocus, 0, true, false, false, true);
michael@0:   }
michael@0:   else {
michael@0:     // Sometimes, an element in a window can be focused before the window is
michael@0:     // visible, which would mean that the widget may not be properly focused.
michael@0:     // When the window becomes visible, make sure the right widget is focused.
michael@0:     EnsureCurrentWidgetFocused();
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::WindowHidden(nsIDOMWindow* aWindow)
michael@0: {
michael@0:   // if there is no window or it is not the same or an ancestor of the
michael@0:   // currently focused window, just return, as the current focus will not
michael@0:   // be affected.
michael@0: 
michael@0:   nsCOMPtr<nsPIDOMWindow> window = do_QueryInterface(aWindow);
michael@0:   NS_ENSURE_TRUE(window, NS_ERROR_INVALID_ARG);
michael@0: 
michael@0:   window = window->GetOuterWindow();
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0:   if (PR_LOG_TEST(gFocusLog, PR_LOG_DEBUG)) {
michael@0:     LOGFOCUS(("Window %p Hidden [Currently: %p %p]", window.get(), mActiveWindow.get(), mFocusedWindow.get()));
michael@0:     nsAutoCString spec;
michael@0:     nsIDocument* doc = window->GetExtantDoc();
michael@0:     if (doc && doc->GetDocumentURI()) {
michael@0:       doc->GetDocumentURI()->GetSpec(spec);
michael@0:       LOGFOCUS(("  Hide Window: %s", spec.get()));
michael@0:     }
michael@0: 
michael@0:     if (mFocusedWindow) {
michael@0:       doc = mFocusedWindow->GetExtantDoc();
michael@0:       if (doc && doc->GetDocumentURI()) {
michael@0:         doc->GetDocumentURI()->GetSpec(spec);
michael@0:         LOGFOCUS(("  Focused Window: %s", spec.get()));
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     if (mActiveWindow) {
michael@0:       doc = mActiveWindow->GetExtantDoc();
michael@0:       if (doc && doc->GetDocumentURI()) {
michael@0:         doc->GetDocumentURI()->GetSpec(spec);
michael@0:         LOGFOCUS(("  Active Window: %s", spec.get()));
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   if (!IsSameOrAncestor(window, mFocusedWindow))
michael@0:     return NS_OK;
michael@0: 
michael@0:   // at this point, we know that the window being hidden is either the focused
michael@0:   // window, or an ancestor of the focused window. Either way, the focus is no
michael@0:   // longer valid, so it needs to be updated.
michael@0: 
michael@0:   nsCOMPtr<nsIContent> oldFocusedContent = mFocusedContent.forget();
michael@0: 
michael@0:   nsCOMPtr<nsIDocShell> focusedDocShell = mFocusedWindow->GetDocShell();
michael@0:   nsCOMPtr<nsIPresShell> presShell = focusedDocShell->GetPresShell();
michael@0: 
michael@0:   if (oldFocusedContent && oldFocusedContent->IsInDoc()) {
michael@0:     NotifyFocusStateChange(oldFocusedContent,
michael@0:                            mFocusedWindow->ShouldShowFocusRing(),
michael@0:                            false);
michael@0:     window->UpdateCommands(NS_LITERAL_STRING("focus"));
michael@0: 
michael@0:     if (presShell) {
michael@0:       SendFocusOrBlurEvent(NS_BLUR_CONTENT, presShell,
michael@0:                            oldFocusedContent->GetCurrentDoc(),
michael@0:                            oldFocusedContent, 1, false);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsPresContext* focusedPresContext =
michael@0:     presShell ? presShell->GetPresContext() : nullptr;
michael@0:   IMEStateManager::OnChangeFocus(focusedPresContext, nullptr,
michael@0:                                  GetFocusMoveActionCause(0));
michael@0:   if (presShell) {
michael@0:     SetCaretVisible(presShell, false, nullptr);
michael@0:   }
michael@0: 
michael@0:   // if the docshell being hidden is being destroyed, then we want to move
michael@0:   // focus somewhere else. Call ClearFocus on the toplevel window, which
michael@0:   // will have the effect of clearing the focus and moving the focused window
michael@0:   // to the toplevel window. But if the window isn't being destroyed, we are
michael@0:   // likely just loading a new document in it, so we want to maintain the
michael@0:   // focused window so that the new document gets properly focused.
michael@0:   bool beingDestroyed;
michael@0:   nsCOMPtr<nsIDocShell> docShellBeingHidden = window->GetDocShell();
michael@0:   docShellBeingHidden->IsBeingDestroyed(&beingDestroyed);
michael@0:   if (beingDestroyed) {
michael@0:     // There is usually no need to do anything if a toplevel window is going
michael@0:     // away, as we assume that WindowLowered will be called. However, this may
michael@0:     // not happen if nsIAppStartup::eForceQuit is used to quit, and can cause
michael@0:     // a leak. So if the active window is being destroyed, call WindowLowered
michael@0:     // directly.
michael@0:     NS_ASSERTION(mFocusedWindow->IsOuterWindow(), "outer window expected");
michael@0:     if (mActiveWindow == mFocusedWindow || mActiveWindow == window)
michael@0:       WindowLowered(mActiveWindow);
michael@0:     else
michael@0:       ClearFocus(mActiveWindow);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // if the window being hidden is an ancestor of the focused window, adjust
michael@0:   // the focused window so that it points to the one being hidden. This
michael@0:   // ensures that the focused window isn't in a chain of frames that doesn't
michael@0:   // exist any more.
michael@0:   if (window != mFocusedWindow) {
michael@0:     nsCOMPtr<nsIWebNavigation> webnav(do_GetInterface(mFocusedWindow));
michael@0:     nsCOMPtr<nsIDocShellTreeItem> dsti = do_QueryInterface(webnav);
michael@0:     if (dsti) {
michael@0:       nsCOMPtr<nsIDocShellTreeItem> parentDsti;
michael@0:       dsti->GetParent(getter_AddRefs(parentDsti));
michael@0:       nsCOMPtr<nsPIDOMWindow> parentWindow = do_GetInterface(parentDsti);
michael@0:       if (parentWindow)
michael@0:         parentWindow->SetFocusedNode(nullptr);
michael@0:     }
michael@0: 
michael@0:     SetFocusedWindowInternal(window);
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::FireDelayedEvents(nsIDocument* aDocument)
michael@0: {
michael@0:   NS_ENSURE_ARG(aDocument);
michael@0: 
michael@0:   // fire any delayed focus and blur events in the same order that they were added
michael@0:   for (uint32_t i = 0; i < mDelayedBlurFocusEvents.Length(); i++) {
michael@0:     if (mDelayedBlurFocusEvents[i].mDocument == aDocument) {
michael@0:       if (!aDocument->GetInnerWindow() ||
michael@0:           !aDocument->GetInnerWindow()->IsCurrentInnerWindow()) {
michael@0:         // If the document was navigated away from or is defunct, don't bother
michael@0:         // firing events on it. Note the symmetry between this condition and
michael@0:         // the similar one in nsDocument.cpp:FireOrClearDelayedEvents.
michael@0:         mDelayedBlurFocusEvents.RemoveElementAt(i);
michael@0:         --i;
michael@0:       } else if (!aDocument->EventHandlingSuppressed()) {
michael@0:         uint32_t type = mDelayedBlurFocusEvents[i].mType;
michael@0:         nsCOMPtr<EventTarget> target = mDelayedBlurFocusEvents[i].mTarget;
michael@0:         nsCOMPtr<nsIPresShell> presShell = mDelayedBlurFocusEvents[i].mPresShell;
michael@0:         mDelayedBlurFocusEvents.RemoveElementAt(i);
michael@0:         SendFocusOrBlurEvent(type, presShell, aDocument, target, 0, false);
michael@0:         --i;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsFocusManager::FocusPlugin(nsIContent* aContent)
michael@0: {
michael@0:   NS_ENSURE_ARG(aContent);
michael@0:   SetFocusInner(aContent, 0, true, false);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: void
michael@0: nsFocusManager::NotifyFocusStateChange(nsIContent* aContent,
michael@0:                                        bool aWindowShouldShowFocusRing,
michael@0:                                        bool aGettingFocus)
michael@0: {
michael@0:   if (!aContent->IsElement()) {
michael@0:     return;
michael@0:   }
michael@0:   EventStates eventState = NS_EVENT_STATE_FOCUS;
michael@0:   if (aWindowShouldShowFocusRing) {
michael@0:     eventState |= NS_EVENT_STATE_FOCUSRING;
michael@0:   }
michael@0:   if (aGettingFocus) {
michael@0:     aContent->AsElement()->AddStates(eventState);
michael@0:   } else {
michael@0:     aContent->AsElement()->RemoveStates(eventState);
michael@0:   }
michael@0: }
michael@0: 
michael@0: // static
michael@0: void
michael@0: nsFocusManager::EnsureCurrentWidgetFocused()
michael@0: {
michael@0:   if (!mFocusedWindow || sTestMode)
michael@0:     return;
michael@0: 
michael@0:   // get the main child widget for the focused window and ensure that the
michael@0:   // platform knows that this widget is focused.
michael@0:   nsCOMPtr<nsIDocShell> docShell = mFocusedWindow->GetDocShell();
michael@0:   if (docShell) {
michael@0:     nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
michael@0:     if (presShell) {
michael@0:       nsViewManager* vm = presShell->GetViewManager();
michael@0:       if (vm) {
michael@0:         nsCOMPtr<nsIWidget> widget;
michael@0:         vm->GetRootWidget(getter_AddRefs(widget));
michael@0:         if (widget)
michael@0:           widget->SetFocus(false);
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFocusManager::SetFocusInner(nsIContent* aNewContent, int32_t aFlags,
michael@0:                               bool aFocusChanged, bool aAdjustWidget)
michael@0: {
michael@0:   // if the element is not focusable, just return and leave the focus as is
michael@0:   nsCOMPtr<nsIContent> contentToFocus = CheckIfFocusable(aNewContent, aFlags);
michael@0:   if (!contentToFocus)
michael@0:     return;
michael@0: 
michael@0:   // check if the element to focus is a frame (iframe) containing a child
michael@0:   // document. Frames are never directly focused; instead focusing a frame
michael@0:   // means focus what is inside the frame. To do this, the descendant content
michael@0:   // within the frame is retrieved and that will be focused instead.
michael@0:   nsCOMPtr<nsPIDOMWindow> newWindow;
michael@0:   nsCOMPtr<nsPIDOMWindow> subWindow = GetContentWindow(contentToFocus);
michael@0:   if (subWindow) {
michael@0:     contentToFocus = GetFocusedDescendant(subWindow, true, getter_AddRefs(newWindow));
michael@0:     // since a window is being refocused, clear aFocusChanged so that the
michael@0:     // caret position isn't updated.
michael@0:     aFocusChanged = false;
michael@0:   }
michael@0: 
michael@0:   // unless it was set above, retrieve the window for the element to focus
michael@0:   if (!newWindow)
michael@0:     newWindow = GetCurrentWindow(contentToFocus);
michael@0: 
michael@0:   // if the element is already focused, just return. Note that this happens
michael@0:   // after the frame check above so that we compare the element that will be
michael@0:   // focused rather than the frame it is in.
michael@0:   if (!newWindow || (newWindow == mFocusedWindow && contentToFocus == mFocusedContent))
michael@0:     return;
michael@0: 
michael@0:   // don't allow focus to be placed in docshells or descendants of docshells
michael@0:   // that are being destroyed. Also, ensure that the page hasn't been
michael@0:   // unloaded. The prevents content from being refocused during an unload event.
michael@0:   nsCOMPtr<nsIDocShell> newDocShell = newWindow->GetDocShell();
michael@0:   nsCOMPtr<nsIDocShell> docShell = newDocShell;
michael@0:   while (docShell) {
michael@0:     bool inUnload;
michael@0:     docShell->GetIsInUnload(&inUnload);
michael@0:     if (inUnload)
michael@0:       return;
michael@0: 
michael@0:     bool beingDestroyed;
michael@0:     docShell->IsBeingDestroyed(&beingDestroyed);
michael@0:     if (beingDestroyed)
michael@0:       return;
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parentDsti;
michael@0:     docShell->GetParent(getter_AddRefs(parentDsti));
michael@0:     docShell = do_QueryInterface(parentDsti);
michael@0:   }
michael@0: 
michael@0:   // if the new element is in the same window as the currently focused element 
michael@0:   bool isElementInFocusedWindow = (mFocusedWindow == newWindow);
michael@0: 
michael@0:   if (!isElementInFocusedWindow && mFocusedWindow && newWindow &&
michael@0:       nsContentUtils::IsHandlingKeyBoardEvent()) {
michael@0:     nsCOMPtr<nsIScriptObjectPrincipal> focused =
michael@0:       do_QueryInterface(mFocusedWindow);
michael@0:     nsCOMPtr<nsIScriptObjectPrincipal> newFocus =
michael@0:       do_QueryInterface(newWindow);
michael@0:     nsIPrincipal* focusedPrincipal = focused->GetPrincipal();
michael@0:     nsIPrincipal* newPrincipal = newFocus->GetPrincipal();
michael@0:     if (!focusedPrincipal || !newPrincipal) {
michael@0:       return;
michael@0:     }
michael@0:     bool subsumes = false;
michael@0:     focusedPrincipal->Subsumes(newPrincipal, &subsumes);
michael@0:     if (!subsumes && !nsContentUtils::IsCallerChrome()) {
michael@0:       NS_WARNING("Not allowed to focus the new window!");
michael@0:       return;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // to check if the new element is in the active window, compare the
michael@0:   // new root docshell for the new element with the active window's docshell.
michael@0:   bool isElementInActiveWindow = false;
michael@0: 
michael@0:   nsCOMPtr<nsIWebNavigation> webnav = do_GetInterface(newWindow);
michael@0:   nsCOMPtr<nsIDocShellTreeItem> dsti = do_QueryInterface(webnav);
michael@0:   nsCOMPtr<nsPIDOMWindow> newRootWindow;
michael@0:   if (dsti) {
michael@0:     nsCOMPtr<nsIDocShellTreeItem> root;
michael@0:     dsti->GetRootTreeItem(getter_AddRefs(root));
michael@0:     newRootWindow = do_GetInterface(root);
michael@0: 
michael@0:     isElementInActiveWindow = (mActiveWindow && newRootWindow == mActiveWindow);
michael@0:   }
michael@0: 
michael@0:   // Exit fullscreen if we're focusing a windowed plugin on a non-MacOSX
michael@0:   // system. We don't control event dispatch to windowed plugins on non-MacOSX,
michael@0:   // so we can't display the "Press ESC to leave fullscreen mode" warning on
michael@0:   // key input if a windowed plugin is focused, so just exit fullscreen
michael@0:   // to guard against phishing.
michael@0: #ifndef XP_MACOSX
michael@0:   nsIDocument* fullscreenAncestor;
michael@0:   if (contentToFocus &&
michael@0:       (fullscreenAncestor = nsContentUtils::GetFullscreenAncestor(contentToFocus->OwnerDoc())) &&
michael@0:       nsContentUtils::HasPluginWithUncontrolledEventDispatch(contentToFocus)) {
michael@0:     nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
michael@0:                                     NS_LITERAL_CSTRING("DOM"),
michael@0:                                     contentToFocus->OwnerDoc(),
michael@0:                                     nsContentUtils::eDOM_PROPERTIES,
michael@0:                                     "FocusedWindowedPluginWhileFullScreen");
michael@0:     nsIDocument::ExitFullscreen(fullscreenAncestor, /* async */ true);
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   // if the FLAG_NOSWITCHFRAME flag is used, only allow the focus to be
michael@0:   // shifted away from the current element if the new shell to focus is
michael@0:   // the same or an ancestor shell of the currently focused shell.
michael@0:   bool allowFrameSwitch = !(aFlags & FLAG_NOSWITCHFRAME) ||
michael@0:                             IsSameOrAncestor(newWindow, mFocusedWindow);
michael@0: 
michael@0:   // if the element is in the active window, frame switching is allowed and
michael@0:   // the content is in a visible window, fire blur and focus events.
michael@0:   bool sendFocusEvent =
michael@0:     isElementInActiveWindow && allowFrameSwitch && IsWindowVisible(newWindow);
michael@0: 
michael@0:   // When the following conditions are true:
michael@0:   //  * an element has focus
michael@0:   //  * isn't called by trusted event (i.e., called by untrusted event or by js)
michael@0:   //  * the focus is moved to another document's element
michael@0:   // we need to check the permission.
michael@0:   if (sendFocusEvent && mFocusedContent &&
michael@0:       mFocusedContent->OwnerDoc() != aNewContent->OwnerDoc()) {
michael@0:     // If the caller cannot access the current focused node, the caller should
michael@0:     // not be able to steal focus from it. E.g., When the current focused node
michael@0:     // is in chrome, any web contents should not be able to steal the focus.
michael@0:     nsCOMPtr<nsIDOMNode> domNode(do_QueryInterface(mFocusedContent));
michael@0:     sendFocusEvent = nsContentUtils::CanCallerAccess(domNode);
michael@0:     if (!sendFocusEvent && mMouseDownEventHandlingDocument) {
michael@0:       // However, while mouse down event is handling, the handling document's
michael@0:       // script should be able to steal focus.
michael@0:       domNode = do_QueryInterface(mMouseDownEventHandlingDocument);
michael@0:       sendFocusEvent = nsContentUtils::CanCallerAccess(domNode);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   LOGCONTENT("Shift Focus: %s", contentToFocus.get());
michael@0:   LOGFOCUS((" Flags: %x Current Window: %p New Window: %p Current Element: %p",
michael@0:            aFlags, mFocusedWindow.get(), newWindow.get(), mFocusedContent.get()));
michael@0:   LOGFOCUS((" In Active Window: %d In Focused Window: %d SendFocus: %d",
michael@0:            isElementInActiveWindow, isElementInFocusedWindow, sendFocusEvent));
michael@0: 
michael@0:   if (sendFocusEvent) {
michael@0:     // return if blurring fails or the focus changes during the blur
michael@0:     if (mFocusedWindow) {
michael@0:       // if the focus is being moved to another element in the same document,
michael@0:       // or to a descendant, pass the existing window to Blur so that the
michael@0:       // current node in the existing window is cleared. If moving to a
michael@0:       // window elsewhere, we want to maintain the current node in the
michael@0:       // window but still blur it.
michael@0:       bool currentIsSameOrAncestor = IsSameOrAncestor(mFocusedWindow, newWindow);
michael@0:       // find the common ancestor of the currently focused window and the new
michael@0:       // window. The ancestor will need to have its currently focused node
michael@0:       // cleared once the document has been blurred. Otherwise, we'll be in a
michael@0:       // state where a document is blurred yet the chain of windows above it
michael@0:       // still points to that document.
michael@0:       // For instance, in the following frame tree:
michael@0:       //   A
michael@0:       //  B C
michael@0:       //  D
michael@0:       // D is focused and we want to focus C. Once D has been blurred, we need
michael@0:       // to clear out the focus in A, otherwise A would still maintain that B
michael@0:       // was focused, and B that D was focused.
michael@0:       nsCOMPtr<nsPIDOMWindow> commonAncestor;
michael@0:       if (!isElementInFocusedWindow)
michael@0:         commonAncestor = GetCommonAncestor(newWindow, mFocusedWindow);
michael@0: 
michael@0:       if (!Blur(currentIsSameOrAncestor ? mFocusedWindow.get() : nullptr,
michael@0:                 commonAncestor, !isElementInFocusedWindow, aAdjustWidget))
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     Focus(newWindow, contentToFocus, aFlags, !isElementInFocusedWindow,
michael@0:           aFocusChanged, false, aAdjustWidget);
michael@0:   }
michael@0:   else {
michael@0:     // otherwise, for inactive windows and when the caller cannot steal the
michael@0:     // focus, update the node in the window, and  raise the window if desired.
michael@0:     if (allowFrameSwitch)
michael@0:       AdjustWindowFocus(newWindow, true);
michael@0: 
michael@0:     // set the focus node and method as needed
michael@0:     uint32_t focusMethod = aFocusChanged ? aFlags & FOCUSMETHODANDRING_MASK :
michael@0:                            newWindow->GetFocusMethod() | (aFlags & FLAG_SHOWRING);
michael@0:     newWindow->SetFocusedNode(contentToFocus, focusMethod);
michael@0:     if (aFocusChanged) {
michael@0:       nsCOMPtr<nsIDocShell> docShell = newWindow->GetDocShell();
michael@0: 
michael@0:       nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
michael@0:       if (presShell)
michael@0:         ScrollIntoView(presShell, contentToFocus, aFlags);
michael@0:     }
michael@0: 
michael@0:     // update the commands even when inactive so that the attributes for that
michael@0:     // window are up to date.
michael@0:     if (allowFrameSwitch)
michael@0:       newWindow->UpdateCommands(NS_LITERAL_STRING("focus"));
michael@0: 
michael@0:     if (aFlags & FLAG_RAISE)
michael@0:       RaiseWindow(newRootWindow);
michael@0:   }
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsFocusManager::IsSameOrAncestor(nsPIDOMWindow* aPossibleAncestor,
michael@0:                                  nsPIDOMWindow* aWindow)
michael@0: {
michael@0:   nsCOMPtr<nsIWebNavigation> awebnav(do_GetInterface(aPossibleAncestor));
michael@0:   nsCOMPtr<nsIDocShellTreeItem> ancestordsti = do_QueryInterface(awebnav);
michael@0: 
michael@0:   nsCOMPtr<nsIWebNavigation> fwebnav(do_GetInterface(aWindow));
michael@0:   nsCOMPtr<nsIDocShellTreeItem> dsti = do_QueryInterface(fwebnav);
michael@0:   while (dsti) {
michael@0:     if (dsti == ancestordsti)
michael@0:       return true;
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parentDsti;
michael@0:     dsti->GetParent(getter_AddRefs(parentDsti));
michael@0:     dsti.swap(parentDsti);
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: already_AddRefed<nsPIDOMWindow>
michael@0: nsFocusManager::GetCommonAncestor(nsPIDOMWindow* aWindow1,
michael@0:                                   nsPIDOMWindow* aWindow2)
michael@0: {
michael@0:   nsCOMPtr<nsIWebNavigation> webnav(do_GetInterface(aWindow1));
michael@0:   nsCOMPtr<nsIDocShellTreeItem> dsti1 = do_QueryInterface(webnav);
michael@0:   NS_ENSURE_TRUE(dsti1, nullptr);
michael@0: 
michael@0:   webnav = do_GetInterface(aWindow2);
michael@0:   nsCOMPtr<nsIDocShellTreeItem> dsti2 = do_QueryInterface(webnav);
michael@0:   NS_ENSURE_TRUE(dsti2, nullptr);
michael@0: 
michael@0:   nsAutoTArray<nsIDocShellTreeItem*, 30> parents1, parents2;
michael@0:   do {
michael@0:     parents1.AppendElement(dsti1);
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parentDsti1;
michael@0:     dsti1->GetParent(getter_AddRefs(parentDsti1));
michael@0:     dsti1.swap(parentDsti1);
michael@0:   } while (dsti1);
michael@0:   do {
michael@0:     parents2.AppendElement(dsti2);
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parentDsti2;
michael@0:     dsti2->GetParent(getter_AddRefs(parentDsti2));
michael@0:     dsti2.swap(parentDsti2);
michael@0:   } while (dsti2);
michael@0: 
michael@0:   uint32_t pos1 = parents1.Length();
michael@0:   uint32_t pos2 = parents2.Length();
michael@0:   nsIDocShellTreeItem* parent = nullptr;
michael@0:   uint32_t len;
michael@0:   for (len = std::min(pos1, pos2); len > 0; --len) {
michael@0:     nsIDocShellTreeItem* child1 = parents1.ElementAt(--pos1);
michael@0:     nsIDocShellTreeItem* child2 = parents2.ElementAt(--pos2);
michael@0:     if (child1 != child2) {
michael@0:       break;
michael@0:     }
michael@0:     parent = child1;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsPIDOMWindow> window = do_GetInterface(parent);
michael@0:   return window.forget();
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFocusManager::AdjustWindowFocus(nsPIDOMWindow* aWindow,
michael@0:                                   bool aCheckPermission)
michael@0: {
michael@0:   bool isVisible = IsWindowVisible(aWindow);
michael@0: 
michael@0:   nsCOMPtr<nsPIDOMWindow> window(aWindow);
michael@0:   while (window) {
michael@0:     // get the containing <iframe> or equivalent element so that it can be
michael@0:     // focused below.
michael@0:     nsCOMPtr<nsIContent> frameContent =
michael@0:       do_QueryInterface(window->GetFrameElementInternal());
michael@0: 
michael@0:     nsCOMPtr<nsIWebNavigation> webnav(do_GetInterface(window));
michael@0:     nsCOMPtr<nsIDocShellTreeItem> dsti = do_QueryInterface(webnav);
michael@0:     if (!dsti) 
michael@0:       return;
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parentDsti;
michael@0:     dsti->GetParent(getter_AddRefs(parentDsti));
michael@0: 
michael@0:     window = do_GetInterface(parentDsti);
michael@0:     if (window) {
michael@0:       // if the parent window is visible but aWindow was not, then we have
michael@0:       // likely moved up and out from a hidden tab to the browser window, or a
michael@0:       // similar such arrangement. Stop adjusting the current nodes.
michael@0:       if (IsWindowVisible(window) != isVisible)
michael@0:         break;
michael@0: 
michael@0:       // When aCheckPermission is true, we should check whether the caller can
michael@0:       // access the window or not.  If it cannot access, we should stop the
michael@0:       // adjusting.
michael@0:       if (aCheckPermission && !nsContentUtils::CanCallerAccess(window))
michael@0:         break;
michael@0: 
michael@0:       window->SetFocusedNode(frameContent);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsFocusManager::IsWindowVisible(nsPIDOMWindow* aWindow)
michael@0: {
michael@0:   if (!aWindow || aWindow->IsFrozen())
michael@0:     return false;
michael@0: 
michael@0:   // Check if the inner window is frozen as well. This can happen when a focus change
michael@0:   // occurs while restoring a previous page.
michael@0:   nsPIDOMWindow* innerWindow = aWindow->GetCurrentInnerWindow();
michael@0:   if (!innerWindow || innerWindow->IsFrozen())
michael@0:     return false;
michael@0: 
michael@0:   nsCOMPtr<nsIDocShell> docShell = aWindow->GetDocShell();
michael@0:   nsCOMPtr<nsIBaseWindow> baseWin(do_QueryInterface(docShell));
michael@0:   if (!baseWin)
michael@0:     return false;
michael@0: 
michael@0:   bool visible = false;
michael@0:   baseWin->GetVisibility(&visible);
michael@0:   return visible;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsFocusManager::IsNonFocusableRoot(nsIContent* aContent)
michael@0: {
michael@0:   NS_PRECONDITION(aContent, "aContent must not be NULL");
michael@0:   NS_PRECONDITION(aContent->IsInDoc(), "aContent must be in a document");
michael@0: 
michael@0:   // If aContent is in designMode, the root element is not focusable.
michael@0:   // NOTE: in designMode, most elements are not focusable, just the document is
michael@0:   //       focusable.
michael@0:   // Also, if aContent is not editable but it isn't in designMode, it's not
michael@0:   // focusable.
michael@0:   // And in userfocusignored context nothing is focusable.
michael@0:   nsIDocument* doc = aContent->GetCurrentDoc();
michael@0:   NS_ASSERTION(doc, "aContent must have current document");
michael@0:   return aContent == doc->GetRootElement() &&
michael@0:            (doc->HasFlag(NODE_IS_EDITABLE) || !aContent->IsEditable() ||
michael@0:             nsContentUtils::IsUserFocusIgnored(aContent));
michael@0: }
michael@0: 
michael@0: nsIContent*
michael@0: nsFocusManager::CheckIfFocusable(nsIContent* aContent, uint32_t aFlags)
michael@0: {
michael@0:   if (!aContent)
michael@0:     return nullptr;
michael@0: 
michael@0:   // this is a special case for some XUL elements where an anonymous child is
michael@0:   // actually focusable and not the element itself.
michael@0:   nsIContent* redirectedFocus = GetRedirectedFocus(aContent);
michael@0:   if (redirectedFocus)
michael@0:     return CheckIfFocusable(redirectedFocus, aFlags);
michael@0: 
michael@0:   nsCOMPtr<nsIDocument> doc = aContent->GetCurrentDoc();
michael@0:   // can't focus elements that are not in documents
michael@0:   if (!doc) {
michael@0:     LOGCONTENT("Cannot focus %s because content not in document", aContent)
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   // Make sure that our frames are up to date
michael@0:   doc->FlushPendingNotifications(Flush_Layout);
michael@0: 
michael@0:   nsIPresShell *shell = doc->GetShell();
michael@0:   if (!shell)
michael@0:     return nullptr;
michael@0: 
michael@0:   // the root content can always be focused,
michael@0:   // except in userfocusignored context.
michael@0:   if (aContent == doc->GetRootElement())
michael@0:     return nsContentUtils::IsUserFocusIgnored(aContent) ? nullptr : aContent;
michael@0: 
michael@0:   // cannot focus content in print preview mode. Only the root can be focused.
michael@0:   nsPresContext* presContext = shell->GetPresContext();
michael@0:   if (presContext && presContext->Type() == nsPresContext::eContext_PrintPreview) {
michael@0:     LOGCONTENT("Cannot focus %s while in print preview", aContent)
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   nsIFrame* frame = aContent->GetPrimaryFrame();
michael@0:   if (!frame) {
michael@0:     LOGCONTENT("Cannot focus %s as it has no frame", aContent)
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   if (aContent->Tag() == nsGkAtoms::area && aContent->IsHTML()) {
michael@0:     // HTML areas do not have their own frame, and the img frame we get from
michael@0:     // GetPrimaryFrame() is not relevant as to whether it is focusable or
michael@0:     // not, so we have to do all the relevant checks manually for them.
michael@0:     return frame->IsVisibleConsideringAncestors() &&
michael@0:            aContent->IsFocusable() ? aContent : nullptr;
michael@0:   }
michael@0: 
michael@0:   // if this is a child frame content node, check if it is visible and
michael@0:   // call the content node's IsFocusable method instead of the frame's
michael@0:   // IsFocusable method. This skips checking the style system and ensures that
michael@0:   // offscreen browsers can still be focused.
michael@0:   nsIDocument* subdoc = doc->GetSubDocumentFor(aContent);
michael@0:   if (subdoc && IsWindowVisible(subdoc->GetWindow())) {
michael@0:     const nsStyleUserInterface* ui = frame->StyleUserInterface();
michael@0:     int32_t tabIndex = (ui->mUserFocus == NS_STYLE_USER_FOCUS_IGNORE ||
michael@0:                         ui->mUserFocus == NS_STYLE_USER_FOCUS_NONE) ? -1 : 0;
michael@0:     return aContent->IsFocusable(&tabIndex, aFlags & FLAG_BYMOUSE) ? aContent : nullptr;
michael@0:   }
michael@0:   
michael@0:   return frame->IsFocusable(nullptr, aFlags & FLAG_BYMOUSE) ? aContent : nullptr;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsFocusManager::Blur(nsPIDOMWindow* aWindowToClear,
michael@0:                      nsPIDOMWindow* aAncestorWindowToFocus,
michael@0:                      bool aIsLeavingDocument,
michael@0:                      bool aAdjustWidgets)
michael@0: {
michael@0:   LOGFOCUS(("<<Blur begin>>"));
michael@0: 
michael@0:   // hold a reference to the focused content, which may be null
michael@0:   nsCOMPtr<nsIContent> content = mFocusedContent;
michael@0:   if (content) {
michael@0:     if (!content->IsInDoc()) {
michael@0:       mFocusedContent = nullptr;
michael@0:       return true;
michael@0:     }
michael@0:     if (content == mFirstBlurEvent)
michael@0:       return true;
michael@0:   }
michael@0: 
michael@0:   // hold a reference to the focused window
michael@0:   nsCOMPtr<nsPIDOMWindow> window = mFocusedWindow;
michael@0:   if (!window) {
michael@0:     mFocusedContent = nullptr;
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDocShell> docShell = window->GetDocShell();
michael@0:   if (!docShell) {
michael@0:     mFocusedContent = nullptr;
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   // Keep a ref to presShell since dispatching the DOM event may cause
michael@0:   // the document to be destroyed.
michael@0:   nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
michael@0:   if (!presShell) {
michael@0:     mFocusedContent = nullptr;
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   bool clearFirstBlurEvent = false;
michael@0:   if (!mFirstBlurEvent) {
michael@0:     mFirstBlurEvent = content;
michael@0:     clearFirstBlurEvent = true;
michael@0:   }
michael@0: 
michael@0:   nsPresContext* focusedPresContext =
michael@0:     mActiveWindow ? presShell->GetPresContext() : nullptr;
michael@0:   IMEStateManager::OnChangeFocus(focusedPresContext, nullptr,
michael@0:                                  GetFocusMoveActionCause(0));
michael@0: 
michael@0:   // now adjust the actual focus, by clearing the fields in the focus manager
michael@0:   // and in the window.
michael@0:   mFocusedContent = nullptr;
michael@0:   bool shouldShowFocusRing = window->ShouldShowFocusRing();
michael@0:   if (aWindowToClear)
michael@0:     aWindowToClear->SetFocusedNode(nullptr);
michael@0: 
michael@0:   LOGCONTENT("Element %s has been blurred", content.get());
michael@0: 
michael@0:   // Don't fire blur event on the root content which isn't editable.
michael@0:   bool sendBlurEvent =
michael@0:     content && content->IsInDoc() && !IsNonFocusableRoot(content);
michael@0:   if (content) {
michael@0:     if (sendBlurEvent) {
michael@0:       NotifyFocusStateChange(content, shouldShowFocusRing, false);
michael@0:     }
michael@0: 
michael@0:     // if an object/plug-in/remote browser is being blurred, move the system focus
michael@0:     // to the parent window, otherwise events will still get fired at the plugin.
michael@0:     // But don't do this if we are blurring due to the window being lowered,
michael@0:     // otherwise, the parent window can get raised again.
michael@0:     if (mActiveWindow) {
michael@0:       nsIFrame* contentFrame = content->GetPrimaryFrame();
michael@0:       nsIObjectFrame* objectFrame = do_QueryFrame(contentFrame);
michael@0:       if (aAdjustWidgets && objectFrame && !sTestMode) {
michael@0:         // note that the presshell's widget is being retrieved here, not the one
michael@0:         // for the object frame.
michael@0:         nsViewManager* vm = presShell->GetViewManager();
michael@0:         if (vm) {
michael@0:           nsCOMPtr<nsIWidget> widget;
michael@0:           vm->GetRootWidget(getter_AddRefs(widget));
michael@0:           if (widget)
michael@0:             widget->SetFocus(false);
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       // if the object being blurred is a remote browser, deactivate remote content
michael@0:       if (TabParent* remote = TabParent::GetFrom(content)) {
michael@0:         remote->Deactivate();
michael@0:         LOGFOCUS(("Remote browser deactivated"));
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   bool result = true;
michael@0:   if (sendBlurEvent) {
michael@0:     // if there is an active window, update commands. If there isn't an active
michael@0:     // window, then this was a blur caused by the active window being lowered,
michael@0:     // so there is no need to update the commands
michael@0:     if (mActiveWindow)
michael@0:       window->UpdateCommands(NS_LITERAL_STRING("focus"));
michael@0: 
michael@0:     SendFocusOrBlurEvent(NS_BLUR_CONTENT, presShell,
michael@0:                          content->GetCurrentDoc(), content, 1, false);
michael@0:   }
michael@0: 
michael@0:   // if we are leaving the document or the window was lowered, make the caret
michael@0:   // invisible.
michael@0:   if (aIsLeavingDocument || !mActiveWindow)
michael@0:     SetCaretVisible(presShell, false, nullptr);
michael@0: 
michael@0:   // at this point, it is expected that this window will be still be
michael@0:   // focused, but the focused content will be null, as it was cleared before
michael@0:   // the event. If this isn't the case, then something else was focused during
michael@0:   // the blur event above and we should just return. However, if
michael@0:   // aIsLeavingDocument is set, a new document is desired, so make sure to
michael@0:   // blur the document and window.
michael@0:   if (mFocusedWindow != window ||
michael@0:       (mFocusedContent != nullptr && !aIsLeavingDocument)) {
michael@0:     result = false;
michael@0:   }
michael@0:   else if (aIsLeavingDocument) {
michael@0:     window->TakeFocus(false, 0);
michael@0: 
michael@0:     // clear the focus so that the ancestor frame hierarchy is in the correct
michael@0:     // state. Pass true because aAncestorWindowToFocus is thought to be
michael@0:     // focused at this point.
michael@0:     if (aAncestorWindowToFocus)
michael@0:       aAncestorWindowToFocus->SetFocusedNode(nullptr, 0, true);
michael@0: 
michael@0:     SetFocusedWindowInternal(nullptr);
michael@0:     mFocusedContent = nullptr;
michael@0: 
michael@0:     // pass 1 for the focus method when calling SendFocusOrBlurEvent just so
michael@0:     // that the check is made for suppressed documents. Check to ensure that
michael@0:     // the document isn't null in case someone closed it during the blur above
michael@0:     nsIDocument* doc = window->GetExtantDoc();
michael@0:     if (doc)
michael@0:       SendFocusOrBlurEvent(NS_BLUR_CONTENT, presShell, doc, doc, 1, false);
michael@0:     if (mFocusedWindow == nullptr)
michael@0:       SendFocusOrBlurEvent(NS_BLUR_CONTENT, presShell, doc, window, 1, false);
michael@0: 
michael@0:     // check if a different window was focused
michael@0:     result = (mFocusedWindow == nullptr && mActiveWindow);
michael@0:   }
michael@0:   else if (mActiveWindow) {
michael@0:     // Otherwise, the blur of the element without blurring the document
michael@0:     // occurred normally. Call UpdateCaret to redisplay the caret at the right
michael@0:     // location within the document. This is needed to ensure that the caret
michael@0:     // used for caret browsing is made visible again when an input field is
michael@0:     // blurred.
michael@0:     UpdateCaret(false, true, nullptr);
michael@0:   }
michael@0: 
michael@0:   if (clearFirstBlurEvent)
michael@0:     mFirstBlurEvent = nullptr;
michael@0: 
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFocusManager::Focus(nsPIDOMWindow* aWindow,
michael@0:                       nsIContent* aContent,
michael@0:                       uint32_t aFlags,
michael@0:                       bool aIsNewDocument,
michael@0:                       bool aFocusChanged,
michael@0:                       bool aWindowRaised,
michael@0:                       bool aAdjustWidgets)
michael@0: {
michael@0:   LOGFOCUS(("<<Focus begin>>"));
michael@0: 
michael@0:   if (!aWindow)
michael@0:     return;
michael@0: 
michael@0:   if (aContent && (aContent == mFirstFocusEvent || aContent == mFirstBlurEvent))
michael@0:     return;
michael@0: 
michael@0:   // Keep a reference to the presShell since dispatching the DOM event may
michael@0:   // cause the document to be destroyed.
michael@0:   nsCOMPtr<nsIDocShell> docShell = aWindow->GetDocShell();
michael@0:   if (!docShell)
michael@0:     return;
michael@0: 
michael@0:   nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
michael@0:   if (!presShell)
michael@0:     return;
michael@0: 
michael@0:   // If the focus actually changed, set the focus method (mouse, keyboard, etc).
michael@0:   // Otherwise, just get the current focus method and use that. This ensures
michael@0:   // that the method is set during the document and window focus events.
michael@0:   uint32_t focusMethod = aFocusChanged ? aFlags & FOCUSMETHODANDRING_MASK :
michael@0:                          aWindow->GetFocusMethod() | (aFlags & FLAG_SHOWRING);
michael@0: 
michael@0:   if (!IsWindowVisible(aWindow)) {
michael@0:     // if the window isn't visible, for instance because it is a hidden tab,
michael@0:     // update the current focus and scroll it into view but don't do anything else
michael@0:     if (CheckIfFocusable(aContent, aFlags)) {
michael@0:       aWindow->SetFocusedNode(aContent, focusMethod);
michael@0:       if (aFocusChanged)
michael@0:         ScrollIntoView(presShell, aContent, aFlags);
michael@0:     }
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   bool clearFirstFocusEvent = false;
michael@0:   if (!mFirstFocusEvent) {
michael@0:     mFirstFocusEvent = aContent;
michael@0:     clearFirstFocusEvent = true;
michael@0:   }
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0:   LOGCONTENT("Element %s has been focused", aContent);
michael@0: 
michael@0:   if (PR_LOG_TEST(gFocusLog, PR_LOG_DEBUG)) {
michael@0:     nsIDocument* docm = aWindow->GetExtantDoc();
michael@0:     if (docm) {
michael@0:       LOGCONTENT(" from %s", docm->GetRootElement());
michael@0:     }
michael@0:     LOGFOCUS((" [Newdoc: %d FocusChanged: %d Raised: %d Flags: %x]",
michael@0:              aIsNewDocument, aFocusChanged, aWindowRaised, aFlags));
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   if (aIsNewDocument) {
michael@0:     // if this is a new document, update the parent chain of frames so that
michael@0:     // focus can be traversed from the top level down to the newly focused
michael@0:     // window.
michael@0:     AdjustWindowFocus(aWindow, false);
michael@0: 
michael@0:     // Update the window touch registration to reflect the state of
michael@0:     // the new document that got focus
michael@0:     aWindow->UpdateTouchState();
michael@0:   }
michael@0: 
michael@0:   // indicate that the window has taken focus.
michael@0:   if (aWindow->TakeFocus(true, focusMethod))
michael@0:     aIsNewDocument = true;
michael@0: 
michael@0:   SetFocusedWindowInternal(aWindow);
michael@0: 
michael@0:   // Update the system focus by focusing the root widget.  But avoid this
michael@0:   // if 1) aAdjustWidgets is false or 2) aContent is a plugin that has its
michael@0:   // own widget and is either already focused or is about to be focused.
michael@0:   nsCOMPtr<nsIWidget> objectFrameWidget;
michael@0:   if (aContent) {
michael@0:     nsIFrame* contentFrame = aContent->GetPrimaryFrame();
michael@0:     nsIObjectFrame* objectFrame = do_QueryFrame(contentFrame);
michael@0:     if (objectFrame)
michael@0:       objectFrameWidget = objectFrame->GetWidget();
michael@0:   }
michael@0:   if (aAdjustWidgets && !objectFrameWidget && !sTestMode) {
michael@0:     nsViewManager* vm = presShell->GetViewManager();
michael@0:     if (vm) {
michael@0:       nsCOMPtr<nsIWidget> widget;
michael@0:       vm->GetRootWidget(getter_AddRefs(widget));
michael@0:       if (widget)
michael@0:         widget->SetFocus(false);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // if switching to a new document, first fire the focus event on the
michael@0:   // document and then the window.
michael@0:   if (aIsNewDocument) {
michael@0:     nsIDocument* doc = aWindow->GetExtantDoc();
michael@0:     // The focus change should be notified to IMEStateManager from here if
michael@0:     // the focused content is a designMode editor since any content won't
michael@0:     // receive focus event.
michael@0:     if (doc && doc->HasFlag(NODE_IS_EDITABLE)) {
michael@0:       IMEStateManager::OnChangeFocus(presShell->GetPresContext(), nullptr,
michael@0:                                      GetFocusMoveActionCause(aFlags));
michael@0:     }
michael@0:     if (doc)
michael@0:       SendFocusOrBlurEvent(NS_FOCUS_CONTENT, presShell, doc,
michael@0:                            doc, aFlags & FOCUSMETHOD_MASK, aWindowRaised);
michael@0:     if (mFocusedWindow == aWindow && mFocusedContent == nullptr)
michael@0:       SendFocusOrBlurEvent(NS_FOCUS_CONTENT, presShell, doc,
michael@0:                            aWindow, aFlags & FOCUSMETHOD_MASK, aWindowRaised);
michael@0:   }
michael@0: 
michael@0:   // check to ensure that the element is still focusable, and that nothing
michael@0:   // else was focused during the events above.
michael@0:   if (CheckIfFocusable(aContent, aFlags) &&
michael@0:       mFocusedWindow == aWindow && mFocusedContent == nullptr) {
michael@0:     mFocusedContent = aContent;
michael@0: 
michael@0:     nsIContent* focusedNode = aWindow->GetFocusedNode();
michael@0:     bool isRefocus = focusedNode && focusedNode->IsEqualNode(aContent);
michael@0: 
michael@0:     aWindow->SetFocusedNode(aContent, focusMethod);
michael@0: 
michael@0:     bool sendFocusEvent =
michael@0:       aContent && aContent->IsInDoc() && !IsNonFocusableRoot(aContent);
michael@0:     nsPresContext* presContext = presShell->GetPresContext();
michael@0:     if (sendFocusEvent) {
michael@0:       // if the focused element changed, scroll it into view
michael@0:       if (aFocusChanged)
michael@0:         ScrollIntoView(presShell, aContent, aFlags);
michael@0: 
michael@0:       NotifyFocusStateChange(aContent, aWindow->ShouldShowFocusRing(), true);
michael@0: 
michael@0:       // if this is an object/plug-in/remote browser, focus its widget.  Note that we might
michael@0:       // no longer be in the same document, due to the events we fired above when
michael@0:       // aIsNewDocument.
michael@0:       if (presShell->GetDocument() == aContent->GetDocument()) {
michael@0:         if (aAdjustWidgets && objectFrameWidget && !sTestMode)
michael@0:           objectFrameWidget->SetFocus(false);
michael@0: 
michael@0:         // if the object being focused is a remote browser, activate remote content
michael@0:         if (TabParent* remote = TabParent::GetFrom(aContent)) {
michael@0:           remote->Activate();
michael@0:           LOGFOCUS(("Remote browser activated"));
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       IMEStateManager::OnChangeFocus(presContext, aContent,
michael@0:                                      GetFocusMoveActionCause(aFlags));
michael@0: 
michael@0:       // as long as this focus wasn't because a window was raised, update the
michael@0:       // commands
michael@0:       // XXXndeakin P2 someone could adjust the focus during the update
michael@0:       if (!aWindowRaised)
michael@0:         aWindow->UpdateCommands(NS_LITERAL_STRING("focus"));
michael@0: 
michael@0:       SendFocusOrBlurEvent(NS_FOCUS_CONTENT, presShell,
michael@0:                            aContent->GetCurrentDoc(),
michael@0:                            aContent, aFlags & FOCUSMETHOD_MASK,
michael@0:                            aWindowRaised, isRefocus);
michael@0:     } else {
michael@0:       IMEStateManager::OnChangeFocus(presContext, nullptr,
michael@0:                                      GetFocusMoveActionCause(aFlags));
michael@0:       if (!aWindowRaised) {
michael@0:         aWindow->UpdateCommands(NS_LITERAL_STRING("focus"));
michael@0:       }
michael@0:     }
michael@0:   }
michael@0:   else {
michael@0:     // If the window focus event (fired above when aIsNewDocument) caused
michael@0:     // the plugin not to be focusable, update the system focus by focusing
michael@0:     // the root widget.
michael@0:     if (aAdjustWidgets && objectFrameWidget &&
michael@0:         mFocusedWindow == aWindow && mFocusedContent == nullptr &&
michael@0:         !sTestMode) {
michael@0:       nsViewManager* vm = presShell->GetViewManager();
michael@0:       if (vm) {
michael@0:         nsCOMPtr<nsIWidget> widget;
michael@0:         vm->GetRootWidget(getter_AddRefs(widget));
michael@0:         if (widget)
michael@0:           widget->SetFocus(false);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     nsPresContext* presContext = presShell->GetPresContext();
michael@0:     IMEStateManager::OnChangeFocus(presContext, nullptr,
michael@0:                                    GetFocusMoveActionCause(aFlags));
michael@0: 
michael@0:     if (!aWindowRaised)
michael@0:       aWindow->UpdateCommands(NS_LITERAL_STRING("focus"));
michael@0:   }
michael@0: 
michael@0:   // update the caret visibility and position to match the newly focused
michael@0:   // element. However, don't update the position if this was a focus due to a
michael@0:   // mouse click as the selection code would already have moved the caret as
michael@0:   // needed. If this is a different document than was focused before, also
michael@0:   // update the caret's visibility. If this is the same document, the caret
michael@0:   // visibility should be the same as before so there is no need to update it.
michael@0:   if (mFocusedContent == aContent)
michael@0:     UpdateCaret(aFocusChanged && !(aFlags & FLAG_BYMOUSE), aIsNewDocument,
michael@0:                 mFocusedContent);
michael@0: 
michael@0:   if (clearFirstFocusEvent)
michael@0:     mFirstFocusEvent = nullptr;
michael@0: }
michael@0: 
michael@0: class FocusBlurEvent : public nsRunnable
michael@0: {
michael@0: public:
michael@0:   FocusBlurEvent(nsISupports* aTarget, uint32_t aType,
michael@0:                  nsPresContext* aContext, bool aWindowRaised,
michael@0:                  bool aIsRefocus)
michael@0:   : mTarget(aTarget), mType(aType), mContext(aContext),
michael@0:     mWindowRaised(aWindowRaised), mIsRefocus(aIsRefocus) {}
michael@0: 
michael@0:   NS_IMETHOD Run()
michael@0:   {
michael@0:     InternalFocusEvent event(true, mType);
michael@0:     event.mFlags.mBubbles = false;
michael@0:     event.fromRaise = mWindowRaised;
michael@0:     event.isRefocus = mIsRefocus;
michael@0:     return EventDispatcher::Dispatch(mTarget, mContext, &event);
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsISupports>   mTarget;
michael@0:   uint32_t                mType;
michael@0:   nsRefPtr<nsPresContext> mContext;
michael@0:   bool                    mWindowRaised;
michael@0:   bool                    mIsRefocus;
michael@0: };
michael@0: 
michael@0: void
michael@0: nsFocusManager::SendFocusOrBlurEvent(uint32_t aType,
michael@0:                                      nsIPresShell* aPresShell,
michael@0:                                      nsIDocument* aDocument,
michael@0:                                      nsISupports* aTarget,
michael@0:                                      uint32_t aFocusMethod,
michael@0:                                      bool aWindowRaised,
michael@0:                                      bool aIsRefocus)
michael@0: {
michael@0:   NS_ASSERTION(aType == NS_FOCUS_CONTENT || aType == NS_BLUR_CONTENT,
michael@0:                "Wrong event type for SendFocusOrBlurEvent");
michael@0: 
michael@0:   nsCOMPtr<EventTarget> eventTarget = do_QueryInterface(aTarget);
michael@0: 
michael@0:   nsCOMPtr<nsINode> n = do_QueryInterface(aTarget);
michael@0:   if (!n) {
michael@0:     nsCOMPtr<nsPIDOMWindow> win = do_QueryInterface(aTarget);
michael@0:     n = win ? win->GetExtantDoc() : nullptr;
michael@0:   }
michael@0:   bool dontDispatchEvent = n && nsContentUtils::IsUserFocusIgnored(n);
michael@0: 
michael@0:   // for focus events, if this event was from a mouse or key and event
michael@0:   // handling on the document is suppressed, queue the event and fire it
michael@0:   // later. For blur events, a non-zero value would be set for aFocusMethod.
michael@0:   if (aFocusMethod && !dontDispatchEvent &&
michael@0:       aDocument && aDocument->EventHandlingSuppressed()) {
michael@0:     // aFlags is always 0 when aWindowRaised is true so this won't be called
michael@0:     // on a window raise.
michael@0:     NS_ASSERTION(!aWindowRaised, "aWindowRaised should not be set");
michael@0: 
michael@0:     for (uint32_t i = mDelayedBlurFocusEvents.Length(); i > 0; --i) {
michael@0:       // if this event was already queued, remove it and append it to the end
michael@0:       if (mDelayedBlurFocusEvents[i - 1].mType == aType &&
michael@0:           mDelayedBlurFocusEvents[i - 1].mPresShell == aPresShell &&
michael@0:           mDelayedBlurFocusEvents[i - 1].mDocument == aDocument &&
michael@0:           mDelayedBlurFocusEvents[i - 1].mTarget == eventTarget) {
michael@0:         mDelayedBlurFocusEvents.RemoveElementAt(i - 1);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     mDelayedBlurFocusEvents.AppendElement(
michael@0:       nsDelayedBlurOrFocusEvent(aType, aPresShell, aDocument, eventTarget));
michael@0:     return;
michael@0:   }
michael@0: 
michael@0: #ifdef ACCESSIBILITY
michael@0:   nsAccessibilityService* accService = GetAccService();
michael@0:   if (accService) {
michael@0:     if (aType == NS_FOCUS_CONTENT)
michael@0:       accService->NotifyOfDOMFocus(aTarget);
michael@0:     else
michael@0:       accService->NotifyOfDOMBlur(aTarget);
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   if (!dontDispatchEvent) {
michael@0:     nsContentUtils::AddScriptRunner(
michael@0:       new FocusBlurEvent(aTarget, aType, aPresShell->GetPresContext(),
michael@0:                          aWindowRaised, aIsRefocus));
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFocusManager::ScrollIntoView(nsIPresShell* aPresShell,
michael@0:                                nsIContent* aContent,
michael@0:                                uint32_t aFlags)
michael@0: {
michael@0:   // if the noscroll flag isn't set, scroll the newly focused element into view
michael@0:   if (!(aFlags & FLAG_NOSCROLL))
michael@0:     aPresShell->ScrollContentIntoView(aContent,
michael@0:                                       nsIPresShell::ScrollAxis(
michael@0:                                         nsIPresShell::SCROLL_MINIMUM,
michael@0:                                         nsIPresShell::SCROLL_IF_NOT_VISIBLE),
michael@0:                                       nsIPresShell::ScrollAxis(
michael@0:                                         nsIPresShell::SCROLL_MINIMUM,
michael@0:                                         nsIPresShell::SCROLL_IF_NOT_VISIBLE),
michael@0:                                       nsIPresShell::SCROLL_OVERFLOW_HIDDEN);
michael@0: }
michael@0: 
michael@0: 
michael@0: void
michael@0: nsFocusManager::RaiseWindow(nsPIDOMWindow* aWindow)
michael@0: {
michael@0:   // don't raise windows that are already raised or are in the process of
michael@0:   // being lowered
michael@0:   if (!aWindow || aWindow == mActiveWindow || aWindow == mWindowBeingLowered)
michael@0:     return;
michael@0: 
michael@0:   if (sTestMode) {
michael@0:     // In test mode, emulate the existing window being lowered and the new
michael@0:     // window being raised.
michael@0:     if (mActiveWindow)
michael@0:       WindowLowered(mActiveWindow);
michael@0:     WindowRaised(aWindow);
michael@0:     return;
michael@0:   }
michael@0: 
michael@0: #if defined(XP_WIN)
michael@0:   // Windows would rather we focus the child widget, otherwise, the toplevel
michael@0:   // widget will always end up being focused. Fortunately, focusing the child
michael@0:   // widget will also have the effect of raising the window this widget is in.
michael@0:   // But on other platforms, we can just focus the toplevel widget to raise
michael@0:   // the window.
michael@0:   nsCOMPtr<nsPIDOMWindow> childWindow;
michael@0:   GetFocusedDescendant(aWindow, true, getter_AddRefs(childWindow));
michael@0:   if (!childWindow)
michael@0:     childWindow = aWindow;
michael@0: 
michael@0:   nsCOMPtr<nsIDocShell> docShell = aWindow->GetDocShell();
michael@0:   if (!docShell)
michael@0:     return;
michael@0: 
michael@0:   nsCOMPtr<nsIPresShell> presShell = docShell->GetPresShell();
michael@0:   if (!presShell)
michael@0:     return;
michael@0: 
michael@0:   nsViewManager* vm = presShell->GetViewManager();
michael@0:   if (vm) {
michael@0:     nsCOMPtr<nsIWidget> widget;
michael@0:     vm->GetRootWidget(getter_AddRefs(widget));
michael@0:     if (widget)
michael@0:       widget->SetFocus(true);
michael@0:   }
michael@0: #else
michael@0:   nsCOMPtr<nsIWebNavigation> webnav = do_GetInterface(aWindow);
michael@0:   nsCOMPtr<nsIBaseWindow> treeOwnerAsWin = do_QueryInterface(webnav);
michael@0:   if (treeOwnerAsWin) {
michael@0:     nsCOMPtr<nsIWidget> widget;
michael@0:     treeOwnerAsWin->GetMainWidget(getter_AddRefs(widget));
michael@0:     if (widget)
michael@0:       widget->SetFocus(true);
michael@0:   }
michael@0: #endif
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFocusManager::UpdateCaretForCaretBrowsingMode()
michael@0: {
michael@0:   UpdateCaret(false, true, mFocusedContent);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFocusManager::UpdateCaret(bool aMoveCaretToFocus,
michael@0:                             bool aUpdateVisibility,
michael@0:                             nsIContent* aContent)
michael@0: {
michael@0:   LOGFOCUS(("Update Caret: %d %d", aMoveCaretToFocus, aUpdateVisibility));
michael@0: 
michael@0:   if (!mFocusedWindow)
michael@0:     return;
michael@0: 
michael@0:   // this is called when a document is focused or when the caretbrowsing
michael@0:   // preference is changed
michael@0:   nsCOMPtr<nsIDocShell> focusedDocShell = mFocusedWindow->GetDocShell();
michael@0:   nsCOMPtr<nsIDocShellTreeItem> dsti = do_QueryInterface(focusedDocShell);
michael@0:   if (!dsti)
michael@0:     return;
michael@0: 
michael@0:   if (dsti->ItemType() == nsIDocShellTreeItem::typeChrome) {
michael@0:     return;  // Never browse with caret in chrome
michael@0:   }
michael@0: 
michael@0:   bool browseWithCaret =
michael@0:     Preferences::GetBool("accessibility.browsewithcaret");
michael@0: 
michael@0:   nsCOMPtr<nsIPresShell> presShell = focusedDocShell->GetPresShell();
michael@0:   if (!presShell)
michael@0:     return;
michael@0: 
michael@0:   // If this is an editable document which isn't contentEditable, or a
michael@0:   // contentEditable document and the node to focus is contentEditable,
michael@0:   // return, so that we don't mess with caret visibility.
michael@0:   bool isEditable = false;
michael@0:   focusedDocShell->GetEditable(&isEditable);
michael@0: 
michael@0:   if (isEditable) {
michael@0:     nsCOMPtr<nsIHTMLDocument> doc =
michael@0:       do_QueryInterface(presShell->GetDocument());
michael@0: 
michael@0:     bool isContentEditableDoc =
michael@0:       doc && doc->GetEditingState() == nsIHTMLDocument::eContentEditable;
michael@0: 
michael@0:     bool isFocusEditable =
michael@0:       aContent && aContent->HasFlag(NODE_IS_EDITABLE);
michael@0:     if (!isContentEditableDoc || isFocusEditable)
michael@0:       return;
michael@0:   }
michael@0: 
michael@0:   if (!isEditable && aMoveCaretToFocus)
michael@0:     MoveCaretToFocus(presShell, aContent);
michael@0: 
michael@0:   if (!aUpdateVisibility)
michael@0:     return;
michael@0: 
michael@0:   // XXXndeakin this doesn't seem right. It should be checking for this only
michael@0:   // on the nearest ancestor frame which is a chrome frame. But this is
michael@0:   // what the existing code does, so just leave it for now.
michael@0:   if (!browseWithCaret) {
michael@0:     nsCOMPtr<nsIContent> docContent =
michael@0:       do_QueryInterface(mFocusedWindow->GetFrameElementInternal());
michael@0:     if (docContent)
michael@0:       browseWithCaret = docContent->AttrValueIs(kNameSpaceID_None,
michael@0:                                                 nsGkAtoms::showcaret,
michael@0:                                                 NS_LITERAL_STRING("true"),
michael@0:                                                 eCaseMatters);
michael@0:   }
michael@0: 
michael@0:   SetCaretVisible(presShell, browseWithCaret, aContent);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFocusManager::MoveCaretToFocus(nsIPresShell* aPresShell, nsIContent* aContent)
michael@0: {
michael@0:   // domDoc is a document interface we can create a range with
michael@0:   nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(aPresShell->GetDocument());
michael@0:   if (domDoc) {
michael@0:     nsRefPtr<nsFrameSelection> frameSelection = aPresShell->FrameSelection();
michael@0:     nsCOMPtr<nsISelection> domSelection = frameSelection->
michael@0:       GetSelection(nsISelectionController::SELECTION_NORMAL);
michael@0:     if (domSelection) {
michael@0:       nsCOMPtr<nsIDOMNode> currentFocusNode(do_QueryInterface(aContent));
michael@0:       // First clear the selection. This way, if there is no currently focused
michael@0:       // content, the selection will just be cleared.
michael@0:       domSelection->RemoveAllRanges();
michael@0:       if (currentFocusNode) {
michael@0:         nsCOMPtr<nsIDOMRange> newRange;
michael@0:         nsresult rv = domDoc->CreateRange(getter_AddRefs(newRange));
michael@0:         if (NS_SUCCEEDED(rv)) {
michael@0:           // Set the range to the start of the currently focused node
michael@0:           // Make sure it's collapsed
michael@0:           newRange->SelectNodeContents(currentFocusNode);
michael@0:           nsCOMPtr<nsIDOMNode> firstChild;
michael@0:           currentFocusNode->GetFirstChild(getter_AddRefs(firstChild));
michael@0:           if (!firstChild ||
michael@0:               aContent->IsNodeOfType(nsINode::eHTML_FORM_CONTROL)) {
michael@0:             // If current focus node is a leaf, set range to before the
michael@0:             // node by using the parent as a container.
michael@0:             // This prevents it from appearing as selected.
michael@0:             newRange->SetStartBefore(currentFocusNode);
michael@0:             newRange->SetEndBefore(currentFocusNode);
michael@0:           }
michael@0:           domSelection->AddRange(newRange);
michael@0:           domSelection->CollapseToStart();
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsFocusManager::SetCaretVisible(nsIPresShell* aPresShell,
michael@0:                                 bool aVisible,
michael@0:                                 nsIContent* aContent)
michael@0: {
michael@0:   // When browsing with caret, make sure caret is visible after new focus
michael@0:   // Return early if there is no caret. This can happen for the testcase
michael@0:   // for bug 308025 where a window is closed in a blur handler.
michael@0:   nsRefPtr<nsCaret> caret = aPresShell->GetCaret();
michael@0:   if (!caret)
michael@0:     return NS_OK;
michael@0: 
michael@0:   bool caretVisible = false;
michael@0:   caret->GetCaretVisible(&caretVisible);
michael@0:   if (!aVisible && !caretVisible)
michael@0:     return NS_OK;
michael@0: 
michael@0:   nsRefPtr<nsFrameSelection> frameSelection;
michael@0:   if (aContent) {
michael@0:     NS_ASSERTION(aContent->GetDocument() == aPresShell->GetDocument(),
michael@0:                  "Wrong document?");
michael@0:     nsIFrame *focusFrame = aContent->GetPrimaryFrame();
michael@0:     if (focusFrame)
michael@0:       frameSelection = focusFrame->GetFrameSelection();
michael@0:   }
michael@0: 
michael@0:   nsRefPtr<nsFrameSelection> docFrameSelection = aPresShell->FrameSelection();
michael@0: 
michael@0:   if (docFrameSelection && caret &&
michael@0:      (frameSelection == docFrameSelection || !aContent)) {
michael@0:     nsISelection* domSelection = docFrameSelection->
michael@0:       GetSelection(nsISelectionController::SELECTION_NORMAL);
michael@0:     if (domSelection) {
michael@0:       // First, hide the caret to prevent attempting to show it in SetCaretDOMSelection
michael@0:       caret->SetCaretVisible(false);
michael@0: 
michael@0:       // Caret must blink on non-editable elements
michael@0:       caret->SetIgnoreUserModify(true);
michael@0:       // Tell the caret which selection to use
michael@0:       caret->SetCaretDOMSelection(domSelection);
michael@0: 
michael@0:       // In content, we need to set the caret. The only special case is edit
michael@0:       // fields, which have a different frame selection from the document.
michael@0:       // They will take care of making the caret visible themselves.
michael@0: 
michael@0:       nsCOMPtr<nsISelectionController> selCon(do_QueryInterface(aPresShell));
michael@0:       if (!selCon)
michael@0:         return NS_ERROR_FAILURE;
michael@0: 
michael@0:       selCon->SetCaretReadOnly(false);
michael@0:       selCon->SetCaretEnabled(aVisible);
michael@0:       caret->SetCaretVisible(aVisible);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsFocusManager::GetSelectionLocation(nsIDocument* aDocument,
michael@0:                                      nsIPresShell* aPresShell,
michael@0:                                      nsIContent **aStartContent,
michael@0:                                      nsIContent **aEndContent)
michael@0: {
michael@0:   *aStartContent = *aEndContent = nullptr;
michael@0:   nsresult rv = NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsPresContext* presContext = aPresShell->GetPresContext();
michael@0:   NS_ASSERTION(presContext, "mPresContent is null!!");
michael@0: 
michael@0:   nsRefPtr<nsFrameSelection> frameSelection = aPresShell->FrameSelection();
michael@0: 
michael@0:   nsCOMPtr<nsISelection> domSelection;
michael@0:   if (frameSelection) {
michael@0:     domSelection = frameSelection->
michael@0:       GetSelection(nsISelectionController::SELECTION_NORMAL);
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDOMNode> startNode, endNode;
michael@0:   bool isCollapsed = false;
michael@0:   nsCOMPtr<nsIContent> startContent, endContent;
michael@0:   int32_t startOffset = 0;
michael@0:   if (domSelection) {
michael@0:     domSelection->GetIsCollapsed(&isCollapsed);
michael@0:     nsCOMPtr<nsIDOMRange> domRange;
michael@0:     rv = domSelection->GetRangeAt(0, getter_AddRefs(domRange));
michael@0:     if (domRange) {
michael@0:       domRange->GetStartContainer(getter_AddRefs(startNode));
michael@0:       domRange->GetEndContainer(getter_AddRefs(endNode));
michael@0:       domRange->GetStartOffset(&startOffset);
michael@0: 
michael@0:       nsIContent *childContent = nullptr;
michael@0: 
michael@0:       startContent = do_QueryInterface(startNode);
michael@0:       if (startContent && startContent->IsElement()) {
michael@0:         NS_ASSERTION(startOffset >= 0, "Start offset cannot be negative");  
michael@0:         childContent = startContent->GetChildAt(startOffset);
michael@0:         if (childContent) {
michael@0:           startContent = childContent;
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       endContent = do_QueryInterface(endNode);
michael@0:       if (endContent && endContent->IsElement()) {
michael@0:         int32_t endOffset = 0;
michael@0:         domRange->GetEndOffset(&endOffset);
michael@0:         NS_ASSERTION(endOffset >= 0, "End offset cannot be negative");
michael@0:         childContent = endContent->GetChildAt(endOffset);
michael@0:         if (childContent) {
michael@0:           endContent = childContent;
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0:   else {
michael@0:     rv = NS_ERROR_INVALID_ARG;
michael@0:   }
michael@0: 
michael@0:   nsIFrame *startFrame = nullptr;
michael@0:   if (startContent) {
michael@0:     startFrame = startContent->GetPrimaryFrame();
michael@0:     if (isCollapsed) {
michael@0:       // Next check to see if our caret is at the very end of a node
michael@0:       // If so, the caret is actually sitting in front of the next
michael@0:       // logical frame's primary node - so for this case we need to
michael@0:       // change caretContent to that node.
michael@0: 
michael@0:       if (startContent->NodeType() == nsIDOMNode::TEXT_NODE) {
michael@0:         nsAutoString nodeValue;
michael@0:         startContent->AppendTextTo(nodeValue);
michael@0: 
michael@0:         bool isFormControl =
michael@0:           startContent->IsNodeOfType(nsINode::eHTML_FORM_CONTROL);
michael@0: 
michael@0:         if (nodeValue.Length() == (uint32_t)startOffset && !isFormControl &&
michael@0:             startContent != aDocument->GetRootElement()) {
michael@0:           // Yes, indeed we were at the end of the last node
michael@0:           nsCOMPtr<nsIFrameEnumerator> frameTraversal;
michael@0:           nsresult rv = NS_NewFrameTraversal(getter_AddRefs(frameTraversal),
michael@0:                                              presContext, startFrame,
michael@0:                                              eLeaf,
michael@0:                                              false, // aVisual
michael@0:                                              false, // aLockInScrollView
michael@0:                                              true      // aFollowOOFs
michael@0:                                              );
michael@0:           NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:           nsIFrame *newCaretFrame = nullptr;
michael@0:           nsCOMPtr<nsIContent> newCaretContent = startContent;
michael@0:           bool endOfSelectionInStartNode(startContent == endContent);
michael@0:           do {
michael@0:             // Continue getting the next frame until the primary content for the frame
michael@0:             // we are on changes - we don't want to be stuck in the same place
michael@0:             frameTraversal->Next();
michael@0:             newCaretFrame = static_cast<nsIFrame*>(frameTraversal->CurrentItem());
michael@0:             if (nullptr == newCaretFrame)
michael@0:               break;
michael@0:             newCaretContent = newCaretFrame->GetContent();
michael@0:           } while (!newCaretContent || newCaretContent == startContent);
michael@0: 
michael@0:           if (newCaretFrame && newCaretContent) {
michael@0:             // If the caret is exactly at the same position of the new frame,
michael@0:             // then we can use the newCaretFrame and newCaretContent for our position
michael@0:             nsRefPtr<nsCaret> caret = aPresShell->GetCaret();
michael@0:             nsRect caretRect;
michael@0:             nsIFrame *frame = caret->GetGeometry(domSelection, &caretRect);
michael@0:             if (frame) {
michael@0:               nsPoint caretWidgetOffset;
michael@0:               nsIWidget *widget = frame->GetNearestWidget(caretWidgetOffset);
michael@0:               caretRect.MoveBy(caretWidgetOffset);
michael@0:               nsPoint newCaretOffset;
michael@0:               nsIWidget *newCaretWidget = newCaretFrame->GetNearestWidget(newCaretOffset);
michael@0:               if (widget == newCaretWidget && caretRect.y == newCaretOffset.y &&
michael@0:                   caretRect.x == newCaretOffset.x) {
michael@0:                 // The caret is at the start of the new element.
michael@0:                 startFrame = newCaretFrame;
michael@0:                 startContent = newCaretContent;
michael@0:                 if (endOfSelectionInStartNode) {
michael@0:                   endContent = newCaretContent; // Ensure end of selection is not before start
michael@0:                 }
michael@0:               }
michael@0:             }
michael@0:           }
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   *aStartContent = startContent;
michael@0:   *aEndContent = endContent;
michael@0:   NS_IF_ADDREF(*aStartContent);
michael@0:   NS_IF_ADDREF(*aEndContent);
michael@0: 
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsFocusManager::DetermineElementToMoveFocus(nsPIDOMWindow* aWindow,
michael@0:                                             nsIContent* aStartContent,
michael@0:                                             int32_t aType, bool aNoParentTraversal,
michael@0:                                             nsIContent** aNextContent)
michael@0: {
michael@0:   *aNextContent = nullptr;
michael@0: 
michael@0:   nsCOMPtr<nsIDocShell> docShell = aWindow->GetDocShell();
michael@0:   if (!docShell)
michael@0:     return NS_OK;
michael@0: 
michael@0:   nsCOMPtr<nsIContent> startContent = aStartContent;
michael@0:   if (!startContent && aType != MOVEFOCUS_CARET) {
michael@0:     if (aType == MOVEFOCUS_FORWARDDOC || aType == MOVEFOCUS_BACKWARDDOC) {
michael@0:       // When moving between documents, make sure to get the right
michael@0:       // starting content in a descendant.
michael@0:       nsCOMPtr<nsPIDOMWindow> focusedWindow;
michael@0:       startContent = GetFocusedDescendant(aWindow, true, getter_AddRefs(focusedWindow));
michael@0:     }
michael@0:     else {
michael@0:       startContent = aWindow->GetFocusedNode();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDocument> doc;
michael@0:   if (startContent)
michael@0:     doc = startContent->GetCurrentDoc();
michael@0:   else
michael@0:     doc = aWindow->GetExtantDoc();
michael@0:   if (!doc)
michael@0:     return NS_OK;
michael@0: 
michael@0:   LookAndFeel::GetInt(LookAndFeel::eIntID_TabFocusModel,
michael@0:                       &nsIContent::sTabFocusModel);
michael@0: 
michael@0:   if (aType == MOVEFOCUS_ROOT) {
michael@0:     NS_IF_ADDREF(*aNextContent = GetRootForFocus(aWindow, doc, false, false));
michael@0:     return NS_OK;
michael@0:   }
michael@0:   if (aType == MOVEFOCUS_FORWARDDOC) {
michael@0:     NS_IF_ADDREF(*aNextContent = GetNextTabbableDocument(startContent, true));
michael@0:     return NS_OK;
michael@0:   }
michael@0:   if (aType == MOVEFOCUS_BACKWARDDOC) {
michael@0:     NS_IF_ADDREF(*aNextContent = GetNextTabbableDocument(startContent, false));
michael@0:     return NS_OK;
michael@0:   }
michael@0:   
michael@0:   nsIContent* rootContent = doc->GetRootElement();
michael@0:   NS_ENSURE_TRUE(rootContent, NS_OK);
michael@0: 
michael@0:   nsIPresShell *presShell = doc->GetShell();
michael@0:   NS_ENSURE_TRUE(presShell, NS_OK);
michael@0: 
michael@0:   if (aType == MOVEFOCUS_FIRST) {
michael@0:     if (!aStartContent)
michael@0:       startContent = rootContent;
michael@0:     return GetNextTabbableContent(presShell, startContent,
michael@0:                                   nullptr, startContent,
michael@0:                                   true, 1, false, aNextContent);
michael@0:   }
michael@0:   if (aType == MOVEFOCUS_LAST) {
michael@0:     if (!aStartContent)
michael@0:       startContent = rootContent;
michael@0:     return GetNextTabbableContent(presShell, startContent,
michael@0:                                   nullptr, startContent,
michael@0:                                   false, 0, false, aNextContent);
michael@0:   }
michael@0: 
michael@0:   bool forward = (aType == MOVEFOCUS_FORWARD || aType == MOVEFOCUS_CARET);
michael@0:   bool doNavigation = true;
michael@0:   bool ignoreTabIndex = false;
michael@0:   // when a popup is open, we want to ensure that tab navigation occurs only
michael@0:   // within the most recently opened panel. If a popup is open, its frame will
michael@0:   // be stored in popupFrame.
michael@0:   nsIFrame* popupFrame = nullptr;
michael@0: 
michael@0:   int32_t tabIndex = forward ? 1 : 0;
michael@0:   if (startContent) {
michael@0:     nsIFrame* frame = startContent->GetPrimaryFrame();
michael@0:     if (startContent->Tag() == nsGkAtoms::area &&
michael@0:         startContent->IsHTML())
michael@0:       startContent->IsFocusable(&tabIndex);
michael@0:     else if (frame)
michael@0:       frame->IsFocusable(&tabIndex, 0);
michael@0:     else
michael@0:       startContent->IsFocusable(&tabIndex);
michael@0: 
michael@0:     // if the current element isn't tabbable, ignore the tabindex and just
michael@0:     // look for the next element. The root content won't have a tabindex
michael@0:     // so just treat this as the beginning of the tab order.
michael@0:     if (tabIndex < 0) {
michael@0:       tabIndex = 1;
michael@0:       if (startContent != rootContent)
michael@0:         ignoreTabIndex = true;
michael@0:     }
michael@0: 
michael@0:     // check if the focus is currently inside a popup. Elements such as the
michael@0:     // autocomplete widget use the noautofocus attribute to allow the focus to
michael@0:     // remain outside the popup when it is opened.
michael@0:     if (frame) {
michael@0:       popupFrame = nsLayoutUtils::GetClosestFrameOfType(frame,
michael@0:                                                         nsGkAtoms::menuPopupFrame);
michael@0:     }
michael@0: 
michael@0:     if (popupFrame) {
michael@0:       // Don't navigate outside of a popup, so pretend that the
michael@0:       // root content is the popup itself
michael@0:       rootContent = popupFrame->GetContent();
michael@0:       NS_ASSERTION(rootContent, "Popup frame doesn't have a content node");
michael@0:     }
michael@0:     else if (!forward) {
michael@0:       // If focus moves backward and when current focused node is root
michael@0:       // content or <body> element which is editable by contenteditable
michael@0:       // attribute, focus should move to its parent document.
michael@0:       if (startContent == rootContent) {
michael@0:         doNavigation = false;
michael@0:       } else {
michael@0:         nsIDocument* doc = startContent->GetCurrentDoc();
michael@0:         if (startContent ==
michael@0:               nsLayoutUtils::GetEditableRootContentByContentEditable(doc)) {
michael@0:           doNavigation = false;
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0:   else {
michael@0: #ifdef MOZ_XUL
michael@0:     if (aType != MOVEFOCUS_CARET) {
michael@0:       // if there is no focus, yet a panel is open, focus the first item in
michael@0:       // the panel
michael@0:       nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
michael@0:       if (pm)
michael@0:         popupFrame = pm->GetTopPopup(ePopupTypePanel);
michael@0:     }
michael@0: #endif
michael@0:     if (popupFrame) {
michael@0:       rootContent = popupFrame->GetContent();
michael@0:       NS_ASSERTION(rootContent, "Popup frame doesn't have a content node");
michael@0:       startContent = rootContent;
michael@0:     }
michael@0:     else {
michael@0:       // Otherwise, for content shells, start from the location of the caret.
michael@0:       if (docShell->ItemType() != nsIDocShellTreeItem::typeChrome) {
michael@0:         nsCOMPtr<nsIContent> endSelectionContent;
michael@0:         GetSelectionLocation(doc, presShell,
michael@0:                              getter_AddRefs(startContent),
michael@0:                              getter_AddRefs(endSelectionContent));
michael@0:         // If the selection is on the rootContent, then there is no selection
michael@0:         if (startContent == rootContent) {
michael@0:           startContent = nullptr;
michael@0:         }
michael@0: 
michael@0:         if (aType == MOVEFOCUS_CARET) {
michael@0:           // GetFocusInSelection finds a focusable link near the caret.
michael@0:           // If there is no start content though, don't do this to avoid
michael@0:           // focusing something unexpected.
michael@0:           if (startContent) {
michael@0:             GetFocusInSelection(aWindow, startContent,
michael@0:                                 endSelectionContent, aNextContent);
michael@0:           }
michael@0:           return NS_OK;
michael@0:         }
michael@0: 
michael@0:         if (startContent) {
michael@0:           // when starting from a selection, we always want to find the next or
michael@0:           // previous element in the document. So the tabindex on elements
michael@0:           // should be ignored.
michael@0:           ignoreTabIndex = true;
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       if (!startContent) {
michael@0:         // otherwise, just use the root content as the starting point
michael@0:         startContent = rootContent;
michael@0:         NS_ENSURE_TRUE(startContent, NS_OK);
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   NS_ASSERTION(startContent, "starting content not set");
michael@0: 
michael@0:   // keep a reference to the starting content. If we find that again, it means
michael@0:   // we've iterated around completely and we don't want to adjust the focus.
michael@0:   // The skipOriginalContentCheck will be set to true only for the first time
michael@0:   // GetNextTabbableContent is called. This ensures that we don't break out
michael@0:   // when nothing is focused to start with. Specifically,
michael@0:   // GetNextTabbableContent first checks the root content -- which happens to
michael@0:   // be the same as the start content -- when nothing is focused and tabbing
michael@0:   // forward. Without skipOriginalContentCheck set to true, we'd end up
michael@0:   // returning right away and focusing nothing. Luckily, GetNextTabbableContent
michael@0:   // will never wrap around on its own, and can only return the original
michael@0:   // content when it is called a second time or later.
michael@0:   bool skipOriginalContentCheck = true;
michael@0:   nsIContent* originalStartContent = startContent;
michael@0: 
michael@0:   LOGCONTENTNAVIGATION("Focus Navigation Start Content %s", startContent.get());
michael@0:   LOGFOCUSNAVIGATION(("  Tabindex: %d Ignore: %d", tabIndex, ignoreTabIndex));
michael@0: 
michael@0:   while (doc) {
michael@0:     if (doNavigation) {
michael@0:       nsCOMPtr<nsIContent> nextFocus;
michael@0:       nsresult rv = GetNextTabbableContent(presShell, rootContent,
michael@0:                                            skipOriginalContentCheck ? nullptr : originalStartContent,
michael@0:                                            startContent, forward,
michael@0:                                            tabIndex, ignoreTabIndex,
michael@0:                                            getter_AddRefs(nextFocus));
michael@0:       NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:       // found a content node to focus.
michael@0:       if (nextFocus) {
michael@0:         LOGCONTENTNAVIGATION("Next Content: %s", nextFocus.get());
michael@0: 
michael@0:         // as long as the found node was not the same as the starting node,
michael@0:         // set it as the return value.
michael@0:         if (nextFocus != originalStartContent)
michael@0:           NS_ADDREF(*aNextContent = nextFocus);
michael@0:         return NS_OK;
michael@0:       }
michael@0: 
michael@0:       if (popupFrame) {
michael@0:         // in a popup, so start again from the beginning of the popup. However,
michael@0:         // if we already started at the beginning, then there isn't anything to
michael@0:         // focus, so just return
michael@0:         if (startContent != rootContent) {
michael@0:           startContent = rootContent;
michael@0:           tabIndex = forward ? 1 : 0;
michael@0:           continue;
michael@0:         }
michael@0:         return NS_OK;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     doNavigation = true;
michael@0:     skipOriginalContentCheck = false;
michael@0:     ignoreTabIndex = false;
michael@0: 
michael@0:     if (aNoParentTraversal) {
michael@0:       if (startContent == rootContent)
michael@0:         return NS_OK;
michael@0: 
michael@0:       startContent = rootContent;
michael@0:       tabIndex = forward ? 1 : 0;
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     // reached the beginning or end of the document. Traverse up to the parent
michael@0:     // document and try again.
michael@0:     nsCOMPtr<nsIDocShellTreeItem> docShellParent;
michael@0:     docShell->GetParent(getter_AddRefs(docShellParent));
michael@0:     if (docShellParent) {
michael@0:       // move up to the parent shell and try again from there.
michael@0: 
michael@0:       // first, get the frame element this window is inside.
michael@0:       nsCOMPtr<nsPIDOMWindow> piWindow = do_GetInterface(docShell);
michael@0:       NS_ENSURE_TRUE(piWindow, NS_ERROR_FAILURE);
michael@0: 
michael@0:       // Next, retrieve the parent docshell, document and presshell.
michael@0:       docShell = do_QueryInterface(docShellParent);
michael@0:       NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
michael@0: 
michael@0:       nsCOMPtr<nsPIDOMWindow> piParentWindow = do_GetInterface(docShellParent);
michael@0:       NS_ENSURE_TRUE(piParentWindow, NS_ERROR_FAILURE);
michael@0:       doc = piParentWindow->GetExtantDoc();
michael@0:       NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
michael@0: 
michael@0:       presShell = doc->GetShell();
michael@0: 
michael@0:       rootContent = doc->GetRootElement();
michael@0:       startContent = do_QueryInterface(piWindow->GetFrameElementInternal());
michael@0:       if (startContent) {
michael@0:         nsIFrame* frame = startContent->GetPrimaryFrame();
michael@0:         if (!frame)
michael@0:           return NS_OK;
michael@0: 
michael@0:         frame->IsFocusable(&tabIndex, 0);
michael@0:         if (tabIndex < 0) {
michael@0:           tabIndex = 1;
michael@0:           ignoreTabIndex = true;
michael@0:         }
michael@0: 
michael@0:         // if the frame is inside a popup, make sure to scan only within the
michael@0:         // popup. This handles the situation of tabbing amongst elements
michael@0:         // inside an iframe which is itself inside a popup. Otherwise,
michael@0:         // navigation would move outside the popup when tabbing outside the
michael@0:         // iframe.
michael@0:         popupFrame = nsLayoutUtils::GetClosestFrameOfType(frame,
michael@0:                                                           nsGkAtoms::menuPopupFrame);
michael@0:         if (popupFrame) {
michael@0:           rootContent = popupFrame->GetContent();
michael@0:           NS_ASSERTION(rootContent, "Popup frame doesn't have a content node");
michael@0:         }
michael@0:       }
michael@0:       else {
michael@0:         startContent = rootContent;
michael@0:         tabIndex = forward ? 1 : 0;
michael@0:       }
michael@0:     }
michael@0:     else {
michael@0:       // no parent, so call the tree owner. This will tell the embedder that
michael@0:       // it should take the focus.
michael@0:       bool tookFocus;
michael@0:       docShell->TabToTreeOwner(forward, &tookFocus);
michael@0:       // if the tree owner, took the focus, blur the current content
michael@0:       if (tookFocus) {
michael@0:         nsCOMPtr<nsPIDOMWindow> window = do_GetInterface(docShell);
michael@0:         if (window->GetFocusedNode() == mFocusedContent)
michael@0:           Blur(mFocusedWindow, nullptr, true, true);
michael@0:         else
michael@0:           window->SetFocusedNode(nullptr);
michael@0:         return NS_OK;
michael@0:       }
michael@0: 
michael@0:       // reset the tab index and start again from the beginning or end
michael@0:       startContent = rootContent;
michael@0:       tabIndex = forward ? 1 : 0;
michael@0:     }
michael@0: 
michael@0:     // wrapped all the way around and didn't find anything to move the focus
michael@0:     // to, so just break out
michael@0:     if (startContent == originalStartContent)
michael@0:       break;
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsFocusManager::GetNextTabbableContent(nsIPresShell* aPresShell,
michael@0:                                        nsIContent* aRootContent,
michael@0:                                        nsIContent* aOriginalStartContent,
michael@0:                                        nsIContent* aStartContent,
michael@0:                                        bool aForward,
michael@0:                                        int32_t aCurrentTabIndex,
michael@0:                                        bool aIgnoreTabIndex,
michael@0:                                        nsIContent** aResultContent)
michael@0: {
michael@0:   *aResultContent = nullptr;
michael@0: 
michael@0:   nsCOMPtr<nsIContent> startContent = aStartContent;
michael@0:   if (!startContent)
michael@0:     return NS_OK;
michael@0: 
michael@0:   LOGCONTENTNAVIGATION("GetNextTabbable: %s", aStartContent);
michael@0:   LOGFOCUSNAVIGATION(("  tabindex: %d", aCurrentTabIndex));
michael@0: 
michael@0:   nsPresContext* presContext = aPresShell->GetPresContext();
michael@0: 
michael@0:   bool getNextFrame = true;
michael@0:   nsCOMPtr<nsIContent> iterStartContent = aStartContent;
michael@0:   while (1) {
michael@0:     nsIFrame* startFrame = iterStartContent->GetPrimaryFrame();
michael@0:     // if there is no frame, look for another content node that has a frame
michael@0:     if (!startFrame) {
michael@0:       // if the root content doesn't have a frame, just return
michael@0:       if (iterStartContent == aRootContent)
michael@0:         return NS_OK;
michael@0: 
michael@0:       // look for the next or previous content node in tree order
michael@0:       iterStartContent = aForward ? iterStartContent->GetNextNode() : iterStartContent->GetPreviousContent();
michael@0:       // we've already skipped over the initial focused content, so we
michael@0:       // don't want to traverse frames.
michael@0:       getNextFrame = false;
michael@0:       if (iterStartContent)
michael@0:         continue;
michael@0: 
michael@0:       // otherwise, as a last attempt, just look at the root content
michael@0:       iterStartContent = aRootContent;
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIFrameEnumerator> frameTraversal;
michael@0:     nsresult rv = NS_NewFrameTraversal(getter_AddRefs(frameTraversal),
michael@0:                                        presContext, startFrame,
michael@0:                                        ePreOrder,
michael@0:                                        false, // aVisual
michael@0:                                        false, // aLockInScrollView
michael@0:                                        true      // aFollowOOFs
michael@0:                                        );
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     if (iterStartContent == aRootContent) {
michael@0:       if (!aForward) {
michael@0:         frameTraversal->Last();
michael@0:       } else if (aRootContent->IsFocusable()) {
michael@0:         frameTraversal->Next();
michael@0:       }
michael@0:     }
michael@0:     else if (getNextFrame &&
michael@0:              (!iterStartContent || iterStartContent->Tag() != nsGkAtoms::area ||
michael@0:               !iterStartContent->IsHTML())) {
michael@0:       // Need to do special check in case we're in an imagemap which has multiple
michael@0:       // content nodes per frame, so don't skip over the starting frame.
michael@0:       if (aForward)
michael@0:         frameTraversal->Next();
michael@0:       else
michael@0:         frameTraversal->Prev();
michael@0:     }
michael@0: 
michael@0:     // Walk frames to find something tabbable matching mCurrentTabIndex
michael@0:     nsIFrame* frame = static_cast<nsIFrame*>(frameTraversal->CurrentItem());
michael@0:     while (frame) {
michael@0:       // TabIndex not set defaults to 0 for form elements, anchors and other
michael@0:       // elements that are normally focusable. Tabindex defaults to -1
michael@0:       // for elements that are not normally focusable.
michael@0:       // The returned computed tabindex from IsFocusable() is as follows:
michael@0:       //          < 0 not tabbable at all
michael@0:       //          == 0 in normal tab order (last after positive tabindexed items)
michael@0:       //          > 0 can be tabbed to in the order specified by this value
michael@0: 
michael@0:       int32_t tabIndex;
michael@0:       frame->IsFocusable(&tabIndex, 0);
michael@0: 
michael@0:       LOGCONTENTNAVIGATION("Next Tabbable %s:", frame->GetContent());
michael@0:       LOGFOCUSNAVIGATION(("  with tabindex: %d expected: %d", tabIndex, aCurrentTabIndex));
michael@0: 
michael@0:       nsIContent* currentContent = frame->GetContent();
michael@0:       if (tabIndex >= 0) {
michael@0:         NS_ASSERTION(currentContent, "IsFocusable set a tabindex for a frame with no content");
michael@0:         if (currentContent->Tag() == nsGkAtoms::img &&
michael@0:             currentContent->HasAttr(kNameSpaceID_None, nsGkAtoms::usemap)) {
michael@0:           // This is an image with a map. Image map areas are not traversed by
michael@0:           // nsIFrameTraversal so look for the next or previous area element.
michael@0:           nsIContent *areaContent =
michael@0:             GetNextTabbableMapArea(aForward, aCurrentTabIndex,
michael@0:                                    currentContent, iterStartContent);
michael@0:           if (areaContent) {
michael@0:             NS_ADDREF(*aResultContent = areaContent);
michael@0:             return NS_OK;
michael@0:           }
michael@0:         }
michael@0:         else if (aIgnoreTabIndex || aCurrentTabIndex == tabIndex) {
michael@0:           // break out if we've wrapped around to the start again.
michael@0:           if (aOriginalStartContent && currentContent == aOriginalStartContent) {
michael@0:             NS_ADDREF(*aResultContent = currentContent);
michael@0:             return NS_OK;
michael@0:           }
michael@0: 
michael@0:           // found a node with a matching tab index. Check if it is a child
michael@0:           // frame. If so, navigate into the child frame instead.
michael@0:           nsIDocument* doc = currentContent->GetCurrentDoc();
michael@0:           NS_ASSERTION(doc, "content not in document");
michael@0:           nsIDocument* subdoc = doc->GetSubDocumentFor(currentContent);
michael@0:           if (subdoc) {
michael@0:             if (!subdoc->EventHandlingSuppressed()) {
michael@0:               if (aForward) {
michael@0:                 // when tabbing forward into a frame, return the root
michael@0:                 // frame so that the canvas becomes focused.
michael@0:                 nsCOMPtr<nsPIDOMWindow> subframe = subdoc->GetWindow();
michael@0:                 if (subframe) {
michael@0:                   // If the subframe body is editable by contenteditable,
michael@0:                   // we should set the editor's root element rather than the
michael@0:                   // actual root element.  Otherwise, we should set the focus
michael@0:                   // to the root content.
michael@0:                   *aResultContent =
michael@0:                     nsLayoutUtils::GetEditableRootContentByContentEditable(subdoc);
michael@0:                   if (!*aResultContent ||
michael@0:                       !((*aResultContent)->GetPrimaryFrame())) {
michael@0:                     *aResultContent =
michael@0:                       GetRootForFocus(subframe, subdoc, false, true);
michael@0:                   }
michael@0:                   if (*aResultContent) {
michael@0:                     NS_ADDREF(*aResultContent);
michael@0:                     return NS_OK;
michael@0:                   }
michael@0:                 }
michael@0:               }
michael@0:               Element* rootElement = subdoc->GetRootElement();
michael@0:               nsIPresShell* subShell = subdoc->GetShell();
michael@0:               if (rootElement && subShell) {
michael@0:                 rv = GetNextTabbableContent(subShell, rootElement,
michael@0:                                             aOriginalStartContent, rootElement,
michael@0:                                             aForward, (aForward ? 1 : 0),
michael@0:                                             false, aResultContent);
michael@0:                 NS_ENSURE_SUCCESS(rv, rv);
michael@0:                 if (*aResultContent)
michael@0:                   return NS_OK;
michael@0:               }
michael@0:             }
michael@0:           }
michael@0:           // otherwise, use this as the next content node to tab to, unless
michael@0:           // this was the element we started on. This would happen for
michael@0:           // instance on an element with child frames, where frame navigation
michael@0:           // could return the original element again. In that case, just skip
michael@0:           // it. Also, if the next content node is the root content, then
michael@0:           // return it. This latter case would happen only if someone made a
michael@0:           // popup focusable.
michael@0:           // Also, when going backwards, check to ensure that the focus
michael@0:           // wouldn't be redirected. Otherwise, for example, when an input in
michael@0:           // a textbox is focused, the enclosing textbox would be found and
michael@0:           // the same inner input would be returned again.
michael@0:           else if (currentContent == aRootContent ||
michael@0:                    (currentContent != startContent &&
michael@0:                     (aForward || !GetRedirectedFocus(currentContent)))) {
michael@0:             NS_ADDREF(*aResultContent = currentContent);
michael@0:             return NS_OK;
michael@0:           }
michael@0:         }
michael@0:       }
michael@0:       else if (aOriginalStartContent && currentContent == aOriginalStartContent) {
michael@0:         // not focusable, so return if we have wrapped around to the original
michael@0:         // content. This is necessary in case the original starting content was
michael@0:         // not focusable.
michael@0:         NS_ADDREF(*aResultContent = currentContent);
michael@0:         return NS_OK;
michael@0:       }
michael@0: 
michael@0:       // Move to the next or previous frame, but ignore continuation frames
michael@0:       // since only the first frame should be involved in focusability.
michael@0:       // Otherwise, a loop will occur in the following example:
michael@0:       //   <span tabindex="1">...<a/><a/>...</span>
michael@0:       // where the text wraps onto multiple lines. Tabbing from the second
michael@0:       // link can find one of the span's continuation frames between the link
michael@0:       // and the end of the span, and the span would end up getting focused
michael@0:       // again.
michael@0:       do {
michael@0:         if (aForward)
michael@0:           frameTraversal->Next();
michael@0:         else
michael@0:           frameTraversal->Prev();
michael@0:         frame = static_cast<nsIFrame*>(frameTraversal->CurrentItem());
michael@0:       } while (frame && frame->GetPrevContinuation());
michael@0:     }
michael@0: 
michael@0:     // If already at lowest priority tab (0), end search completely.
michael@0:     // A bit counterintuitive but true, tabindex order goes 1, 2, ... 32767, 0
michael@0:     if (aCurrentTabIndex == (aForward ? 0 : 1)) {
michael@0:       // if going backwards, the canvas should be focused once the beginning
michael@0:       // has been reached.
michael@0:       if (!aForward) {
michael@0:         nsCOMPtr<nsPIDOMWindow> window = GetCurrentWindow(aRootContent);
michael@0:         NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
michael@0:         NS_IF_ADDREF(*aResultContent =
michael@0:                      GetRootForFocus(window, aRootContent->GetCurrentDoc(), false, true));
michael@0:       }
michael@0:       break;
michael@0:     }
michael@0: 
michael@0:     // continue looking for next highest priority tabindex
michael@0:     aCurrentTabIndex = GetNextTabIndex(aRootContent, aCurrentTabIndex, aForward);
michael@0:     startContent = iterStartContent = aRootContent;
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: nsIContent*
michael@0: nsFocusManager::GetNextTabbableMapArea(bool aForward,
michael@0:                                        int32_t aCurrentTabIndex,
michael@0:                                        nsIContent* aImageContent,
michael@0:                                        nsIContent* aStartContent)
michael@0: {
michael@0:   nsAutoString useMap;
michael@0:   aImageContent->GetAttr(kNameSpaceID_None, nsGkAtoms::usemap, useMap);
michael@0: 
michael@0:   nsCOMPtr<nsIDocument> doc = aImageContent->GetDocument();
michael@0:   if (doc) {
michael@0:     nsCOMPtr<nsIContent> mapContent = doc->FindImageMap(useMap);
michael@0:     if (!mapContent)
michael@0:       return nullptr;
michael@0:     uint32_t count = mapContent->GetChildCount();
michael@0:     // First see if the the start content is in this map
michael@0: 
michael@0:     int32_t index = mapContent->IndexOf(aStartContent);
michael@0:     int32_t tabIndex;
michael@0:     if (index < 0 || (aStartContent->IsFocusable(&tabIndex) &&
michael@0:                       tabIndex != aCurrentTabIndex)) {
michael@0:       // If aStartContent is in this map we must start iterating past it.
michael@0:       // We skip the case where aStartContent has tabindex == aStartContent
michael@0:       // since the next tab ordered element might be before it
michael@0:       // (or after for backwards) in the child list.
michael@0:       index = aForward ? -1 : (int32_t)count;
michael@0:     }
michael@0: 
michael@0:     // GetChildAt will return nullptr if our index < 0 or index >= count
michael@0:     nsCOMPtr<nsIContent> areaContent;
michael@0:     while ((areaContent = mapContent->GetChildAt(aForward ? ++index : --index)) != nullptr) {
michael@0:       if (areaContent->IsFocusable(&tabIndex) && tabIndex == aCurrentTabIndex) {
michael@0:         return areaContent;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: int32_t
michael@0: nsFocusManager::GetNextTabIndex(nsIContent* aParent,
michael@0:                                 int32_t aCurrentTabIndex,
michael@0:                                 bool aForward)
michael@0: {
michael@0:   int32_t tabIndex, childTabIndex;
michael@0: 
michael@0:   if (aForward) {
michael@0:     tabIndex = 0;
michael@0:     for (nsIContent* child = aParent->GetFirstChild();
michael@0:          child;
michael@0:          child = child->GetNextSibling()) {
michael@0:       childTabIndex = GetNextTabIndex(child, aCurrentTabIndex, aForward);
michael@0:       if (childTabIndex > aCurrentTabIndex && childTabIndex != tabIndex) {
michael@0:         tabIndex = (tabIndex == 0 || childTabIndex < tabIndex) ? childTabIndex : tabIndex;
michael@0:       }
michael@0: 
michael@0:       nsAutoString tabIndexStr;
michael@0:       child->GetAttr(kNameSpaceID_None, nsGkAtoms::tabindex, tabIndexStr);
michael@0:       nsresult ec;
michael@0:       int32_t val = tabIndexStr.ToInteger(&ec);
michael@0:       if (NS_SUCCEEDED (ec) && val > aCurrentTabIndex && val != tabIndex) {
michael@0:         tabIndex = (tabIndex == 0 || val < tabIndex) ? val : tabIndex;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0:   else { /* !aForward */
michael@0:     tabIndex = 1;
michael@0:     for (nsIContent* child = aParent->GetFirstChild();
michael@0:          child;
michael@0:          child = child->GetNextSibling()) {
michael@0:       childTabIndex = GetNextTabIndex(child, aCurrentTabIndex, aForward);
michael@0:       if ((aCurrentTabIndex == 0 && childTabIndex > tabIndex) ||
michael@0:           (childTabIndex < aCurrentTabIndex && childTabIndex > tabIndex)) {
michael@0:         tabIndex = childTabIndex;
michael@0:       }
michael@0: 
michael@0:       nsAutoString tabIndexStr;
michael@0:       child->GetAttr(kNameSpaceID_None, nsGkAtoms::tabindex, tabIndexStr);
michael@0:       nsresult ec;
michael@0:       int32_t val = tabIndexStr.ToInteger(&ec);
michael@0:       if (NS_SUCCEEDED (ec)) {
michael@0:         if ((aCurrentTabIndex == 0 && val > tabIndex) ||
michael@0:             (val < aCurrentTabIndex && val > tabIndex) ) {
michael@0:           tabIndex = val;
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return tabIndex;
michael@0: }
michael@0: 
michael@0: nsIContent*
michael@0: nsFocusManager::GetRootForFocus(nsPIDOMWindow* aWindow,
michael@0:                                 nsIDocument* aDocument,
michael@0:                                 bool aIsForDocNavigation,
michael@0:                                 bool aCheckVisibility)
michael@0: {
michael@0:   // the root element's canvas may be focused as long as the document is in a
michael@0:   // a non-chrome shell and does not contain a frameset.
michael@0:   if (aIsForDocNavigation) {
michael@0:     nsCOMPtr<nsIContent> docContent =
michael@0:       do_QueryInterface(aWindow->GetFrameElementInternal());
michael@0:     // document navigation skips iframes and frames that are specifically non-focusable
michael@0:     if (docContent) {
michael@0:       if (docContent->Tag() == nsGkAtoms::iframe)
michael@0:         return nullptr;
michael@0: 
michael@0:       nsIFrame* frame = docContent->GetPrimaryFrame();
michael@0:       if (!frame || !frame->IsFocusable(nullptr, 0))
michael@0:         return nullptr;
michael@0:     }
michael@0:   } else {
michael@0:     nsCOMPtr<nsIDocShell> docShell = aWindow->GetDocShell();
michael@0:     if (docShell->ItemType() == nsIDocShellTreeItem::typeChrome) {
michael@0:       return nullptr;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (aCheckVisibility && !IsWindowVisible(aWindow))
michael@0:     return nullptr;
michael@0: 
michael@0:   Element *rootElement = aDocument->GetRootElement();
michael@0:   if (!rootElement) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   if (aCheckVisibility && !rootElement->GetPrimaryFrame()) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   // Finally, check if this is a frameset
michael@0:   nsCOMPtr<nsIHTMLDocument> htmlDoc = do_QueryInterface(aDocument);
michael@0:   if (htmlDoc && aDocument->GetHtmlChildElement(nsGkAtoms::frameset)) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   return rootElement;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFocusManager::GetLastDocShell(nsIDocShellTreeItem* aItem,
michael@0:                                 nsIDocShellTreeItem** aResult)
michael@0: {
michael@0:   *aResult = nullptr;
michael@0: 
michael@0:   nsCOMPtr<nsIDocShellTreeItem> curItem = aItem;
michael@0:   while (curItem) {
michael@0:     int32_t childCount = 0;
michael@0:     curItem->GetChildCount(&childCount);
michael@0:     if (!childCount) {
michael@0:       *aResult = curItem;
michael@0:       NS_ADDREF(*aResult);
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     
michael@0:     curItem->GetChildAt(childCount - 1, getter_AddRefs(curItem));
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFocusManager::GetNextDocShell(nsIDocShellTreeItem* aItem,
michael@0:                                 nsIDocShellTreeItem** aResult)
michael@0: {
michael@0:   *aResult = nullptr;
michael@0: 
michael@0:   int32_t childCount = 0;
michael@0:   aItem->GetChildCount(&childCount);
michael@0:   if (childCount) {
michael@0:     aItem->GetChildAt(0, aResult);
michael@0:     if (*aResult)
michael@0:       return;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIDocShellTreeItem> curItem = aItem;
michael@0:   while (curItem) {
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parentItem;
michael@0:     curItem->GetParent(getter_AddRefs(parentItem));
michael@0:     if (!parentItem)
michael@0:       return;
michael@0: 
michael@0:     // Note that we avoid using GetChildOffset() here because docshell
michael@0:     // child offsets can't be trusted to be correct. bug 162283.
michael@0:     nsCOMPtr<nsIDocShellTreeItem> iterItem;
michael@0:     childCount = 0;
michael@0:     parentItem->GetChildCount(&childCount);
michael@0:     for (int32_t index = 0; index < childCount; ++index) {
michael@0:       parentItem->GetChildAt(index, getter_AddRefs(iterItem));
michael@0:       if (iterItem == curItem) {
michael@0:         ++index;
michael@0:         if (index < childCount) {
michael@0:           parentItem->GetChildAt(index, aResult);
michael@0:           if (*aResult)
michael@0:             return;
michael@0:         }
michael@0:         break;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     curItem = parentItem;
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFocusManager::GetPreviousDocShell(nsIDocShellTreeItem* aItem,
michael@0:                                     nsIDocShellTreeItem** aResult)
michael@0: {
michael@0:   *aResult = nullptr;
michael@0: 
michael@0:   nsCOMPtr<nsIDocShellTreeItem> parentItem;
michael@0:   aItem->GetParent(getter_AddRefs(parentItem));
michael@0:   if (!parentItem)
michael@0:     return;
michael@0: 
michael@0:   // Note that we avoid using GetChildOffset() here because docshell
michael@0:   // child offsets can't be trusted to be correct. bug 162283.
michael@0:   int32_t childCount = 0;
michael@0:   parentItem->GetChildCount(&childCount);
michael@0:   nsCOMPtr<nsIDocShellTreeItem> prevItem, iterItem;
michael@0:   for (int32_t index = 0; index < childCount; ++index) {
michael@0:     parentItem->GetChildAt(index, getter_AddRefs(iterItem));
michael@0:     if (iterItem == aItem)
michael@0:       break;
michael@0:     prevItem = iterItem;
michael@0:   }
michael@0: 
michael@0:   if (prevItem)
michael@0:     GetLastDocShell(prevItem, aResult);
michael@0:   else
michael@0:     NS_ADDREF(*aResult = parentItem);
michael@0: }
michael@0: 
michael@0: nsIContent*
michael@0: nsFocusManager::GetNextTabbablePanel(nsIDocument* aDocument, nsIFrame* aCurrentPopup, bool aForward)
michael@0: {
michael@0:   nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
michael@0:   if (!pm)
michael@0:     return nullptr;
michael@0: 
michael@0:   // Iterate through the array backwards if aForward is false.
michael@0:   nsTArray<nsIFrame *> popups;
michael@0:   pm->GetVisiblePopups(popups);
michael@0:   int32_t i = aForward ? 0 : popups.Length() - 1;
michael@0:   int32_t end = aForward ? popups.Length() : -1;
michael@0: 
michael@0:   for (; i != end; aForward ? i++ : i--) {
michael@0:     nsIFrame* popupFrame = popups[i];
michael@0:     if (aCurrentPopup) {
michael@0:       // If the current popup is set, then we need to skip over this popup and
michael@0:       // wait until the currently focused popup is found. Once found, the
michael@0:       // current popup will be cleared so that the next popup is used.
michael@0:       if (aCurrentPopup == popupFrame)
michael@0:         aCurrentPopup = nullptr;
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     // Skip over non-panels
michael@0:     if (popupFrame->GetContent()->Tag() != nsGkAtoms::panel ||
michael@0:         (aDocument && popupFrame->GetContent()->GetCurrentDoc() != aDocument)) {
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     // Find the first focusable content within the popup. If there isn't any
michael@0:     // focusable content in the popup, skip to the next popup.
michael@0:     nsIPresShell* presShell = popupFrame->PresContext()->GetPresShell();
michael@0:     if (presShell) {
michael@0:       nsCOMPtr<nsIContent> nextFocus;
michael@0:       nsIContent* popup = popupFrame->GetContent();
michael@0:       nsresult rv = GetNextTabbableContent(presShell, popup,
michael@0:                                            nullptr, popup,
michael@0:                                            true, 1, false,
michael@0:                                            getter_AddRefs(nextFocus));
michael@0:       if (NS_SUCCEEDED(rv) && nextFocus) {
michael@0:         return nextFocus.get();
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return nullptr;
michael@0: }
michael@0: 
michael@0: nsIContent*
michael@0: nsFocusManager::GetNextTabbableDocument(nsIContent* aStartContent, bool aForward)
michael@0: {
michael@0:   // If currentPopup is set, then the starting content is in a panel.
michael@0:   nsIFrame* currentPopup = nullptr;
michael@0:   nsCOMPtr<nsIDocument> doc;
michael@0:   nsCOMPtr<nsIDocShell> startDocShell;
michael@0: 
michael@0:   if (aStartContent) {
michael@0:     doc = aStartContent->GetCurrentDoc();
michael@0:     if (doc) {
michael@0:       startDocShell = doc->GetWindow()->GetDocShell();
michael@0:     }
michael@0: 
michael@0:     // Check if the starting content is inside a panel. Document navigation
michael@0:     // must start from this panel instead of the document root.
michael@0:     nsIContent* content = aStartContent;
michael@0:     while (content) {
michael@0:       if (content->NodeInfo()->Equals(nsGkAtoms::panel, kNameSpaceID_XUL)) {
michael@0:         currentPopup = content->GetPrimaryFrame();
michael@0:         break;
michael@0:       }
michael@0:       content = content->GetParent();
michael@0:     }
michael@0:   }
michael@0:   else if (mFocusedWindow) {
michael@0:     startDocShell = mFocusedWindow->GetDocShell();
michael@0:     doc = mFocusedWindow->GetExtantDoc();
michael@0:   }
michael@0:   else {
michael@0:     nsCOMPtr<nsIWebNavigation> webnav = do_GetInterface(mActiveWindow);
michael@0:     startDocShell = do_QueryInterface(webnav);
michael@0: 
michael@0:     if (mActiveWindow) {
michael@0:       doc = mActiveWindow->GetExtantDoc();
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   if (!startDocShell)
michael@0:     return nullptr;
michael@0: 
michael@0:   // perform a depth first search (preorder) of the docshell tree
michael@0:   // looking for an HTML Frame or a chrome document
michael@0:   nsIContent* content = aStartContent;
michael@0:   nsCOMPtr<nsIDocShellTreeItem> curItem = startDocShell.get();
michael@0:   nsCOMPtr<nsIDocShellTreeItem> nextItem;
michael@0:   do {
michael@0:     // If moving forward, check for a panel in the starting document. If one
michael@0:     // exists with focusable content, return that content instead of the next
michael@0:     // document. If currentPopup is set, then, another panel may exist. If no
michael@0:     // such panel exists, then continue on to check the next document.
michael@0:     // When moving backwards, and the starting content is in a panel, then
michael@0:     // check for additional panels in the starting document. If the starting
michael@0:     // content is not in a panel, move back to the previous document and check
michael@0:     // for panels there.
michael@0: 
michael@0:     bool checkPopups = false;
michael@0:     nsCOMPtr<nsPIDOMWindow> nextFrame = nullptr;
michael@0: 
michael@0:     if (doc && (aForward || currentPopup)) {
michael@0:       nsIContent* popupContent = GetNextTabbablePanel(doc, currentPopup, aForward);
michael@0:       if (popupContent)
michael@0:         return popupContent;
michael@0: 
michael@0:       if (!aForward && currentPopup) {
michael@0:         // The starting content was in a popup, yet no other popups were
michael@0:         // found. Move onto the starting content's document.
michael@0:         nextFrame = doc->GetWindow();
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     // Look for the next or previous document.
michael@0:     if (!nextFrame) {
michael@0:       if (aForward) {
michael@0:         GetNextDocShell(curItem, getter_AddRefs(nextItem));
michael@0:         if (!nextItem) {
michael@0:           // wrap around to the beginning, which is the top of the tree
michael@0:           startDocShell->GetRootTreeItem(getter_AddRefs(nextItem));
michael@0:         }
michael@0:       }
michael@0:       else {
michael@0:         GetPreviousDocShell(curItem, getter_AddRefs(nextItem));
michael@0:         if (!nextItem) {
michael@0:           // wrap around to the end, which is the last item in the tree
michael@0:           nsCOMPtr<nsIDocShellTreeItem> rootItem;
michael@0:           startDocShell->GetRootTreeItem(getter_AddRefs(rootItem));
michael@0:           GetLastDocShell(rootItem, getter_AddRefs(nextItem));
michael@0:         }
michael@0: 
michael@0:         // When going back to the previous document, check for any focusable
michael@0:         // popups in that previous document first.
michael@0:         checkPopups = true;
michael@0:       }
michael@0: 
michael@0:       curItem = nextItem;
michael@0:       nextFrame = do_GetInterface(nextItem);
michael@0:     }
michael@0: 
michael@0:     if (!nextFrame)
michael@0:       return nullptr;
michael@0: 
michael@0:     // Clear currentPopup for the next iteration
michael@0:     currentPopup = nullptr;
michael@0: 
michael@0:     // If event handling is suppressed, move on to the next document. Set
michael@0:     // content to null so that the popup check will be skipped on the next
michael@0:     // loop iteration.
michael@0:     doc = nextFrame->GetExtantDoc();
michael@0:     if (!doc || doc->EventHandlingSuppressed()) {
michael@0:       content = nullptr;
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     if (checkPopups) {
michael@0:       // When iterating backwards, check the panels of the previous document
michael@0:       // first. If a panel exists that has focusable content, focus that.
michael@0:       // Otherwise, continue on to focus the document.
michael@0:       nsIContent* popupContent = GetNextTabbablePanel(doc, nullptr, false);
michael@0:       if (popupContent)
michael@0:         return popupContent;
michael@0:     }
michael@0: 
michael@0:     content = GetRootForFocus(nextFrame, doc, true, true);
michael@0:     if (content && !GetRootForFocus(nextFrame, doc, false, false)) {
michael@0:       // if the found content is in a chrome shell or a frameset, navigate
michael@0:       // forward one tabbable item so that the first item is focused. Note
michael@0:       // that we always go forward and not back here.
michael@0:       nsCOMPtr<nsIContent> nextFocus;
michael@0:       Element* rootElement = doc->GetRootElement();
michael@0:       nsIPresShell* presShell = doc->GetShell();
michael@0:       if (presShell) {
michael@0:         nsresult rv = GetNextTabbableContent(presShell, rootElement,
michael@0:                                              nullptr, rootElement,
michael@0:                                              true, 1, false,
michael@0:                                              getter_AddRefs(nextFocus));
michael@0:         return NS_SUCCEEDED(rv) ? nextFocus.get() : nullptr;
michael@0:       }
michael@0:     }
michael@0: 
michael@0:   } while (!content);
michael@0: 
michael@0:   return content;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFocusManager::GetFocusInSelection(nsPIDOMWindow* aWindow,
michael@0:                                     nsIContent* aStartSelection,
michael@0:                                     nsIContent* aEndSelection,
michael@0:                                     nsIContent** aFocusedContent)
michael@0: {
michael@0:   *aFocusedContent = nullptr;
michael@0: 
michael@0:   nsCOMPtr<nsIContent> testContent = aStartSelection;
michael@0:   nsCOMPtr<nsIContent> nextTestContent = aEndSelection;
michael@0: 
michael@0:   nsCOMPtr<nsIContent> currentFocus = aWindow->GetFocusedNode();
michael@0: 
michael@0:   // We now have the correct start node in selectionContent!
michael@0:   // Search for focusable elements, starting with selectionContent
michael@0: 
michael@0:   // Method #1: Keep going up while we look - an ancestor might be focusable
michael@0:   // We could end the loop earlier, such as when we're no longer
michael@0:   // in the same frame, by comparing selectionContent->GetPrimaryFrame()
michael@0:   // with a variable holding the starting selectionContent
michael@0:   while (testContent) {
michael@0:     // Keep testing while selectionContent is equal to something,
michael@0:     // eventually we'll run out of ancestors
michael@0: 
michael@0:     nsCOMPtr<nsIURI> uri;
michael@0:     if (testContent == currentFocus ||
michael@0:         testContent->IsLink(getter_AddRefs(uri))) {
michael@0:       NS_ADDREF(*aFocusedContent = testContent);
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     // Get the parent
michael@0:     testContent = testContent->GetParent();
michael@0: 
michael@0:     if (!testContent) {
michael@0:       // We run this loop again, checking the ancestor chain of the selection's end point
michael@0:       testContent = nextTestContent;
michael@0:       nextTestContent = nullptr;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // We couldn't find an anchor that was an ancestor of the selection start
michael@0:   // Method #2: look for anchor in selection's primary range (depth first search)
michael@0: 
michael@0:   // Turn into nodes so that we can use GetNextSibling() and GetFirstChild()
michael@0:   nsCOMPtr<nsIDOMNode> selectionNode(do_QueryInterface(aStartSelection));
michael@0:   nsCOMPtr<nsIDOMNode> endSelectionNode(do_QueryInterface(aEndSelection));
michael@0:   nsCOMPtr<nsIDOMNode> testNode;
michael@0: 
michael@0:   do {
michael@0:     testContent = do_QueryInterface(selectionNode);
michael@0: 
michael@0:     // We're looking for any focusable link that could be part of the
michael@0:     // main document's selection.
michael@0:     nsCOMPtr<nsIURI> uri;
michael@0:     if (testContent == currentFocus ||
michael@0:         testContent->IsLink(getter_AddRefs(uri))) {
michael@0:       NS_ADDREF(*aFocusedContent = testContent);
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     selectionNode->GetFirstChild(getter_AddRefs(testNode));
michael@0:     if (testNode) {
michael@0:       selectionNode = testNode;
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     if (selectionNode == endSelectionNode)
michael@0:       break;
michael@0:     selectionNode->GetNextSibling(getter_AddRefs(testNode));
michael@0:     if (testNode) {
michael@0:       selectionNode = testNode;
michael@0:       continue;
michael@0:     }
michael@0: 
michael@0:     do {
michael@0:       selectionNode->GetParentNode(getter_AddRefs(testNode));
michael@0:       if (!testNode || testNode == endSelectionNode) {
michael@0:         selectionNode = nullptr;
michael@0:         break;
michael@0:       }
michael@0:       testNode->GetNextSibling(getter_AddRefs(selectionNode));
michael@0:       if (selectionNode)
michael@0:         break;
michael@0:       selectionNode = testNode;
michael@0:     } while (true);
michael@0:   }
michael@0:   while (selectionNode && selectionNode != endSelectionNode);
michael@0: }
michael@0: 
michael@0: class PointerUnlocker : public nsRunnable
michael@0: {
michael@0: public:
michael@0:   PointerUnlocker()
michael@0:   {
michael@0:     MOZ_ASSERT(!PointerUnlocker::sActiveUnlocker);
michael@0:     PointerUnlocker::sActiveUnlocker = this;
michael@0:   }
michael@0: 
michael@0:   ~PointerUnlocker()
michael@0:   {
michael@0:     if (PointerUnlocker::sActiveUnlocker == this) {
michael@0:       PointerUnlocker::sActiveUnlocker = nullptr;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   NS_IMETHOD Run()
michael@0:   {
michael@0:     if (PointerUnlocker::sActiveUnlocker == this) {
michael@0:       PointerUnlocker::sActiveUnlocker = nullptr;
michael@0:     }
michael@0:     NS_ENSURE_STATE(nsFocusManager::GetFocusManager());
michael@0:     nsPIDOMWindow* focused =
michael@0:       nsFocusManager::GetFocusManager()->GetFocusedWindow();
michael@0:     nsCOMPtr<nsIDocument> pointerLockedDoc =
michael@0:       do_QueryReferent(EventStateManager::sPointerLockedDoc);
michael@0:     if (pointerLockedDoc &&
michael@0:         !nsContentUtils::IsInPointerLockContext(focused)) {
michael@0:       nsIDocument::UnlockPointer();
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   static PointerUnlocker* sActiveUnlocker;
michael@0: };
michael@0: 
michael@0: PointerUnlocker*
michael@0: PointerUnlocker::sActiveUnlocker = nullptr;
michael@0: 
michael@0: void
michael@0: nsFocusManager::SetFocusedWindowInternal(nsPIDOMWindow* aWindow)
michael@0: {
michael@0:   if (!PointerUnlocker::sActiveUnlocker &&
michael@0:       nsContentUtils::IsInPointerLockContext(mFocusedWindow) &&
michael@0:       !nsContentUtils::IsInPointerLockContext(aWindow)) {
michael@0:     nsCOMPtr<nsIRunnable> runnable = new PointerUnlocker();
michael@0:     NS_DispatchToCurrentThread(runnable);
michael@0:   }
michael@0:   mFocusedWindow = aWindow;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsFocusManager::MarkUncollectableForCCGeneration(uint32_t aGeneration)
michael@0: {
michael@0:   if (!sInstance) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   if (sInstance->mActiveWindow) {
michael@0:     sInstance->mActiveWindow->
michael@0:       MarkUncollectableForCCGeneration(aGeneration);
michael@0:   }
michael@0:   if (sInstance->mFocusedWindow) {
michael@0:     sInstance->mFocusedWindow->
michael@0:       MarkUncollectableForCCGeneration(aGeneration);
michael@0:   }
michael@0:   if (sInstance->mWindowBeingLowered) {
michael@0:     sInstance->mWindowBeingLowered->
michael@0:       MarkUncollectableForCCGeneration(aGeneration);
michael@0:   }
michael@0:   if (sInstance->mFocusedContent) {
michael@0:     sInstance->mFocusedContent->OwnerDoc()->
michael@0:       MarkUncollectableForCCGeneration(aGeneration);
michael@0:   }
michael@0:   if (sInstance->mFirstBlurEvent) {
michael@0:     sInstance->mFirstBlurEvent->OwnerDoc()->
michael@0:       MarkUncollectableForCCGeneration(aGeneration);
michael@0:   }
michael@0:   if (sInstance->mFirstFocusEvent) {
michael@0:     sInstance->mFirstFocusEvent->OwnerDoc()->
michael@0:       MarkUncollectableForCCGeneration(aGeneration);
michael@0:   }
michael@0:   if (sInstance->mMouseDownEventHandlingDocument) {
michael@0:     sInstance->mMouseDownEventHandlingDocument->
michael@0:       MarkUncollectableForCCGeneration(aGeneration);
michael@0:   }
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: NS_NewFocusManager(nsIFocusManager** aResult)
michael@0: {
michael@0:   NS_IF_ADDREF(*aResult = nsFocusManager::GetFocusManager());
michael@0:   return NS_OK;
michael@0: }