Move MHTML file writing out of the renderer main thread.

third_party/WebKit/Source/web/tests/MHTMLTest.cpp

 /*
  * Copyright (C) 2014 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 128 matching lines @@
     addResource("http://www.test.com/green_background.png", "image/png",
                 "green_background.png");
     addResource("http://www.test.com/blue_background.png", "image/png",
                 "blue_background.png");
     addResource("http://www.test.com/purple_background.png", "image/png",
                 "purple_background.png");
     addResource("http://www.test.com/ul-dot.png", "image/png", "ul-dot.png");
     addResource("http://www.test.com/ol-dot.png", "image/png", "ol-dot.png");
   }
 
-  static PassRefPtr<SharedBuffer> generateMHTMLData(
+  static std::vector<char> generateMHTMLData(
       const Vector<SerializedResource>& resources,
       MHTMLArchive::EncodingPolicy encodingPolicy,
       const String& title,
       const String& mimeType) {
     // This boundary is as good as any other.  Plus it gets used in almost
     // all the examples in the MHTML spec - RFC 2557.
     String boundary = String::fromUTF8("boundary-example");
 
-    RefPtr<SharedBuffer> mhtmlData = SharedBuffer::create();
-    MHTMLArchive::generateMHTMLHeader(boundary, title, mimeType, *mhtmlData);
+    std::vector<char> mhtmlData;
+    MHTMLArchive::generateMHTMLHeader(boundary, title, mimeType, mhtmlData);
     for (const auto& resource : resources) {
       MHTMLArchive::generateMHTMLPart(boundary, String(), encodingPolicy,
-                                      resource, *mhtmlData);
+                                      resource, mhtmlData);
     }
-    MHTMLArchive::generateMHTMLFooter(boundary, *mhtmlData);
-    return mhtmlData.release();
+    MHTMLArchive::generateMHTMLFooter(boundary, mhtmlData);
+    return mhtmlData;
   }
 
-  PassRefPtr<SharedBuffer> serialize(
-      const char* title,
-      const char* mime,
-      MHTMLArchive::EncodingPolicy encodingPolicy) {
+  std::vector<char> serialize(const char* title,
+                              const char* mime,
+                              MHTMLArchive::EncodingPolicy encodingPolicy) {
     return generateMHTMLData(m_resources, encodingPolicy, title, mime);
   }
 
  private:
   PassRefPtr<SharedBuffer> readFile(const char* fileName) {
     String filePath = m_filePath + fileName;
     return testing::readFromFile(filePath);
   }
 
   String m_filePath;
@@ skipping 17 matching lines @@
   ASSERT_TRUE(document);
 
   EXPECT_STREQ(kFileURL, frame->domWindow()->location()->href().ascii().data());
 
   SecurityOrigin* origin = document->getSecurityOrigin();
   EXPECT_STRNE("localhost", origin->domain().ascii().data());
 }
 
 TEST_F(MHTMLTest, TestMHTMLEncoding) {
   addTestResources();
-  RefPtr<SharedBuffer> data = serialize("Test Serialization", "text/html",
-                                        MHTMLArchive::UseDefaultEncoding);
+  std::vector<char> data = serialize("Test Serialization", "text/html",
+                                     MHTMLArchive::UseDefaultEncoding);
 
   // Read the MHTML data line per line and do some pseudo-parsing to make sure
   // the right encoding is used for the different sections.
-  LineReader lineReader(std::string(data->data(), data->size()));
+  LineReader lineReader(std::string(&data.front(), data.size()));
   int sectionCheckedCount = 0;
   const char* expectedEncoding = 0;
   std::string line;
   while (lineReader.getNextLine(&line)) {
     if (line.compare(0, 13, "Content-Type:") == 0) {
       ASSERT_FALSE(expectedEncoding);
       if (line.find("multipart/related;") != std::string::npos) {
         // Skip this one, it's part of the MHTML header.
         continue;
       }
@@ skipping 10 matching lines @@
       EXPECT_NE(line.find(expectedEncoding), std::string::npos);
       expectedEncoding = 0;
       sectionCheckedCount++;
     }
   }
   EXPECT_EQ(12, sectionCheckedCount);
 }
 
 TEST_F(MHTMLTest, MHTMLFromScheme) {
   addTestResources();
-  RefPtr<SharedBuffer> data = serialize("Test Serialization", "text/html",
-                                        MHTMLArchive::UseDefaultEncoding);
+  std::vector<char> dataVector = serialize("Test Serialization", "text/html",
+                                           MHTMLArchive::UseDefaultEncoding);
+  RefPtr<SharedBuffer> data =
+      SharedBuffer::create(&dataVector.front(), dataVector.size());
   KURL httpURL = toKURL("http://www.example.com");
   KURL contentURL = toKURL("content://foo");
   KURL fileURL = toKURL("file://foo");
   KURL specialSchemeURL = toKURL("fooscheme://bar");
 
   // MHTMLArchives can only be initialized from local schemes, http/https
   // schemes, and content scheme(Android specific).
   EXPECT_NE(nullptr, MHTMLArchive::create(httpURL, data.get()));
 #if OS(ANDROID)
   EXPECT_NE(nullptr, MHTMLArchive::create(contentURL, data.get()));
@@ skipping 22 matching lines @@
   // Full sandboxing should be turned on.
   EXPECT_TRUE(document->isSandboxed(SandboxAll));
 
   // MHTML document should be loaded into unique origin.
   EXPECT_TRUE(document->getSecurityOrigin()->isUnique());
   // Script execution should be disabled.
   EXPECT_FALSE(frame->script().canExecuteScripts(NotAboutToExecuteScript));
 }
 
 }  // namespace blink