Add non-native file handling in FileSelectorHelper class.

chrome/browser/file_select_helper.cc

 // 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.
 
 #include "chrome/browser/file_select_helper.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 14 matching lines @@
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/file_chooser_file_info.h"
 #include "content/public/common/file_chooser_params.h"
 #include "net/base/mime_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/shell_dialogs/selected_file_info.h"
 
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/file_manager/fileapi_util.h"
+#include "content/public/browser/site_instance.h"
+#endif
+
 using content::BrowserThread;
 using content::FileChooserParams;
 using content::RenderViewHost;
 using content::RenderWidgetHost;
 using content::WebContents;
 
 namespace {
 
 // There is only one file-selection happening at any given time,
 // so we allocate an enumeration ID for that purpose.  All IDs from
 // the renderer must start at 0 and increase.
 const int kFileSelectEnumerationId = -1;
 
-void NotifyRenderViewHost(
-    RenderViewHost* render_view_host,
-    const std::vector<ui::SelectedFileInfo>& files,
-    FileChooserParams::Mode dialog_mode) {
-  std::vector<content::FileChooserFileInfo> chooser_files;
-  for (size_t i = 0; i < files.size(); ++i) {
-    content::FileChooserFileInfo chooser_file;
-    chooser_file.file_path = files[i].local_path;
-    chooser_file.display_name = files[i].display_name;
-    chooser_files.push_back(chooser_file);
-  }
-  render_view_host->FilesSelectedInChooser(chooser_files, dialog_mode);
-}
-
 // Converts a list of FilePaths to a list of ui::SelectedFileInfo.
 std::vector<ui::SelectedFileInfo> FilePathListToSelectedFileInfoList(
     const std::vector<base::FilePath>& paths) {
   std::vector<ui::SelectedFileInfo> selected_files;
   for (size_t i = 0; i < paths.size(); ++i) {
     selected_files.push_back(
         ui::SelectedFileInfo(paths[i], paths[i]));
   }
   return selected_files;
 }
@@ skipping 73 matching lines @@
   }
 
   std::vector<ui::SelectedFileInfo> files;
   files.push_back(file);
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE_USER_BLOCKING,
       FROM_HERE,
       base::Bind(&FileSelectHelper::ProcessSelectedFilesMac, this, files));
+#elif defined(OS_CHROMEOS)
+  ProcessSelectedFilesChromeOS(files);
 #else
-  NotifyRenderViewHostAndEnd(files);
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+  ProcessSelectedFiles(files);
+#endif
 }
 
 void FileSelectHelper::MultiFilesSelected(
     const std::vector<base::FilePath>& files,
     void* params) {
   std::vector<ui::SelectedFileInfo> selected_files =
       FilePathListToSelectedFileInfoList(files);
 
   MultiFilesSelectedWithExtraInfo(selected_files, params);
 }
 
 void FileSelectHelper::MultiFilesSelectedWithExtraInfo(
     const std::vector<ui::SelectedFileInfo>& files,
     void* params) {
   if (!files.empty())
     profile_->set_last_selected_directory(files[0].file_path.DirName());
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE_USER_BLOCKING,
       FROM_HERE,
       base::Bind(&FileSelectHelper::ProcessSelectedFilesMac, this, files));
+#elif defined(OS_CHROMEOS)
+  ProcessSelectedFilesChromeOS(files);
 #else
