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 125 matching lines @@
         addResource("http://www.test.com/red_background.png", "image/png", "red_background.png");
         addResource("http://www.test.com/orange_background.png", "image/png", "orange_background.png");
         addResource("http://www.test.com/yellow_background.png", "image/png", "yellow_background.png");
         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);
+                boundary, String(), encodingPolicy, resource, mhtmlData);
         }
-        MHTMLArchive::generateMHTMLFooter(boundary, *mhtmlData);
-        return mhtmlData.release();
+        MHTMLArchive::generateMHTMLFooter(boundary, mhtmlData);
+        return std::move(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);
+        return std::move(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 19 matching lines @@
 
     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 11 matching lines @@
             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()));
 #else
@@ skipping 23 matching lines @@
     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