Oilpan: Remove WillBe types (part 7)

third_party/WebKit/Source/core/frame/FrameSerializer.cpp

 /*
  * Copyright (C) 2011 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 65 matching lines @@
     if (isHTMLScriptElement(element))
         return true;
     if (isHTMLNoScriptElement(element))
         return true;
     return isHTMLMetaElement(element) && toHTMLMetaElement(element).computeEncoding().isValid();
 }
 
 class SerializerMarkupAccumulator : public MarkupAccumulator {
     STACK_ALLOCATED();
 public:
-    SerializerMarkupAccumulator(FrameSerializer::Delegate&, const Document&, WillBeHeapVector<RawPtrWillBeMember<Node>>&);
+    SerializerMarkupAccumulator(FrameSerializer::Delegate&, const Document&, HeapVector<Member<Node>>&);
     ~SerializerMarkupAccumulator() override;
 
 protected:
     void appendText(StringBuilder& out, Text&) override;
     bool shouldIgnoreAttribute(const Attribute&) override;
     void appendElement(StringBuilder& out, Element&, Namespaces*) override;
     void appendAttribute(StringBuilder& out, const Element&, const Attribute&, Namespaces*) override;
     void appendStartTag(Node&, Namespaces* = nullptr) override;
     void appendEndTag(const Element&) override;
 
 private:
     void appendAttributeValue(StringBuilder& out, const String& attributeValue);
     void appendRewrittenAttribute(
         StringBuilder& out,
         const Element&,
         const String& attributeName,
         const String& attributeValue);
 
     FrameSerializer::Delegate& m_delegate;
-    RawPtrWillBeMember<const Document> m_document;
+    Member<const Document> m_document;
 
     // FIXME: |FrameSerializer| uses |m_nodes| for collecting nodes in document
     // included into serialized text then extracts image, object, etc. The size
     // of this vector isn't small for large document. It is better to use
     // callback like functionality.
-    WillBeHeapVector<RawPtrWillBeMember<Node>>& m_nodes;
+    HeapVector<Member<Node>>& m_nodes;
 
     // Elements with links rewritten via appendAttribute method.
-    WillBeHeapHashSet<RawPtrWillBeMember<const Element>> m_elementsWithRewrittenLinks;
+    HeapHashSet<Member<const Element>> m_elementsWithRewrittenLinks;
 };
 
-SerializerMarkupAccumulator::SerializerMarkupAccumulator(FrameSerializer::Delegate& delegate, const Document& document, WillBeHeapVector<RawPtrWillBeMember<Node>>& nodes)
+SerializerMarkupAccumulator::SerializerMarkupAccumulator(FrameSerializer::Delegate& delegate, const Document& document, HeapVector<Member<Node>>& nodes)
     : MarkupAccumulator(ResolveAllURLs)
     , m_delegate(delegate)
     , m_document(&document)
     , m_nodes(nodes)
 {
 }
 
 SerializerMarkupAccumulator::~SerializerMarkupAccumulator()
 {
 }
@@ skipping 124 matching lines @@
     Document& document = *frame.document();
     KURL url = document.url();
 
     // If frame is an image document, add the image and don't continue
     if (document.isImageDocument()) {
         ImageDocument& imageDocument = toImageDocument(document);
         addImageToResources(imageDocument.cachedImage(), url);
         return;
     }
 
-    WillBeHeapVector<RawPtrWillBeMember<Node>> serializedNodes;
+    HeapVector<Member<Node>> serializedNodes;
     SerializerMarkupAccumulator accumulator(m_delegate, document, serializedNodes);
     String text = serializeNodes<EditingStrategy>(accumulator, document, IncludeNode);
 
     CString frameHTML = document.encoding().encode(text, WTF::EntitiesForUnencodables);
     m_resources->append(SerializedResource(url, document.suggestedMIMEType(), SharedBuffer::create(frameHTML.data(), frameHTML.length())));
 
     for (Node* node: serializedNodes) {
         ASSERT(node);
         if (!node->isElementNode())
             continue;
@@ skipping 149 matching lines @@
 void FrameSerializer::retrieveResourcesForProperties(const StylePropertySet* styleDeclaration, Document& document)
 {
     if (!styleDeclaration)
         return;
 
     // The background-image and list-style-image (for ul or ol) are the CSS properties
     // that make use of images. We iterate to make sure we include any other
     // image properties there might be.
     unsigned propertyCount = styleDeclaration->propertyCount();
     for (unsigned i = 0; i < propertyCount; ++i) {
-        RefPtrWillBeRawPtr<CSSValue> cssValue = styleDeclaration->propertyAt(i).value();
+        RawPtr<CSSValue> cssValue = styleDeclaration->propertyAt(i).value();
         retrieveResourcesForCSSValue(cssValue.get(), document);
     }
 }
 
 void FrameSerializer::retrieveResourcesForCSSValue(CSSValue* cssValue, Document& document)
 {
     if (cssValue->isImageValue()) {
         CSSImageValue* imageValue = toCSSImageValue(cssValue);
         if (imageValue->isCachePending())
             return;
@@ skipping 32 matching lines @@
             continue;
         }
         emitsMinus = ch == '-';
         builder.append(ch);
     }
     CString escapedUrl = builder.toString().ascii();
     return String::format("saved from url=(%04d)%s", static_cast<int>(escapedUrl.length()), escapedUrl.data());
 }
 
 } // namespace blink