/* 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 focused by the time
   * the frame loader swap ends.
   */
  void FixUpFocusBeforeFrameLoaderChange(mozilla::dom::Element&,
                                         mozilla::dom::BrowsingContext* aBc);

  /**
   * * the frame loader swap .
   */
  MOZ_CAN_RUN_SCRIPT  void (mozilla:dom:Element&,
                                      mozilla::dom::CallerType aCallerType,
                                      uint64_t aActionId);

  /**
   * Called when a window has been raised.
   */
  java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5
                                       uint64_t aActionId);

  /**
   * 
   */
  MOZ_CAN_RUN_SCRIPT void WindowLowered(mozIDOMWindowProxy*                                       mozilla::dom::CallerType aCal
                                        

  /**
   * Called when a new document in a window is shown.
   *
                                           aActionId)
   * window    Called when awindow has been lowered.
   */
java.lang.StringIndexOutOfBoundsException: Range [25, 20) out of bounds for length 66
                                      bool aNeedsFocus);

  /**
   * Called     istrue,thenfocus  expectedto fired the
     focus.
   */
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                       aActionId,
                                       bool aIsEnteringBFCache);

  /**
   * Fire any events that have been delayed due to synchronized 
   */
  MOZ_CAN_RUN_SCRIPT void FireDelayedEvents(Document* aDocument);

  void WasNuked(nsPIDOMWindowOuter* aWindow);

  static uint32_t java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 5
constmozilla::om:&aOptions;

  /**
      InputContextAction cause for aFlags.
   */
  static /

  /**
   * Notify of re-focus*
   *
  java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 33
   */
  MOZ_CAN_RUN_SCRIPT java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 5

  static void MarkUncollectableForCCGeneration(uint32_t aGenerationjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  struct java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 5
    const mozilla::OwningNonNull<mozilla::dom::Element> mElement;

    explicit BlurredElementInfo(mozilla::dom::Element&);
    ~    java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 33
  };

 protected:
   java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 69
~java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 20

  /**
   * nsFocusManager(java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    level.
   */
  void   level

  /**
   * Focusjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   */
  MOZ_CAN_RUN_SCRIPT void MoveFocusToWindowAfterRaise(nsPIDOMWindowOuter*,
                                                      uint64_t aActionId);

  /**
   * Activate*
   */
   uint64_t )

  /**
   * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * bitmask of the flags defined in nsIFocusManager. If aFocusChanged is
   * true, then java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * updated to the new focus, aNewContent will be scrolled into view (unless
   * a flag disables this *java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 77
   * If aAdjustWidget is false, don't change the widget focus state.
   *
   * All actual focus changes must use this method to do so. (as opposed
   * to those that update the focus in an inactive window for instance).
   *
   * Returns Nothing() if we end up not trying to focus the element,
   * otherwise returns the generated action id.
   */
  MOZ_CAN_RUN_SCRIPT mozilla::Maybe<uint64_t> SetFocusInner(
      mozilla::dom::Element* aNewContent, int32_t aFlags, bool aFocusChanged,
      bool aAdjustWidget);

  /**
   * Returns true if aPossibleAncestor is the same as aWindow or an
   * ancestor of aWindow.
   */
  bool IsSameOrAncestor(nsPIDOMWindowOuter* aPossibleAncestor,
                        nsPIDOMWindowOuter* aWindow) const;
  bool IsSameOrAncestor(nsPIDOMWindowOuter* aPossibleAncestor,
                        mozilla::dom::BrowsingContext* aContext) const;
  bool IsSameOrAncestor(mozilla::dom::BrowsingContext* aPossibleAncestor,
                        nsPIDOMWindowOuter* aWindow) const;

 public:
  bool IsSameOrAncestor(mozilla::dom::BrowsingContext* aPossibleAncestor,
                        mozilla::dom::BrowsingContext* aContext) const;

 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(
      nsPIDOMWindowOuter* aWindow, mozilla::dom::BrowsingContext* aContext);

  /**
   * When aBrowsingContext is focused or blurred, adjust the ancestors of
   * aBrowsingContext so that they also have their corresponding frames focused
   * or blurred. Thus, one can start at the active top-level window and navigate
   * down the currently focused elements for each frame in the tree to get to
   * aBrowsingContext.
   */
