Oilpan: Remove most WillBe types from the code base

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

 /*
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  * 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, 2009, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
@@ skipping 80 matching lines @@
     , m_activeSelectionState(false)
     , m_shouldRecalcListItems(false)
     , m_suggestedIndex(-1)
     , m_isAutofilledByPreview(false)
     , m_indexToSelectOnCancel(-1)
     , m_popupIsVisible(false)
 {
     setHasCustomStyleCallbacks();
 }
 
-PassRefPtrWillBeRawPtr<HTMLSelectElement> HTMLSelectElement::create(Document& document)
+RawPtr<HTMLSelectElement> HTMLSelectElement::create(Document& document)
 {
-    RefPtrWillBeRawPtr<HTMLSelectElement> select = adoptRefWillBeNoop(new HTMLSelectElement(document, 0));
+    RawPtr<HTMLSelectElement> select = (new HTMLSelectElement(document, 0));
     select->ensureUserAgentShadowRoot();
     return select.release();
 }
 
-PassRefPtrWillBeRawPtr<HTMLSelectElement> HTMLSelectElement::create(Document& document, HTMLFormElement* form)
+RawPtr<HTMLSelectElement> HTMLSelectElement::create(Document& document, HTMLFormElement* form)
 {
-    RefPtrWillBeRawPtr<HTMLSelectElement> select = adoptRefWillBeNoop(new HTMLSelectElement(document, form));
+    RawPtr<HTMLSelectElement> select = (new HTMLSelectElement(document, form));
     select->ensureUserAgentShadowRoot();
     return select.release();
 }
 
 HTMLSelectElement::~HTMLSelectElement()
 {
 }
 
 const AtomicString& HTMLSelectElement::formControlType() const
 {
@@ skipping 102 matching lines @@
 
 int HTMLSelectElement::activeSelectionEndListIndex() const
 {
     if (m_activeSelectionEndIndex >= 0)
         return m_activeSelectionEndIndex;
     return lastSelectedListIndex();
 }
 
 void HTMLSelectElement::add(const HTMLOptionElementOrHTMLOptGroupElement& element, const HTMLElementOrLong& before, ExceptionState& exceptionState)
 {
-    RefPtrWillBeRawPtr<HTMLElement> elementToInsert;
+    RawPtr<HTMLElement> elementToInsert;
     ASSERT(!element.isNull());
     if (element.isHTMLOptionElement())
         elementToInsert = element.getAsHTMLOptionElement();
     else
         elementToInsert = element.getAsHTMLOptGroupElement();
 
-    RefPtrWillBeRawPtr<HTMLElement> beforeElement;
+    RawPtr<HTMLElement> beforeElement;
     if (before.isHTMLElement())
         beforeElement = before.getAsHTMLElement();
     else if (before.isLong())
         beforeElement = options()->item(before.getAsLong());
     else
         beforeElement = nullptr;
 
     insertBefore(elementToInsert, beforeElement.get(), exceptionState);
     setNeedsValidityCheck();
 }
@@ skipping 143 matching lines @@
     return !usesMenuList();
 }
 
 LayoutObject* HTMLSelectElement::createLayoutObject(const ComputedStyle&)
 {
     if (usesMenuList())
         return new LayoutMenuList(this);
     return new LayoutListBox(this);
 }
 
-PassRefPtrWillBeRawPtr<HTMLCollection> HTMLSelectElement::selectedOptions()
+RawPtr<HTMLCollection> HTMLSelectElement::selectedOptions()
 {
     updateListItemSelectedStates();
     return ensureCachedCollection<HTMLCollection>(SelectedOptions);
 }
 
-PassRefPtrWillBeRawPtr<HTMLOptionsCollection> HTMLSelectElement::options()
+RawPtr<HTMLOptionsCollection> HTMLSelectElement::options()
 {
     return ensureCachedCollection<HTMLOptionsCollection>(SelectOptions);
 }
 
 void HTMLSelectElement::updateListItemSelectedStates()
 {
     if (!m_shouldRecalcListItems)
         return;
     recalcListItems();
     setNeedsValidityCheck();
@@ skipping 92 matching lines @@
     if (diff < 0) { // Add dummy elements.
         do {
             appendChild(document().createElement(optionTag, false), exceptionState);
             if (exceptionState.hadException())
                 break;
         } while (++diff);
     } else {
         // Removing children fires mutation events, which might mutate the DOM
         // further, so we first copy out a list of elements that we intend to
         // remove then attempt to remove them one at a time.
-        WillBeHeapVector<RefPtrWillBeMember<Element>> itemsToRemove;
+        HeapVector<Member<Element>> itemsToRemove;
         size_t optionIndex = 0;
         for (auto& item : listItems()) {
             if (isHTMLOptionElement(item) && optionIndex++ >= newLen) {
                 ASSERT(item->parentNode());
                 itemsToRemove.append(item.get());
             }
         }
 
         for (auto& item : itemsToRemove) {
             if (item->parentNode())
@@ skipping 189 matching lines @@
     bool fireOnChange = false;
     for (unsigned i = 0; i < items.size(); ++i) {
         HTMLElement* element = items[i];
         bool selected = isHTMLOptionElement(*element) && toHTMLOptionElement(element)->selected();
         if (selected != m_lastOnChangeSelection[i])
             fireOnChange = true;
         m_lastOnChangeSelection[i] = selected;
     }
 
     if (fireOnChange) {
-        RefPtrWillBeRawPtr<HTMLSelectElement> protector(this);
+        RawPtr<HTMLSelectElement> protector(this);
         dispatchInputEvent();
         dispatchFormControlChangeEvent();
     }
 }
 
 void HTMLSelectElement::dispatchInputAndChangeEventForMenuList()
 {
     ASSERT(usesMenuList());
 
     HTMLOptionElement* selectedOption = this->selectedOption();
     if (m_lastOnChangeOption.get() != selectedOption) {
         m_lastOnChangeOption = selectedOption;
-        RefPtrWillBeRawPtr<HTMLSelectElement> protector(this);
+        RawPtr<HTMLSelectElement> protector(this);
         dispatchInputEvent();
         dispatchFormControlChangeEvent();
     }
 }
 
 void HTMLSelectElement::scrollToSelection()
 {
     if (!isFinishedParsingChildren())
         return;
     if (usesMenuList())
@@ skipping 10 matching lines @@
             toLayoutMenuList(layoutObject)->setOptionsChanged(true);
     }
 }
 
 const HTMLSelectElement::ListItems& HTMLSelectElement::listItems() const
 {
     if (m_shouldRecalcListItems) {
         recalcListItems();
     } else {
 #if ENABLE(ASSERT)
-        WillBeHeapVector<RawPtrWillBeMember<HTMLElement>> items = m_listItems;
+        HeapVector<Member<HTMLElement>> items = m_listItems;
         recalcListItems(false);
         ASSERT(items == m_listItems);
 #endif
     }
 
     return m_listItems;
 }
 
 void HTMLSelectElement::invalidateSelectedItems()
 {
@@ skipping 150 matching lines @@
     // unnecessary. The specified listIndex must point an HTMLOptionElement, but
     // our code about activeSelection{Anchor,End}Index is not reliable.
     if (!isHTMLOptionElement(*items[listIndex]))
         return;
     bool hasPendingTask = m_optionToScrollTo;
     // We'd like to keep an HTMLOptionElement reference rather than |listIndex|
     // because the task should work even if unselected option is inserted before
     // |listIndex| before executing scrollToIndexTask().
     m_optionToScrollTo = toHTMLOptionElement(items[listIndex]);
     if (!hasPendingTask)
-        document().postTask(BLINK_FROM_HERE, createSameThreadTask(&HTMLSelectElement::scrollToIndexTask, PassRefPtrWillBeRawPtr<HTMLSelectElement>(this)));
+        document().postTask(BLINK_FROM_HERE, createSameThreadTask(&HTMLSelectElement::scrollToIndexTask, RawPtr<HTMLSelectElement>(this)));
 }
 
 void HTMLSelectElement::scrollToIndexTask()
 {
-    RefPtrWillBeRawPtr<HTMLOptionElement> option = m_optionToScrollTo.release();
+    RawPtr<HTMLOptionElement> option = m_optionToScrollTo.release();
     if (!option || !inDocument())
         return;
     // optionRemoved() makes sure m_optionToScrollTo doesn't have an option with
     // another owner.
     ASSERT(option->ownerSelectElement() == this);
     document().updateLayoutIgnorePendingStylesheets();
     if (!layoutObject() || !layoutObject()->isListBox())
         return;
     LayoutRect bounds = option->boundingBox();
     toLayoutListBox(layoutObject())->scrollToRect(bounds);
@@ skipping 835 matching lines @@
 {
     HTMLFormControlElementWithState::finishParsingChildren();
     updateListItemSelectedStates();
     if (usesMenuList())
         return;
     scrollToIndex(optionToListIndex(selectedIndex()));
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->listboxActiveIndexChanged(this);
 }
 
-bool HTMLSelectElement::anonymousIndexedSetter(unsigned index, PassRefPtrWillBeRawPtr<HTMLOptionElement> value, ExceptionState& exceptionState)
+bool HTMLSelectElement::anonymousIndexedSetter(unsigned index, RawPtr<HTMLOptionElement> value, ExceptionState& exceptionState)
 {
     if (!value) { // undefined or null
         remove(index);
         return true;
     }
     setOption(index, value.get(), exceptionState);
     return true;
 }
 
 bool HTMLSelectElement::isInteractiveContent() const
@@ skipping 27 matching lines @@
     // recalcListItems will update the selected state of the <option> elements
     // in this <select> so we need to do it before we recalc their style so they
     // match the right selectors (ex. :checked).
     // TODO(esprehn): Find a way to avoid needing a willRecalcStyle callback.
     if (m_shouldRecalcListItems)
         recalcListItems();
 }
 
 void HTMLSelectElement::didAddUserAgentShadowRoot(ShadowRoot& root)
 {
-    RefPtrWillBeRawPtr<HTMLContentElement> content = HTMLContentElement::create(document());
+    RawPtr<HTMLContentElement> content = HTMLContentElement::create(document());
     content->setAttribute(selectAttr, "option,optgroup,hr");
     root.appendChild(content);
 }
 
 HTMLOptionElement* HTMLSelectElement::spatialNavigationFocusedOption()
 {
     if (!isSpatialNavigationEnabled(document().frame()))
         return nullptr;
     int focusedIndex = activeSelectionEndListIndex();
     if (focusedIndex < 0)
@@ skipping 142 matching lines @@
     m_popupIsVisible = false;
     m_popup = nullptr;
 }
 
 void HTMLSelectElement::resetTypeAheadSessionForTesting()
 {
     m_typeAhead.resetSession();
 }
 
 } // namespace blink