Added support for KDE file dialogs.

chrome/browser/ui/gtk/dialogs_kde.cc

+// Copyright (c) 2011 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 <gdk/gdkx.h>
+#include <gtk/gtk.h>
+#include <map>
+#include <set>
+
+#include "base/command_line.h"
+#include "base/file_util.h"
+#include "base/logging.h"
+#include "base/message_loop.h"
+#include "base/mime_util.h"
+#include "base/process_util.h"
+#include "base/string_number_conversions.h"
+#include "base/string_util.h"
+#include "base/sys_string_conversions.h"
+#include "base/threading/thread.h"
+#include "base/threading/thread_restrictions.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/ui/gtk/dialogs_common.h"
+#include "chrome/browser/ui/shell_dialogs.h"
+#include "content/browser/browser_thread.h"
+#include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
+
+// Implementation of SelectFileDialog that shows a KDE common dialog for
+// choosing a file or folder. This acts as a modal dialog.
+class SelectFileDialogImplKDE : public SelectFileDialogImpl {
+ public:
+  explicit SelectFileDialogImplKDE(Listener* listener);
+  ~SelectFileDialogImplKDE();
+
+ protected:
+  // SelectFileDialog implementation.
+  // |params| is user data we pass back via the Listener interface.
+  virtual void SelectFileImpl(Type type,
+                              const string16& title,
+                              const FilePath& default_path,
+                              const FileTypeInfo* file_types,
+                              int file_type_index,
+                              const FilePath::StringType& default_extension,
+                              gfx::NativeWindow owning_window,
+                              void* params);
+
+ private:
+  // Get the filters from |file_types_| and concatenate them into
+  // |filter_string|.
+  std::string GetMimeTypeFilterString();
+
+  // Get KDialog command line representing the Argv array for KDialog.
+  void GetKDialogCommandLine(const std::string& type, const std::string& title,
+      const FilePath& default_path, gfx::NativeWindow parent,
+      bool file_operation, bool multiple_selection, CommandLine* command_line);
+
+  // Call KDialog on the FILE thread and post results back to the UI thread.
+  void CallKDialogOutput(const CommandLine& command_line, void* params,
+      gfx::NativeWindow parent,
+      void (SelectFileDialogImplKDE::*callback)(const std::string&,
+                                                int, void*));
+
+  // Notifies the listener that a single file was chosen.
+  void FileSelected(const FilePath& path, void* params);
+
+  // Notifies the listener that multiple files were chosen.
+  void MultiFilesSelected(const std::vector<FilePath>& files, void* params);
+
+  // Notifies the listener that no file was chosen (the action was canceled).
+  // Dialog is passed so we can find that |params| pointer that was passed to
+  // us when we were told to show the dialog.
+  void FileNotSelected(void *params);
+
+  void CreateSelectFolderDialog(const std::string& title,
+                                const FilePath& default_path,
+                                gfx::NativeWindow parent, void* params);
+
+  void CreateFileOpenDialog(const std::string& title,
+                                  const FilePath& default_path,
+                                  gfx::NativeWindow parent, void* params);
+
+  void CreateMultiFileOpenDialog(const std::string& title,
+                                 const FilePath& default_path,
+                                 gfx::NativeWindow parent, void* params);
+
+  void CreateSaveAsDialog(const std::string& title,
+                          const FilePath& default_path,
+                          gfx::NativeWindow parent, void* params);
+
+  // Common function for OnSelectSingleFileDialogResponse and
+  // OnSelectSingleFolderDialogResponse.
+  void SelectSingleFileHelper(const std::string& output, int exit_code,
+                              void* params, bool allow_folder);
+
+  void OnSelectSingleFileDialogResponse(const std::string& output,
+                                        int exit_code, void* params);
+  void OnSelectMultiFileDialogResponse(const std::string& output,
+                                       int exit_code, void* params);
+  void OnSelectSingleFolderDialogResponse(const std::string& output,
+                                          int exit_code, void* params);
+
+  DISALLOW_COPY_AND_ASSIGN(SelectFileDialogImplKDE);
+};
+
+SelectFileDialogImpl* SelectFileDialogImpl::NewSelectFileDialogImplKDE(
+    Listener* listener) {
+  return new SelectFileDialogImplKDE(listener);
+}
+
+SelectFileDialogImplKDE::SelectFileDialogImplKDE(Listener* listener)
+    : SelectFileDialogImpl(listener) {
+}
+
+SelectFileDialogImplKDE::~SelectFileDialogImplKDE() {
+}
+
+// We ignore |default_extension|.
+void SelectFileDialogImplKDE::SelectFileImpl(
+    Type type,
+    const string16& title,
+    const FilePath& default_path,
+    const FileTypeInfo* file_types,
+    int file_type_index,
+    const FilePath::StringType& default_extension,
+    gfx::NativeWindow owning_window,
+    void* params) {
+  type_ = type;
+  // |owning_window| can be null when user right-clicks on a downloadable item
+  // and chooses 'Open Link in New Tab' when 'Ask where to save each file
+  // before downloading.' preference is turned on. (http://crbug.com/29213)
+  if (owning_window)
+    parents_.insert(owning_window);
+
+  std::string title_string = UTF16ToUTF8(title);
+
+  file_type_index_ = file_type_index;
+  if (file_types)
+    file_types_ = *file_types;
+  else
+    file_types_.include_all_files = true;
+
+  switch (type) {
+    case SELECT_FOLDER:
+      CreateSelectFolderDialog(title_string, default_path,
+                               owning_window, params);
+      return;
+    case SELECT_OPEN_FILE:
+      CreateFileOpenDialog(title_string, default_path, owning_window,
+                           params);
+      return;
+    case SELECT_OPEN_MULTI_FILE:
+      CreateMultiFileOpenDialog(title_string, default_path,
+                                owning_window, params);
+      return;
+    case SELECT_SAVEAS_FILE:
+      CreateSaveAsDialog(title_string, default_path, owning_window,
+                         params);
+      return;
+    default:
+      NOTREACHED();
+      return;
+  }
+}
+
+std::string SelectFileDialogImplKDE::GetMimeTypeFilterString() {
+  std::string filter_string;
+  // We need a filter set because the same mime type can appear multiple times.
+  std::set<std::string> filter_set;
+  for (size_t i = 0; i < file_types_.extensions.size(); ++i) {
+    for (size_t j = 0; j < file_types_.extensions[i].size(); ++j) {
+      if (!file_types_.extensions[i][j].empty()) {
+        // Allow IO in the file dialog. http://crbug.com/72637
+        base::ThreadRestrictions::ScopedAllowIO allow_io;

[Mike Mammarella, 2011/09/14 06:42:24]

It looks like the reason you need this is that GetMimeTypeFilterString is called
from GetKDialogCommandLine which is called before switching to the file thread.
Could you move this work onto the file thread instead, and avoid needing this?

[dfilimon, 2011/09/14 22:06:08]

Right, I've uploaded a change incorporating your other feedback except for this
because putting this on the FILE thread would need some more refactoring.

Does it seem reasonable to create the command line entirely in that thread (thus
passing in all of arguments to GetKDialogCommandLine?)

+        std::string mime_type = mime_util::GetFileMimeType(
+            FilePath("name").ReplaceExtension(file_types_.extensions[i][j]));
+        filter_set.insert(mime_type);
+      }
+    }
+  }
+  // Add the *.* filter, but only if we have added other filters (otherwise it
+  // is implied).
+  if (file_types_.include_all_files && !file_types_.extensions.empty())
+    filter_set.insert("application/octet-stream");
+  // Create the final output string.
+  filter_string.clear();
+  for (std::set<std::string>::iterator it = filter_set.begin(),
+           e = filter_set.end(); it != e; ++it) {

[Mike Mammarella, 2011/09/14 06:42:24]

This loop construct took me a moment to figure out, trying to figure out where e
was actually defined and what it was for. I wonder if it's worth the tiny (if
any) performance difference compared to the additional overhead to understand
the code. It's probably not that big a deal either way though.

[dfilimon, 2011/09/14 22:06:08]

I removed it for clarity.

+    filter_string.append(*it + " ");
+  }
+  return filter_string;
+}
+
+void SelectFileDialogImplKDE::CallKDialogOutput(
+    const CommandLine& command_line, void* params, gfx::NativeWindow parent,
+    void (SelectFileDialogImplKDE::*callback)(const std::string&, int, void*)) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  std::string output;
+  int exit_code;
+  // Get output from KDialog
+  base::GetAppOutputWithExitCode(command_line, &output, &exit_code);
+  if (!output.empty())
+    output.erase(output.size() - 1, 1);
+  // Now the dialog is no longer showing. We can erase its parent from the
+  // parent set.
+  std::set<GtkWindow*>::iterator iter = parents_.find(parent);
+  if (iter != parents_.end())
+    parents_.erase(iter);
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+      NewRunnableMethod(this, callback, output, exit_code, params));
+}
+
+void SelectFileDialogImplKDE::GetKDialogCommandLine(const std::string& type,
+    const std::string& title, const FilePath& path,
+    gfx::NativeWindow parent, bool file_operation, bool multiple_selection,
+    CommandLine* command_line) {
+  if (!command_line) {
+    LOG(ERROR) << "Command line for KDialog is NULL" << std::endl;
+    return;
+  }
+  // Attach to the current Chrome window.
+  GdkWindow* gdk_window =
+      gtk_widget_get_window(GTK_WIDGET((parent)));
+  int window_id = GDK_DRAWABLE_XID(gdk_window);
+  command_line->AppendSwitchASCII("--attach", base::IntToString(window_id));
+  // Set the correct title for the dialog.
+  if (!title.empty()) {
+    command_line->AppendSwitchASCII("--title", title);

[Mike Mammarella, 2011/09/14 06:42:24]

What happens if the title is not ASCII?

[dfilimon, 2011/09/14 22:06:08]

Yeah, you're right! Shame on me, especially being in Internationalization.

I was trying to get it to work and was unsure which function I should use to
append. Fixing.

+  }
+  // Enable multiple file selection if we need to.
+  if (multiple_selection) {
+    command_line->AppendSwitch("--multiple");
+    command_line->AppendSwitch("--separate-output");
+  }
+  command_line->AppendSwitch(type);
+  command_line->AppendArgPath(path);
+  // Depending on the type of the operation we need, get the path to the
+  // file/folder and set up mime type filters.
+  if (file_operation) {
+    command_line->AppendArg(GetMimeTypeFilterString());
+  }
+  LOG(INFO) << "KDialog command line: "

[Mike Mammarella, 2011/09/14 06:42:24]

It seems that a while back we switched to mostly doing VLOG(1) instead of
LOG(INFO). (I think the bots were generating way too much output and it was
annoying and/or slow. IIRC Evan was involved in making things better.)

[dfilimon, 2011/09/14 22:06:08]

Done.

+            << command_line->GetCommandLineString() << std::endl;
+}
+
+void SelectFileDialogImplKDE::FileSelected(const FilePath& path, void* params) {
+  if (type_ == SELECT_SAVEAS_FILE)
+    *last_saved_path_ = path.DirName();
+  else if (type_ == SELECT_OPEN_FILE)
+    *last_opened_path_ = path.DirName();
+  else if (type_ == SELECT_FOLDER)
+    *last_opened_path_ = path;
+  else
+    NOTREACHED();
+  if (listener_) {  // What does the filter index actually do?
+    // TODO(dfilimon): Get a reasonable index value from somewhere.
+    listener_->FileSelected(path, 1, params);
+  }
+}
+
+void SelectFileDialogImplKDE::MultiFilesSelected(
+    const std::vector<FilePath>& files, void* params) {
+  *last_opened_path_ = files[0].DirName();
+  if (listener_)
+    listener_->MultiFilesSelected(files, params);
+}
+
+void SelectFileDialogImplKDE::FileNotSelected(void* params) {
+  if (listener_)
+    listener_->FileSelectionCanceled(params);
+}
+
+void SelectFileDialogImplKDE::CreateSelectFolderDialog(
+    const std::string& title, const FilePath& default_path,
+    gfx::NativeWindow parent, void *params) {
+  std::string title_string = !title.empty() ? title :
+        l10n_util::GetStringUTF8(IDS_SELECT_FOLDER_DIALOG_TITLE);
+
+  CommandLine command_line(FilePath("kdialog"));
+  GetKDialogCommandLine(
+      "--getexistingdirectory", title,
+      default_path.empty() ? *last_saved_path_ : default_path,
+      parent, false, false, &command_line);
+  Task* dialog_task =
+      NewRunnableMethod(
+          this, &SelectFileDialogImplKDE::CallKDialogOutput,
+          command_line, params, parent,
+          &SelectFileDialogImplKDE::OnSelectSingleFolderDialogResponse);
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, dialog_task);
+}
+
+void SelectFileDialogImplKDE::CreateFileOpenDialog(
+    const std::string& title, const FilePath& default_path,
+    gfx::NativeWindow parent, void* params) {
+  std::string title_string = !title.empty() ? title :
+        l10n_util::GetStringUTF8(IDS_OPEN_FILE_DIALOG_TITLE);
+
+  CommandLine command_line(FilePath("kdialog"));
+  GetKDialogCommandLine(
+      "--getopenfilename", title,
+      default_path.empty() ? *last_saved_path_ : default_path,
+      parent, true, false, &command_line);
+  Task* dialog_task =
+      NewRunnableMethod(
+          this, &SelectFileDialogImplKDE::CallKDialogOutput,
+          command_line, params, parent,
+          &SelectFileDialogImplKDE::OnSelectSingleFileDialogResponse);
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, dialog_task);
+}
+
+void SelectFileDialogImplKDE::CreateMultiFileOpenDialog(
+    const std::string& title, const FilePath& default_path,
+    gfx::NativeWindow parent, void* params) {
+  std::string title_string = !title.empty() ? title :
+        l10n_util::GetStringUTF8(IDS_OPEN_FILES_DIALOG_TITLE);
+
+  CommandLine command_line(FilePath("kdialog"));
+  GetKDialogCommandLine(
+      "--getopenfilename", title,
+      default_path.empty() ? *last_saved_path_ : default_path,
+      parent, true, true, &command_line);
+  Task* dialog_task =
+      NewRunnableMethod(
+          this, &SelectFileDialogImplKDE::CallKDialogOutput,
+          command_line, params, parent,
+          &SelectFileDialogImplKDE::OnSelectMultiFileDialogResponse);
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, dialog_task);
+}
+
+void SelectFileDialogImplKDE::CreateSaveAsDialog(
+    const std::string& title, const FilePath& default_path,
+    gfx::NativeWindow parent, void* params) {
+  std::string title_string = !title.empty() ? title :
+        l10n_util::GetStringUTF8(IDS_SAVE_AS_DIALOG_TITLE);
+
+  CommandLine command_line(FilePath("kdialog"));
+  GetKDialogCommandLine(
+      "--getsavefilename", title,
+      default_path.empty() ? *last_saved_path_ : default_path,
+      parent, true, false, &command_line);
+  Task* dialog_task =
+      NewRunnableMethod(
+          this, &SelectFileDialogImplKDE::CallKDialogOutput,
+          command_line, params, parent,
+          &SelectFileDialogImplKDE::OnSelectSingleFileDialogResponse);
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, dialog_task);
+}
+
+void SelectFileDialogImplKDE::SelectSingleFileHelper(const std::string& output,
+    int exit_code, void* params, bool allow_folder) {
+  LOG(INFO) << "[kdialog] SingleFileResponse: " << output << std::endl;
+  if (exit_code != 0 || output.empty()) {
+    FileNotSelected(params);
+    return;
+  }
+
+  FilePath path(output);
+  if (allow_folder) {
+    FileSelected(path, params);
+    return;
+  }
+
+  if (CallDirectoryExistsOnUIThread(path))
+    FileNotSelected(params);
+  else
+    FileSelected(path, params);
+}
+
+void SelectFileDialogImplKDE::OnSelectSingleFileDialogResponse(
+    const std::string& output, int exit_code, void* params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  SelectSingleFileHelper(output, exit_code, params, false);
+}
+
+void SelectFileDialogImplKDE::OnSelectSingleFolderDialogResponse(
+    const std::string& output, int exit_code, void* params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  SelectSingleFileHelper(output, exit_code, params, true);
+}
+
+void SelectFileDialogImplKDE::OnSelectMultiFileDialogResponse(
+    const std::string& output, int exit_code, void* params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  LOG(INFO) << "[kdialog] MultiFileResponse: " << output << std::endl;
+
+  if (exit_code != 0 || output.empty()) {
+    FileNotSelected(params);
+    return;
+  }
+
+  std::vector<std::string> filenames;
+  Tokenize(output, "\n", &filenames);
+  std::vector<FilePath> filenames_fp;
+  for (std::vector<std::string>::iterator iter = filenames.begin();
+       iter != filenames.end(); ++iter) {
+    FilePath path(*iter);
+    if (CallDirectoryExistsOnUIThread(path))
+      continue;
+    filenames_fp.push_back(path);
+  }
+
+  if (filenames_fp.empty()) {
+    FileNotSelected(params);
+    return;
+  }
+  MultiFilesSelected(filenames_fp, params);
+}
+

[Mike Mammarella, 2011/09/14 06:42:24]

Please remove the trailing whitespace lines.

[dfilimon, 2011/09/14 22:06:08]

Done.

+