Remove Windows "Save As" dialogs from Save Page code....

chrome/browser/download/save_package.h

 // Copyright (c) 2006-2008 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 CHROME_BROWSER_DOWNLOAD_SAVE_PACKAGE_H_
 #define CHROME_BROWSER_DOWNLOAD_SAVE_PACKAGE_H_
 
 #include <queue>
 #include <string>
 #include <utility>
@@ skipping 14 matching lines @@
 class DownloadItem;
 class DownloadManager;
 class GURL;
 class MessageLoop;
 class PrefService;
 class Profile;
 class WebContents;
 class URLRequestContext;
 class WebContents;
 
+#if defined(OS_WIN) || defined(OS_LINUX)
+// TODO(port): port this header.
+#include "chrome/browser/shell_dialogs.h"
+#elif defined(OS_MACOSX)
+#include "chrome/common/temp_scaffolding_stubs.h"
+#endif
+
 namespace base {
 class Thread;
 class Time;
 }
 
+struct SavePackageParam;
+
 // 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.
 //
 // 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 tab's life time.
 class SavePackage : public base::RefCountedThreadSafe<SavePackage>,
-                    public RenderViewHostDelegate::Save {
+                    public RenderViewHostDelegate::Save,
+                    public SelectFileDialog::Listener {
  public:
   enum SavePackageType {
     // User chose to save only the HTML of the page.
     SAVE_AS_ONLY_HTML = 0,
     // User chose to save complete-html page.
     SAVE_AS_COMPLETE_HTML = 1
   };
 
   enum WaitState {
     // State when created but not initialized.
     INITIALIZE = 0,
     // State when after initializing, but not yet saving.
     START_PROCESS,
     // Waiting on a list of savable resources from the backend.
     RESOURCES_LIST,
     // Waiting for data sent from net IO or from file system.
     NET_FILES,
     // Waiting for html DOM data sent from render process.
     HTML_DATA,
     // Saving page finished successfully.
     SUCCESSFUL,
     // Failed to save page.
     FAILED
   };
 
+  // Constructor for user initiated page saving. This constructor results in a
+  // SavePackage that will generate and sanitize a suggested name for the user
+  // in the "Save As" dialog box.
+  SavePackage(WebContents* web_content);
+
+  // 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(WebContents* web_content,
               SavePackageType save_type,
               const FilePath& file_full_path,
               const FilePath& directory_full_path);
 
   ~SavePackage();
 
   // 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
@@ skipping 21 matching lines @@
   bool canceled() { return user_canceled_ || disk_error_occurred_; }
 
   // Accessor
   bool finished() { return finished_; }
   SavePackageType save_type() { return save_type_; }
 
   // Since for one tab, it can only have one SavePackage in same time.
   // Now we actually use render_process_id as tab's unique id.
   int tab_id() const { return tab_id_; }
 
+  void GetSaveInfo();
+  void ContinueSave(SavePackageParam* param,
+                    const std::wstring& final_name,
+                    int index);
+
   // RenderViewHostDelegate::Save ----------------------------------------------
 
   // Process all of the current page's savable links of subresources, resources
   // referrers and frames (including the main frame and subframes) from the
   // render view host.
   virtual void OnReceivedSavableResourceLinksForCurrentPage(
       const std::vector<GURL>& resources_list,
       const std::vector<GURL>& referrers_list,
       const std::vector<GURL>& frames_list);
 
   // Process the serialized html content data of a specified web page
   // gotten from render process.
   virtual void OnReceivedSerializedHtmlData(const GURL& frame_url,
                                             const std::string& data,
                                             int32 status);
 
   // Statics -------------------------------------------------------------------
 
   // Used to disable prompting the user for a directory/filename of the saved
   // web page.  This is available for testing.
   static void SetShouldPromptUser(bool should_prompt);
 
   // Helper function for preparing suggested name for the SaveAs Dialog. The
   // suggested name is composed of the default save path and the web document's
   // title.
   static FilePath GetSuggestNameForSaveAs(PrefService* prefs,
                                           const FilePath& name);
 
-  // This structure is for storing parameters which we will use to create
-  // a SavePackage object later.
-  struct SavePackageParam {
-    // MIME type of current tab contents.
-    const std::string& current_tab_mime_type;
-    // Pointer to preference service.
-    PrefService* prefs;
-    // Type about saving page as only-html or complete-html.
-    SavePackageType save_type;
-    // File path for main html file.
-    FilePath saved_main_file_path;
-    // Directory path for saving sub resources and sub html frames.
-    FilePath dir;
-
-    SavePackageParam(const std::string& mime_type)
-        : current_tab_mime_type(mime_type) { }
-  };
-  static bool GetSaveInfo(const FilePath& suggest_name,
-                          gfx::NativeView container_window,
-                          SavePackageParam* param,
-                          DownloadManager* download_manager);
-
   // Check whether we can do the saving page operation for the specified URL.
   static bool IsSavableURL(const GURL& url);
 
   // Check whether we can do the saving page operation for the contents which
   // have the specified MIME type.
   static bool IsSavableContents(const std::string& contents_mime_type);
 
   // Check whether we can save page as complete-HTML for the contents which
   // have specified a MIME type. Now only contents which have the MIME type
   // "text/html" can be saved as complete-HTML.
@@ skipping 14 matching lines @@
   // file path. If the length of specified file path is great than
   // |max_file_path_len|, the |pure_file_name| will output new pure file name
   // part for making sure the length of specified file path is less than
   // specified maximum length of file path. Return false if the function can
   // not get a safe pure file name, otherwise it returns true.
   static bool GetSafePureFileName(const FilePath& dir_path,
                                   const FilePath::StringType& file_name_ext,
                                   uint32 max_file_path_len,
                                   FilePath::StringType* pure_file_name);
 
+  // SelectFileDialog::Listener interface.
+  virtual void FileSelected(const std::wstring& path, int index, void* params);
+  virtual void FileSelectionCanceled(void* params);
+
  private:
   // For testing only.
   SavePackage(const FilePath& file_full_path,
               const FilePath& directory_full_path);
 
   void Stop();
   void CheckFinish();
   void SaveNextFile(bool process_all_remainder_items);
   void DoSavingProcess();
 
@@ skipping 80 matching lines @@
   // This map is used to track serial number for specified filename.
   FileNameCountMap file_name_count_map_;
 
   // Indicates current waiting state when SavePackage try to get something
   // from outside.
   WaitState wait_state_;
 
   // Unique id for this SavePackage.
   const int tab_id_;
 
+  // For managing select file dialogs.
+  scoped_refptr<SelectFileDialog> select_file_dialog_;
+
   friend class SavePackageTest;
   DISALLOW_COPY_AND_ASSIGN(SavePackage);
 };
 
 #endif  // CHROME_BROWSER_DOWNLOAD_SAVE_PACKAGE_H_