Save Page As MHTML

content/browser/download/save_package.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/save_package.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 123 matching lines @@
       user_canceled_(false),
       disk_error_occurred_(false),
       save_type_(save_type),
       all_save_items_count_(0),
       wait_state_(INITIALIZE),
       contents_id_(web_contents->GetRenderProcessHost()->GetID()),
       unique_id_(g_save_package_id++),
       wrote_to_completed_file_(false),
       wrote_to_failed_file_(false) {
   DCHECK(page_url_.is_valid());
-  DCHECK(save_type_ == content::SAVE_PAGE_TYPE_AS_ONLY_HTML ||
-         save_type_ == content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML);
+  DCHECK((save_type_ == content::SAVE_PAGE_TYPE_AS_ONLY_HTML) ||
+         (save_type_ == content::SAVE_PAGE_TYPE_AS_MHTML) ||
+         (save_type_ == content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML));
   DCHECK(!saved_main_file_path_.empty() &&
          saved_main_file_path_.value().length() <= kMaxFilePathLength);
   DCHECK(!saved_main_directory_path_.empty() &&
          saved_main_directory_path_.value().length() < kMaxFilePathLength);
   InternalInit();
 }
 
 SavePackage::SavePackage(WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       file_manager_(NULL),
@@ skipping 102 matching lines @@
 
   file_manager_ = rdh->save_file_manager();
   DCHECK(file_manager_);
 
   download_manager_ = web_contents()->GetBrowserContext()->GetDownloadManager();
   DCHECK(download_manager_);
 
   download_stats::RecordSavePackageEvent(download_stats::SAVE_PACKAGE_STARTED);
 }
 
-bool SavePackage::Init() {
+bool SavePackage::Init(
+    const content::SaveFileDownloadCreatedCallback& download_created_callback) {
   // Set proper running state.
   if (wait_state_ != INITIALIZE)
     return false;
 
   wait_state_ = START_PROCESS;
 
   // Initialize the request context and resource dispatcher.
   content::BrowserContext* browser_context =
       web_contents()->GetBrowserContext();
   if (!browser_context) {
     NOTREACHED();
     return false;
   }
 
   // The download manager keeps ownership but adds us as an observer.
   download_ = download_manager_->CreateSavePackageDownloadItem(
-      saved_main_file_path_, page_url_,
-      browser_context->IsOffTheRecord(), this);
+      saved_main_file_path_,
+      page_url_,
+      browser_context->IsOffTheRecord(),
+      ((save_type_ == content::SAVE_PAGE_TYPE_AS_MHTML) ?
+       "multipart/related" : "text/html"),
+      this);
+  if (!download_created_callback.is_null())
+    download_created_callback.Run(download_);
 
   // Check save type and process the save page job.
   if (save_type_ == content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML) {
     // Get directory
     DCHECK(!saved_main_directory_path_.empty());
     GetAllSavableResourceLinksForCurrentPage();
+  } else if (save_type_ == content::SAVE_PAGE_TYPE_AS_MHTML) {
+    web_contents()->GenerateMHTML(saved_main_file_path_, base::Bind(
+        &SavePackage::OnMHTMLGenerated, this));
   } else {
     wait_state_ = NET_FILES;
     SaveFileCreateInfo::SaveFileSource save_source = page_url_.SchemeIsFile() ?
         SaveFileCreateInfo::SAVE_FILE_FROM_FILE :
         SaveFileCreateInfo::SAVE_FILE_FROM_NET;
     SaveItem* save_item = new SaveItem(page_url_,
                                        GURL(),
                                        this,
                                        save_source);
     // Add this item to waiting list.
     waiting_item_queue_.push(save_item);
     all_save_items_count_ = 1;
     download_->SetTotalBytes(1);
 
     DoSavingProcess();
   }
 
   return true;
 }
 
