Update Source/platform/ to assume Oilpan only.

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 28 matching lines @@
 #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 GarbageCollectedFinalized<MIMEHeader> {
 public:
-    static RawPtr<MIMEHeader> create()
+    static MIMEHeader* create()
     {
-        return new MIMEHeader();
+        return new MIMEHeader;
     }
 
     enum Encoding {
         QuotedPrintable,
         Base64,
         EightBit,
         SevenBit,
         Binary,
         Unknown
     };
 
-    static RawPtr<MIMEHeader> parseHeader(SharedBufferChunkReader* crLFLineReader);
+    static 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;
 }
 
-RawPtr<MIMEHeader> MIMEHeader::parseHeader(SharedBufferChunkReader* buffer)
+MIMEHeader* MIMEHeader::parseHeader(SharedBufferChunkReader* buffer)
 {
-    RawPtr<MIMEHeader> mimeHeader = MIMEHeader::create();
+    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 13 matching lines @@
 
     mimeParametersIterator = keyValuePairs.find("content-location");
     if (mimeParametersIterator != keyValuePairs.end())
         mimeHeader->m_contentLocation = mimeParametersIterator->value;
 
     // See rfc2557 - section 8.3 - Use of the Content-ID header and CID URLs.
     mimeParametersIterator = keyValuePairs.find("content-id");
     if (mimeParametersIterator != keyValuePairs.end())
         mimeHeader->m_contentID = mimeParametersIterator->value;
 
-    return mimeHeader.release();
+    return mimeHeader;
 }
 
 MIMEHeader::Encoding MIMEHeader::parseContentTransferEncoding(const String& text)
 {
     String encoding = text.stripWhiteSpace().lower();
     if (encoding == "base64")
         return Base64;
     if (encoding == "quoted-printable")
         return QuotedPrintable;
     if (encoding == "8bit")
@@ skipping 21 matching lines @@
     return false;
 }
 
 MHTMLParser::MHTMLParser(SharedBuffer* data)
     : m_lineReader(data, "\r\n")
 {
 }
 
 HeapVector<Member<ArchiveResource>> MHTMLParser::parseArchive()
 {
-    RawPtr<MIMEHeader> header = MIMEHeader::parseHeader(&m_lineReader);
+    MIMEHeader* header = MIMEHeader::parseHeader(&m_lineReader);
     HeapVector<Member<ArchiveResource>> resources;
-    if (!parseArchiveWithHeader(header.get(), resources))
+    if (!parseArchiveWithHeader(header, resources))
         resources.clear();
     return resources;
 }
 
 bool MHTMLParser::parseArchiveWithHeader(MIMEHeader* header, HeapVector<Member<ArchiveResource>>& resources)
 {
     if (!header) {
         DLOG(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;
-        RawPtr<ArchiveResource> resource = parseNextPart(*header, String(), String(), endOfArchiveReached);
+        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) {
-        RawPtr<MIMEHeader> resourceHeader = MIMEHeader::parseHeader(&m_lineReader);
+        MIMEHeader* resourceHeader = MIMEHeader::parseHeader(&m_lineReader);
         if (!resourceHeader) {
             DLOG(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)) {
+            if (!parseArchiveWithHeader(resourceHeader, resources)) {
                 DLOG(ERROR) << "Failed to parse MHTML subframe.";
                 return false;
             }
             bool endOfPartReached = skipLinesUntilBoundaryFound(m_lineReader, header->endOfPartBoundary());
             ASSERT_UNUSED(endOfPartReached, endOfPartReached);
             continue;
         }
 
-        RawPtr<ArchiveResource> resource = parseNextPart(*resourceHeader, header->endOfPartBoundary(), header->endOfDocumentBoundary(), endOfArchive);
+        ArchiveResource* resource = parseNextPart(*resourceHeader, header->endOfPartBoundary(), header->endOfDocumentBoundary(), endOfArchive);
         if (!resource) {
             DLOG(ERROR) << "Failed to parse MHTML part.";
             return false;
         }
         resources.append(resource);
     }
     return true;
 }
 
 
-RawPtr<ArchiveResource> MHTMLParser::parseNextPart(const MIMEHeader& mimeHeader, const String& endOfPartBoundary, const String& endOfDocumentBoundary, bool& endOfArchiveReached)
+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