[Offline Pages] Generate MHTML header in the browser process.

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>
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/guid.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/scoped_observer.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
+#include "base/strings/utf_string_conversion_utils.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/download/mhtml_extra_parts_impl.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #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/mhtml_extra_parts.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 kContentLocation[] = "Content-Location: ";
 const char kContentType[] = "Content-Type: ";
 int kInvalidFileSize = -1;
+
+// This is used for compatibility with IE.
+bool IsASCIIPrintable(base::char16 c) {
+  return c >= ' ' && c <= '~';
+}
+
+constexpr int DAY_OF_WEEK_COUNT = 7;
+const char weekdays[DAY_OF_WEEK_COUNT][4] = {"Sun", "Mon", "Tue", "Wed",
+                                             "Thu", "Fri", "Sat"};
+
+constexpr int MONTH_COUNT = 12;
+const char months[MONTH_COUNT][4] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+                                     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+
+const char* GetDayOfWeek(int day_of_week) {
+  DCHECK(day_of_week >= 0);
+  DCHECK(day_of_week < DAY_OF_WEEK_COUNT);
+  return weekdays[day_of_week];
+}
+
+const char* GetMonthOfYear(int month_of_year) {
+  DCHECK(month_of_year >= 0);
+  DCHECK(month_of_year < MONTH_COUNT);
+  return months[month_of_year];
+}
+
+// See http://tools.ietf.org/html/rfc2822#section-3.3 for more information.
+std::string MakeRFC2822DateString(base::Time time) {
+  base::Time::Exploded utc_exploded;
+  time.UTCExplode(&utc_exploded);
+  return base::StringPrintf(
+      "Date: %3.3s, %.2u %3.3s %u %.2u:%.2u:%.2u GMT",
+      GetDayOfWeek(utc_exploded.day_of_week), utc_exploded.day_of_month,
+      // Month of year is 1-based.
+      GetMonthOfYear(utc_exploded.month - 1), utc_exploded.year,
+      utc_exploded.hour, utc_exploded.minute, utc_exploded.second);
+}
+
+static std::string ReplaceNonPrintableCharacters(const base::string16& text) {
+  base::string16 quoted_text;
+  base::string16 question_mark = base::ASCIIToUTF16("?");
+
+  for (size_t i = 0; i < text.length(); ++i) {
+    base::char16 c = text[i];
+    if (IsASCIIPrintable(c))
+      quoted_text.append(1, c);
+    else
+      quoted_text.append(question_mark);
+  }
+  return base::UTF16ToUTF8(quoted_text);
+}
+
 }  // 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);
   ~Job() override;
 
   int id() const { return job_id_; }
+
   void set_browser_file(base::File file) { browser_file_ = std::move(file); }
   base::TimeTicks creation_time() const { return creation_time_; }
 
   const GenerateMHTMLCallback& callback() const { return callback_; }
 
   // Indicates whether we expect a message from the |sender| at this time.
   // We expect only one message per frame - therefore calling this method
   // will always clear |frame_tree_node_id_of_busy_frame_|.
   bool IsMessageFromFrameExpected(RenderFrameHostImpl* sender);
 
   // Handler for FrameHostMsg_SerializeAsMHTMLResponse (a notification from the
   // renderer that the MHTML generation for previous frame has finished).
   // Returns MhtmlSaveStatus::SUCCESS or a specific error status.
   MhtmlSaveStatus OnSerializeAsMHTMLResponse(
       const std::set<std::string>& digests_of_uris_of_serialized_resources);
 
   // Sends IPC to the renderer, asking for MHTML generation of the next frame.
   // Returns MhtmlSaveStatus::SUCCESS or a specific error status.
   MhtmlSaveStatus SendToNextRenderFrame();
 
   // Indicates if more calls to SendToNextRenderFrame are needed.
   bool IsDone() const {
     bool waiting_for_response_from_renderer =
         frame_tree_node_id_of_busy_frame_ !=
         FrameTreeNode::kFrameTreeNodeInvalidId;
     bool no_more_requests_to_send = pending_frame_tree_node_ids_.empty();
     return !waiting_for_response_from_renderer && no_more_requests_to_send;
   }
 
+  // Generates the MHTML header.
+  std::string CreateHeader();
+
   // Write the MHTML footer and close the file on the file thread and respond
   // back on the UI thread with the updated status and file size (which will be
   // negative in case of errors).
   void CloseFile(
       base::Callback<void(const std::tuple<MhtmlSaveStatus, int64_t>&)>
           callback,
       MhtmlSaveStatus save_status);
 
   // RenderProcessHostObserver:
   void RenderProcessExited(RenderProcessHost* host,
@@ skipping 65 matching lines @@
   // The handle to the file the MHTML is saved to for the browser process.
   base::File browser_file_;
 
   // Map from frames to content ids (see WebFrameSerializer::generateMHTMLParts
   // for more details about what "content ids" are and how they are used).
   std::map<int, std::string> frame_tree_node_to_content_id_;
 
   // MIME multipart boundary to use in the MHTML doc.
   const std::string mhtml_boundary_marker_;
 
+  // Title of the main page (extracted from the WebContents) for use in the
+  // header.
+  const base::string16 title_;
+
+  // Mime type of the main page (extracted from the WebContents) for use in the
+  // header.
+  const std::string mime_type_;
+
   // Digests of URIs of already generated MHTML parts.
   std::set<std::string> digests_of_already_serialized_uris_;
   std::string salt_;
 
   // The callback to call once generation is complete.
   const GenerateMHTMLCallback callback_;
 
   // Whether the job is finished (set to true only for the short duration of
   // time between MHTMLGenerationManager::JobFinished is called and the job is
   // destroyed by MHTMLGenerationManager::OnFileClosed).
@@ skipping 11 matching lines @@
 
 MHTMLGenerationManager::Job::Job(int job_id,
                                  WebContents* web_contents,
                                  const MHTMLGenerationParams& params,
                                  const GenerateMHTMLCallback& callback)
     : job_id_(job_id),
       creation_time_(base::TimeTicks::Now()),
       params_(params),
       frame_tree_node_id_of_busy_frame_(FrameTreeNode::kFrameTreeNodeInvalidId),
       mhtml_boundary_marker_(net::GenerateMimeMultipartBoundary()),
+      title_(web_contents->GetTitle()),
+      mime_type_(web_contents->GetContentsMimeType()),
       salt_(base::GenerateGUID()),
       callback_(callback),
       is_finished_(false),
       observed_renderer_process_host_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   web_contents->ForEachFrame(base::Bind(
       &MHTMLGenerationManager::Job::AddFrame,
       base::Unretained(this)));  // Safe because ForEachFrame is synchronous.
 
   // Main frame needs to be processed first.
@@ skipping 287 matching lines @@
     DCHECK(base::IsStringASCII(serialized_extra_data_part));
 
     serialized_extra_data_parts += serialized_extra_data_part;
   }
 
   // Write the string into the file.  Returns false if we failed the write.
   return (file.WriteAtCurrentPos(serialized_extra_data_parts.data(),
                                  serialized_extra_data_parts.size()) >= 0);
 }
 
+std::string MHTMLGenerationManager::Job::CreateHeader() {
+  DCHECK(!mhtml_boundary_marker_.empty());
+  DCHECK(!mime_type_.empty());
+
+  std::vector<std::string> headers = {
+      "From: <Saved by Blink>",
+      base::StringPrintf("Subject: %s",
+                         ReplaceNonPrintableCharacters(title_).c_str()),
+      MakeRFC2822DateString(base::Time::Now()),
+      "Mime-Version: 1.0",
+      "Content-Type: multipart/related;",
+      base::StringPrintf("\ttype=\"%s\";", mime_type_.c_str()),
+      base::StringPrintf("\tboundary=\"%s\";", mhtml_boundary_marker_.c_str()),
+      "\r\n"};
+
+  return base::JoinString(headers, "\r\n");
+}
+
 // static
 bool MHTMLGenerationManager::Job::WriteFooter(const std::string& boundary,
                                               base::File& file) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   std::string footer = base::StringPrintf("--%s--\r\n", boundary.c_str());
   DCHECK(base::IsStringASCII(footer));
   return (file.WriteAtCurrentPos(footer.data(), footer.size()) >= 0);
 }
 
 // static
