Oilpan: Remove most WillBe types from the code base

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 74 matching lines @@
     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;
-    RawPtrWillBeMember<HTMLSlotElement> m_rootSlot;
-    RawPtrWillBeMember<Element> m_current;
+    Member<ContainerNode> m_rootNode;
+    Member<HTMLSlotElement> m_rootSlot;
+    Member<Element> m_current;
 };
 
 ScopedFocusNavigation::ScopedFocusNavigation(TreeScope& treeScope, const Element* current)
     : m_rootNode(treeScope.rootNode())
     , m_rootSlot(nullptr)
     , m_current(const_cast<Element*>(current))
 {
 }
 
 ScopedFocusNavigation::ScopedFocusNavigation(HTMLSlotElement& slot, const Element* current)
@@ skipping 34 matching lines @@
         m_current = ElementTraversal::previous(*m_current);
         while (m_current && SlotScopedTraversal::isSlotScoped(*m_current))
             m_current = ElementTraversal::previous(*m_current);
     }
 }
 
 void ScopedFocusNavigation::moveToFirst()
 {
     if (m_rootSlot) {
         if (!m_rootSlot->getAssignedNodes().isEmpty()) {
-            WillBeHeapVector<RefPtrWillBeMember<Node>> assignedNodes = m_rootSlot->getAssignedNodes();
+            HeapVector<Member<Node>> assignedNodes = m_rootSlot->getAssignedNodes();
             for (auto assignedNode : assignedNodes) {
                 if (assignedNode->isElementNode()) {
                     m_current = toElement(assignedNode);
                     break;
                 }
             }
         } else {
             m_current = nullptr;
         }
     } else {
         Element* first = m_rootNode->isElementNode() ? &toElement(*m_rootNode) : ElementTraversal::next(*m_rootNode);
         while (first && SlotScopedTraversal::isSlotScoped(*first))
             first = ElementTraversal::next(*first, m_rootNode);
         m_current = first;
     }
 }
 
 void ScopedFocusNavigation::moveToLast()
 {
     if (m_rootSlot) {
         if (!m_rootSlot->getAssignedNodes().isEmpty()) {
-            WillBeHeapVector<RefPtrWillBeMember<Node>> assignedNodes = m_rootSlot->getAssignedNodes();
+            HeapVector<Member<Node>> assignedNodes = m_rootSlot->getAssignedNodes();
             for (auto assignedNode = assignedNodes.rbegin(); assignedNode != assignedNodes.rend(); ++assignedNode) {
                 if ((*assignedNode)->isElementNode()) {
                     m_current = ElementTraversal::lastWithinOrSelf(*toElement(*assignedNode));
                     break;
                 }
             }
         } else {
             m_current = nullptr;
         }
     } else {
@@ skipping 95 matching lines @@
     if (document->focusedElement() && isHTMLPlugInElement(document->focusedElement()))
         toHTMLPlugInElement(document->focusedElement())->setPluginFocus(focused);
 
     // Do not fire events while modal dialogs are up.  See https://bugs.webkit.org/show_bug.cgi?id=33962
     if (Page* page = document->page()) {
         if (page->defersLoading())
             return;
     }
 
     if (!focused && document->focusedElement()) {
-        RefPtrWillBeRawPtr<Element> focusedElement(document->focusedElement());
+        RawPtr<Element> focusedElement(document->focusedElement());
         focusedElement->setFocus(false);
         dispatchBlurEvent(*document, *focusedElement);
     }
 
     if (LocalDOMWindow* window = document->domWindow())
         window->dispatchEvent(Event::create(focused ? EventTypeNames::focus : EventTypeNames::blur));
     if (focused && document->focusedElement()) {
-        RefPtrWillBeRawPtr<Element> focusedElement(document->focusedElement());
+        RawPtr<Element> focusedElement(document->focusedElement());
         focusedElement->setFocus(true);
         dispatchFocusEvent(*document, *focusedElement);
     }
 }
 
 inline bool hasCustomFocusLogic(const Element& element)
 {
     return element.isHTMLElement() && toHTMLElement(element).hasCustomFocusLogic();
 }
 
@@ skipping 352 matching lines @@
 } // anonymous namespace
 
 FocusController::FocusController(Page* page)
     : m_page(page)
     , m_isActive(false)
     , m_isFocused(false)
     , m_isChangingFocusedFrame(false)
 {
 }
 
