Remove a wrong assert and use Document directly, instead of documentElement()

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 64 matching lines @@
     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 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 104 matching lines @@
     // 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)
 {
     if (SlotScopedTraversal::isSlotScoped(root))
         return ScopedFocusNavigation(*SlotScopedTraversal::findScopeOwnerSlot(root), current);
-    return ScopedFocusNavigation(*&root.treeScope(), current);
+    return ScopedFocusNavigation(root.treeScope(), current);
+}
+
+ScopedFocusNavigation ScopedFocusNavigation::createScopedFocusNavigationForDocument(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));
     ASSERT(isHTMLSlotElement(element));
     return ScopedFocusNavigation::ownedByHTMLSlotElement(toHTMLSlotElement(element));
@@ skipping 623 matching lines @@
         start = toHTMLFrameOwnerElement(from->owner());
     }
 
     return advanceFocusInDocumentOrder(to, start, type, false, sourceCapabilities);
 }
 
 bool FocusController::advanceFocusInDocumentOrder(LocalFrame* frame, Element* start, WebFocusType type, bool initialFocus, InputDeviceCapabilities* sourceCapabilities)
 {
     ASSERT(frame);
     Document* document = frame->document();
-    ASSERT(document->documentElement());
     document->updateDistribution();
 
     Element* current = start;
     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 = ScopedFocusNavigation::createScopedFocusNavigation(current ? *current : *document->documentElement(), current);
+    ScopedFocusNavigation scope = current ? ScopedFocusNavigation::createScopedFocusNavigation(*current, current) : ScopedFocusNavigation::createScopedFocusNavigationForDocument(*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::createScopedFocusNavigation(*toLocalFrame(m_page->mainFrame())->document()->documentElement(), nullptr);
+        ScopedFocusNavigation scope = ScopedFocusNavigation::createScopedFocusNavigationForDocument(*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 351 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink