Move MHTML file writing out of the renderer main thread.

third_party/WebKit/Source/platform/mhtml/MHTMLArchive.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 27 matching lines @@
 #include "platform/mhtml/MHTMLParser.h"
 #include "platform/text/QuotedPrintable.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "wtf/Assertions.h"
 #include "wtf/CryptographicallyRandomNumber.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/DateMath.h"
 #include "wtf/text/Base64.h"
 #include "wtf/text/StringBuilder.h"
 
-namespace blink {
+
+namespace {
 
 const char* const quotedPrintable = "quoted-printable";
 const char* const base64 = "base64";
 const char* const binary = "binary";
 
+enum class Encoding {
+    QuotedPrintable,
+    Base64,
+    Binary,
+};
+
+}
+
+namespace blink {
+
 static String replaceNonPrintableCharacters(const String& text)
 {
     StringBuilder stringBuilder;
     for (size_t i = 0; i < text.length(); ++i) {
         if (isASCIIPrintable(text[i]))
             stringBuilder.append(text[i]);
         else
             stringBuilder.append('?');
     }
     return stringBuilder.toString();
@@ skipping 37 matching lines @@
         return true;
 #if OS(ANDROID)
     if (url.protocolIs("content"))
         return true;
 #endif
     return false;
 }
 
 void MHTMLArchive::generateMHTMLHeader(
     const String& boundary, const String& title, const String& mimeType,
-    SharedBuffer& outputBuffer)
+    std::vector<char>& outputBuffer)
 {
     ASSERT(!boundary.isEmpty());
     ASSERT(!mimeType.isEmpty());
 
     DateComponents now;
     now.setMillisecondsSinceEpochForDateTime(currentTimeMS());
     // TODO(lukasza): Passing individual date/time components seems fragile.
     String dateString = makeRFC2822DateString(
         now.weekDay(), now.monthDay(), now.month(), now.fullYear(),
         now.hour(), now.minute(), now.second(), 0);
@@ skipping 12 matching lines @@
     stringBuilder.append("\";\r\n");
     stringBuilder.append("\tboundary=\"");
     stringBuilder.append(boundary);
     stringBuilder.append("\"\r\n\r\n");
 
     // We use utf8() below instead of ascii() as ascii() replaces CRLFs with ??
     // (we still only have put ASCII characters in it).
     ASSERT(stringBuilder.toString().containsOnlyASCII());
     CString asciiString = stringBuilder.toString().utf8();
 
-    outputBuffer.append(asciiString.data(), asciiString.length());
+    outputBuffer.reserve(outputBuffer.size() + asciiString.length());
+    outputBuffer.insert(outputBuffer.end(), asciiString.data(), asciiString.data() + asciiString.length());
 }
 
 void MHTMLArchive::generateMHTMLPart(
     const String& boundary,
     const String& contentID,
     EncodingPolicy encodingPolicy,
     const SerializedResource& resource,
-    SharedBuffer& outputBuffer)
+    std::vector<char>& outputBuffer)
 {
     ASSERT(!boundary.isEmpty());
     ASSERT(contentID.isEmpty() || contentID[0] == '<');
 
     StringBuilder stringBuilder;
     stringBuilder.append("--");
     stringBuilder.append(boundary);
     stringBuilder.append("\r\n");
 
     stringBuilder.append("Content-Type: ");
     stringBuilder.append(resource.mimeType);
     stringBuilder.append("\r\n");
 
     if (!contentID.isEmpty()) {
         stringBuilder.append("Content-ID: ");
         stringBuilder.append(contentID);
         stringBuilder.append("\r\n");
     }
 
-    const char* contentEncoding = 0;
-    if (encodingPolicy == UseBinaryEncoding)
-        contentEncoding = binary;
-    else if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(resource.mimeType) || MIMETypeRegistry::isSupportedNonImageMIMEType(resource.mimeType))
-        contentEncoding = quotedPrintable;
-    else
-        contentEncoding = base64;
+    const char* contentEncodingText = 0;
+    Encoding encoding = Encoding::Base64;
+    if (encodingPolicy == UseBinaryEncoding) {
+        contentEncodingText = binary;
+        encoding = Encoding::Binary;
+    } else if (MIMETypeRegistry::isSupportedJavaScriptMIMEType(resource.mimeType) || MIMETypeRegistry::isSupportedNonImageMIMEType(resource.mimeType)) {
+        contentEncodingText = quotedPrintable;
+        encoding = Encoding::QuotedPrintable;
+    } else {
+        contentEncodingText = base64;
+    }
 
     stringBuilder.append("Content-Transfer-Encoding: ");
