Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/platform/mhtml/MHTMLParser.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 26 matching lines @@
 #include "wtf/RefCounted.h"
 #include "wtf/text/Base64.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/StringConcatenate.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 // This class is a limited MIME parser used to parse the MIME headers of MHTML files.
-class MIMEHeader : public RefCountedWillBeGarbageCollectedFinalized<MIMEHeader> {
+class MIMEHeader : public GarbageCollectedFinalized<MIMEHeader> {
 public:
-    static PassRefPtrWillBeRawPtr<MIMEHeader> create()
+    static RawPtr<MIMEHeader> create()
     {
-        return adoptRefWillBeNoop(new MIMEHeader());
+        return (new MIMEHeader());
     }
 
     enum Encoding {
         QuotedPrintable,
         Base64,
         EightBit,
         SevenBit,
         Binary,
         Unknown
     };
 
-    static PassRefPtrWillBeRawPtr<MIMEHeader> parseHeader(SharedBufferChunkReader* crLFLineReader);
+    static RawPtr<MIMEHeader> parseHeader(SharedBufferChunkReader* crLFLineReader);
 
     bool isMultipart() const { return m_contentType.startsWith("multipart/", TextCaseInsensitive); }
 
     String contentType() const { return m_contentType; }
     String charset() const { return m_charset; }
     Encoding contentTransferEncoding() const { return m_contentTransferEncoding; }
     String contentLocation() const { return m_contentLocation; }
     String contentID() const { return m_contentID; }
 
     // Multi-part type and boundaries are only valid for multipart MIME headers.
@@ skipping 49 matching lines @@
         }
         key = line.substring(0, semiColonIndex).lower().stripWhiteSpace();
         value.append(line.substring(semiColonIndex + 1));
     }
     // Store the last property if there is one.
     if (!key.isEmpty())
         keyValuePairs.set(key, value.toString().stripWhiteSpace());
     return keyValuePairs;
 }
 