+void SavePackage::OnMHTMLGenerated(const FilePath& path, int64 size) {
+  if (size <= 0) {
+    Cancel(false);
+    return;
+  }
+  wrote_to_completed_file_ = true;
+  download_->SetTotalBytes(size);
+  download_->UpdateProgress(size, size, DownloadItem::kEmptyFileHash);
+  // Must call OnAllDataSaved here in order for
+  // GDataDownloadObserver::ShouldUpload() to return true.
+  // ShouldCompleteDownload() may depend on the gdata uploader to finish.
+  download_->OnAllDataSaved(size, DownloadItem::kEmptyFileHash);
+  // GDataDownloadObserver is waiting for the upload to complete. When that
+  // happens, it will call download_->MaybeCompleteDownload(), which will call
+  // through our OnDownloadUpdated() allowing us to Finish().
+  // OnDownloadUpdated() may have been called in OnAllDataSaved(), so |this| may
+  // be deleted at this point.
+}
+
 // On POSIX, the length of |pure_file_name| + |file_name_ext| is further
 // restricted by NAME_MAX. The maximum allowed path looks like:
 // '/path/to/save_dir' + '/' + NAME_MAX.
 uint32 SavePackage::GetMaxPathLengthForDirectory(const FilePath& base_dir) {
 #if defined(OS_POSIX)
   return std::min(kMaxFilePathLength,
                   static_cast<uint32>(base_dir.value().length()) +
                   NAME_MAX + 1);
 #else
   return kMaxFilePathLength;
@@ skipping 375 matching lines @@
        it != saved_failed_items_.end(); ++it)
     save_ids.push_back(it->second->save_id());
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&SaveFileManager::RemoveSavedFileFromFileMap,
                  file_manager_,
                  save_ids));
 
   if (download_) {
-    download_->OnAllDataSaved(all_save_items_count_,
-                              DownloadItem::kEmptyFileHash);
+    if (save_type_ != content::SAVE_PAGE_TYPE_AS_MHTML)
+      download_->OnAllDataSaved(all_save_items_count_,
+                                DownloadItem::kEmptyFileHash);
     download_->MarkAsComplete();
     FinalizeDownloadEntry();
   }
 }
 
 // Called for updating end state.
 void SavePackage::SaveFinished(int32 save_id, int64 size, bool is_success) {
   // Because we might have canceled this saving job before,
   // so we might not find corresponding SaveItem. Just ignore it.
   SaveItem* save_item = LookupItemInProcessBySaveId(save_id);
@@ skipping 47 matching lines @@
 
   save_item->Finish(0, false);
 
   PutInProgressItemToSavedMap(save_item);
 
   // Inform the DownloadItem to update UI.
   // We use the received bytes as number of saved files.
   if (download_)
     download_->UpdateProgress(completed_count(), CurrentSpeed(), "");
 
-  if (save_type_ == content::SAVE_PAGE_TYPE_AS_ONLY_HTML ||
-      save_item->save_source() == SaveFileCreateInfo::SAVE_FILE_FROM_DOM) {
+  if ((save_type_ == content::SAVE_PAGE_TYPE_AS_ONLY_HTML) ||
+      (save_type_ == content::SAVE_PAGE_TYPE_AS_MHTML) ||
+      (save_item->save_source() == SaveFileCreateInfo::SAVE_FILE_FROM_DOM)) {
     // We got error when saving page. Treat it as disk error.
     Cancel(true);
   }
 
   if (canceled()) {
     DCHECK(finished_);
     return;
   }
 
   // Continue processing the save page job.
@@ skipping 85 matching lines @@
         wait_state_ = HTML_DATA;
         // All non-HTML resources have been finished, start all remaining
         // HTML files.
         SaveNextFile(true);
       }
     } else if (in_process_count()) {
       // Continue asking for HTML data.
       DCHECK(wait_state_ == HTML_DATA);
     }
   } else {
-    // Save as HTML only.
+    // Save as HTML only or MHTML.
     DCHECK(wait_state_ == NET_FILES);
-    DCHECK(save_type_ == content::SAVE_PAGE_TYPE_AS_ONLY_HTML);
+    DCHECK((save_type_ == content::SAVE_PAGE_TYPE_AS_ONLY_HTML) ||
+           (save_type_ == content::SAVE_PAGE_TYPE_AS_MHTML));
     if (waiting_item_queue_.size()) {
       DCHECK(all_save_items_count_ == waiting_item_queue_.size());
       SaveNextFile(false);
     }
   }
 }
 
 bool SavePackage::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SavePackage, message)
