Oilpan: Remove most WillBe types from the code base

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003-2008, 2011, 2012, 2014 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Samsung Electronics. All rights reserved.
  *
  * 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
  * version 2 of the License, or (at your option) any later version.
@@ skipping 151 matching lines @@
     return DoNotInvalidateOnAttributeChanges;
 }
 
 HTMLCollection::HTMLCollection(ContainerNode& ownerNode, CollectionType type, ItemAfterOverrideType itemAfterOverrideType)
     : LiveNodeListBase(ownerNode, rootTypeFromCollectionType(type), invalidationTypeExcludingIdAndNameAttributes(type), type)
     , m_overridesItemAfter(itemAfterOverrideType == OverridesItemAfter)
     , m_shouldOnlyIncludeDirectChildren(shouldTypeOnlyIncludeDirectChildren(type))
 {
 }
 
-PassRefPtrWillBeRawPtr<HTMLCollection> HTMLCollection::create(ContainerNode& base, CollectionType type)
+RawPtr<HTMLCollection> HTMLCollection::create(ContainerNode& base, CollectionType type)
 {
-    return adoptRefWillBeNoop(new HTMLCollection(base, type, DoesNotOverrideItemAfter));
+    return new HTMLCollection(base, type, DoesNotOverrideItemAfter);
 }
 
 HTMLCollection::~HTMLCollection()
 {
 #if !ENABLE(OILPAN)
     if (hasValidIdNameCache())
         unregisterIdNameCacheFromDocument(document());
     // Named HTMLCollection types remove cache by themselves.
     if (isUnnamedHTMLCollectionType(type()))
         ownerNode().nodeLists()->removeCache(this, type());
@@ skipping 98 matching lines @@
     IsMatch(const HTMLCollectionType& list)
         : m_list(&list)
     { }
 
     bool operator() (const Element& element) const
     {
         return m_list->elementMatches(element);
     }
 
 private:
-    RawPtrWillBeMember<const HTMLCollectionType> m_list;
+    Member<const HTMLCollectionType> m_list;
 };
 
 } // namespace
 
 template <class HTMLCollectionType>
 static inline IsMatch<HTMLCollectionType> makeIsMatch(const HTMLCollectionType& list) { return IsMatch<HTMLCollectionType>(list); }
 
 Element* HTMLCollection::virtualItemAfter(Element*) const
 {
     ASSERT_NOT_REACHED();
@@ skipping 88 matching lines @@
 Element* HTMLCollection::namedItem(const AtomicString& name) const
 {
     // http://msdn.microsoft.com/workshop/author/dhtml/reference/methods/nameditem.asp
     // This method first searches for an object with a matching id
     // attribute. If a match is not found, the method then searches for an
     // object with a matching name attribute, but only on those elements
     // that are allowed a name attribute.
     updateIdNameCache();
 
     const NamedItemCache& cache = namedItemCache();
-    WillBeHeapVector<RawPtrWillBeMember<Element>>* idResults = cache.getElementsById(name);
+    HeapVector<Member<Element>>* idResults = cache.getElementsById(name);
     if (idResults && !idResults->isEmpty())
         return idResults->first();
 
-    WillBeHeapVector<RawPtrWillBeMember<Element>>* nameResults = cache.getElementsByName(name);
+    HeapVector<Member<Element>>* nameResults = cache.getElementsByName(name);
     if (nameResults && !nameResults->isEmpty())
         return nameResults->first();
 
     return nullptr;
 }
 
 bool HTMLCollection::namedPropertyQuery(const AtomicString& name, ExceptionState&)
 {
     return namedItem(name);
 }
@@ skipping 32 matching lines @@
 void HTMLCollection::namedPropertyEnumerator(Vector<String>& names, ExceptionState&)
 {
     supportedPropertyNames(names);
 }
 
 void HTMLCollection::updateIdNameCache() const
 {
     if (hasValidIdNameCache())
         return;
 
-    OwnPtrWillBeRawPtr<NamedItemCache> cache = NamedItemCache::create();
+    RawPtr<NamedItemCache> cache = NamedItemCache::create();
     unsigned length = this->length();
     for (unsigned i = 0; i < length; ++i) {
         Element* element = item(i);
         const AtomicString& idAttrVal = element->getIdAttribute();
         if (!idAttrVal.isEmpty())
             cache->addElementWithId(idAttrVal, element);
         if (!element->isHTMLElement())
             continue;
         const AtomicString& nameAttrVal = element->getNameAttribute();
         if (!nameAttrVal.isEmpty() && idAttrVal != nameAttrVal && (type() != DocAll || nameShouldBeVisibleInDocumentAll(toHTMLElement(*element))))
             cache->addElementWithName(nameAttrVal, element);
     }
     // Set the named item cache last as traversing the tree may cause cache invalidation.
     setNamedItemCache(cache.release());
 }
 
-void HTMLCollection::namedItems(const AtomicString& name, WillBeHeapVector<RefPtrWillBeMember<Element>>& result) const
+void HTMLCollection::namedItems(const AtomicString& name, HeapVector<Member<Element>>& result) const
 {
     ASSERT(result.isEmpty());
     if (name.isEmpty())
         return;
 
     updateIdNameCache();
 
     const NamedItemCache& cache = namedItemCache();
-    if (WillBeHeapVector<RawPtrWillBeMember<Element>>* idResults = cache.getElementsById(name)) {
+    if (HeapVector<Member<Element>>* idResults = cache.getElementsById(name)) {
         for (unsigned i = 0; i < idResults->size(); ++i)
             result.append(idResults->at(i));
     }
-    if (WillBeHeapVector<RawPtrWillBeMember<Element>>* nameResults = cache.getElementsByName(name)) {
+    if (HeapVector<Member<Element>>* nameResults = cache.getElementsByName(name)) {
         for (unsigned i = 0; i < nameResults->size(); ++i)
             result.append(nameResults->at(i));
     }
 }
 
 HTMLCollection::NamedItemCache::NamedItemCache()
 {
 }
 
 DEFINE_TRACE(HTMLCollection)
 {
     visitor->trace(m_namedItemCache);
     visitor->trace(m_collectionItemsCache);
     LiveNodeListBase::trace(visitor);
 }
 
 } // namespace blink