Refactoring; switch the |filter| parameter into something that is more amenab...

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>
 
 #include <algorithm>
 #include <set>
 
 #include "base/file_util.h"
 #include "base/registry.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/gfx/chrome_font.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/win_util.h"
 #include "grit/generated_resources.h"
 
+// Helpers to show certain types of Windows shell dialogs in a way that doesn't
+// block the UI of the entire app.
+
 class ShellDialogThread : public base::Thread {
  public:
   ShellDialogThread() : base::Thread("Chrome_ShellDialogThread") { }
 
  protected:
   void Init() {
     // Initializes the COM library on the current thread.
     CoInitialize(NULL);
   }
 
@@ skipping 150 matching lines @@
 
 // Implementation of SelectFileDialog that shows a Windows common dialog for
 // choosing a file or folder.
 class SelectFileDialogImpl : public SelectFileDialog,
                              public BaseShellDialogImpl {
  public:
   explicit SelectFileDialogImpl(Listener* listener);
   virtual ~SelectFileDialogImpl();
 
   // SelectFileDialog implementation:
-  virtual void SelectFile(Type type, const string16& title,
+  virtual void SelectFile(Type type,
+                          const string16& title,
                           const FilePath& default_path,
-                          const std::wstring& filter,
-                          int filter_index,
+                          const FileTypeInfo* file_types,
+                          int file_type_index,
                           const FilePath::StringType& default_extension,
-                          HWND owning_hwnd,
+                          gfx::NativeWindow owning_window,
                           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 FilePath& default_path,
-                        const std::wstring& filter,
-                        int filter_index,
+                        const FileTypeInfo* file_types,
+                        int file_type_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) {
+        : type(type),
+          title(title),
+          default_path(default_path),
+          file_type_index(file_type_index),
+          default_extension(default_extension),
+          run_state(run_state),
+          owner(owner),
+          params(params) {
+      if (file_types) {
+        this->file_types = *file_types;
+      } else {
+        this->file_types.include_all_files = true;
+      }
     }
     SelectFileDialog::Type type;
     std::wstring title;
     FilePath default_path;
-    std::wstring filter;
-    int filter_index;
+    FileTypeInfo file_types;
+    int file_type_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(const ExecuteSelectParams& params);
 
@@ skipping 48 matching lines @@
       BaseShellDialogImpl() {
 }
 
 SelectFileDialogImpl::~SelectFileDialogImpl() {
 }
 
 void SelectFileDialogImpl::SelectFile(
     Type type,
     const string16& title,
     const FilePath& default_path,
-    const std::wstring& filter,
-    int filter_index,
+    const FileTypeInfo* file_types,
+    int file_type_index,
     const FilePath::StringType& default_extension,
-    HWND owner,
+    gfx::NativeWindow owning_window,
     void* params) {
   ExecuteSelectParams execute_params(type, UTF16ToWide(title), default_path,
-                                     filter, filter_index, default_extension,
-                                     BeginRun(owner), owner, params);
+                                     file_types, file_type_index,
+                                     default_extension, BeginRun(owning_window),
+                                     owning_window, 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(
     const ExecuteSelectParams& params) {
+  std::vector<std::wstring> exts;
+  for (size_t i=0; i<params.file_types.extensions.size(); ++i) {
+    const std::vector<std::wstring>& inner_exts =
+        params.file_types.extensions[i];
+    std::wstring ext_string;
+    for (size_t j=0; j<inner_exts.size(); ++j) {
+      if (!ext_string.empty())
+        ext_string.push_back(L';');
+      ext_string.push_back(L'.');
+      ext_string.append(inner_exts[j]);
+    }
+    exts.push_back(ext_string);
+  }
+  std::wstring filter = win_util::FormatFilterForExtensions(
+      exts,
+      params.file_types.extension_description_overrides,
+      params.file_types.include_all_files);
+
   FilePath path = params.default_path;
   bool success = false;
-  unsigned filter_index = params.filter_index;
+  unsigned filter_index = params.file_type_index;
   if (params.type == SELECT_FOLDER) {
     success = RunSelectFolderDialog(params.title,
                                     params.run_state.owner,
                                     &path);
   } else if (params.type == SELECT_SAVEAS_FILE) {
     std::wstring path_as_wstring = path.ToWStringHack();
     success = win_util::SaveFileAsWithFilter(params.run_state.owner,
-        params.default_path.ToWStringHack(), params.filter,
+        params.default_path.ToWStringHack(), filter,
         params.default_extension, false, &filter_index, &path_as_wstring);
     if(success) {
       path = FilePath::FromWStringHack(path_as_wstring);
     }
     DisableOwner(params.run_state.owner);
   } else if (params.type == SELECT_OPEN_FILE) {
-    success = RunOpenFileDialog(params.title, params.filter,
+    success = RunOpenFileDialog(params.title, filter,
                                 params.run_state.owner, &path);
   } else if (params.type == SELECT_OPEN_MULTI_FILE) {
     std::vector<FilePath> paths;
-    if (RunOpenMultiFileDialog(params.title, params.filter,
+    if (RunOpenMultiFileDialog(params.title, filter,
                                params.run_state.owner, &paths)) {
       ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
           &SelectFileDialogImpl::MultiFilesSelected,
           paths, params.params, params.run_state));
       return;
     }
   }
 
   if (success) {
     ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
@@ skipping 67 matching lines @@
   DisableOwner(owner);
   if (list) {
     STRRET out_dir_buffer;
     ZeroMemory(&out_dir_buffer, sizeof(out_dir_buffer));
     out_dir_buffer.uType = STRRET_WSTR;
     CComPtr<IShellFolder> shell_folder = NULL;
     if (SHGetDesktopFolder (&shell_folder) == NOERROR) {
       HRESULT hr = shell_folder->GetDisplayNameOf(list, SHGDN_FORPARSING,
                                                  &out_dir_buffer);
       if (SUCCEEDED(hr) && out_dir_buffer.uType == STRRET_WSTR) {
-        *path = FilePath::FromWStringHack(out_dir_buffer.pOleStr);
+        *path = FilePath(out_dir_buffer.pOleStr);
         CoTaskMemFree(out_dir_buffer.pOleStr);
         result = true;
       }
       else {
         // Use old way if we don't get what we want.
         wchar_t old_out_dir_buffer[MAX_PATH + 1];
         if (SHGetPathFromIDList(list, old_out_dir_buffer)) {
-          *path = FilePath::FromWStringHack(old_out_dir_buffer);
+          *path = FilePath(old_out_dir_buffer);
           result = true;
         }
       }
 
       // According to MSDN, win2000 will not resolve shortcuts, so we do it
       // ourself.
       file_util::ResolveShortcut(path);
     }
     CoTaskMemFree(list);
   }
@@ skipping 244 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);
 }