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 39 matching lines @@
 #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 11 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);
       // 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