-    stringBuilder.append(contentEncoding);
+    stringBuilder.append(contentEncodingText);
     stringBuilder.append("\r\n");
 
     if (!resource.url.protocolIsAbout()) {
         stringBuilder.append("Content-Location: ");
         stringBuilder.append(resource.url.getString());
         stringBuilder.append("\r\n");
     }
 
     stringBuilder.append("\r\n");
 
     CString asciiString = stringBuilder.toString().utf8();
-    outputBuffer.append(asciiString.data(), asciiString.length());
 
-    if (!strcmp(contentEncoding, binary)) {
+    // Best guess for a reserved size. It should work well for binary and base64
+    // (see https://en.wikipedia.org/wiki/Base64#MIME); not so much for
+    // quoted-printable which is harder to estimate.
+    std::size_t expectedFinalSize = outputBuffer.size() + asciiString.length();
+    if (encoding == Encoding::Base64)
+        expectedFinalSize += static_cast<std::size_t>(resource.data->size() * 1.37);
+    else
+        expectedFinalSize += resource.data->size();
+    outputBuffer.reserve(expectedFinalSize);
+
+    outputBuffer.insert(outputBuffer.end(), asciiString.data(), asciiString.data() + asciiString.length());
+
+    if (encoding == Encoding::Binary) {
         const char* data;
         size_t position = 0;
         while (size_t length = resource.data->getSomeData(data, position)) {
-            outputBuffer.append(data, length);
+            outputBuffer.insert(outputBuffer.end(), data, data + length);
             position += length;
         }
     } else {
         // FIXME: ideally we would encode the content as a stream without having to fetch it all.
         const char* data = resource.data->data();
         size_t dataLength = resource.data->size();
         Vector<char> encodedData;
-        if (!strcmp(contentEncoding, quotedPrintable)) {
+        if (encoding == Encoding::QuotedPrintable) {
             quotedPrintableEncode(data, dataLength, encodedData);
-            outputBuffer.append(encodedData.data(), encodedData.size());
-            outputBuffer.append("\r\n", 2u);
+            outputBuffer.insert(outputBuffer.end(), encodedData.data(), encodedData.data() + encodedData.size());
+            outputBuffer.push_back('\r');
+            outputBuffer.push_back('\n');
         } else {
-            ASSERT(!strcmp(contentEncoding, base64));
+            DCHECK(encoding == Encoding::Base64);

[carlosk, 2016/10/03 23:51:05]

I replaced ASSERT with DCHECK here as I understand this is the way forward.
Should I replace all other occurrences in this file?

             // We are not specifying insertLFs = true below as it would cut the lines with LFs and MHTML requires CRLFs.
             base64Encode(data, dataLength, encodedData);
             const size_t maximumLineLength = 76;
             size_t index = 0;
             size_t encodedDataLength = encodedData.size();
             do {
                 size_t lineLength = std::min(encodedDataLength - index, maximumLineLength);
-                outputBuffer.append(encodedData.data() + index, lineLength);
-                outputBuffer.append("\r\n", 2u);
+                outputBuffer.insert(outputBuffer.end(), encodedData.data() + index, encodedData.data() + index + lineLength);
+                outputBuffer.push_back('\r');
+                outputBuffer.push_back('\n');
                 index += maximumLineLength;
             } while (index < encodedDataLength);
         }
     }
 }
 
 void MHTMLArchive::generateMHTMLFooter(
     const String& boundary,
-    SharedBuffer& outputBuffer)
+    std::vector<char>& outputBuffer)
 {
     ASSERT(!boundary.isEmpty());
     CString asciiString = String("--" + boundary + "--\r\n").utf8();
-    outputBuffer.append(asciiString.data(), asciiString.length());
+    outputBuffer.reserve(outputBuffer.size() + asciiString.length());
+    outputBuffer.insert(outputBuffer.end(), asciiString.data(), asciiString.data() + asciiString.length());
 }
 
 void MHTMLArchive::setMainResource(ArchiveResource* mainResource)
 {
     m_mainResource = mainResource;
 }
 
 void MHTMLArchive::addSubresource(ArchiveResource* resource)
 {
     const KURL& url = resource->url();
     m_subresources.set(url, resource);
     KURL cidURI = MHTMLParser::convertContentIDToURI(resource->contentID());
     if (cidURI.isValid())
         m_subresources.set(cidURI, resource);
 }
 
 ArchiveResource* MHTMLArchive::subresourceForURL(const KURL& url) const
 {
     return m_subresources.get(url.getString());
 }
 
 DEFINE_TRACE(MHTMLArchive)
 {
     visitor->trace(m_mainResource);
     visitor->trace(m_subresources);
 }
 
 } // namespace blink