Oilpan: move MHTML objects to the heap.

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 14 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "platform/mhtml/MHTMLParser.h"
 
 #include "platform/MIMETypeRegistry.h"
+#include "platform/mhtml/ArchiveResource.h"
 #include "platform/mhtml/MHTMLArchive.h"
 #include "platform/network/ParsedContentType.h"
 #include "platform/text/QuotedPrintable.h"
 #include "wtf/HashMap.h"
 #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 WebCore {
 
 // This class is a limited MIME parser used to parse the MIME headers of MHTML files.
-class MIMEHeader : public RefCounted<MIMEHeader> {
+class MIMEHeader : public RefCountedWillBeGarbageCollectedFinalized<MIMEHeader> {
 public:
+    static PassRefPtrWillBeRawPtr<MIMEHeader> create()
+    {
+        return adoptRefWillBeNoop(new MIMEHeader());
+    }
+
     enum Encoding {
         QuotedPrintable,
         Base64,
         EightBit,
         SevenBit,
         Binary,
         Unknown
     };
 
-    static PassRefPtr<MIMEHeader> parseHeader(SharedBufferChunkReader* crLFLineReader);
+    static PassRefPtrWillBeRawPtr<MIMEHeader> parseHeader(SharedBufferChunkReader* crLFLineReader);
 
     bool isMultipart() const { return m_contentType.startsWith("multipart/"); }
 
     String contentType() const { return m_contentType; }
     String charset() const { return m_charset; }
     Encoding contentTransferEncoding() const { return m_contentTransferEncoding; }
     String contentLocation() const { return m_contentLocation; }
 
     // Multi-part type and boundaries are only valid for multipart MIME headers.
     String multiPartType() const { return m_multipartType; }
     String endOfPartBoundary() const { return m_endOfPartBoundary; }
     String endOfDocumentBoundary() const { return m_endOfDocumentBoundary; }
 
+    void trace(Visitor*) { }
+
 private:
     MIMEHeader();
 
     static Encoding parseContentTransferEncoding(const String&);
 
     String m_contentType;
     String m_charset;
     Encoding m_contentTransferEncoding;
     String m_contentLocation;
     String m_multipartType;
@@ skipping 32 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;
 }
 
-PassRefPtr<MIMEHeader> MIMEHeader::parseHeader(SharedBufferChunkReader* buffer)
+PassRefPtrWillBeRawPtr<MIMEHeader> MIMEHeader::parseHeader(SharedBufferChunkReader* buffer)
 {
-    RefPtr<MIMEHeader> mimeHeader = adoptRef(new MIMEHeader);
+    RefPtrWillBeRawPtr<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 48 matching lines @@
             return true;
     }
     return false;
 }
 
 MHTMLParser::MHTMLParser(SharedBuffer* data)
     : m_lineReader(data, "\r\n")
 {
 }
 
-PassRefPtr<MHTMLArchive> MHTMLParser::parseArchive()
+PassRefPtrWillBeRawPtr<MHTMLArchive> MHTMLParser::parseArchive()
 {
-    RefPtr<MIMEHeader> header = MIMEHeader::parseHeader(&m_lineReader);
+    RefPtrWillBeRawPtr<MIMEHeader> header = MIMEHeader::parseHeader(&m_lineReader);
     return parseArchiveWithHeader(header.get());
 }
 
