Fail when saving page as MHTML provides information about the cause.

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 38 matching lines @@
 
   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 |true| upon success; |false| otherwise.
-  bool OnSerializeAsMHTMLResponse(
+  // 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 true if the message was sent successfully; false otherwise.
-  bool SendToNextRenderFrame();
+  // 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;
   }
 
@@ skipping 117 matching lines @@
     int routing_id =
         ftn->render_manager()->GetRoutingIdForSiteInstance(site_instance);
     if (routing_id == MSG_ROUTING_NONE)
       continue;
 
     result[routing_id] = content_id;
   }
   return result;
 }
 
-bool MHTMLGenerationManager::Job::SendToNextRenderFrame() {
+MhtmlSaveStatus MHTMLGenerationManager::Job::SendToNextRenderFrame() {
   DCHECK(browser_file_.IsValid());
   DCHECK(!pending_frame_tree_node_ids_.empty());
 
   FrameMsg_SerializeAsMHTML_Params ipc_params;
   ipc_params.job_id = job_id_;
   ipc_params.mhtml_boundary_marker = mhtml_boundary_marker_;
   ipc_params.mhtml_binary_encoding = params_.use_binary_encoding;
   ipc_params.mhtml_cache_control_policy = params_.cache_control_policy;
 
   int frame_tree_node_id = pending_frame_tree_node_ids_.front();
   pending_frame_tree_node_ids_.pop();
   ipc_params.is_last_frame = pending_frame_tree_node_ids_.empty();
 
   FrameTreeNode* ftn = FrameTreeNode::GloballyFindByID(frame_tree_node_id);
   if (!ftn)  // The contents went away.
-    return false;
+    return MhtmlSaveStatus::FRAME_NO_LONGER_EXIST;
   RenderFrameHost* rfh = ftn->current_frame_host();
 
   // Get notified if the target of the IPC message dies between responding.
   observed_renderer_process_host_.RemoveAll();
   observed_renderer_process_host_.Add(rfh->GetProcess());
 
   // Tell the renderer to skip (= deduplicate) already covered MHTML parts.
   ipc_params.salt = salt_;
   ipc_params.digests_of_uris_to_skip = digests_of_already_serialized_uris_;
 
   ipc_params.destination_file = IPC::GetPlatformFileForTransit(
       browser_file_.GetPlatformFile(), false);  // |close_source_handle|.
   ipc_params.frame_routing_id_to_content_id =
       CreateFrameRoutingIdToContentId(rfh->GetSiteInstance());
 
   // Send the IPC asking the renderer to serialize the frame.
   DCHECK_EQ(FrameTreeNode::kFrameTreeNodeInvalidId,
             frame_tree_node_id_of_busy_frame_);
   frame_tree_node_id_of_busy_frame_ = frame_tree_node_id;
   rfh->Send(new FrameMsg_SerializeAsMHTML(rfh->GetRoutingID(), ipc_params));
   TRACE_EVENT_NESTABLE_ASYNC_BEGIN1("page-serialization", "WaitingOnRenderer",
                                     this, "frame tree node id",
                                     frame_tree_node_id);
   DCHECK(wait_on_renderer_start_time_.is_null());
   wait_on_renderer_start_time_ = base::TimeTicks::Now();
-  return true;
+  return MhtmlSaveStatus::SUCCESS;
 }
 
 void MHTMLGenerationManager::Job::RenderProcessExited(
     RenderProcessHost* host,
     base::TerminationStatus status,
     int exit_code) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   MHTMLGenerationManager::GetInstance()->RenderProcessExited(this);
 }
 
@@ skipping 86 matching lines @@
   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
   // from the same |sender| will be rejected.
   frame_tree_node_id_of_busy_frame_ = FrameTreeNode::kFrameTreeNodeInvalidId;
 
   return true;
 }
 
