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),
       tab_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 118 matching lines @@
   wait_state_ = START_PROCESS;
 
   // Initialize the request context and resource dispatcher.
   content::BrowserContext* browser_context =
       web_contents()->GetBrowserContext();
   if (!browser_context) {
     NOTREACHED();
     return false;
   }
 
+  if (save_type_ == content::SAVE_PAGE_TYPE_AS_MHTML) {
+    // Force the extension to be mht. If the extension is left as html, then
+    // chrome will render it as html when opened instead of mhtml.
+    // Force the extension before creating the DownloadItem.
+    // TODO(benjhayden): Figure out how to move this back into the file picker.
+    // If the .html file already exists, then the user will be prompted to
+    // replace it, even thought it won't be replaced. If the .mht already
+    // exists, then the user will not be prompted to replace it, even though it
+    // will be replaced. The user will only be prompted to replace the .mht if
+    // they type out the filename including .mht.
+    saved_main_file_path_ = saved_main_file_path_.ReplaceExtension(
+        FILE_PATH_LITERAL("mht"));
+  }
+
   // 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);
 
   // 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::MHTMLGenerated, 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::MHTMLGenerated(const FilePath& path, int64 size) {
+  if (size <= 0) {
+    Cancel(false);
+  } else {
+    download_->SetTotalBytes(size);
+    download_->OnAllDataSaved(size, DownloadItem::kEmptyFileHash);
+    download_->UpdateProgress(size, 0, "");
+    wrote_to_completed_file_ = true;
+    Finish();
+  }
+}
+
 // 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) {

[Randy Smith (Not in Mondays), 2012/04/16 17:45:47]

I'm somewhat torn about this and related logic.  It looks like the behavior
we're going to end up with is:
* HTML only: Size == count of items == 1
* HTML complete: Size == count of items == n
* MHTML: Size == number of bytes downloads

Before we were broken but consistent (size was always count of items).  Now
we're inconsistent, and to my mind, inconsistently inconsistent (because the
other single file case is still count of items rather than number of bytes).  Is
this really the behavior we want?

[benjhayden, 2012/04/16 19:08:06]

Done.

+      download_->OnAllDataSaved(all_save_items_count_,

[Randy Smith (Not in Mondays), 2012/04/16 17:45:47]

nit: If there's an easy, not too ugly way to do it, I'd like all the
OnAllDataSaved calls to be in the same place.  That way a) there's less chance
of us ending up with two or zero calls at some change in the future, and b)
whatever behavior we decide on with regard to size will be very visible at one
place in the code.

[benjhayden, 2012/04/16 19:08:06]

Done.

+                                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 417 matching lines @@
     StopObservation();
 }
 
 void SavePackage::FinalizeDownloadEntry() {
   DCHECK(download_);
   DCHECK(download_manager_);
 
   download_manager_->SavePageDownloadFinished(download_);
   StopObservation();
 }