Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/html/HTMLTextFormControlElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 391 matching lines @@
     it.advance(index - 1);
     return createVisiblePosition(it.endPosition(), TextAffinity::Upstream);
 }
 
 int HTMLTextFormControlElement::indexForVisiblePosition(const VisiblePosition& pos) const
 {
     Position indexPosition = pos.deepEquivalent().parentAnchoredEquivalent();
     if (enclosingTextFormControl(indexPosition) != this)
         return 0;
     ASSERT(indexPosition.document());
-    RefPtrWillBeRawPtr<Range> range = Range::create(*indexPosition.document());
+    RawPtr<Range> range = Range::create(*indexPosition.document());
     range->setStart(innerEditorElement(), 0, ASSERT_NO_EXCEPTION);
     range->setEnd(indexPosition.computeContainerNode(), indexPosition.offsetInContainerNode(), ASSERT_NO_EXCEPTION);
     return TextIterator::rangeLength(range->startPosition(), range->endPosition());
 }
 
 int HTMLTextFormControlElement::selectionStart() const
 {
     if (!isTextFormControl())
         return 0;
     if (document().focusedElement() != this)
@@ skipping 75 matching lines @@
 {
     if (node->isTextNode()) {
         containerNode = node;
         offsetInContainer = offset;
     } else {
         containerNode = node->parentNode();
         offsetInContainer = node->nodeIndex() + offset;
     }
 }
 
-PassRefPtrWillBeRawPtr<Range> HTMLTextFormControlElement::selection() const
+RawPtr<Range> HTMLTextFormControlElement::selection() const
 {
     if (!layoutObject() || !isTextFormControl())
         return nullptr;
 
     int start = m_cachedSelectionStart;
     int end = m_cachedSelectionEnd;
 
     ASSERT(start <= end);
     HTMLElement* innerText = innerEditorElement();
     if (!innerText)
@@ skipping 68 matching lines @@
     cacheSelection(computeSelectionStart(), computeSelectionEnd(), computeSelectionDirection());
 
     if (LocalFrame* frame = document().frame()) {
         if (frame->selection().isRange() && userTriggered)
             dispatchEvent(Event::createBubble(EventTypeNames::select));
     }
 }
 
 void HTMLTextFormControlElement::scheduleSelectEvent()
 {
-    RefPtrWillBeRawPtr<Event> event = Event::createBubble(EventTypeNames::select);
+    RawPtr<Event> event = Event::createBubble(EventTypeNames::select);
     event->setTarget(this);
     document().enqueueUniqueAnimationFrameEvent(event.release());
 }
 
 void HTMLTextFormControlElement::parseAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& value)
 {
     if (name == autocapitalizeAttr)
         UseCounter::count(document(), UseCounter::AutocapitalizeAttribute);
 
     if (name == placeholderAttr) {
         updatePlaceholderText();
         updatePlaceholderVisibility();
         UseCounter::count(document(), UseCounter::PlaceholderAttribute);
     } else {
         HTMLFormControlElementWithState::parseAttribute(name, oldValue, value);
     }
 }
 
 bool HTMLTextFormControlElement::lastChangeWasUserEdit() const
 {
     if (!isTextFormControl())
         return false;
     return m_lastChangeWasUserEdit;
 }
 
-PassRefPtrWillBeRawPtr<Node> HTMLTextFormControlElement::createPlaceholderBreakElement() const
+RawPtr<Node> HTMLTextFormControlElement::createPlaceholderBreakElement() const
 {
     return HTMLBRElement::create(document());
 }
 
 void HTMLTextFormControlElement::addPlaceholderBreakElementIfNecessary()
 {
     HTMLElement* innerEditor = innerEditorElement();
     if (innerEditor->layoutObject() && !innerEditor->layoutObject()->style()->preserveNewline())
         return;
     Node* lastChild = innerEditor->lastChild();
@@ skipping 158 matching lines @@
 {
     return toHTMLElement(userAgentShadowRoot()->getElementById(ShadowElementNames::innerEditor()));
 }
 
 static Position innerNodePosition(const Position& innerPosition)
 {
     ASSERT(!innerPosition.isBeforeAnchor());
     ASSERT(!innerPosition.isAfterAnchor());
     HTMLElement* element = toHTMLElement(innerPosition.anchorNode());
     ASSERT(element);
-    RefPtrWillBeRawPtr<NodeList> childNodes = element->childNodes();
+    RawPtr<NodeList> childNodes = element->childNodes();
     if (!childNodes->length())
         return Position(element, 0);
 
     unsigned offset = 0;
 
     if (innerPosition.isOffsetInAnchor())
         offset = std::max(0, std::min(innerPosition.offsetInContainerNode(), static_cast<int>(childNodes->length())));
     else if (innerPosition.isAfterChildren())
         offset = childNodes->length();
 
     if (offset == childNodes->length())
         return Position(element->lastChild(), PositionAnchorType::AfterAnchor);
 
     Node* node = childNodes->item(offset);
     if (node->isTextNode())
         return Position(toText(node), 0);
 
     return Position(node, PositionAnchorType::BeforeAnchor);
 }
 
 enum FindOption {
     FindStart,
     FindEnd
 };
 
 static Position findWordBoundary(const HTMLElement* innerEditor, const Position& startPosition, const Position& endPosition, FindOption findOption)
 {
     StringBuilder concatTexts;
     Vector<unsigned> lengthList;
-    WillBeHeapVector<RawPtrWillBeMember<Text>> textList;
+    HeapVector<Member<Text>> textList;
 
     if (startPosition.anchorNode()->isTextNode())
         ASSERT(startPosition.isOffsetInAnchor());
     if (endPosition.anchorNode()->isTextNode())
         ASSERT(endPosition.isOffsetInAnchor());
 
     // Traverse text nodes.
     for (Node* node = startPosition.anchorNode(); node; node = NodeTraversal::next(*node, innerEditor)) {
         bool isStartNode = node == startPosition.anchorNode();
         bool isEndNode = node == endPosition.anchorNode();
@@ skipping 185 matching lines @@
 }
 
 void HTMLTextFormControlElement::copyNonAttributePropertiesFromElement(const Element& source)
 {
     const HTMLTextFormControlElement& sourceElement = static_cast<const HTMLTextFormControlElement&>(source);
     m_lastChangeWasUserEdit = sourceElement.m_lastChangeWasUserEdit;
     HTMLFormControlElement::copyNonAttributePropertiesFromElement(source);
 }
 
 } // namespace blink