-PassOwnPtrWillBeRawPtr<FocusController> FocusController::create(Page* page)
+RawPtr<FocusController> FocusController::create(Page* page)
 {
-    return adoptPtrWillBeNoop(new FocusController(page));
+    return new FocusController(page);
 }
 
-void FocusController::setFocusedFrame(PassRefPtrWillBeRawPtr<Frame> frame, bool notifyEmbedder)
+void FocusController::setFocusedFrame(RawPtr<Frame> frame, bool notifyEmbedder)
 {
     ASSERT(!frame || frame->page() == m_page);
     if (m_focusedFrame == frame || (m_isChangingFocusedFrame && frame))
         return;
 
     m_isChangingFocusedFrame = true;
 
-    RefPtrWillBeRawPtr<LocalFrame> oldFrame = (m_focusedFrame && m_focusedFrame->isLocalFrame()) ? toLocalFrame(m_focusedFrame.get()) : nullptr;
+    RawPtr<LocalFrame> oldFrame = (m_focusedFrame && m_focusedFrame->isLocalFrame()) ? toLocalFrame(m_focusedFrame.get()) : nullptr;
 
-    RefPtrWillBeRawPtr<LocalFrame> newFrame = (frame && frame->isLocalFrame()) ? toLocalFrame(frame.get()) : nullptr;
+    RawPtr<LocalFrame> newFrame = (frame && frame->isLocalFrame()) ? toLocalFrame(frame.get()) : nullptr;
 
     m_focusedFrame = frame.get();
 
     // Now that the frame is updated, fire events and update the selection focused states of both frames.
     if (oldFrame && oldFrame->view()) {
         oldFrame->selection().setFocused(false);
         oldFrame->domWindow()->dispatchEvent(Event::create(EventTypeNames::blur));
     }
 
     if (newFrame && newFrame->view() && isFocused()) {
         newFrame->selection().setFocused(true);
         newFrame->domWindow()->dispatchEvent(Event::create(EventTypeNames::focus));
     }
 
     m_isChangingFocusedFrame = false;
 
     // Checking client() is necessary, as the frame might have been detached as
     // part of dispatching the focus event above. See https://crbug.com/570874.
     if (m_focusedFrame && m_focusedFrame->client() && notifyEmbedder)
         m_focusedFrame->client()->frameFocused();
 }
 
-void FocusController::focusDocumentView(PassRefPtrWillBeRawPtr<Frame> frame, bool notifyEmbedder)
+void FocusController::focusDocumentView(RawPtr<Frame> frame, bool notifyEmbedder)
 {
     ASSERT(!frame || frame->page() == m_page);
     if (m_focusedFrame == frame)
         return;
 
-    RefPtrWillBeRawPtr<LocalFrame> focusedFrame = (m_focusedFrame && m_focusedFrame->isLocalFrame()) ? toLocalFrame(m_focusedFrame.get()) : nullptr;
+    RawPtr<LocalFrame> focusedFrame = (m_focusedFrame && m_focusedFrame->isLocalFrame()) ? toLocalFrame(m_focusedFrame.get()) : nullptr;
     if (focusedFrame && focusedFrame->view()) {
-        RefPtrWillBeRawPtr<Document> document = focusedFrame->document();
+        RawPtr<Document> document = focusedFrame->document();
         Element* focusedElement = document ? document->focusedElement() : nullptr;
         if (focusedElement)
             dispatchBlurEvent(*document, *focusedElement);
     }
 
-    RefPtrWillBeRawPtr<LocalFrame> newFocusedFrame = (frame && frame->isLocalFrame()) ? toLocalFrame(frame.get()) : nullptr;
+    RawPtr<LocalFrame> newFocusedFrame = (frame && frame->isLocalFrame()) ? toLocalFrame(frame.get()) : nullptr;
     if (newFocusedFrame && newFocusedFrame->view()) {
-        RefPtrWillBeRawPtr<Document> document = newFocusedFrame->document();
+        RawPtr<Document> document = newFocusedFrame->document();
         Element* focusedElement = document ? document->focusedElement() : nullptr;
         if (focusedElement)
             dispatchFocusEvent(*document, *focusedElement);
     }
 
     setFocusedFrame(frame, notifyEmbedder);
 }
 
 LocalFrame* FocusController::focusedFrame() const
 {
@@ skipping 127 matching lines @@
         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::createFor(*current) : ScopedFocusNavigation::createForDocument(*document);
-    RefPtrWillBeRawPtr<Element> element = findFocusableElementAcrossFocusScopes(type, scope);
+    RawPtr<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;
         }
