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

chrome/browser/views/shell_dialogs_win.cc

 // 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.
 
 #include "chrome/browser/shell_dialogs.h"
 
 #include <windows.h>
 #include <commdlg.h>
 #include <shlobj.h>
 #include <atlbase.h>
@@ skipping 177 matching lines @@
 class SelectFileDialogImpl : public SelectFileDialog,
                              public BaseShellDialogImpl {
  public:
   explicit SelectFileDialogImpl(Listener* listener);
   virtual ~SelectFileDialogImpl();
 
   // SelectFileDialog implementation:
   virtual void SelectFile(Type type, const std::wstring& title,
                           const std::wstring& default_path,
                           const std::wstring& filter,
+                          int filter_index,
                           const std::wstring& default_extension,
                           HWND owning_hwnd,
                           void* params);
   virtual bool IsRunning(HWND owning_hwnd) const;
   virtual void ListenerDestroyed();
 
  private:
+  // A struct for holding all the state necessary for displaying a Save dialog.
+  struct ExecuteSelectParams {
+    ExecuteSelectParams(Type type,
+                        const std::wstring& title,
+                        const std::wstring& default_path,
+                        const std::wstring& filter,
+                        int filter_index,
+                        const std::wstring& default_extension,
+                        RunState run_state,
+                        HWND owner,
+                        void* params)
+        : type(type), title(title), default_path(default_path), filter(filter),
+          filter_index(filter_index), default_extension(default_extension),
+          run_state(run_state), owner(owner), params(params) {
+    }
+    SelectFileDialog::Type type;
+    std::wstring title;
+    std::wstring default_path;
+    std::wstring filter;
+    int filter_index;
+    std::wstring default_extension;
+    RunState run_state;
+    HWND owner;
+    void* params;
+  };
+
   // Shows the file selection dialog modal to |owner| and calls the result
   // back on the ui thread. Run on the dialog thread.
-  void ExecuteSelectFile(Type type,
-                         const std::wstring& title,
-                         const std::wstring& default_path,
-                         const std::wstring& filter,
-                         const std::wstring& default_extension,
-                         RunState run_state,
-                         void* params);
+  void ExecuteSelectFile(const ExecuteSelectParams& params);
 
   // Notifies the listener that a folder was chosen. Run on the ui thread.
-  void FileSelected(const std::wstring& path, void* params, RunState run_state);
+  void FileSelected(const std::wstring& path, int index,
+                    void* params, RunState run_state);
 
   // Notifies listener that multiple files were chosen. Run on the ui thread.
   void MultiFilesSelected(const std::vector<std::wstring>& paths, void* params,
                          RunState run_state);
 
   // Notifies the listener that no file was chosen (the action was canceled).
   // Run on the ui thread.
   void FileNotSelected(void* params, RunState run_state);
 
   // Runs a Folder selection dialog box, passes back the selected folder in
@@ skipping 35 matching lines @@
       BaseShellDialogImpl() {
 }
 
 SelectFileDialogImpl::~SelectFileDialogImpl() {
 }
 
 void SelectFileDialogImpl::SelectFile(Type type,
                                       const std::wstring& title,
                                       const std::wstring& default_path,
                                       const std::wstring& filter,
+                                      int filter_index,
                                       const std::wstring& default_extension,
                                       HWND owner,
                                       void* params) {
-  RunState run_state = BeginRun(owner);
-  run_state.dialog_thread->message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(this, &SelectFileDialogImpl::ExecuteSelectFile, type,
-                        title, default_path, filter, default_extension,
-                        run_state, params));
+  ExecuteSelectParams execute_params(type, title, default_path, filter,
+                                     filter_index, default_extension,
+                                     BeginRun(owner), owner, params);
+  execute_params.run_state.dialog_thread->message_loop()->PostTask(FROM_HERE,
+      NewRunnableMethod(this, &SelectFileDialogImpl::ExecuteSelectFile,
+                        execute_params));
 }
 
 bool SelectFileDialogImpl::IsRunning(HWND owning_hwnd) const {
   return listener_ && IsRunningDialogForOwner(owning_hwnd);
 }
 
 void SelectFileDialogImpl::ListenerDestroyed() {
   // Our associated listener has gone away, so we shouldn't call back to it if
   // our worker thread returns after the listener is dead.
   listener_ = NULL;
 }
 
 void SelectFileDialogImpl::ExecuteSelectFile(
-    Type type,
-    const std::wstring& title,
-    const std::wstring& default_path,
-    const std::wstring& filter,
-    const std::wstring& default_extension,
-    RunState run_state,
-    void* params) {
-  std::wstring path = default_path;
+    const ExecuteSelectParams& params) {
+  std::wstring path = params.default_path;
   bool success = false;
-  if (type == SELECT_FOLDER) {
-    success = RunSelectFolderDialog(title, run_state.owner, &path);
-  } else if (type == SELECT_SAVEAS_FILE) {
-    unsigned index = 0;
-    success = win_util::SaveFileAsWithFilter(run_state.owner, default_path,
-        filter, default_extension, false, &index, &path);
-    DisableOwner(run_state.owner);
-  } else if (type == SELECT_OPEN_FILE) {
-    success = RunOpenFileDialog(title, filter, run_state.owner, &path);
-  } else if (type == SELECT_OPEN_MULTI_FILE) {
+  unsigned filter_index = params.filter_index;
+  if (params.type == SELECT_FOLDER) {
+    success = RunSelectFolderDialog(params.title,
+                                    params.run_state.owner,
+                                    &path);
+  } else if (params.type == SELECT_SAVEAS_FILE) {
+    success = win_util::SaveFileAsWithFilter(params.run_state.owner,
+        params.default_path, params.filter, params.default_extension, false,
+        &filter_index, &path);
+    DisableOwner(params.run_state.owner);
+  } else if (params.type == SELECT_OPEN_FILE) {
+    success = RunOpenFileDialog(params.title, params.filter,
+                                params.run_state.owner, &path);
+  } else if (params.type == SELECT_OPEN_MULTI_FILE) {
     std::vector<std::wstring> paths;
-    if (RunOpenMultiFileDialog(title, filter, run_state.owner, &paths)) {
+    if (RunOpenMultiFileDialog(params.title, params.filter,
+                               params.run_state.owner, &paths)) {
       ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-          &SelectFileDialogImpl::MultiFilesSelected, paths, params, run_state));
+          &SelectFileDialogImpl::MultiFilesSelected,
+          paths, params.params, params.run_state));
       return;
     }
   }
 
   if (success) {
     ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &SelectFileDialogImpl::FileSelected, path, params, run_state));
+        &SelectFileDialogImpl::FileSelected, path, filter_index,
+        params.params, params.run_state));
   } else {
     ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &SelectFileDialogImpl::FileNotSelected, params, run_state));
+        &SelectFileDialogImpl::FileNotSelected, params.params,
+        params.run_state));
   }
 }
 
 void SelectFileDialogImpl::FileSelected(const std::wstring& selected_folder,
+                                        int index,
                                         void* params,
                                         RunState run_state) {
   if (listener_)
-    listener_->FileSelected(selected_folder, params);
+    listener_->FileSelected(selected_folder, index, params);
   EndRun(run_state);
 }
 
 void SelectFileDialogImpl::MultiFilesSelected(
   const std::vector<std::wstring>& selected_files,
   void* params,
   RunState run_state) {
   if (listener_)
     listener_->MultiFilesSelected(selected_files, params);
   EndRun(run_state);
@@ skipping 315 matching lines @@
 void SelectFontDialogImpl::FontNotSelected(void* params, RunState run_state) {
   if (listener_)
     listener_->FontSelectionCanceled(params);
   EndRun(run_state);
 }
 
 // static
 SelectFontDialog* SelectFontDialog::Create(Listener* listener) {
   return new SelectFontDialogImpl(listener);
 }