-bool MHTMLGenerationManager::Job::OnSerializeAsMHTMLResponse(
+MhtmlSaveStatus MHTMLGenerationManager::Job::OnSerializeAsMHTMLResponse(
     const std::set<std::string>& digests_of_uris_of_serialized_resources) {
   DCHECK(!wait_on_renderer_start_time_.is_null());
   base::TimeDelta renderer_wait_time =
       base::TimeTicks::Now() - wait_on_renderer_start_time_;
   UMA_HISTOGRAM_TIMES(
       "PageSerialization.MhtmlGeneration.BrowserWaitForRendererTime."
       "SingleFrame",
       renderer_wait_time);
   all_renderers_wait_time_ += renderer_wait_time;
   wait_on_renderer_start_time_ = base::TimeTicks();
 
   // Renderer should be deduping resources with the same uris.
   DCHECK_EQ(0u, base::STLSetIntersection<std::set<std::string>>(
                     digests_of_already_serialized_uris_,
                     digests_of_uris_of_serialized_resources).size());
   digests_of_already_serialized_uris_.insert(
       digests_of_uris_of_serialized_resources.begin(),
       digests_of_uris_of_serialized_resources.end());
 
+  // Report success if all frames have been processed.
   if (pending_frame_tree_node_ids_.empty())
-    return true;  // Report success - all frames have been processed.
+    return MhtmlSaveStatus::SUCCESS;
 
   return SendToNextRenderFrame();
 }
 
 // static
 int64_t MHTMLGenerationManager::Job::CloseFileOnFileThread(base::File file) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DCHECK(file.IsValid());
   int64_t file_size = file.GetLength();
   file.Close();
@@ skipping 24 matching lines @@
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&MHTMLGenerationManager::CreateFile, params.file_path),
       base::Bind(&MHTMLGenerationManager::OnFileAvailable,
                  base::Unretained(this),  // Safe b/c |this| is a singleton.
                  job->id()));
 }
 
 void MHTMLGenerationManager::OnSerializeAsMHTMLResponse(
     RenderFrameHostImpl* sender,
     int job_id,
-    bool mhtml_generation_in_renderer_succeeded,
+    MhtmlSaveStatus save_status,
     const std::set<std::string>& digests_of_uris_of_serialized_resources,
     base::TimeDelta renderer_main_thread_time) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   Job* job = FindJob(job_id);
   if (!job || !job->IsMessageFromFrameExpected(sender)) {
     NOTREACHED();
     ReceivedBadMessage(sender->GetProcess(),
                        bad_message::DWNLD_INVALID_SERIALIZE_AS_MHTML_RESPONSE);
     return;
   }
 
   TRACE_EVENT_NESTABLE_ASYNC_END0("page-serialization", "WaitingOnRenderer",
                                   job);
   job->ReportRendererMainThreadTime(renderer_main_thread_time);
 
