[Oilpan]: Move HTMLStackItem and friends to the oilpan heap.

Source/core/html/parser/HTMLFormattingElementList.cpp

 /*
  * Copyright (C) 2010 Google, Inc. All Rights Reserved.
  *
  * 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 61 matching lines @@
     return 0;
 }
 
 HTMLFormattingElementList::Bookmark HTMLFormattingElementList::bookmarkFor(Element* element)
 {
     size_t index = m_entries.reverseFind(element);
     ASSERT(index != kNotFound);
     return Bookmark(&at(index));
 }
 
-void HTMLFormattingElementList::swapTo(Element* oldElement, PassRefPtr<HTMLStackItem> newItem, const Bookmark& bookmark)
+void HTMLFormattingElementList::swapTo(Element* oldElement, PassRefPtrWillBeRawPtr<HTMLStackItem> newItem, const Bookmark& bookmark)
 {
     ASSERT(contains(oldElement));
     ASSERT(!contains(newItem->element()));
     if (!bookmark.hasBeenMoved()) {
         ASSERT(bookmark.mark()->element() == oldElement);
         bookmark.mark()->replaceElement(newItem);
         return;
     }
     size_t index = bookmark.mark() - first();
     ASSERT_WITH_SECURITY_IMPLICATION(index < size());
     m_entries.insert(index + 1, newItem);
     remove(oldElement);
 }
 
-void HTMLFormattingElementList::append(PassRefPtr<HTMLStackItem> item)
+void HTMLFormattingElementList::append(PassRefPtrWillBeRawPtr<HTMLStackItem> item)
 {
     ensureNoahsArkCondition(item.get());
     m_entries.append(item);
 }
 
 void HTMLFormattingElementList::remove(Element* element)
 {
     size_t index = m_entries.reverseFind(element);
     if (index != kNotFound)
         m_entries.remove(index);
 }
 
 void HTMLFormattingElementList::appendMarker()
 {
     m_entries.append(Entry::MarkerEntry);
 }
 
 void HTMLFormattingElementList::clearToLastMarker()
 {
     // http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#clear-the-list-of-active-formatting-elements-up-to-the-last-marker
     while (m_entries.size()) {
         bool shouldStop = m_entries.last().isMarker();
         m_entries.removeLast();
         if (shouldStop)
             break;
     }
 }
 
-void HTMLFormattingElementList::tryToEnsureNoahsArkConditionQuickly(HTMLStackItem* newItem, Vector<HTMLStackItem*>& remainingCandidates)
+void HTMLFormattingElementList::tryToEnsureNoahsArkConditionQuickly(HTMLStackItem* newItem, WillBeHeapVector<RawPtrWillBeMember<HTMLStackItem> >& remainingCandidates)
 {
     ASSERT(remainingCandidates.isEmpty());
 
     if (m_entries.size() < kNoahsArkCapacity)
         return;
 
     // Use a vector with inline capacity to avoid a malloc in the common case
     // of a quickly ensuring the condition.
-    Vector<HTMLStackItem*, 10> candidates;
+    WillBeHeapVector<RawPtrWillBeMember<HTMLStackItem>, 10> candidates;
 
     size_t newItemAttributeCount = newItem->attributes().size();
 
     for (size_t i = m_entries.size(); i; ) {
         --i;
         Entry& entry = m_entries[i];
         if (entry.isMarker())
             break;
 
         // Quickly reject obviously non-matching candidates.
         HTMLStackItem* candidate = entry.stackItem().get();
         if (newItem->localName() != candidate->localName() || newItem->namespaceURI() != candidate->namespaceURI())
             continue;
         if (candidate->attributes().size() != newItemAttributeCount)
             continue;
 
         candidates.append(candidate);
     }
 
     if (candidates.size() < kNoahsArkCapacity)
         return; // There's room for the new element in the ark. There's no need to copy out the remainingCandidates.
 
     remainingCandidates.appendVector(candidates);
 }
 
 void HTMLFormattingElementList::ensureNoahsArkCondition(HTMLStackItem* newItem)
 {
-    Vector<HTMLStackItem*> candidates;
+    WillBeHeapVector<RawPtrWillBeMember<HTMLStackItem> > candidates;
     tryToEnsureNoahsArkConditionQuickly(newItem, candidates);
     if (candidates.isEmpty())
         return;
 
     // We pre-allocate and re-use this second vector to save one malloc per
     // attribute that we verify.
-    Vector<HTMLStackItem*> remainingCandidates;
+    WillBeHeapVector<RawPtrWillBeMember<HTMLStackItem> > remainingCandidates;
     remainingCandidates.reserveInitialCapacity(candidates.size());
 
     const Vector<Attribute>& attributes = newItem->attributes();
     for (size_t i = 0; i < attributes.size(); ++i) {
         const Attribute& attribute = attributes[i];
 
         for (size_t j = 0; j < candidates.size(); ++j) {
             HTMLStackItem* candidate = candidates[j];
 
             // These properties should already have been checked by tryToEnsureNoahsArkConditionQuickly.
@@ skipping 28 matching lines @@
         if (entry.isMarker())
             fprintf(stderr, "marker\n");
         else
             entry.element()->showNode();
     }
 }
 
 #endif
 
 }