Refactor ScopedFocusNavigation

third_party/WebKit/Source/core/page/FocusController.cpp

 /*
  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nuanti Ltd.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 63 matching lines @@
 class ScopedFocusNavigation {
     STACK_ALLOCATED();
 public:
     Element* currentElement() const;
     void setCurrentElement(Element*);
     void moveToNext();
     void moveToPrevious();
     void moveToFirst();
     void moveToLast();
     Element* owner() const;
-    static ScopedFocusNavigation createScopedFocusNavigation(const Element& root, const Element* current);
-    static ScopedFocusNavigation createScopedFocusNavigationForDocument(Document&);
+    static ScopedFocusNavigation createFor(const Element&);
+    static ScopedFocusNavigation createForDocument(Document&);
     static ScopedFocusNavigation ownedByNonFocusableFocusScopeOwner(Element&);
     static ScopedFocusNavigation ownedByShadowHost(const Element&);
     static ScopedFocusNavigation ownedByShadowInsertionPoint(HTMLShadowElement&);
     static ScopedFocusNavigation ownedByHTMLSlotElement(const HTMLSlotElement&);
     static ScopedFocusNavigation ownedByIFrame(const HTMLFrameOwnerElement&);
 
 private:
     ScopedFocusNavigation(TreeScope&, const Element*);
     ScopedFocusNavigation(HTMLSlotElement&, const Element*);
     RawPtrWillBeMember<ContainerNode> m_rootNode;
@@ skipping 100 matching lines @@
     if (m_rootNode->isShadowRoot()) {
         ShadowRoot& shadowRoot = toShadowRoot(*m_rootNode);
         return shadowRoot.isYoungest() ? shadowRoot.host() : shadowRoot.shadowInsertionPointOfYoungerShadowRoot();
     }
     // FIXME: Figure out the right thing for OOPI here.
     if (Frame* frame = m_rootNode->document().frame())
         return frame->deprecatedLocalOwner();
     return nullptr;
 }
 
-ScopedFocusNavigation ScopedFocusNavigation::createScopedFocusNavigation(const Element& root, const Element* current)
+ScopedFocusNavigation ScopedFocusNavigation::createFor(const Element& current)
 {
-    if (SlotScopedTraversal::isSlotScoped(root))
-        return ScopedFocusNavigation(*SlotScopedTraversal::findScopeOwnerSlot(root), current);
-    return ScopedFocusNavigation(root.treeScope(), current);
+    if (SlotScopedTraversal::isSlotScoped(current))
+        return ScopedFocusNavigation(*SlotScopedTraversal::findScopeOwnerSlot(current), &current);
+    return ScopedFocusNavigation(current.treeScope(), &current);
 }
 
-ScopedFocusNavigation ScopedFocusNavigation::createScopedFocusNavigationForDocument(Document& document)
+ScopedFocusNavigation ScopedFocusNavigation::createForDocument(Document& document)
 {
     return ScopedFocusNavigation(document, nullptr);
 }
 
 ScopedFocusNavigation ScopedFocusNavigation::ownedByNonFocusableFocusScopeOwner(Element& element)
 {
     if (isShadowHost(element))
         return ScopedFocusNavigation::ownedByShadowHost(element);
     if (isShadowInsertionPointFocusScopeOwner(element))
         return ScopedFocusNavigation::ownedByShadowInsertionPoint(toHTMLShadowElement(element));
@@ skipping 378 matching lines @@
     } else {
         found = findFocusableElementRecursivelyForward(scope);
     }
 
     // If there's no focusable element to advance to, move up the focus scopes until we find one.
     ScopedFocusNavigation currentScope = scope;
     while (!found) {
         Element* owner = currentScope.owner();
         if (!owner)
             break;
-        currentScope = ScopedFocusNavigation::createScopedFocusNavigation(*owner, owner);
+        currentScope = ScopedFocusNavigation::createFor(*owner);
         found = findFocusableElementRecursivelyForward(currentScope);
     }
     return findFocusableElementDescendingDownIntoFrameDocument(WebFocusTypeForward, found);
 }
 
 Element* findFocusableElementAcrossFocusScopesBackward(ScopedFocusNavigation& scope)
 {
     ASSERT(!scope.currentElement() || !isNonFocusableShadowHost(*scope.currentElement()));
     Element* found = findFocusableElementRecursivelyBackward(scope);
 
     // If there's no focusable element to advance to, move up the focus scopes until we find one.
     ScopedFocusNavigation currentScope = scope;
     while (!found) {
         Element* owner = currentScope.owner();
         if (!owner)
             break;
-        currentScope = ScopedFocusNavigation::createScopedFocusNavigation(*owner, owner);
+        currentScope = ScopedFocusNavigation::createFor(*owner);
         if (isKeyboardFocusableShadowHost(*owner) && !isShadowHostDelegatesFocus(*owner)) {
             found = owner;
             break;
         }
         found = findFocusableElementRecursivelyBackward(currentScope);
     }
     return findFocusableElementDescendingDownIntoFrameDocument(WebFocusTypeBackward, found);
 }
 
 Element* findFocusableElementAcrossFocusScopes(WebFocusType type, ScopedFocusNavigation& scope)
@@ skipping 222 matching lines @@
     if (!current && !initialFocus)
         current = document->sequentialFocusNavigationStartingPoint(type);
 
     // FIXME: Not quite correct when it comes to focus transitions leaving/entering the WebView itself
     bool caretBrowsing = frame->settings() && frame->settings()->caretBrowsingEnabled();
 
     if (caretBrowsing && !current)
         current = adjustToElement(frame->selection().start().anchorNode(), type);
 
     document->updateLayoutIgnorePendingStylesheets();
-    ScopedFocusNavigation scope = current ? ScopedFocusNavigation::createScopedFocusNavigation(*current, current) : ScopedFocusNavigation::createScopedFocusNavigationForDocument(*document);
+    ScopedFocusNavigation scope = current ? ScopedFocusNavigation::createFor(*current) : ScopedFocusNavigation::createForDocument(*document);
     RefPtrWillBeRawPtr<Element> element = findFocusableElementAcrossFocusScopes(type, scope);
 
     if (!element) {
         // If there's a RemoteFrame on the ancestor chain, we need to continue
         // searching for focusable elements there.
         if (frame->localFrameRoot() != frame->tree().top()) {
             document->clearFocusedElement();
             document->setSequentialFocusNavigationStartingPoint(nullptr);
             toRemoteFrame(frame->localFrameRoot()->tree().parent())->advanceFocus(type, frame->localFrameRoot());
             return true;
         }
 
         // We didn't find an element to focus, so we should try to pass focus to Chrome.
         if (!initialFocus && m_page->chromeClient().canTakeFocus(type)) {
             document->clearFocusedElement();
             document->setSequentialFocusNavigationStartingPoint(nullptr);
             setFocusedFrame(nullptr);
             m_page->chromeClient().takeFocus(type);
             return true;
         }
 
         // Chrome doesn't want focus, so we should wrap focus.
-        ScopedFocusNavigation scope = ScopedFocusNavigation::createScopedFocusNavigationForDocument(*toLocalFrame(m_page->mainFrame())->document());
+        ScopedFocusNavigation scope = ScopedFocusNavigation::createForDocument(*toLocalFrame(m_page->mainFrame())->document());
         element = findFocusableElementRecursively(type, scope);
         element = findFocusableElementDescendingDownIntoFrameDocument(type, element.get());
 
         if (!element)
             return false;
     }
 
     ASSERT(element);
 
     if (element == document->focusedElement()) {
@@ skipping 40 matching lines @@
     }
 
     element->focus(FocusParams(SelectionBehaviorOnFocus::Reset, type, sourceCapabilities));
     return true;
 }
 
 Element* FocusController::findFocusableElement(WebFocusType type, Element& element)
 {
     // FIXME: No spacial navigation code yet.
     ASSERT(type == WebFocusTypeForward || type == WebFocusTypeBackward);
-    ScopedFocusNavigation scope = ScopedFocusNavigation::createScopedFocusNavigation(element, &element);
+    ScopedFocusNavigation scope = ScopedFocusNavigation::createFor(element);
     return findFocusableElementAcrossFocusScopes(type, scope);
 }
 
 Element* FocusController::findFocusableElementInShadowHost(const Element& shadowHost)
 {
     ASSERT(shadowHost.authorShadowRoot());
     ScopedFocusNavigation scope = ScopedFocusNavigation::ownedByShadowHost(shadowHost);
     return findFocusableElementAcrossFocusScopes(WebFocusTypeForward, scope);
 }
 
@@ skipping 290 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink