Move MHTML file writing out of the renderer main thread.

third_party/WebKit/public/web/WebFrameSerializer.h

 /*
  * Copyright (C) 2009 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 19 matching lines @@
 
 #ifndef WebFrameSerializer_h
 #define WebFrameSerializer_h
 
 #include "../platform/WebCommon.h"
 #include "../platform/WebData.h"
 #include "../platform/WebString.h"
 #include "../platform/WebURL.h"
 #include "../platform/WebVector.h"
 #include "WebFrameSerializerCacheControlPolicy.h"
+#include <vector>
 
 namespace blink {
 
 class WebFrameSerializerClient;
 class WebFrame;
 class WebLocalFrame;
 template <typename T>
 class WebVector;
 
 // Serialization of frame contents into html or mhtml.
@@ skipping 20 matching lines @@
 
   // Generates and returns an MHTML header.
   //
   // Contents of the header (i.e. title and mime type) will be based
   // on the frame passed as an argument (which typically should be
   // the main, top-level frame).
   //
   // Same |boundary| needs to used for all generateMHTMLHeader and
   // generateMHTMLParts and generateMHTMLFooter calls that belong to the same
   // MHTML document (see also rfc1341, section 7.2.1, "boundary" description).
-  BLINK_EXPORT static WebData generateMHTMLHeader(
+  BLINK_EXPORT static std::vector<char> generateMHTMLHeader(

[dcheng, 2016/10/04 04:34:48]

We don't allow STL containers (string, vector, map, etc) in the public headers.
Similarly, we also don't use STL inside Blink currently.

Historical background can be found at
https://lists.webkit.org/pipermail/webkit-dev/2008-January/003100.html

In order to use STL containers in Blink, at least several things need
investigation:
- Performance: someone needs to measure if the STL equivalent to the WTF version
is just as performant. There are anecdotes that the WTF versions are a perf win,
but IIRC, no one has measured recently.
- Consistency: if there are perf issues, it's easier to have consistent rules
and just not allow STL containers
- Codegen: On some platforms, std::string is actually COW and inlines a ton of
code. Someone needs to demonstrate that the STL versions are no worse than the
WTF versions (and ideally better)

So unfortunately, this will have to use WebData or WebThreadSafeData, if we need
to pass between threads.

* You'll see some usage in tests, but that's about it.

       const WebString& boundary,
       WebLocalFrame*,
       MHTMLPartsGenerationDelegate*);
 
   // Generates and returns MHTML parts for the given frame and the
   // savable resources underneath.
   //
   // Same |boundary| needs to used for all generateMHTMLHeader and
   // generateMHTMLParts and generateMHTMLFooter calls that belong to the same
   // MHTML document (see also rfc1341, section 7.2.1, "boundary" description).
-  BLINK_EXPORT static WebData generateMHTMLParts(const WebString& boundary,
-                                                 WebLocalFrame*,
-                                                 MHTMLPartsGenerationDelegate*);
+  BLINK_EXPORT static std::vector<char> generateMHTMLParts(
+      const WebString& boundary,
+      WebLocalFrame*,
+      MHTMLPartsGenerationDelegate*);
 
   // Generates and returns an MHTML footer.
   //
   // Same |boundary| needs to used for all generateMHTMLHeader and
   // generateMHTMLParts and generateMHTMLFooter calls that belong to the same
   // MHTML document (see also rfc1341, section 7.2.1, "boundary" description).
-  BLINK_EXPORT static WebData generateMHTMLFooter(const WebString& boundary);
+  BLINK_EXPORT static std::vector<char> generateMHTMLFooter(
+      const WebString& boundary);
 
   // IMPORTANT:
   // The API below is an older implementation of frame serialization that
   // will be removed soon.
 
   class LinkRewritingDelegate {
    public:
     // Method allowing the delegate control which URLs are written into the
     // generated html document.
     //
@@ skipping 36 matching lines @@
   // Generate the MOTW declaration.
   BLINK_EXPORT static WebString generateMarkOfTheWebDeclaration(const WebURL&);
   // Generate the default base tag declaration.
   BLINK_EXPORT static WebString generateBaseTagDeclaration(
       const WebString& baseTarget);
 };
 
 }  // namespace blink
 
 #endif