-  NotifyRenderViewHostAndEnd(files);
-#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+  ProcessSelectedFiles(files);
+#endif
 }
 
 void FileSelectHelper::FileSelectionCanceled(void* params) {
-  NotifyRenderViewHostAndEnd(std::vector<ui::SelectedFileInfo>());
+  ProcessSelectedFiles(std::vector<ui::SelectedFileInfo>());
 }
 
 void FileSelectHelper::StartNewEnumeration(const base::FilePath& path,
                                            int request_id,
                                            RenderViewHost* render_view_host) {
   scoped_ptr<ActiveDirectoryEnumeration> entry(new ActiveDirectoryEnumeration);
   entry->rvh_ = render_view_host;
   entry->delegate_.reset(new DirectoryListerDispatchDelegate(this, request_id));
   entry->lister_.reset(new net::DirectoryLister(path,
                                                 true,
@@ skipping 29 matching lines @@
   if (!entry->rvh_)
     return;
   if (error) {
     FileSelectionCanceled(NULL);
     return;
   }
 
   std::vector<ui::SelectedFileInfo> selected_files =
       FilePathListToSelectedFileInfoList(entry->results_);
 
-  if (id == kFileSelectEnumerationId)
-    NotifyRenderViewHost(entry->rvh_, selected_files, dialog_mode_);
-  else
+  if (id == kFileSelectEnumerationId) {
+#if defined(OS_CHROMEOS)
+    ProcessSelectedFilesChromeOS(selected_files);
+#else
+    ProcessSelectedFiles(selected_files);
+#endif  // defined(OS_CHROMEOS)
+  } else {
     entry->rvh_->DirectoryEnumerationFinished(id, entry->results_);
+    EnumerateDirectoryEnd();
+  }
+}
 
-  EnumerateDirectoryEnd();
+#if defined(OS_CHROMEOS)
+void FileSelectHelper::ProcessSelectedFilesChromeOS(
+    const std::vector<ui::SelectedFileInfo>& files) {
+  if (!render_view_host_) {
+    RunFileChooserEnd();
+    return;
+  }
+
+  file_manager::util::ConvertSelectedFileInfoListToFileChooserFileInfoList(
+      file_manager::util::GetFileSystemContextForRenderViewHost(
+          profile_, render_view_host_),
+      web_contents_->GetSiteInstance()->GetSiteURL(),
+      files,
+      base::Bind(&FileSelectHelper::ProcessSelectedFilesChromeOSAfterConvresion,
+                 this));
+}
+
+void FileSelectHelper::ProcessSelectedFilesChromeOSAfterConvresion(
+    scoped_ptr<std::vector<content::FileChooserFileInfo>> list) {
+  NotifyRenderViewHostAndEnd(
+      list ? *list : std::vector<content::FileChooserFileInfo>());
+}
+#endif  // defined(OS_CHROMEOS)
+
+void FileSelectHelper::ProcessSelectedFiles(
+    const std::vector<ui::SelectedFileInfo>& files) {
+  std::vector<content::FileChooserFileInfo> chooser_files;
+  for (size_t i = 0; i < files.size(); ++i) {
+    chooser_files[i].file_path = files[i].local_path;
+    chooser_files[i].display_name = files[i].display_name;
+  }
+  NotifyRenderViewHostAndEnd(chooser_files);
 }
 
 void FileSelectHelper::NotifyRenderViewHostAndEnd(
-    const std::vector<ui::SelectedFileInfo>& files) {
+    const std::vector<content::FileChooserFileInfo>& files) {
   if (render_view_host_)
-    NotifyRenderViewHost(render_view_host_, files, dialog_mode_);
+    render_view_host_->FilesSelectedInChooser(files, dialog_mode_);
 
   // No members should be accessed from here on.
   RunFileChooserEnd();
 }
 
 void FileSelectHelper::DeleteTemporaryFiles() {
   BrowserThread::PostTask(BrowserThread::FILE,
                           FROM_HERE,
                           base::Bind(&DeleteFiles, temporary_files_));
   temporary_files_.clear();
@@ skipping 270 matching lines @@
   // of an extension or a "/" in the case of a MIME type).
   std::string unused;
   if (accept_type.length() <= 1 ||
       base::StringToLowerASCII(accept_type) != accept_type ||
       base::TrimWhitespaceASCII(accept_type, base::TRIM_ALL, &unused) !=
           base::TRIM_NONE) {
     return false;
   }
   return true;
 }