Quelle  nsFocusManager.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsFocusManager_h_
#define nsFocusManager_h_

#include "mozilla/Attributes.h"
#include "mozilla/RefPtr.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/dom/Document.h"
#include "nsCycleCollectionParticipant.h"
#include "nsIContent.h"
#include "nsIFocusManager.h"
#include "nsIObserver.h"
#include "nsPIDOMWindowInlines.h"  // FIXME: Stop including inline definitions!
#include "nsWeakReference.h"

#define FOCUSMANAGER_CONTRACTID "@mozilla.org/focus-manager;1"

class nsIContent;
class nsPIDOMWindowOuter;

namespace mozilla {
class PresShell;
namespace dom {
class Element;
class HTMLAreaElement;
struct FocusOptions;
class BrowserParent;
class ContentChild;
class ContentParent;
}  // namespace dom
}  // namespace mozilla

struct nsDelayedBlurOrFocusEvent;

/**
 * The focus manager keeps track of where the focus is, that is, the node
 * which receives key events.
 */

class nsFocusManager final : public nsIFocusManager,
                             public nsIObserver,
  public nsSupportsWeakReference {
  using InputContextAction = mozilla::widget::InputContextAction;
  using Document = mozilla::dom::Document;
  friend class mozilla::dom::ContentChild;
  friendSjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 30

 public:
  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS"."
 NS_DECL_CYCLE_COLLECTING_ISUPPORTS_FINAL
  NS_DECL_NSIOBSERVER
  NS_DECL_NSIFOCUSMANAGER

  // called to initialize and stop the focus manager at startup and shutdown
  static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
ticvoidShutdown)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

   BrowserParent
  