@@ skipping 363 matching lines @@
   // The WebContents which owns this SavePackage may have disappeared during
   // the UI->FILE->UI thread hop of
   // GetSaveInfo->CreateDirectoryOnFileThread->ContinueGetSaveInfo.
   if (!web_contents())
     return;
 
   FilePath::StringType default_extension;
   if (can_save_as_complete)
     default_extension = kDefaultHtmlExtension;
 
-  // On ChromeOS, OnPathPicked is not invoked; SavePackageFilePickerChromeOS
-  // handles the the save.
   download_manager_->delegate()->ChooseSavePath(
-      web_contents(), suggested_path, default_extension, can_save_as_complete,
+      web_contents(),
+      suggested_path,
+      default_extension,
+      can_save_as_complete,
       base::Bind(&SavePackage::OnPathPicked, AsWeakPtr()));
 }
 
-void SavePackage::OnPathPicked(const FilePath& final_name,
-                               content::SavePageType type) {
+void SavePackage::OnPathPicked(
+    const FilePath& final_name,
+    content::SavePageType type,
+    const content::SaveFileDownloadCreatedCallback& download_created_callback) {
   // Ensure the filename is safe.
   saved_main_file_path_ = final_name;
   // TODO(asanka): This call may block on IO and shouldn't be made
   // from the UI thread.  See http://crbug.com/61827.
   net::GenerateSafeFileName(web_contents()->GetContentsMimeType(), false,
                             &saved_main_file_path_);
 
   saved_main_directory_path_ = saved_main_file_path_.DirName();
   save_type_ = type;
   if (save_type_ == content::SAVE_PAGE_TYPE_AS_COMPLETE_HTML) {
     // Make new directory for saving complete file.
     saved_main_directory_path_ = saved_main_directory_path_.Append(
         saved_main_file_path_.RemoveExtension().BaseName().value() +
         FILE_PATH_LITERAL("_files"));
   }
 
-  Init();
+  Init(download_created_callback);
 }
 
 void SavePackage::StopObservation() {
   DCHECK(download_);
   DCHECK(download_manager_);
 
   download_->RemoveObserver(this);
   download_ = NULL;
   download_manager_ = NULL;
 }
 
 void SavePackage::OnDownloadUpdated(DownloadItem* download) {
   DCHECK(download_);
   DCHECK(download_ == download);
   DCHECK(download_manager_);
 
   // Check for removal.
-  if (download->GetState() == DownloadItem::REMOVING)
+  if (download_->GetState() == DownloadItem::REMOVING) {
     StopObservation();
+  }
+
+  // MHTML saves may need to wait for GData to finish uploading.
+  if ((save_type_ == content::SAVE_PAGE_TYPE_AS_MHTML) &&
+      download_->AllDataSaved() &&
+      !download_->IsComplete() &&
+      download_manager_->delegate()->ShouldCompleteDownload(download_)) {
+    Finish();

[asanka, 2012/04/27 16:00:55]

Note that this does a state transition on the DownloadItem while it's in the
middle of UpdateObsevers(). This causes a nested UpdateObservers() to run
causing SavePackage::OnDownloadUpdated() to re-enter.

This can be problematic. Can we post a task to call Finish() instead?

[benjhayden, 2012/04/27 17:28:52]

Done.

+  }
 }
 
 void SavePackage::FinalizeDownloadEntry() {
   DCHECK(download_);
   DCHECK(download_manager_);
 
   download_manager_->SavePageDownloadFinished(download_);
   StopObservation();
 }