@@ skipping 25 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   Job* job = NewJob(web_contents, params, callback);
   TRACE_EVENT_NESTABLE_ASYNC_BEGIN2(
       "page-serialization", "SavingMhtmlJob", job, "url",
       web_contents->GetLastCommittedURL().possibly_invalid_spec(),
       "file", params.file_path.AsUTF8Unsafe());
 
   BrowserThread::PostTaskAndReplyWithResult(
       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&MHTMLGenerationManager::CreateFile, params.file_path),
+      base::Bind(&MHTMLGenerationManager::CreateFileAndWriteHeader,
+                 params.file_path, job->CreateHeader()),
       base::Bind(&MHTMLGenerationManager::OnFileAvailable,
                  base::Unretained(this),  // Safe b/c |this| is a singleton.
                  job->id()));
 }
 
 void MHTMLGenerationManager::OnSerializeAsMHTMLResponse(
     RenderFrameHostImpl* sender,
     int job_id,
     MhtmlSaveStatus save_status,
     const std::set<std::string>& digests_of_uris_of_serialized_resources,
@@ skipping 24 matching lines @@
     JobFinished(job, save_status);
     return;
   }
 
   // Otherwise report completion if the job is done.
   if (job->IsDone())
     JobFinished(job, MhtmlSaveStatus::SUCCESS);
 }
 
 // static
-base::File MHTMLGenerationManager::CreateFile(const base::FilePath& file_path) {
+MHTMLGenerationManager::FileCreationResult
+MHTMLGenerationManager::CreateFileAndWriteHeader(
+    const base::FilePath& file_path,
+    const std::string& header) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   // SECURITY NOTE: A file descriptor to the file created below will be passed
   // to multiple renderer processes which (in out-of-process iframes mode) can
   // act on behalf of separate web principals.  Therefore it is important to
   // only allow writing to the file and forbid reading from the file (as this
   // would allow reading content generated by other renderers / other web
   // principals).
   uint32_t file_flags = base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE;
+  FileCreationResult result;
+  result.file = base::File(file_path, file_flags);
+  result.header_size = -1;

[carlosk, 2017/04/25 01:28:08]

Set default to -1 so not to have to re-set it here.

+  if (!result.file.IsValid()) {
+    LOG(ERROR) << "Failed to create file to save MHTML at: "
+               << file_path.value();
+    return result;
+  }
 
-  base::File browser_file(file_path, file_flags);
-  if (!browser_file.IsValid()) {
-    LOG(ERROR) << "Failed to create file to save MHTML at: " <<
-        file_path.value();
-  }
-  return browser_file;
+  result.header_size =
+      result.file.WriteAtCurrentPos(header.data(), header.size());
+  return result;

[carlosk, 2017/04/25 01:28:07]

Could you differentiate here between an error creating the file
(MhtmlSaveStatus::FILE_CREATION_ERROR) and another for trying to write the
header (MhtmlSaveStatus::FILE_WRITTING_ERROR)? As header_size is only user for
error checking you could replace it with a MhtmlSaveStatus member.

 }
 
 void MHTMLGenerationManager::OnFileAvailable(int job_id,
-                                             base::File browser_file) {
+                                             FileCreationResult result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   Job* job = FindJob(job_id);
   DCHECK(job);
 
-  if (!browser_file.IsValid()) {
+  if (!result.file.IsValid() || result.header_size < 0) {
     LOG(ERROR) << "Failed to create file";
     JobFinished(job, MhtmlSaveStatus::FILE_CREATION_ERROR);
     return;
   }
 
-  job->set_browser_file(std::move(browser_file));
+  job->set_browser_file(std::move(result.file));
 
   MhtmlSaveStatus save_status = job->SendToNextRenderFrame();
   if (save_status != MhtmlSaveStatus::SUCCESS) {
     JobFinished(job, save_status);
   }
 }
 
 void MHTMLGenerationManager::JobFinished(Job* job,
                                          MhtmlSaveStatus save_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 49 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