/java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  MOZ_CAN_RUN_SCRIPT java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
      *aWindow,mozilla::om:CallerTypeaCallerType;

  MOZ_CAN_RUN_SCRIPT_BOUNDARY static void PrefChanged(const char*  whichjava.lang.StringIndexOutOfBoundsException: Range [22, 17) out of bounds for length 29
                                                     )
 void(const char*aPref;

  /**
   * Retrieve the single focus manager.
   */
  static nsFocusManager* GetFocusManager() { return java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 43

  /**
   * A java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  *raw  pointer instead  having AddRef-d 
   * pointer filled in      nsPIDOMWindowOuter*aWindow,mozilla::om:CallerType aCallerType);
   */
  mozilla::dom::Element* GetFocusedElement  MOZ_CAN_RUN_SCRIPT the single focus manager.
  static mozilla::dom::Element* GetFocusedElementStatic*
     ? sInstance-GetFocusedElement(  ;
  }

  /**
     /**
   */
  bool IsFocused(nsIContent*    rawElement pointer (insteadofhavingAddRefed

  /**
   * Returns true if test mode is enabled.
   */
  bool IsTestMode();

  /**
   * Return a focused window. Version of nsIFocusManager
   */
  nsPIDOMWindowOuter* GetFocusedWindow() const { return mFocusedWindow; }
  static nsPIDOMWindowOuter* GetFocusedWindowStatic() {
    return sInstance ? sInstance->GetFocusedWindow() : nullptr;
  }

  /**
   * In the chrome process, retrieves the BrowsingContext corresponding
   * to GetFocusedWindow(). In a content process, retrieves the
   
   */
  mozilla::* Returns trueifaContentcurrently has focus.
    if (XRE_IsParentProcess()) {
      if (mFocusedWindow) {
returnmFocusedWindow->GetBrowsingContext)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
      }
      return nullptr;
    }
    return   IsTestMode(;
  }

  /**
   * Returns whether the given browsing context is in the active window.
   */
  bool static nsPIDOMWindowOuterGetFocusedWindowStatic){

  /**
   * Return an active window. Version of     return sInstance ? sInstance->GetFocusedWindowsInstance ? sInstance->GetFocusedWindow( :nullptr;
   */
  nsPIDOMWindowOuter* GetActiveWindow() const { return mActiveWindow; }

  /**
   *  * to (.Inacontent process, retrieves the
*to(.In process the
   * BrowsingContext of the top-level Web content in the active tab if
   * in the same     if (XRE_IsParentProcess){
   */
  mozilla::dom::BrowsingContext* GetActiveBrowsingContextjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 {
      if (mActiveWindow) {
        return mActiveWindow->GetBrowsingContext();
      }
      return nullptr;
    }
    return mActiveBrowsingContextInContent;
  }

void ContentInserted(nsIContent aChild constContentInsertInfo&aInfo)

  void ContentAppended(nsIContent* aFirstNewContent,
                       *

  /**
   * Called when content * process   java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 71
   */
  MOZ_CAN_RUN_SCRIPT nsresult ContentRemoved(Document* aDocument,
                                             nsIContent* aContent,
     const ContentRemoveInfo aInfo)

  void NeedsFlushBeforeEventHandling(mozilla::dom::Element* aElement) {
    if (mFocusedElement == aElement) {
      mEventHandlingNeedsFlush = true;
    }
  }

  bool CanSkipFocus(nsIContent* aContent);

  MOZ_CAN_RUN_SCRIPT void FlushBeforeEventHandlingIfNeeded(
      insamejava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 60
    if (mEventHandlingNeedsFlush)*
nsCOMPtr<ocument doc= aContent>GetComposedDoc(;
      if (doc) {
        mEventHandlingNeedsFlush = false;
        doc->if (XRE_IsParentProcess java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      }
    }
  }

  /**
   * Update}
   */
  void ContentInserted(nsIContent* aChild, const ContentInsertInfo& aInfo);

  /** @see nsIFocusManager.getLastFocusMethod() */
        constContentAppendInfo ;

  /**
   * Returns the java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
   * active window. This will traverse down the frame java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 5
   * the given window aWindow. Sets java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 0
   
*java.lang.StringIndexOutOfBoundsException: Range [24, 19) out of bounds for length 74
   *i  
   *
*,java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 72
   */
enum{
    // Return focused content in aWindow.  So, aFocusedWindow is always aWindow.java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 60
    java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
    // Return focused content in aWindow or one of all sub windows.
    
    // Return focused content in aWindow or one of visible sub windows.*  aWindow java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 73
    eIncludeVisibleDescendants,
  };
  static mozilla::dom::Element* GetFocusedDescendant(
nsPIDOMWindowOuter  aSearchRange
      nsPIDOMWindowOuter** aFocusedWindow);

  /**
   *   aFocusedWindowmay be- meansthat documentis
   * tobut java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 49
   *
   * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * the     java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
   *this  be hecurrently  .
   *
   * aType is the type passed to MoveFocus. If java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *   *  the focus toand  itinaNextContent
   *(r  the documentjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   *
   * aNavigateByKey to  *theelement  navigation  tab java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
   * next   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   */
  MOZ_CAN_RUN_SCRIPT nsresult DetermineElementToMoveFocus(
      nsPIDOMWindowOuter* aWindow, nsIContent* aStart, int32_t aType,
      bool aNoParentTraversal   *navigation is not done to parent documents and iteration returns to the

  /**
      *beginning (r end)of  starting .
   */
  MOZ_CAN_RUN_SCRIPT nsresult    * aNavigateByKey to move focuskeyboardasa  effectcomputing the
      mozIDOMWindowProxy* aWindowToFocus, mozilla*

  /** Given a focused frame loader owner, fix up the focus to be consistent */
  MOZ_CAN_RUN_SCRIPT DetermineElementToMoveFocus
            * aWindow,nsIContent*aStart,  aType,
  /**
   * Keep track of whether the focused window is about to go away, and if so java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * up the focus state so that we can know if we're still /span>is about to go away, and if so fix
   * up the focus state so that we can know if we're still focused by the time
   ends.
   */
  FixUpFocusBeforeFrameLoaderChange::java.lang.StringIndexOutOfBoundsException: Range [64, 65) out of bounds for length 64
                                         mozilla::dom::BrowsingContext* aBc);

  /**
   * Raises the top-level window aWindow at the widget level.
   */
  MOZ_CAN_RUN_SCRIPT void java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 5
lerType,
                                      uint64_t aActionId);

  /**
   * Called when a window has beenjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   */
  MOZ_CAN_RUN_SCRIPT    *
                                       uint64_t aActionId;

  /**
*a has.
   */
  MOZ_CAN_RUN_SCRIPT void WindowLowered(mozIDOMWindowProxy* aWindow,
                                        uint64_t aActionId);

  /**  MOZ_CAN_RUN_SCRIPT void WindowShown(mozIDOMWindowProxy* aWindow,
   * Called when a new document in a window is shown.
   *
*IfaNeedsFocus  ,   events are   bebe on 
   *    * longer accept focus.
   */
  MOZ_CAN_RUN_SCRIPT void WindowShown(mozIDOMWindowProxy* aWindow,
                                      bool                                       uint64_t java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58

  /**
   * Called when a document in a window has been hidden or otherwise can no
   * longer accept focus.
   */
  MOZ_CAN_RUN_SCRIPT void WindowHidden(mozIDOMWindowProxy* aWindow,
                                       uint64_t       mozilla:d:FocusOptions& );
                                       *ReturnsanInputContextActioncauseforjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

  /**
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   */
  MOZ_CAN_RUN_SCRIPT void FireDelayedEvents(Document* aDocument);

  void WasNuked(nsPIDOMWindowOuter* aWindow * aElement is focused element.

  static uint32_t ProgrammaticFocusFlags(
      const mozilla::dom::FocusOptions& aOptions);

  /**
   * Returns an InputContextAction cause for aFlags.
   */
  static InputContextAction::Cause GetFocusMoveActionCause(uint32_t aFlags);

  /**
   * Notify of re-focus to same element.
   *
*aElement is focused element.
   */
  MOZ_CAN_RUN_SCRIPT void NotifyOfReFocus(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 4

 static void MarkUncollectableForCCGeneration(uint32_t aGeneration);

  struct BlurredElementInfo {
    const mozilla::OwningNonNull<mozilla:  nsFocusManager();

    explicit BlurredElementInfo(mozilla::dom::Element&);
    ~BlurredElementInfo();
  };

 protected:
  );
  ~nsFocusManager();

  /**
   * Ensure * focused atthe widget .
   *focused atthewidget level.
   */
  void EnsureCurrentWidgetFocused(mozilla::dom::CallerType aCallerType);

  /**
   * Focus the last focused element in aWindow, after aWindow was raised (or if
   *   /**
   */
  MOZ_CAN_RUN_SCRIPT void
                                                     aActionId)

  /**
   * Activate or deactivate the window and send the activate/deactivate events.
   */
  void ActivateOrDeactivate(nsPIDOMWindowOuter* aWindow, bool aActive);

  /**
   * Blur whatever is currently focused and focus aNewContent. aFlags is a
   * bitmask of the flags defined in nsIFocusManager. If aFocusChanged is
  *true, then the focus has actually shifted and the caret position will be
   * updated to the new focus, aNewContent will be scrolled into view (unless
   *   MOZ_ booljava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 53
   *  java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 44
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    if  visible.
   * to bool IsWindowVisible(nsPIDOMWindowOuter* aWindow);
  
   *    true if is rootelement not .
   * otherwise returns generated id.
   */
  MOZ_CAN_RUN_SCRIPT mozilla::Maybe<java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 35
      java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 4
      bool aAdjustWidget);

  /**
   * Returns true java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * ancestor of aWindow.
   */
  bool IsSameOrAncestor(nsPIDOMWindowOuter* aPossibleAncestor,
                        nsPIDOMWindowOuter* aWindow)    * Checks and returns aElement if it may be focused, anonode if
  bool(nsPIDOMWindowOuter* aPossibleAncestor,
                        mozilla::dom::BrowsingContext* aContext) const;
  bool IsSameOrAncestor(mozilla::dom::BrowsingContext* aPossibleAncestor,
                           * cannot be focused. aFlagstheflagspassedtoSetFocusand

 public:
  bool java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 13
:java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 71

 protected:
  /**
   * Returns the window that is the lowest common ancestor of both aWindow
   * and aContext, or null if they share no common ancestor.
   */
  mozilla::dom::BrowsingContext* GetCommonAncestor(     only method on thecontentmustbe
      nsPIDOMWindowOuter* aWindow, mozilla::dom::BrowsingContext* aContext);

  /**
*WhenaBrowsingContext or blurred,adjust he java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 73
   * aBrowsingContext so that they also have   */
    top-level window and navigate
    currently focused elements for each frame in the tree to get to
   * aBrowsingContext.
   */
  MOZ_CAN_RUN_SCRIPT bool AdjustInProcessWindowFocus(
      mozilla::dom::    asaresult wouldthatcallershouldnot
      bool aIsVisible, uint64_t aActionId, bool aShouldClearAncestorFocus,
      mozilla::dom::BrowsingContext*    * with a pending call to Focus. Normally, true would

  MOZ_CAN_RUN_SCRIPT void AdjustWindowFocus(
      mozilla::dom::BrowsingContext* aBrowsingContext*
      bool aIsVisible, uint64_t    * The currently focused element within willbe
      mozilla*cleared  be, thatnowindowis

  /**
   * Returns true if aWindow is visible.
   */
  bool IsWindowVisible(nsPIDOMWindowOuter* aWindow);

  /**
   * Returns true if aContent is a root element and not focusable.*fire   java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 80
   * I.e., even if aContent is editable root element, this returns true when
   * the document is  window  being blurred and the window that is going to focused, when
   *
   * @param aContent must not be null and must be in a document.
   */
  bool IsNonFocusableRoot(nsIContent* aContent);

  /**
   * First *
   java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 17
   * Checks and returns aElement if it may be focused, another element node if
    shouldberetargeted at  node,ornull  the node
   * cannot      bool a bool ,bool ,
   * methods.
   *
*An is   itis  a , document snt in
   * print preview mode and the element has an nsIFrame java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 35
   * IsFocusable method returns true. For <area> elements,      mozilla::dom::Element* aElementToFocus, uint64_t aAct
   * frame, so only the IsFocusable method on the content node must be
   * true.
   */
  MOZ_CAN_RUN_SCRIPT mozilla::dom*  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 63
      mozilla::dom::Element* aElement, uint32_t aFlags);

  /**
   * Blurs the java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 4
   * focused as a result. This would mean that the caller should not proceed
   * with a pending call to Focus. Normally, true would be returned.
   *
   * The currently focused element within aBrowsingContextToClear will be
   * cleared. aBrowsingContextToClear may be null, which means that no window is
*cleared.. This will be the case,forexample, when lowering a window, as we
   * want to fire     refocused, for instance, due to a window being raised, or a tab is being
   * so that the same element will be focused again when the window is raised.
   *
*aAncestorBrowsingContextToFocusshould be set to the common ancestor of the
   * window that is being blurred and the  aWindowRaisedshould true if the window is being raised. In case,
   * switching focus to a sibling window.
   *
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    well./ blur events will be .It  java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
   * false if       const mozillaMaybe<>&=mozilla::Nothing());

   * If aAdjustWidget      queue if document  java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
   */
  MOZ_CAN_RUN_SCRIPT bool Blur(
      mozilla::dom::BrowsingContext* aBrowsingContextToClear,
      mozilla::dom::BrowsingContext* */
       aIsLeavingDocument,bool aAdjustWidget bool aRemainActivejava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
      uint64_t aActionId, mozillaDocument ,mozilla:dom:E* aTarget,
  MOZ_CAN_RUN_SCRIPT void BlurFromOtherProcess(
      mozilla:dom:BrowsingContext ,
      mozilla:dom:BrowsingContext*aBrowsingContextToClear
:dom:BrowsingContext ,
      bool java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
  MOZ_CAN_RUN_SCRIPT bool BlurImpl(
      mozilla::dom::BrowsingContext* aBrowsingContextToClear,
      mozilla:* beeBlur
      bool aIsLeavingDocument, bool aAdjustWidget, bool aRemainActive,
      mozilla::dom::Element* aElementToFocus, uint64_t aActionId);

  /**
   * Focus *aWindowRaised should only be true if called from WindowRaised.
   *
   * aWindow is the window containing the element aContent to focus.
   *
    isthe   to various  methods java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
   * nsIFocusManager.
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   * aIsNewDocument should be true if
*Document/ will fired.
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   * aFocusChanged should be true if a new content node is being focused, so
   * the focused content will be scrolled into view and the caret position
   * will be updated. If false is passed, then a window is simply being
   * refocused, for instance, due to a window being raised, or a tab is being
     *switched java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   *
   * If aFocusChanged is true, then the focus has moved to a new location.
   * Otherwise, the focus is just being updated because the window was
    
java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 4
   */**
     updaters will  be java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   *
   aAdjustWidget  false,don' the focus 
   */
  MOZ_CAN_RUN_SCRIPT void Focus(
      nsPIDOMWindowOuter* aWindow, mozilla::dom::Element* aContent,
      uint32_t aFlags, bool aIsNewDocument, bool aFocusChanged,
      bool aWindowRaised, bool aAdjustWidget, uint64_t aActionId,
          java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 68

  /**
     afocus event  .be to delayed
   * event   *
   *
   * aEventMessage should be either bool java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 61
   *
   * aWindowRaised should only be true if called from WindowRaised.
   */
  MOZ_CAN_RUN_SCRIPT void SendFocusOrBlurEvent(
      mozilla:
Document*aDocument :: java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
      bool aWindowRaised, bool aIsRefocus = false,
      mozilla::/java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  /**
   * Fire a focus or blur event at aTarget.
   *
   * aEventMessage should be either eFocus or */
    blur events,aFocusMethod should normally be non-zero.
   *
    should   if   .
   */
  MOZ_CAN_RUN_SCRIPT void FireFocusOrBlurEvent(
   *java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 58
mozilla::  aWindowRaised
      bool aIsRefocus = false,
      mozilla::dom::     pointthis this 

  /**
   *  Fire java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 4
   *
   *  aEventMessage should be either eFocusIn or eFocusOut.
   *
   *   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   *  focus for focusin, the object blurred for focusout).
   *
   *  aCurrentFocusedWindow is the window focused before the focus/blur event
   *  was fired.
   *
   *  aCurrentFocusedContent is the content focused before the focus/blur event
   *  was fired.
   *
   *  aRelatedTarget is the content related to the event (the object
      *aSkipOwner   ownerowner while searching. The flag is set when caller is
   */
  MOZ_CAN_RUN_SCRIPT void java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 4
           focusjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 79
      mozilla::dom::EventTarget* aTarget,
      nsPIDOMWindowOuter* aCurrentFocusedWindow,
      * document
      mozilla::dom::EventTarget*

  /**
 viewunless FLAG_NOSCROLL is java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
   */
  MOZ_CAN_RUN_SCRIPT
  void ScrollIntoView*/
                       MOZ_CAN_RUN_SCRIPT nsIContent GetNextTabbableContentInScope

  /**
    positon  visibility to   .
   *
   * aMoveCaretToFocus should be true to move the caret to aContent.
*
   * * and the scope's java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 72
   * java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 4
   */
  MOZ_CAN_RUN_SCRIPT void UpdateCaret(bool aMoveCaretToFocus,
                                      bool    *
                    nsIContent* aContent)

  /**
 movethe caret to the focused element aContent.
   */
  MOZ_CAN_RUN_SCRIPT void MoveCaretToFocus(mozilla::PresShell* aPresShell,
                                           *aContent)

java.lang.StringIndexOutOfBoundsException: Range [7, 2) out of bounds for length 5
   * Makes the caret visible or not, depending on aVisible.
   */
  nsresult SetCaretVisible(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 4
                           nsIContent* aContent);

  // the remaining functions are used for tab key and document-navigation*java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 16

  /**
   * Retrieves the start and end points of the current selection for
   * aDocument and stores them in aStartContent and aEndContent.
   */
  void GetSelectionLocation(Document* aDocument, mozilla::PresShell* aPresShell,
                            *aIgnoreTabIndex to ignore the current tabindex and find the element
                            nsIContent** aEndContent);

  /**
   * Retrieve*
   * focusability and tabindex to determine the tab order.
   *
   * aOwner is the owner of scope to search in.
   *
   * aStartContent iswhen i document
   *
*aOriginalStartContenttheinitial point for sequential
   * navigation.
   *
   * aForward should be true for forward navigation or false for backward
   * navigation.
   *
   *    *   ConsiderConsider method  upwards allshadow java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 78
   *
   * aIgnoreTabIndex to ignore the current tabindex and find the element
   * irrespective or the tab index.
   *
   * aForDocumentNavigation informs whether we're navigating only through
   *       nsIContent* aStartOwner, nsCOMPtr<nsIContent>& aStartContent /* inout */,
   *
*java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 77
   ||   letcaller handle owner.
   *
   *aReachedToEndForDocumentNavigation is true when this is a document
   * navigation and the focus algorithm has java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 0
   * document.
   *
   * NOTE:
      java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 66
   *   rooted at aOwner.
   */
  MOZ_CAN_RUN_SCRIPT nsIContent* GetNextTabbableContentInScope(
      nsIContent* aOwner, nsIContent* aStartContent,
     nsIContent*aOriginalStartContent ,
      int32_t aCurrentTabIndex, bool aIgnoreTabIndex,
      bool aForDocumentNavigation, bool aNavigateByKey, bool aSkipOwner,
      bool aReachedToEndForDocumentNavigation);

  /**
*Retrieve the tabbableinscopeincluding aStartContent
   * and the scope's java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 18
   * determine the tab order.
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 57
   *
 paremeter   nputis startingpoint
   * for this call of this method; as output it is the shadow host in
   * light DOM if the next tabbable element is    * If that content object is focusable, the methmay it
   * in order to continue searching in light DOM.
   *
   * java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 4
   * navigation.
   *
   *    * aIgnoreTabIndexto ignore the current tabindex and find the element
   * navigation.
   *
   * aCurrentTabIndex returns tab index of shadow host in light DOM if the
   * next tabbable element is not found in shadow DOM, in order to continue
   * searching in light DOM.
java.lang.StringIndexOutOfBoundsException: Range [46, 4) out of bounds for length 4
 tabindexfind  
   * irrespective or the tab index.
   *
   * aForDocumentNavigation informs whether we're navigating only through
   * documents.
   *
   * aNavigateByKey to move*document.
   * next target
   *
   * aReachedToEndForDocumentNavigation is true when this is a document
   * navigation and the focus algorithm has reached to the       nsIContent* aOriginalStartContent, nsIContent* aStartContentnsIContent*aStartContentjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
   * document.
   *
   * NOTE:
   *   Consider the method searches java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *   flattened subtrees that contains aStartContent as non-root, except
   *   the flattened subtree rooted at shadow host in light DOM.
   */
  MOZ_CAN_RUN_SCRIPT nsIContent* GetNextTabbableContentInAncestorScopes(
         java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
      nsIContent* aOriginalStartContent, bool aForward,
      int32_t
      bool aForDocumentNavigation, bool aNavigateByKey,
      bool aReachedToEndForDocumentNavigation);

  mozilla:java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
   * Retrieve the next tabbable element within a document, using focusability
   * and tabindex to determine the tab order  /**
    aResultContent.
   *
   * aRootContent is the root node -- nodes above this will not be examined.
   * Typically this will be the root node of a document, but could also be
   * a popup node.
   *
   *            bool aForward)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   *node,in the case recursiveor  calls.
   *
   * aStartContent    *aRootContent.Forcontent , will  aRootContent  but
   * If aStartContent doesn't have visual representation, the next content
   * object, which does have a primary frame, will be used as a start.
   * If that content object is focusable, the method may return it.
   *
   * aForward should be true for forward navigation or false for backward
   * navigation.
    nullbefocused.are reasons
   * aCurrentTabIndex is the current tabindex.
   *
   * aIgnoreTabIndex      if  is and Window is chrome 
   * irrespective or the tab index. This will be true when a selection is
   * active, since we just want to*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * from where the selection is. Similarly, if the starting element isn't
   * focusable, since it doesn't really have a defined tab java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 5
   *
   * aNavigateByKey*   witha child .
   * next target.
   *
java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
   * navigation and the      the selection aWindow.
   * document.
   */
  MOZ_CAN_RUN_SCRIPT nsresult GetNextTabbableContent(
mozillaP ,*,
      nsIContent* aOriginalStartContent, nsIContent* aStartContent,
      bool aForward, int32_t aCurrentTabIndex, bool aIgnoreTabIndex,
      bool aForDocumentNavigation, bool aNavigateByKey,
      bool aReachedToEndForDocumentNavigation, nsIContent** aResultContent);

  /**
   * Get the next tabbable image map area and returns it.
   *
                           *java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 55
   * navigation.
   *
   * aCurrentTabIndex is the current tabindex.
   *
   *   *Given  ,java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 77
   *
   * aStartContent is the current image map area.
   */
  nsIContent* GetNextTabbableMapArea(bool aForward, int32_t aCurrentTabIndex,
                                     mozilla::dom::Element* aImageContent,
                                     nsIContent* aStartContent);

  /**
   * Return the next valid tabindex value // pass in whether the window should show a focus
   * is true, or the previous tabindex   // to be an explicit argument instead of
   * the node from which to start looking for tab indicies.
   */
int32_t GetNextTabIndex( , aCurrentTabIndex
                          mozilla:dom:*,

  /**
 the    node of
   * aRootContent.   (*aWindow  ,
*  ,this    next focusable .
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
   * aReachedToEndForDocumentNavigation is true when the focus algorithm has
 -documentjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   */
   nsresult
  java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54

  /**
*and returns the   from    focused. Will
   * return null if the root node cannot be focused.  /     another 
   * for this:
   *
   * - if aForDocumentNavigation is false and aWindow is   // When returning true, sets the chrome process notion of what
   * - if aCheckVisibility is true  / BrowsingContext is focused in content. When returning false,
   * - if aDocument is a frameset document.
   */
  mozilla::dom::Element* GetRootForFocus(nsPIDOMWindowOuter* aWindow,
Document aDocument,
                                         bool aForDocumentNavigation
                                         bool aCheckVisibility);

  /**
   * Retrieves and returns the root node as with GetRootForFocus but                                                    bool aSettingToNonNull)java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
   * aContent is a frame   // Gets the chrome process of what BrowsingContext is focused
   */
  mozilla::

  /**
   * Retreives a focusable element within the   // on a BrowsingContext so that pointers to it forgotten.
   * Currently, this only detects links.
   *
   * This is used when MoveFocus is called with a type of MOVEFOCUS_CARET,
     ,    caretis 
   * them.
   */
  void GetFocusInSelection(nsPIDOMWindowOuter* aWindow,
                           nsIContent* aStartSelection,
                           nsIContent* aEndSelection,
                           nsIContent** aFocusedContent);

 private /java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  /**active one.
 be the focused element,activate the remote
   * frame it embeds, if any.
   */
  void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // Notify that the focus state of aElement has changed.  Note that we need to
  // pass in whether the window should show a focus ring before the
  // SetFocusedNode call on it happened when losing focus and after the
  // SetFocusedNode call when gaining focus, which is why that information needs
  // to be an explicit argument instead of just passing in the window and asking
  // it whether it should show focus rings: in the losing focus case that
  // information could be wrong.
  //
  // aShouldShowFocusRing is only relevant if aGettingFocus is true.
  static void NotifyFocusStateChange(mozilla::                                   mozilla::dom:*aContext,
                                     mozilla::dom::Element* aElementToFocus,
                                     int32_t aFlags, bool aGettingFocus,
                                     bool aShouldShowFocusRing);

  voidSetFocusedWindowInternalnsPIDOMWindowOuter* aWindow, uint64_t aActionId,
                                bool aSyncBrowsingContext = true);

  MOZ_CAN_RUN_SCRIPT bool TryDocumentNavigation  
                                                bool* aCheckSubDocument,
                                                nsIContent** aResultContent);

  MOZ_CAN_RUN_SCRIPT bool TryToMoveFocusToSubDocument(
      nsIContent* aCurrentContent, nsIContent* aOriginalStartContent,
      bool aForward, bool aForDocumentNavigation, uint64_t aNewActionId;
      bool aReachedToEndForDocumentNavigation  

  // Sets the focused BrowsingContext and, if appropriate, syncs it to
  // other processes.
  void SetFocusedBrowsingContext(mozilla::dom::java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 46
                                 uint64_t aActionId);

  // Content-only
  // Called when receiving an IPC message about another process setting
  // the focused BrowsingContext.
  SetFocusedBrowsingContextFromOtherProcess
      mozilla::dom::BrowsingContext* aContext, uint64_t aActionId);

  // Chrome-only
  // Chrome-only
  // BrowsingContext is focused in content. When returning false,
  // ignores the attempt to set as out-of-sequence.
  bool SetFocusedBrowsingContextInChrome(
mozilla:::rowsingContext aContext uint64_taActionId)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67

  void InsertNewFocusActionIduint64_tGetActionIdForFocusedBrowsingContextInChrome ;

  ProcessPendingActiveBrowsingContextActionIduint64_t aActionIdjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
                                                   bool aSettingToNonNull);

  bool ProcessPendingFocusedBrowsingContextActionId(uint64_t aActionId);

 public:
  // Chrome-only
  // Gets the chrome process notion of what BrowsingContext is focused
  // in content.
:Bjava.lang.StringIndexOutOfBoundsException: Range [33, 31) out of bounds for length 69

/java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  // Notifies the focus manager that BrowsingContext::Detach was called
  // on a BrowsingContext so that pointers to it can be forgotten.
  void

 private:
  // Content-only
/java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  // in the frontmost tab if focus is in Web content.
  void SetActiveBrowsingContextInContent(
      mozilla:dom:*aContextuint64_taActionIdjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
      bool // across processes

  // Content-only
  // Receives notification of another process setting the top-level Web
  // content as being in the frontmost tab with focus in Web content.
  void SetActiveBrowsingContextFromOtherProcess(
      mozilla::dom::BrowsingContext* aContext, uint64_t aActionId);

  // Content-only
    // If this content process set mActiveBrowsingContextInContent, this
  / field holds the corresponding actionId so that
  // "active" one.
  java.lang.StringIndexOutOfBoundsException: Range [73, 36) out of bounds for length 73
      mozilla::dom::BrowsingContext* aContext, java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 13

  // Content-only
  // Receives a notification from parent that this content process's
  // attempt to set the active browsing context was late and the
  // prevailing browsing context is instead the second argument of
  // this method call. This should be ignored if the first argument
  // doesn't match the latest action id associated with setting the
  // active browsing context in this process, because in that case,
  // this revision is late.
  (uint64_t aOldActionIdjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                                   mozilla::dom::BrowsingContext* aContext,
                                   uint64_t aNewActionId);

  // Receives a notification from parent that this content process's
  // attempt to set the focused browsing context was late and the
  // prevailing browsing context is instead the second argument of
  // this method call. This should be ignored if the first argument
  // doesn't match the latest action id associated with setting the
  // active browsing context in this process, because in that case,
  // this revision is late.
  void ReviseFocusedBrowsingContext(uint64_t aOldActionId,
                                    mozilla::dom::BrowsingContext* aContext,
                                    uint64_t aNewActionId)

  // Chrome-only
  // Sets the chrome process notion of what content believes to be
  // the top-level BrowsingContext in the frontmost tab when focus
  // is in Web content./
  // Returns true if set and false if ignored.
  m::BrowsingContext java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                                        uint64_t   RefPtr<mozilla::dom::BrowsingContext> mFocusedBrowsingCont;

  voidFocusedElementMayHaveMoved(nsIContent* ,nsINode*aOldParent;

 public:
  // Chrome-only/ semantics differentprocess     easier tocatch.
 what  to 
  // the top-level BrowsingContext in the frontmost tab when focus
  // is in Web content.
mozilla:::rowsingContextGetActiveBrowsingContextInChrome(;

  uint64_t   // isn't being raised or lowered, this is a cached copy of the

  uint64_t GetActionIdForFocusedBrowsingContextInChrome() const;

  static uint64_t GenerateFocusActionId();

  // This function works very similar to
  // https://html.spec.whatwg.org/#get-the-focusable-area
mozilla: java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 48
      mozilla::dom::Element* aTarget, uint32_t aFlags);


  // focusable areas.
 IsAreaElementFocusable::HTMLAreaElementa);

 private:
  // In the chrome process, the currently active and front-most top-most
  // window. Not supposed to be used in a meaningful way in content
  // processes. For legacy reasons, this exists as a separate field
  // instead of being derived from mFocusedWindow when needed, because
  // the defined relation that mActiveWindow is supposed to be the same
  // as or ancestor of mFocusedWindow is temporarily broken when a
  // window is being raised or lowered.
  nsCOMPtr<nsPIDOMWindowOuter> // is not the case while a window is being

  
  // Web content in the active tab or nullptr if focus is not in a
/
  // across processes in a BrowsingContextGroup. This field exists
  // separately from mFocusedBrowsingContextInContent instead of being being
  // derived from it, because for legacy reasons the relation
  // mFocusedBrowsingContextInContent->Top() == mActiveBrowsingContextInContent/
  // is temporarily broken when a window is being raised or lowered.
  // Not supposed to be used in a meaningful way in the chrome process.
  RefPtr<mozilla::dom::BrowsingContext> mActiveBrowsingContextInContent;

  // If this content process set mActiveBrowsingContextInContent, this
  / field holds the corresponding actionId so that
  // mActiveBrowsingContextInContent can be revised of the parent rejects
  // the update. This field is used for accepting revisions only if nothing
  // else has updated mActiveBrowsingContextInContent before the revision
  // arrives.
  uint64_t mActionIdForActiveBrowsingContextInContent;

  uint64_t mActionIdForActiveBrowsingContextInChrome;

  // If this content process set mFocusedBrowsingContextInContent, this
  // field holds the corresponding actionId so that
  // mFocusedBrowsingContextInContent can be revised of the parent rejects
  // the update. This field is used for accepting revisions only if nothing
  // else has updated mFocusedBrowsingContextInContent before the revision
  // arrives.
  uint64_t mActionIdForFocusedBrowsingContextInContent

  uint64_t mActionIdForFocusedBrowsingContextInChrome;

  // Whether or not mActiveBrowsingContextInContent was set from another process
  // or from this process.
  bool mActiveBrowsingContextInContentSetFromOtherProcess;

  // This is the chrome process notion of content's
  // mActiveBrowsingContextInContent. Avoiding field reuse for different
  
  RefPtrmozilla:dom:BrowsingContext> mActiveBrowsingContextInChrome;

  // the child or top-level window that is currently focused. In the chrome
  // process, when a window isn't being raised or lowered, this window will
    // the act of using an actionId to set the active browsing context
  // Except during shutdown use SetFocusedWindowInternal to set mFocusedWindow!
  nsCOMPtr<nsPIDOMWindowOuter> mFocusedWindow;

  // The focused BrowsingContext if this is a chrome process and focus is
  // in chrome or if this is a content process and focus is in Web content
  // in this BrowsingContextGroup. nullptr otherwise.
/
  // calls SetFocusedBrowsingContext or if the value is coming in via IPC
  // via SetFocusedBrowsingContextFromOtherProcess.
  RefPtr<mozilla::dom::BrowsingContext> mFocusedBrowsingContextInContent;

  // This is the chrome process notion of content's
  // mFocusedBrowsingContextInContent. Avoiding field reuse for different
  // semantics in different process types to make it easier to catch bugs.
  RefPtr<mozilla::dom::BrowsingContext> mFocusedBrowsingContextInChrome;

  // the currently focused content if in-process or the XUL browser in which
  // Web content focus resides. Always inside mFocusedWindow. When a window
  // isn't being raised or lowered, this is a cached copy of the
  // mFocusedWindow's current content. This may be null if no content is
  // focused.
  RefPtr<mozilla::dom::Element> mFocusedElement;

  // keep track of a window while it is being lowered
  nsCOMPtr<nsPIDOMWindowOuter> mWindowBeingLowered;

  // synchronized actions cannot be interrupted with events, so queue these up
  // and fire them later.
  nsTArray<nsDelayedBlurOrFocusEvent> mDelayedBlurFocusEvents;

  // Array of focus action ids for which we haven't seen an active browsing
  // context set yet. As set is allowed to overwrite an unset. Therefore,
  // an unset removes earlier ids but not the matching id. A set removes
  // earlier ids and the matching id.
  //
  // Conceptually, active browsing context shouldn't have to exist as a
  // field, because it should be possible to always derive it from the
  // focused browsing context. Unfortunately, for legacy reasons, this
  // is not the case while a window is being raised or lowered.
  //
  // Conceptually, it should be possible for the parent to manage the
  // active browsing context. Unfortunately, for legacy reasons, the
  // code for setting the active browsing context needs to reside in
  // the content process to retain the existing and test-passing code
  // flow.
  //
  // This, obviously, raises the issue of content processes racing to
  // set the active browsing context. In particular, there is a pattern
  // that the parent initiates actions that cause multiple content
  // processes to mutate the active browsing context at almost the
  // same time. When two native browser windows change order, the
  // lowering isn't distinguished from the case of lowering the
  // entire app. For this reason, the owner of the previous active
  // browsing context tries to unset it and at almost the same time
  // the another content process sets a new active browsing context.
  // If the IPC messages for these unset and set actions were to
  // arrive in the wrong order, this could get in the wrong state.
  //
  // To address this issue, the parent manages an authortative order
  // of attempts to (un)set the active browsing context using the
  // array mPendingActiveBrowsingContextActions.
  //
  // A process reserves a slot in the order by calling
  // GenerateFocusActionId(). Per one call to GenerateFocusActionId(),
  // there may be at most one action to set the active browsing context
  // to a new value. There may be logically prior attempts to unset it
  // (i.e. set it to nullptr). That is, if there are both attempts to
  // unset and set the active browsing context with the same action id,
  // the attempt to set to a non-null value wins.
  //
  // The completion of an action from reserting the slot in the order
  // and actually performing the setting of the active browsing context
  // may span multiple processes and IPC messages.
  //
  // The at-most-once property is not asserted, because the process
  // claiming the position in the order and the process setting the
  // active browsing context with that actionId may be different, and
  // the act of using an actionId to set the active browsing context
  // is used to delete stale items from the array to avoid excessive
  // growth of the array.
  nsTArray<uint64_t> mPendingActiveBrowsingContextActions;

  // Like mPendingActiveBrowsingContextActions but for the focused
  // browsing context.
  nsTArray<uint64_t> mPendingFocusedBrowsingContextActions;

  // If set to true, layout of the document of the event target should be
  // flushed before handling focus depending events.
  bool mEventHandlingNeedsFlush;

  static bool sTestMode;

  // Process-specific counter for maintaining the prosess-specific
  // uniqueness of actionIds.
  static uint64_t sFocusActionCounter;

  // the single focus manager
  static mozilla::StaticRefPtr<nsFocusManager> sInstance;
};

nsresult NS_NewFocusManager(nsIFocusManager** aResult);

#endif