-PassRefPtr<MHTMLArchive> MHTMLParser::parseArchiveWithHeader(MIMEHeader* header)
+PassRefPtrWillBeRawPtr<MHTMLArchive> MHTMLParser::parseArchiveWithHeader(MIMEHeader* header)
 {
     if (!header) {
         WTF_LOG_ERROR("Failed to parse MHTML part: no header.");
         return nullptr;
     }
 
-    RefPtr<MHTMLArchive> archive = MHTMLArchive::create();
+    RefPtrWillBeRawPtr<MHTMLArchive> archive = MHTMLArchive::create();
     if (!header->isMultipart()) {
         // With IE a page with no resource is not multi-part.
         bool endOfArchiveReached = false;
-        RefPtr<ArchiveResource> resource = parseNextPart(*header, String(), String(), endOfArchiveReached);
+        RefPtrWillBeRawPtr<ArchiveResource> resource = parseNextPart(*header, String(), String(), endOfArchiveReached);
         if (!resource)
             return nullptr;
         archive->setMainResource(resource);
         return archive;
     }
 
     // Skip the message content (it's a generic browser specific message).
     skipLinesUntilBoundaryFound(m_lineReader, header->endOfPartBoundary());
 
     bool endOfArchive = false;
     while (!endOfArchive) {
-        RefPtr<MIMEHeader> resourceHeader = MIMEHeader::parseHeader(&m_lineReader);
+        RefPtrWillBeRawPtr<MIMEHeader> resourceHeader = MIMEHeader::parseHeader(&m_lineReader);
         if (!resourceHeader) {
             WTF_LOG_ERROR("Failed to parse MHTML, invalid MIME header.");
             return nullptr;
         }
         if (resourceHeader->contentType() == "multipart/alternative") {
             // Ignore IE nesting which makes little sense (IE seems to nest only some of the frames).
-            RefPtr<MHTMLArchive> subframeArchive = parseArchiveWithHeader(resourceHeader.get());
+            RefPtrWillBeRawPtr<MHTMLArchive> subframeArchive = parseArchiveWithHeader(resourceHeader.get());
             if (!subframeArchive) {
                 WTF_LOG_ERROR("Failed to parse MHTML subframe.");
                 return nullptr;
             }
             bool endOfPartReached = skipLinesUntilBoundaryFound(m_lineReader, header->endOfPartBoundary());
             ASSERT_UNUSED(endOfPartReached, endOfPartReached);
             // The top-frame is the first frame found, regardless of the nesting level.
             if (subframeArchive->mainResource())
                 addResourceToArchive(subframeArchive->mainResource(), archive.get());
             archive->addSubframeArchive(subframeArchive);
             continue;
         }
 
-        RefPtr<ArchiveResource> resource = parseNextPart(*resourceHeader, header->endOfPartBoundary(), header->endOfDocumentBoundary(), endOfArchive);
+        RefPtrWillBeRawPtr<ArchiveResource> resource = parseNextPart(*resourceHeader, header->endOfPartBoundary(), header->endOfDocumentBoundary(), endOfArchive);
         if (!resource) {
             WTF_LOG_ERROR("Failed to parse MHTML part.");
             return nullptr;
         }
         addResourceToArchive(resource.get(), archive.get());
     }
 
     return archive.release();
 }
 
 void MHTMLParser::addResourceToArchive(ArchiveResource* resource, MHTMLArchive* archive)
 {
     const AtomicString& mimeType = resource->mimeType();
     if (!MIMETypeRegistry::isSupportedNonImageMIMEType(mimeType) || MIMETypeRegistry::isSupportedJavaScriptMIMEType(mimeType) || mimeType == "text/css") {
         m_resources.append(resource);
         return;
     }
 
     // The first document suitable resource is the main frame.
     if (!archive->mainResource()) {
         archive->setMainResource(resource);
         m_frames.append(archive);
         return;
     }
 
-    RefPtr<MHTMLArchive> subframe = MHTMLArchive::create();
+    RefPtrWillBeRawPtr<MHTMLArchive> subframe = MHTMLArchive::create();
     subframe->setMainResource(resource);
     m_frames.append(subframe);
 }
 
-PassRefPtr<ArchiveResource> MHTMLParser::parseNextPart(const MIMEHeader& mimeHeader, const String& endOfPartBoundary, const String& endOfDocumentBoundary, bool& endOfArchiveReached)
+PassRefPtrWillBeRawPtr<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 89 matching lines @@
 {
     return m_resources.size();
 }
 
 ArchiveResource* MHTMLParser::subResourceAt(size_t index) const
 {
     return m_resources[index].get();
 }
 
 }