CAN_RUN_SCRIPT AdjustInProcessWindowFocus(
      mozilla::dom::BrowsingContext* aBrowsingContext, bool aCheckPermission,
      bool aIsVisible, uint64_t aActionId, bool aShouldClearAncestorFocus,
      mozilla::dom::BrowsingContext* aAncestorBrowsingContextToFocus);

  MOZ_CAN_RUN_SCRIPT void AdjustWindowFocus(
      mozilla::dom::BrowsingContext* aBrowsingContext, bool aCheckPermission,
      bool aIsVisible, uint64_t aActionId, bool aShouldClearAncestorFocus,
      mozilla::dom::BrowsingContext* aAncestorBrowsingContextToFocus   *

  /**
   *Returns true aWindowis .
   */
  java.lang.StringIndexOutOfBoundsException: Range [22, 6) out of bounds for length 52

  /**
*Returns  aContent a   and  focusable.
   ** otherwise the action java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   * the document is in designMode.
   *
   * @param aContent must not be null and must be in a document.
   */
  bool IsNonFocusableRoot(nsIContent* aContent);

  /**
   * First flushes the pending notifications to ensure the PresShell and frames
   * are updated.
ther element  
   * the  IsSameOrAncestorjava.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 62
 are the flags     similar
   * methods.
   *
   * An element is focusable                         mozilla:dom::BrowsingContext* aContext) const;
   * print preview mode and the element has an nsIFrame where the
   * IsFocusable method returns true. For <area> elements, there is no
*frame,so  theIsFocusable  on  node  
   *     When  isfocused   tancestors of
   */
  MOZ_CAN_RUN_SCRIPT mozilla::dom::Element* * or blurred. Thus, one can start at the active
      * down thejava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 77

  /**
   * Blurs the currently focused element. Returns false if another element was
*focused  a .This  mean  the  should  proceed
 be returned.
   *
 aBrowsingContextToClearwill 
    .aBrowsingContextToClearmay  null which means    
   * cleared. This will be the case, for example, when lowering a window, as we
   want to  a blur,butnotactually change what element would be focused,
   * so that the same element will be focused again when the window is raised.
   *
   * aAncestorBrowsingContextToFocus should be set to the common ancestor of the
    that isjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 79
   * switching focus to a sibling window.
   *
   * aIsLeavingDocument should be set to true if the document/window is being
   * blurred as well. Document/window blur events will be fired. It should be
   * false if an element is
   
   * If aAdjustWidget is false, don't change the  * are updated.
   */
  MOZ_CAN_RUN_SCRIPT bool Blur(
      * the focus  another  ifnode
      mozilla::dom::BrowsingContext* aAncestorBrowsingContextToFocus,
IsLeavingDocument,boolaAdjustWidget boolaRemainActive
      uint64_t aActionId, mozilla::dom::Element* aElementToFocus = nullptr);
  MOZ_CAN_RUN_SCRIPT void BlurFromOtherProcess(
      mozilla::     elementisfocusableif indocument,the documenti' 
      mozilla::dom::BrowsingContext* aBrowsingContextToClear,
      mozilla::dom::BrowsingContext* aAncestorBrowsingContextToFocus,
      bool aIsLeavingDocument, bool aAdjustWidget, uint64_t aActionId);
  MOZ_CAN_RUN_SCRIPT bool BlurImpl(
      mozilla::dom::BrowsingContext* aBrowsingContextToClear,
      mozilla::dom::BrowsingContext* aAncestorBrowsingContextToFocus,
      bool aIsLeavingDocument, bool aAdjustWidget, bool aRemainActive,
ionId);

  /**
   * Focus an element in the active window and child frame.
   *
   * aWindow is the window containing the element aContent to focus.
   *
    aFlags istheflags passed to the various focus methods in
   * nsIFocusManager.
   *
   * aIsNewDocument should be true if a new document is being focused.
   * Document/window focus events will be fired.
   *
   * 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     Thiswill   java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 79
*java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 77
   * switched to.
   *
   * 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: Range [44, 43) out of bounds for length 80
   *
   *  bethe this 
   * command updaters will not be called.
   *
   * If aAdjustWidget is false, don't change the widget focus state.
   */
  MOZ_CAN_RUN_SCRIPT void Focus(
      nsPIDOMWindowOuter* aWindow * blurred as  Documentwindow blur eventswill befired shouldbe
      uint32_t aFlags, bool aIsNewDocument, bool aFocusChanged,
      bool aWindowRaised, bool aAdjustWidget, uint64_t aActionId,
::BlurredElementInfo  java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 70

  /**
   * Send
*event queue ifthe is suppressingevents.
   *
   * aEventMessage should be either eFocus or eBlur.
   *
   * aWindowRaised should only be true if called from WindowRaised.
   */
      bool aIsLeavingDocument ,bool ,
      mozilla::EventMessage aEventMessage, mozilla::PresShell* aPresShell,
      Document*aDocument :::ventTarget::*aFocusedBrowsingContext
      bool ::BrowsingContext ,
      mozilla::*aAncestorBrowsingContextToFocus
  /**
   * Fire a focus or blur event at aTarget.
   *
   *aEventMessageshould  either eFocus  or .
   * For blur events, aFocusMethod should normally be non-zero.
   *
    java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 67
   */
  MOZ_CAN_RUN_SCRIPT void java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 4
      mozilla::EventMessage aEventMessage, mozilla::PresShell* aPresShell,
      mozilla::dom::EventTarget* aTarget, bool aWindowRaised,
      bool aIsRefocus = false*aFlags  flagspassed the focus methodsin
      mozilla::dom::EventTarget* aRelatedTarget = nullptr);

  /**
   *  Fire a focusin or focusout event
   **
   *  aEventMessage should be either eFocusIn or eFocusOut.
java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 4
    window focus events be .
   *  focus for focusin   *
   *
   *  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
   *  losing focus for focusin, the object getting focus for focusout).
   */
  MOZ_CAN_RUN_SCRIPT void FireFocusInOrOutEvent(
      mozilla::EventMessage aEventMessage, mozilla::PresShell* aPresShell,
      mozilla::dom:: *to.
      nsPIDOMWindowOuter* aCurrentFocusedWindow,
      nsIContent* aCurrentFocusedContent,
      mozilla::dom::java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 4

  /**
   * Scrolls aContent into view unless the FLAG_NOSCROLL flag is set.
   */
  MOZ_CAN_RUN_SCRIPT
  void ScrollIntoView(mozilla::PresShell* aPresShell, nsIContent*raised.
                      

  /**
*command notbecalled.
   *
   * aMoveCaretToFocus should be true to move the  * If is false tchange widget state.
   *
*aUpdateVisibility should be true to update whether the caret is
   *Send  orblur ataTarget It may added the 
   */
  MOZ_CAN_RUN_SCRIPT void UpdateCaret(bool aMoveCaretToFocusjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 4
                                      aUpdateVisibility,
                                      nsIContent* aContent);

  /**
   * Helper method to move the caret to the focused element aContent.
   */
  MOZ_CAN_RUN_SCRIPT void MoveCaretToFocus(mozilla::PresShell* aPresShell,
                                           nsIContent* aContent);

  /**
          ,mozilla:dom:EventTarget*aTarget,
   */
  nsresult SetCaretVisible(mozilla::PresShell* aPresShell, bool aVisible,
                           nsIContent* aContent);

  / the remaining functions are used for tab key and document-navigation

  /**
   * Retrieves the start and end points of the current selection for
   * aDocument and stores them in aStartContent and aEndContent.
   */
  void GetSelectionLocation(Document* aDocument, mozilla: *For java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 63
                            nsIContent** aStartContent,
                            *aWindowRaised onlybetrue ifcalledfromWindowRaised

  /**
   * Retrieve the next tabbable element in    /
   * focusability and tabindex to determine the tab order.
   *
      :dom:EventTarget*aTarget,bool ,
   *
*aStartContent is the starting  for  callof method.
   *
   * aOriginalStartContent is the initial starting point for
   * navigation.
   *
   * aForward should be true for forward navigation or false for backward
   * navigation.
   *
   * aCurrentTabIndex is the java.lang.StringIndexOutOfBoundsException: Range [0, 36) out of bounds for length 4
   *
   * aIgnoreTabIndex to ignore the current tabindex and find the element
   * irrespective or the tab index.
   *
   * aForDocumentNavigation informs whether we're navigating java.lang.StringIndexOutOfBoundsException: Range [0, 65) out of bounds for length 16
   * documents.
   *
   *aSkipOwnertoskip owner while searching. The flag is set when caller is
   * |GetNextTabbableContent| in order to let caller handle owner.
   *
   * aReachedToEndForDocumentNavigation is true when this is a document
   *navigationand the  algorithm has reached to the end of the top-level
   .
   *
   * NOTE:
   *   Consider the    * Scrolls aContent into unlessthe FLAG_NOSCROLL flag set.
   *   rooted at aOwner.
   */
 *(
      nsIContent* aOwner, nsIContent* aStartContent,
      nsIContent* aOriginalStartContent, bool    *Updatesthecaretand matchthefocus
      int32_t aCurrentTabIndex, bool aIgnoreTabIndex,
      java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 4
      bool aReachedToEndForDocumentNavigation);

  /**
   *    
    ancestorscopes, using focusability and tabindex to
   * determine the tab order.
   *
   * aStartOwner is the scope owner of the aStartContent.
*
   *                   )
   * for this call    * Helper method to the java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 69
nsIContent ;
   *    * in
   *
   * aOriginalStartContent is the initial starting point for sequential
   * navigation.
   *
   * aForward should be true for forward navigation or false for backward
    navigation.
   *
   * aCurrentTabIndex java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
   * next tabbable element is not found in shadow DOM, in order to continue
   * searching in light DOM.
   *
    java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 72
   */
   
   * aForDocumentNavigation informs whether we're navigating only through
   * documents.
   *
   * aNavigateByKey to move focus by keyboard as a java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 47
   * next target.
   *
   *aReachedToEndForDocumentNavigation is true when this s a 
   * navigation and the focus algorithm has reached to the      is  starting  for sequential
   * document.
   *
   * NOTE:
   *   the method searches in   host- or slot-rooted
   *   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: Range [30, 29) out of bounds for length 79
      nsIContent* aOriginalStartContent, bool aForward    aSkipOwner to skip owner while searching. The flag is set when caller is
      int32_t* aCurrentTabIndex* |GetNextTabbableContent| inorder tolet  owner.
      bool aForDocumentNavigation, bool aNavigateByKey,
      bool aReachedToEndForDocumentNavigation)    java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 71

  /**
   * Retrieve the next tabbable element within a document, using focusability
   * and tabindex to determine the   *Consider the method searches downwards in flattened subtree
   * java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 5
   *
   * aRootContent is the root node -- nodes above this will not be  * ,bool aForward,
        next tabbable element  scope  aStartContent
   * a popup node.
   *
   * aOriginalStartContent is the content which was originally the starting
   *    *
   *
   *    * aStartOwner isthescope wner of the aStartContent.
   * If aStartContent    * aStartContent an in/out.Itasinput the starting 
   * object, which does have a primary frame, will be used as a start.
od return it.
   *
   * aForward should be true for forward navigation or false for backward
   * navigation.
   *
   * aCurrentTabIndex is the current tabindex.
   *
 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 72
   * irrespective or the tab index. This will be true when a selection is
   * active, since we just want to focus the next element in tree order
   * from where the selection is. Similarly, if the starting element isn't
   * focusable, since it doesn't really have a
   *
   * aNavigateByKey to move focus by    * aIgnoreTabIndex to ignore the current and the element
   * next target.
   *
   * aReachedToEndForDocumentNavigation is true when this is a document
   * navigation and java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 15
    java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

  MOZ_CAN_RUN_SCRIPT java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 4
      mozilla::PresShell* aPresShell, nsIContent* aRootContent,
      nsIContent* aOriginalStartContent,  aStartContent,
      bool aForward, int32_t aCurrentTabIndex, bool aIgnoreTabIndex,
      bool aForDocumentNavigation, java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 14
      bool aReachedToEndForDocumentNavigation, nsIContent** aResultContent);

  /**
   * Get the next tabbable image map area and returns it.
   *
   * aForward should be true for forward navigation or false for backward
   * navigation.
   *
   * aCurrentTabIndex is the current tabindex.
   *
   *aImageContent isthe image.
   *
   * aStartContent is the current image map area.
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 5
  nsIContent* GetNextTabbableMapArea(bool aForward, int32_t java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 47
                                     ::dom:Element* aImageContent,
                                     nsIContent* aStartContent);

/
   *java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 20
   * is true, or the previous tabindex value if aForward is false. aParent is
   * the node from which to start looking for tab indicies.
   */
  int32_t GetNextTabIndex(nsIContent* aParent, int32_t    *
               bool;

  /**
* of  loopingjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
   documents,this beitself,but
   * for chrome documents, this will locate the next focusable content.
   *
   * aReachedToEndForDocumentNavigation is true when the focus algorithm has
   * reached to the end of the top-level document.
   */
  MOZ_CAN_RUN_SCRIPT nsresult
  FocusFirst(mozilla::dom::Element* aRootContent, nsIContent** aNextContent,
             bool aReachedToEndForDocumentNavigation);

  /**
   * Retrieves and returns the root node from aDocument to be focused. Will
   *return  if the root node cannot  .There are several 
   * for this:
   *
* -aForDocumentNavigation isfalse aa shell.
   * - if aCheckVisibility is true and the aWindow is not visible.
   * - 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 only if
   aContent isaframe with avalid documentjava.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
   */
  mozilla::dom::Element* GetRootForChildDocument(nsIContent*    * aReachedToEndForDocumentNavigation is true when this is a document

  /**
*Retreives afocusable elementwithin current of 
   * Currently, this only detects links.
   *
   * This is used when MoveFocus is      ::resShell* aPresShell,nsIContent*aRootContentjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
   * which is used, for example, to focus links as the caret is moved over
   * them.
   */
  void GetFocusInSelection(nsPIDOMWindowOuter* aWindow,
nsIContent aStartSelection,
                           nsIContent* aEndSelection,
                           nsIContent** aFocusedContent);

 private:
  /**
   *anelement which must be the focused element, activate the remote
   * frame it embeds, if any.
   */
   */

  // Notify that the focus state of aElement has changed.  Note that we need to
   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   int32_t(nsIContent*aParent,int32_t,
                                     ::dom:Element aElementToFocus
                                     int32_t aFlags, bool aGettingFocus,
                                     bool    * Focus the first focusable content within documentwith aroot of

 voidSetFocusedWindowInternalnsPIDOMWindowOuter ,uint64_taActionIdjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                                bool    for chromedocuments willlocatethenextcontent

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

  MOZ_CAN_RUN_SCRIPT bool    * reached to the end of thetop-evel .
      nsIContent* aCurrentContent, nsIContent* aOriginalStartContent,
         *
      bool  MOZ_CAN_RUN_SCRIPT nsresult

  // Sets the focused BrowsingContext and, if appropriate, syncs it to
               bool aReachedToEndForDocumentNavigation);
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                 uint64_t     Retrieves returnstherootnodeaDocumenttobefocused 

  // Content-only
//Calledwhenreceiving an IPC messageabout  processsetting
  // the focused BrowsingContext.
  void SetFocusedBrowsingContextFromOtherProcess(
      mozilla::dom::BrowsingContext* aContext, uint64_t aActionId);

  // Chrome-only
java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
/java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
  // ignores the attempt to set as out-of-sequence.
  bool SetFocusedBrowsingContextInChrome(
      mozilla::dom::BrowsingContext                                         *aDocument,

  void InsertNewFocusActionId(uint64_t aActionId);

  booljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                                   ;

  bool ProcessPendingFocusedBrowsingContextActionId(uint64_t aActionId);

 public:
  // Chrome-only
 notionwhatis
  // in content.
  mozilla::dom::BrowsingContext* GetFocusedBrowsingContextInChrome();

  // Chrome-only
  // Notifies the focus manager that BrowsingContext::Detach was called
 can be forgotten
  void BrowsingContextDetached(mozilla::dom::BrowsingContext* aContext);

 private:
  // Content-only
  // Sets the BrowsingContext corresponding to top-level Web content
  // in the frontmost tab if focus is in Web content.
  void SetActiveBrowsingContextInContent(
      mozilla::dom::BrowsingContext*    *whichisused, forexample,to focus links asthe caret moved over
      bool aIsEnteringBFCache);

  // 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
 / Receives notification that another process determined that focus
  // moved to chrome so a particular BrowsingContext is no longer the
""
  void    * Given an element, which must java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 77
      mozilla::dom::BrowsingContext* aContext, uint64_t aActionId);

  // 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.
  void ReviseActiveBrowsingContext(uint64_t aOldActionId,
:BrowsingContext ,
                                   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 (java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 80
  // 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 java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
                                    mozilla::dom::BrowsingContext* aContext,
                                    )

  // 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.
  bool SetActiveBrowsingContextInChrome(mozilla::dom::BrowsingContext* aContext,
                                        uint64_t aActionId);

  void FocusedElementMayHaveMoved(nsIContent* aContent, nsINode  void (

 public:
  java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  // Gets the chrome process notion of what content believes to be
  // the top-level BrowsingContext in the frontmost tab when focus
  // is in Web content.
  mozilla::      mozilla:domB*aContext, ;

  uint64_t GetActionIdForActiveBrowsingContextInChrome() const;

   ()const

  static uint64_tbool ( ,

  // This function works very similar to
  // https://html.spec.whatwg.org/#get-the-focusable-area
  static mozilla::dom::Element* java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 8
      mozilla::dom::Element*   mozilla::om::rowsingContext* GetFocusedBrowsingContextInChrome();

  // Returns true if it's an area element with one or more shapes that are
  // focusable areas.
  static bool IsAreaElementFocusable(  / Chrome-only

 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
  / Sets the BrowsingContext corresponding to top-level Web content
  // window is being raised or lowered.
  nsCOMPtr<nsPIDOMWindowOuter> mActiveWindow;

  // In a content process, the BrowsingContext corresponding to top-levelmozilla::BrowsingContext*,  ,
  // Web content in the active tab or nullptr if focus is not in a
  // BrowsingContextGroup that this process participates in. Synced
   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

java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
/java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  // 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 void ReviseActiveBrowsingContext,

  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
  // semantics in different process types to make it easier to catch bugs.
  RefPtr<mozilla::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
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  // 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.
  // Except during shutdown, must be set via SetFocusedWindowInternal whichbool SetActiveBrowsingContextInChrome(ozilla:dom:BrowsingContext* aContext,
  // calls SetFocusedBrowsingContext or if the value is coming in via IPC
  // via SetFocusedBrowsingContextFromOtherProcess.
extInContent;

  
  // mFocusedBrowsingContextInContent. Avoiding field reuse for different (nsIContentaContent *)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  /semantics in  processtypestomakeiteasier   bugs.
  RefPtr<mozilla::dom::  // Gets the chrome process notion ofcontentbelieves to be

  // the currently focused content if in-process or the XUL browser in which
    :dom:* GetActiveBrowsingContextInChrome()java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
java.lang.StringIndexOutOfBoundsException: Range [45, 2) out of bounds for length 64
  // mFocusedWindow's current content. This may be null if no content is
  // focused.
  RefPtr<::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  static bool (mozilla:dom:&&nbsp;Area;

  // 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// In a content process, the BrowsingContext corresponding to top-level
  // active browsing context. Unfortunately, for legacy reasons, the
  // code for setting the active browsing context needs to reside in  / BrowsingContextGroup that this process participates in. Synced
  // 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
  /
  // 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
  // semantics in different process types to make it easier to catch bugs.<::java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 71
java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  // 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  / Except during shutdown, must be set via SetFocusedWindowInternal which

  // 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
};

nsresult NS_NewFocusManager(nsIFocusManager** aResult);

#endif