Save Page As MHTML

content/browser/download/save_package.h

 // 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.
 
 #ifndef CONTENT_BROWSER_DOWNLOAD_SAVE_PACKAGE_H_
 #define CONTENT_BROWSER_DOWNLOAD_SAVE_PACKAGE_H_
 #pragma once
 
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/download_item.h"
+#include "content/public/browser/download_manager_delegate.h"
 #include "content/public/browser/save_page_type.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "googleurl/src/gurl.h"
 
 class GURL;
 class SaveFileManager;
 class SaveItem;
 class SavePackage;
 struct SaveFileCreateInfo;
 
 namespace content {
 class DownloadManager;
 class WebContents;
 }
 
 // The SavePackage object manages the process of saving a page as only-html or
-// complete-html and providing the information for displaying saving status.
-// Saving page as only-html means means that we save web page to a single HTML
-// file regardless internal sub resources and sub frames.
-// Saving page as complete-html page means we save not only the main html file
-// the user told it to save but also a directory for the auxiliary files such
-// as all sub-frame html files, image files, css files and js files.
+// complete-html or MHTML and providing the information for displaying saving
+// status.  Saving page as only-html means means that we save web page to a
+// single HTML file regardless internal sub resources and sub frames.  Saving
+// page as complete-html page means we save not only the main html file the user
+// told it to save but also a directory for the auxiliary files such as all
+// sub-frame html files, image files, css files and js files.  Saving page as
+// MHTML means the same thing as complete-html, but it uses the MHTML format to
+// contain the html and all auxiliary files in a single text file.
 //
 // Each page saving job may include one or multiple files which need to be
 // saved. Each file is represented by a SaveItem, and all SaveItems are owned
 // by the SavePackage. SaveItems are created when a user initiates a page
 // saving job, and exist for the duration of one contents's life time.
 class CONTENT_EXPORT SavePackage
     : public base::RefCountedThreadSafe<SavePackage>,
       public content::WebContentsObserver,
       public content::DownloadItem::Observer,
       public base::SupportsWeakPtr<SavePackage> {
@@ skipping 23 matching lines @@
   explicit SavePackage(content::WebContents* web_contents);
 
   // This contructor is used only for testing. We can bypass the file and
   // directory name generation / sanitization by providing well known paths
   // better suited for tests.
   SavePackage(content::WebContents* web_contents,
               content::SavePageType save_type,
               const FilePath& file_full_path,
               const FilePath& directory_full_path);
 
-  // Initialize the SavePackage. Returns true if it initializes properly.
-  // Need to make sure that this method must be called in the UI thread because
-  // using g_browser_process on a non-UI thread can cause crashes during
-  // shutdown.
-  bool Init();
+  // Initialize the SavePackage. Returns true if it initializes properly.  Need
+  // to make sure that this method must be called in the UI thread because using
+  // g_browser_process on a non-UI thread can cause crashes during shutdown.
+  // |cb| will be called when the DownloadItem is created, before data is
+  // written to disk.
+  bool Init(const content::SavePackageDownloadCreatedCallback& cb);
 
   // Cancel all in progress request, might be called by user or internal error.
   void Cancel(bool user_action);
 
   void Finish();
 
   // Notifications sent from the file thread to the UI thread.
   void StartSave(const SaveFileCreateInfo* info);
   bool UpdateSaveProgress(int32 save_id, int64 size, bool write_success);
   void SaveFinished(int32 save_id, int64 size, bool is_success);
   void SaveFailed(const GURL& save_url);
   void SaveCanceled(SaveItem* save_item);
 
   // Rough percent complete, -1 means we don't know (since we didn't receive a
   // total size).
   int PercentComplete();
 
   bool canceled() const { return user_canceled_ || disk_error_occurred_; }
   bool finished() const { return finished_; }
   content::SavePageType save_type() const { return save_type_; }
   int contents_id() const { return contents_id_; }
   int id() const { return unique_id_; }
   content::WebContents* web_contents() const;
 
   void GetSaveInfo();
 
  private:
   friend class base::RefCountedThreadSafe<SavePackage>;
 
+  // Callback for content::WebContents::GenerateMHTML().
+  void OnMHTMLGenerated(const FilePath& path, int64 size);
+
   // For testing only.
   SavePackage(content::WebContents* web_contents,
               const FilePath& file_full_path,
               const FilePath& directory_full_path);
 
   virtual ~SavePackage();
 
   // Notes from Init() above applies here as well.
   void InternalInit();
 
@@ skipping 47 matching lines @@
 
   // Retrieves the URL to be saved from the WebContents.
   GURL GetUrlToBeSaved();
 
   void CreateDirectoryOnFileThread(const FilePath& website_save_dir,
                                    const FilePath& download_save_dir,
                                    const std::string& mime_type,
                                    const std::string& accept_langs);
   void ContinueGetSaveInfo(const FilePath& suggested_path,
                            bool can_save_as_complete);
-  void OnPathPicked(const FilePath& final_name, content::SavePageType type);
+  void OnPathPicked(
+      const FilePath& final_name,
+      content::SavePageType type,
+      const content::SavePackageDownloadCreatedCallback& cb);
   void OnReceivedSavableResourceLinksForCurrentPage(
       const std::vector<GURL>& resources_list,
       const std::vector<GURL>& referrers_list,
       const std::vector<GURL>& frames_list);
 
   void OnReceivedSerializedHtmlData(const GURL& frame_url,
                                     const std::string& data,
                                     int32 status);
 
   typedef base::hash_map<std::string, SaveItem*> SaveUrlItemMap;
@@ skipping 64 matching lines @@
 
   // The title of the page the user wants to save.
   string16 title_;
 
   // Used to calculate package download speed (in files per second).
   base::TimeTicks start_tick_;
 
   // Indicates whether the actual saving job is finishing or not.
   bool finished_;
 
+  // Indicates whether a call to Finish() has been scheduled.
+  bool mhtml_finishing_;
+
   // Indicates whether user canceled the saving job.
   bool user_canceled_;
 
   // Indicates whether user get disk error.
   bool disk_error_occurred_;
 
   // Type about saving page as only-html or complete-html.
   content::SavePageType save_type_;
 
   // Number of all need to be saved resources.
@@ skipping 24 matching lines @@
   bool wrote_to_failed_file_;
 
   friend class SavePackageTest;
   FRIEND_TEST_ALL_PREFIXES(SavePackageTest, TestSuggestedSaveNames);
   FRIEND_TEST_ALL_PREFIXES(SavePackageTest, TestLongSafePureFilename);
 
   DISALLOW_COPY_AND_ASSIGN(SavePackage);
 };
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_SAVE_PACKAGE_H_