-  if (!mhtml_generation_in_renderer_succeeded) {
-    JobFinished(job, JobStatus::FAILURE);
-    return;
+  if (save_status == MhtmlSaveStatus::SUCCESS) {
+    save_status = job->OnSerializeAsMHTMLResponse(
+        digests_of_uris_of_serialized_resources);
   }
 
-  if (!job->OnSerializeAsMHTMLResponse(
-          digests_of_uris_of_serialized_resources)) {
-    JobFinished(job, JobStatus::FAILURE);
+  if (save_status != MhtmlSaveStatus::SUCCESS) {
+    JobFinished(job, save_status);
     return;
   }
 
   if (job->IsDone())
-    JobFinished(job, JobStatus::SUCCESS);
+    JobFinished(job, MhtmlSaveStatus::SUCCESS);
 }
 
 // static
 base::File MHTMLGenerationManager::CreateFile(const base::FilePath& file_path) {
   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
@@ skipping 11 matching lines @@
 
 void MHTMLGenerationManager::OnFileAvailable(int job_id,
                                              base::File browser_file) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   Job* job = FindJob(job_id);
   DCHECK(job);
 
   if (!browser_file.IsValid()) {
     LOG(ERROR) << "Failed to create file";
-    JobFinished(job, JobStatus::FAILURE);
+    JobFinished(job, MhtmlSaveStatus::FILE_CREATION_ERROR);
     return;
   }
 
   job->set_browser_file(std::move(browser_file));
 
-  if (!job->SendToNextRenderFrame()) {
-    JobFinished(job, JobStatus::FAILURE);
+  MhtmlSaveStatus save_status = job->SendToNextRenderFrame();
+  if (save_status != MhtmlSaveStatus::SUCCESS) {
+    JobFinished(job, save_status);
   }
 }
 
-void MHTMLGenerationManager::JobFinished(Job* job, JobStatus job_status) {
+void MHTMLGenerationManager::JobFinished(Job* job,
+                                         MhtmlSaveStatus save_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(job);
 
   job->MarkAsFinished();
   job->CloseFile(
       base::Bind(&MHTMLGenerationManager::OnFileClosed,
                  base::Unretained(this),  // Safe b/c |this| is a singleton.
-                 job->id(), job_status));
+                 job->id(), save_status));
 }
 
 void MHTMLGenerationManager::OnFileClosed(int job_id,
-                                          JobStatus job_status,
+                                          MhtmlSaveStatus save_status,
                                           int64_t file_size) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
+  // Checks if an error happened while closing the file.
+  if (save_status == MhtmlSaveStatus::SUCCESS && file_size < 0)
+    save_status = MhtmlSaveStatus::FILE_CLOSING_ERROR;

[Łukasz Anforowicz, 2016/11/22 19:22:13]

Interesting, I didn't know that base::File::GetLength can return a negative
value to indicate a failure.

[carlosk, 2016/11/22 23:26:23]

It can't. But that's the "error code" response when CloseFile invokes this
method as a callback. See MHTMLGenerationManager::Job::CloseFile.

+
   Job* job = FindJob(job_id);
   TRACE_EVENT_NESTABLE_ASYNC_END2(
-      "page-serialization", "SavingMhtmlJob", job, "job result",
-      job_status == JobStatus::SUCCESS ? "success" : "failure", "file size",
-      file_size);
+      "page-serialization", "SavingMhtmlJob", job, "job save status",
+      save_status == MhtmlSaveStatus::SUCCESS
+          ? "success"
+          : base::StringPrintf("failure (%d)", static_cast<int>(save_status)),
+      "file size", file_size);
   UMA_HISTOGRAM_TIMES("PageSerialization.MhtmlGeneration.FullPageSavingTime",
                       base::TimeTicks::Now() - job->creation_time());
-  job->callback().Run(job_status == JobStatus::SUCCESS ? file_size : -1);
+  UMA_HISTOGRAM_ENUMERATION("PageSerialization.MhtmlGeneration.FinalSaveStatus",
+                            static_cast<int>(save_status),
+                            static_cast<int>(MhtmlSaveStatus::STATUS_COUNT));
+  job->callback().Run(save_status == MhtmlSaveStatus::SUCCESS ? file_size : -1);
   id_to_job_.erase(job_id);
 }
 
 MHTMLGenerationManager::Job* MHTMLGenerationManager::NewJob(
     WebContents* web_contents,
     const MHTMLGenerationParams& params,
     const GenerateMHTMLCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   Job* job = new Job(++next_job_id_, web_contents, params, callback);
   id_to_job_[job->id()] = base::WrapUnique(job);
   return job;
 }
 
 MHTMLGenerationManager::Job* MHTMLGenerationManager::FindJob(int job_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   auto iter = id_to_job_.find(job_id);
   if (iter == id_to_job_.end()) {
     NOTREACHED();
     return nullptr;
   }
   return iter->second.get();
 }
 
 void MHTMLGenerationManager::RenderProcessExited(Job* job) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(job);
-  JobFinished(job, JobStatus::FAILURE);
+  JobFinished(job, MhtmlSaveStatus::RENDER_PROCESS_EXITED);
 }
 
 }  // namespace content