@@ skipping 108 matching lines @@
 
     if (!enclosingTextFormControl(selectionStartNode))
         return;
 
     if (selectionStartNode->isInShadowTree() && selectionStartNode->shadowHost() == newFocusedElement)
         return;
 
     selection.clear();
 }
 
-bool FocusController::setFocusedElement(Element* element, PassRefPtrWillBeRawPtr<Frame> newFocusedFrame)
+bool FocusController::setFocusedElement(Element* element, RawPtr<Frame> newFocusedFrame)
 {
     return setFocusedElement(element, newFocusedFrame, FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeNone, nullptr));
 }
 
-bool FocusController::setFocusedElement(Element* element, PassRefPtrWillBeRawPtr<Frame> newFocusedFrame, const FocusParams& params)
+bool FocusController::setFocusedElement(Element* element, RawPtr<Frame> newFocusedFrame, const FocusParams& params)
 {
-    RefPtrWillBeRawPtr<LocalFrame> oldFocusedFrame = focusedFrame();
-    RefPtrWillBeRawPtr<Document> oldDocument = oldFocusedFrame ? oldFocusedFrame->document() : nullptr;
+    RawPtr<LocalFrame> oldFocusedFrame = focusedFrame();
+    RawPtr<Document> oldDocument = oldFocusedFrame ? oldFocusedFrame->document() : nullptr;
 
     Element* oldFocusedElement = oldDocument ? oldDocument->focusedElement() : nullptr;
     if (element && oldFocusedElement == element)
         return true;
 
     // FIXME: Might want to disable this check for caretBrowsing
     if (oldFocusedElement && oldFocusedElement->isRootEditableElement() && !relinquishesEditingFocus(*oldFocusedElement))
         return false;
 
     m_page->chromeClient().willSetInputMethodState();
 
-    RefPtrWillBeRawPtr<Document> newDocument = nullptr;
+    RawPtr<Document> newDocument = nullptr;
     if (element)
         newDocument = &element->document();
     else if (newFocusedFrame && newFocusedFrame->isLocalFrame())
         newDocument = toLocalFrame(newFocusedFrame.get())->document();
 
     if (newDocument && oldDocument == newDocument && newDocument->focusedElement() == element)
         return true;
 
     if (newFocusedFrame && newFocusedFrame->isLocalFrame())
         clearSelectionIfNeeded(oldFocusedFrame.get(), toLocalFrame(newFocusedFrame.get()), element);
 
     if (oldDocument && oldDocument != newDocument)
         oldDocument->clearFocusedElement();
 
     if (newFocusedFrame && !newFocusedFrame->page()) {
         setFocusedFrame(nullptr);
         return false;
     }
     setFocusedFrame(newFocusedFrame);
 
     // Setting the focused element can result in losing our last reft to element when JS event handlers fire.
-    RefPtrWillBeRawPtr<Element> protect = element;
+    RawPtr<Element> protect = element;
     ALLOW_UNUSED_LOCAL(protect);
     if (newDocument) {
         bool successfullyFocused = newDocument->setFocusedElement(element, params);
         if (!successfullyFocused)
             return false;
     }
 
     return true;
 }
 
@@ skipping 202 matching lines @@
     return consumed;
 }
 
 DEFINE_TRACE(FocusController)
 {
     visitor->trace(m_page);
     visitor->trace(m_focusedFrame);
 }
 
 } // namespace blink