Get signals working in the EXTRA_DATA section of MHTML

content/browser/download/mhtml_generation_manager.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/download/mhtml_generation_manager.h"
 
 #include <map>
 #include <queue>
 #include <utility>
 
@@ skipping 14 matching lines @@
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/mhtml_generation_params.h"
 #include "net/base/mime_util.h"
 
+namespace {
+const char kApplicationJson[] = "application/json";
+}  // namespace
+
 namespace content {
 
 // The class and all of its members live on the UI thread.  Only static methods
 // are executed on other threads.
 class MHTMLGenerationManager::Job : public RenderProcessHostObserver {
  public:
   Job(int job_id,
       WebContents* web_contents,
       const MHTMLGenerationParams& params,
       const GenerateMHTMLCallback& callback);
@@ skipping 49 matching lines @@
 
  private:
   // Writes the MHTML footer to the file and closes it.
   //
   // Note: The same |boundary| marker must be used for all "boundaries" -- in
   // the header, parts and footer -- that belong to the same MHTML document (see
   // also rfc1341, section 7.2.1, "boundary" description).
   static std::tuple<MhtmlSaveStatus, int64_t> CloseFileOnFileThread(
       MhtmlSaveStatus save_status,
       const std::string& boundary,
-      base::File file);
+      base::File file,
+      const std::string& extra_data);
   void AddFrame(RenderFrameHost* render_frame_host);
 
+  // If we have any extra data sections to write out, write them into the file
+  // while on the file thread.  Returns true for success.
+  static bool WriteExtraDataSectionOnFileThread(const std::string& boundary,
+                                                base::File& file,
+                                                const std::string& extra_data);
+
   // Creates a new map with values (content ids) the same as in
   // |frame_tree_node_to_content_id_| map, but with the keys translated from
   // frame_tree_node_id into a |site_instance|-specific routing_id.
   std::map<int, std::string> CreateFrameRoutingIdToContentId(
       SiteInstance* site_instance);
 
   // Id used to map renderer responses to jobs.
   // See also MHTMLGenerationManager::id_to_job_ map.
   const int job_id_;
 
@@ skipping 231 matching lines @@
     return;
   }
 
   // If no previous error occurred the boundary should be sent.
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(
           &MHTMLGenerationManager::Job::CloseFileOnFileThread, save_status,
           (save_status == MhtmlSaveStatus::SUCCESS ? mhtml_boundary_marker_
                                                    : std::string()),
-          base::Passed(&browser_file_)),
+          base::Passed(&browser_file_), params_.extra_data),
       callback);
 }
 
 bool MHTMLGenerationManager::Job::IsMessageFromFrameExpected(
     RenderFrameHostImpl* sender) {
   int sender_id = sender->frame_tree_node()->frame_tree_node_id();
   if (sender_id != frame_tree_node_id_of_busy_frame_)
     return false;
 
   // We only expect one message per frame - let's make sure subsequent messages
@@ skipping 25 matching lines @@
 
   // Report success if all frames have been processed.
   if (pending_frame_tree_node_ids_.empty())
     return MhtmlSaveStatus::SUCCESS;
 
   return SendToNextRenderFrame();
 }
 
 // static
 std::tuple<MhtmlSaveStatus, int64_t>
-MHTMLGenerationManager::Job::CloseFileOnFileThread(MhtmlSaveStatus save_status,
-                                                   const std::string& boundary,
-                                                   base::File file) {
+MHTMLGenerationManager::Job::CloseFileOnFileThread(
+    MhtmlSaveStatus save_status,
+    const std::string& boundary,
+    base::File file,
+    const std::string& extra_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   // If no previous error occurred the boundary should have been provided.
   if (save_status == MhtmlSaveStatus::SUCCESS) {
     TRACE_EVENT0("page-serialization",
                  "MHTMLGenerationManager::Job MHTML footer writing");
     DCHECK(!boundary.empty());
+
+    // Write the extra data into a section of its own, if we have any.
+    if (!WriteExtraDataSectionOnFileThread(boundary, file, extra_data))
+      save_status = MhtmlSaveStatus::FILE_WRITTING_ERROR;
+
     std::string footer = base::StringPrintf("--%s--\r\n", boundary.c_str());
     DCHECK(base::IsStringASCII(footer));
     if (file.WriteAtCurrentPos(footer.data(), footer.size()) < 0)
       save_status = MhtmlSaveStatus::FILE_WRITTING_ERROR;
   }
 
   // If the file is still valid try to close it. Only update the status if that
   // won't hide an earlier error.
   int64_t file_size = -1;
   if (file.IsValid()) {
     file_size = file.GetLength();
     file.Close();
   } else if (save_status == MhtmlSaveStatus::SUCCESS) {
     save_status = MhtmlSaveStatus::FILE_CLOSING_ERROR;
   }
 
   return std::make_tuple(save_status, file_size);
 }
 
+// static
+bool MHTMLGenerationManager::Job::WriteExtraDataSectionOnFileThread(
+    const std::string& boundary,
+    base::File& file,
+    const std::string& extra_data) {
+  // Write a newline, then a boundary, then the mime type, another newline,
+  // the extra data string, and end with a newline.
+  std::string extra_data_section =
+      base::StringPrintf("--%s--\r\n%s\r\n%s\r\n", boundary.c_str(),

[Dmitry Titov, 2017/03/14 01:16:02]

It looks like you are trying to form a 'legit' MHTML part here, with header and
body subparts separated with \r\n. This is good, and perhaps we should use legit
HTTP headers here as Content-Type: and  Content-Location: (the latter with a
generated CID).

Also, the content type could have been provided by the same code that serializes
the 'extra_data' string, because that code is deciding what kind of
serialization to use. 

[romax, 2017/03/14 19:08:05]

is it possible to have some kind of signs that this section is used for signal
recording? An explicit sign would be pretty helpful when parsing the raw MHTML.

[Pete Williamson, 2017/03/15 22:38:22]

I explicitly kept this section as extra data.  Signals is just one potential
use.  So, from the point of view of the MHTML file, this is just extra data it
doesn't know much about, but from the point of view of the offliner, this is
signal data.  The naming in each file reflects this idea.

[Pete Williamson, 2017/03/15 22:38:22]

I moved the Content-Type to where I build the data.
I've added Content-Location, but not sure what to use for CID - any ideas? 
Maybe just the filename for the MHTML file?

+                         kApplicationJson, extra_data.c_str());
+  // Now actually write the string into the file.
+  DCHECK(base::IsStringASCII(extra_data_section));
+  if (file.WriteAtCurrentPos(extra_data_section.data(),
+                             extra_data_section.size()) < 0)
+    return false;
+
+  return true;
+}
+
 MHTMLGenerationManager* MHTMLGenerationManager::GetInstance() {
   return base::Singleton<MHTMLGenerationManager>::get();
 }
 
 MHTMLGenerationManager::MHTMLGenerationManager() : next_job_id_(0) {}
 
 MHTMLGenerationManager::~MHTMLGenerationManager() {
 }
 
 void MHTMLGenerationManager::SaveMHTML(WebContents* web_contents,
@@ skipping 149 matching lines @@
   return iter->second.get();
 }
 
 void MHTMLGenerationManager::RenderProcessExited(Job* job) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(job);
   JobFinished(job, MhtmlSaveStatus::RENDER_PROCESS_EXITED);
 }
 
 }  // namespace content