-PassRefPtrWillBeRawPtr<MIMEHeader> MIMEHeader::parseHeader(SharedBufferChunkReader* buffer)
+RawPtr<MIMEHeader> MIMEHeader::parseHeader(SharedBufferChunkReader* buffer)
 {
-    RefPtrWillBeRawPtr<MIMEHeader> mimeHeader = MIMEHeader::create();
+    RawPtr<MIMEHeader> mimeHeader = MIMEHeader::create();
     KeyValueMap keyValuePairs = retrieveKeyValuePairs(buffer);
     KeyValueMap::iterator mimeParametersIterator = keyValuePairs.find("content-type");
     if (mimeParametersIterator != keyValuePairs.end()) {
         ParsedContentType parsedContentType(mimeParametersIterator->value);
         mimeHeader->m_contentType = parsedContentType.mimeType();
         if (!mimeHeader->isMultipart()) {
             mimeHeader->m_charset = parsedContentType.charset().stripWhiteSpace();
         } else {
             mimeHeader->m_multipartType = parsedContentType.parameterValueForName("type");
             mimeHeader->m_endOfPartBoundary = parsedContentType.parameterValueForName("boundary");
@@ skipping 53 matching lines @@
             return true;
     }
     return false;
 }
 
 MHTMLParser::MHTMLParser(SharedBuffer* data)
     : m_lineReader(data, "\r\n")
 {
 }
 
-WillBeHeapVector<RefPtrWillBeMember<ArchiveResource>> MHTMLParser::parseArchive()
+HeapVector<Member<ArchiveResource>> MHTMLParser::parseArchive()
 {
-    RefPtrWillBeRawPtr<MIMEHeader> header = MIMEHeader::parseHeader(&m_lineReader);
-    WillBeHeapVector<RefPtrWillBeMember<ArchiveResource>> resources;
+    RawPtr<MIMEHeader> header = MIMEHeader::parseHeader(&m_lineReader);
+    HeapVector<Member<ArchiveResource>> resources;
     if (!parseArchiveWithHeader(header.get(), resources))
         resources.clear();
     return resources;
 }
 
-bool MHTMLParser::parseArchiveWithHeader(MIMEHeader* header, WillBeHeapVector<RefPtrWillBeMember<ArchiveResource>>& resources)
+bool MHTMLParser::parseArchiveWithHeader(MIMEHeader* header, HeapVector<Member<ArchiveResource>>& resources)
 {
     if (!header) {
         WTF_LOG_ERROR("Failed to parse MHTML part: no header.");
         return false;
     }
 
     if (!header->isMultipart()) {
         // With IE a page with no resource is not multi-part.
         bool endOfArchiveReached = false;
-        RefPtrWillBeRawPtr<ArchiveResource> resource = parseNextPart(*header, String(), String(), endOfArchiveReached);
+        RawPtr<ArchiveResource> resource = parseNextPart(*header, String(), String(), endOfArchiveReached);
         if (!resource)
             return false;
         resources.append(resource);
         return true;
     }
 
     // Skip the message content (it's a generic browser specific message).
     skipLinesUntilBoundaryFound(m_lineReader, header->endOfPartBoundary());
 
     bool endOfArchive = false;
     while (!endOfArchive) {
-        RefPtrWillBeRawPtr<MIMEHeader> resourceHeader = MIMEHeader::parseHeader(&m_lineReader);
+        RawPtr<MIMEHeader> resourceHeader = MIMEHeader::parseHeader(&m_lineReader);
         if (!resourceHeader) {
             WTF_LOG_ERROR("Failed to parse MHTML, invalid MIME header.");
             return false;
         }
         if (resourceHeader->contentType() == "multipart/alternative") {
             // Ignore IE nesting which makes little sense (IE seems to nest only some of the frames).
             if (!parseArchiveWithHeader(resourceHeader.get(), resources)) {
                 WTF_LOG_ERROR("Failed to parse MHTML subframe.");
                 return false;
             }
             bool endOfPartReached = skipLinesUntilBoundaryFound(m_lineReader, header->endOfPartBoundary());
             ASSERT_UNUSED(endOfPartReached, endOfPartReached);
             continue;
         }
 
-        RefPtrWillBeRawPtr<ArchiveResource> resource = parseNextPart(*resourceHeader, header->endOfPartBoundary(), header->endOfDocumentBoundary(), endOfArchive);
+        RawPtr<ArchiveResource> resource = parseNextPart(*resourceHeader, header->endOfPartBoundary(), header->endOfDocumentBoundary(), endOfArchive);
         if (!resource) {
             WTF_LOG_ERROR("Failed to parse MHTML part.");
             return false;
         }
         resources.append(resource);
     }
     return true;
 }
 
 
-PassRefPtrWillBeRawPtr<ArchiveResource> MHTMLParser::parseNextPart(const MIMEHeader& mimeHeader, const String& endOfPartBoundary, const String& endOfDocumentBoundary, bool& endOfArchiveReached)
+RawPtr<ArchiveResource> MHTMLParser::parseNextPart(const MIMEHeader& mimeHeader, const String& endOfPartBoundary, const String& endOfDocumentBoundary, bool& endOfArchiveReached)
 {
     ASSERT(endOfPartBoundary.isEmpty() == endOfDocumentBoundary.isEmpty());
 
     // If no content transfer encoding is specified, default to binary encoding.
     MIMEHeader::Encoding contentTransferEncoding = mimeHeader.contentTransferEncoding();
     if (contentTransferEncoding == MIMEHeader::Unknown)
         contentTransferEncoding = MIMEHeader::Binary;
 
     RefPtr<SharedBuffer> content = SharedBuffer::create();
     const bool checkBoundary = !endOfPartBoundary.isEmpty();
@@ skipping 92 matching lines @@
     if (!contentID.startsWith('<') || !contentID.endsWith('>'))
         return KURL();
 
     StringBuilder uriBuilder;
     uriBuilder.append("cid:");
     uriBuilder.append(contentID, 1, contentID.length() - 2);
     return KURL(KURL(), uriBuilder.toString());
 }
 
 } // namespace blink