Support choosing multiple files with fileSystem.chooseEntry.

chrome/browser/extensions/api/file_system/file_system_api.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/extensions/api/file_system/file_system_api.h"
 
 #include "apps/saved_files_service.h"
 #include "apps/shell_window.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/value_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/shell_window_registry.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
@@ skipping 28 matching lines @@
 using apps::SavedFileEntry;
 using apps::SavedFilesService;
 using apps::ShellWindow;
 using fileapi::IsolatedContext;
 
 const char kInvalidParameters[] = "Invalid parameters";
 const char kSecurityError[] = "Security error";
 const char kInvalidCallingPage[] = "Invalid calling page. This function can't "
     "be called from a background page.";
 const char kUserCancelled[] = "User cancelled";
-const char kWritableFileError[] =
+const char kWritableFileRestrictedLocationError[] =
     "Cannot write to file in a restricted location";
+const char kWritableFileErrorFormat[] = "Error opening %s";
 const char kRequiresFileSystemWriteError[] =
     "Operation requires fileSystem.write permission";
+const char kMultipleUnsupportedError[] =
+    "acceptsMultiple: true is not supported for 'saveFile'";
 const char kUnknownIdError[] = "Unknown id";
 
 namespace file_system = extensions::api::file_system;
 namespace ChooseEntry = file_system::ChooseEntry;
 
 namespace {
 
 const int kBlacklistedPaths[] = {
   chrome::DIR_APP,
   chrome::DIR_USER_DATA,
@@ skipping 72 matching lines @@
       && home_path.AppendRelativePath(source_path, &display_path))
     return display_path;
 #endif
   return source_path;
 }
 #endif  // defined(OS_MACOSX)
 
 bool g_skip_picker_for_test = false;
 bool g_use_suggested_path_for_test = false;
 base::FilePath* g_path_to_be_picked_for_test;
+std::vector<base::FilePath>* g_paths_to_be_picked_for_test;
 
 bool GetFileSystemAndPathOfFileEntry(
     const std::string& filesystem_name,
     const std::string& filesystem_path,
     const content::RenderViewHost* render_view_host,
     std::string* filesystem_id,
     base::FilePath* file_path,
     std::string* error) {
   if (!fileapi::CrackIsolatedFileSystemName(filesystem_name, filesystem_id)) {
     *error = kInvalidParameters;
@@ skipping 34 matching lines @@
   std::string filesystem_id;
   return GetFileSystemAndPathOfFileEntry(filesystem_name,
                                          filesystem_path,
                                          render_view_host,
                                          &filesystem_id,
                                          file_path,
                                          error);
 }
 
 bool DoCheckWritableFile(const base::FilePath& path,
-                         const base::FilePath& extension_directory) {
+                         const base::FilePath& extension_directory,
+                         std::string* error_message) {
   // Don't allow links.
-  if (base::PathExists(path) && file_util::IsLink(path))
+  if (base::PathExists(path) && file_util::IsLink(path)) {
+    *error_message = base::StringPrintf(kWritableFileErrorFormat,
+                                        path.BaseName().AsUTF8Unsafe().c_str());
     return false;
+  }
 
-  if (extension_directory == path || extension_directory.IsParent(path))
+  if (extension_directory == path || extension_directory.IsParent(path)) {
+    *error_message = kWritableFileRestrictedLocationError;
     return false;
+  }
 
   bool is_whitelisted_path = false;
 
 #if defined(OS_CHROMEOS)
   for (size_t i = 0; i < arraysize(kWhitelistedPaths); i++) {
     base::FilePath whitelisted_path;
     if (PathService::Get(kWhitelistedPaths[i], &whitelisted_path) &&
         (whitelisted_path == path || whitelisted_path.IsParent(path))) {
       is_whitelisted_path = true;
       break;
     }
   }
 #endif
 
   if (!is_whitelisted_path) {
     for (size_t i = 0; i < arraysize(kBlacklistedPaths); i++) {
       base::FilePath blacklisted_path;
       if (PathService::Get(kBlacklistedPaths[i], &blacklisted_path) &&
           (blacklisted_path == path || blacklisted_path.IsParent(path))) {
+        *error_message = kWritableFileRestrictedLocationError;
         return false;
       }
     }
   }
 
   // Create the file if it doesn't already exist.
   base::PlatformFileError error = base::PLATFORM_FILE_OK;
   int creation_flags = base::PLATFORM_FILE_CREATE |
                        base::PLATFORM_FILE_READ |
                        base::PLATFORM_FILE_WRITE;
   base::PlatformFile file = base::CreatePlatformFile(path, creation_flags,
                                                      NULL, &error);
   // Close the file so we don't keep a lock open.
   if (file != base::kInvalidPlatformFileValue)
     base::ClosePlatformFile(file);
-  return error == base::PLATFORM_FILE_OK ||
-         error == base::PLATFORM_FILE_ERROR_EXISTS;
+  if (error != base::PLATFORM_FILE_OK &&
+      error != base::PLATFORM_FILE_ERROR_EXISTS) {
+    *error_message = base::StringPrintf(kWritableFileErrorFormat,
+                                        path.BaseName().AsUTF8Unsafe().c_str());
+    return false;
+  }
+
+  return true;
 }
 
-void CheckLocalWritableFile(const base::FilePath& path,
-                            const base::FilePath& extension_directory,
-                            const base::Closure& on_success,
-                            const base::Closure& on_failure) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
-  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-      DoCheckWritableFile(path, extension_directory) ? on_success : on_failure);
-}
+// Checks whether a list of paths are all OK for writing and calls a provided
+// on_success or on_failure callback when done. A file is OK for writing if it
+// is not a symlink, is not in a blacklisted path and can be opened for writing;
+// files are created if they do not exist.
+class WritableFileChecker
+    : public base::RefCountedThreadSafe<WritableFileChecker> {
+ public:
+  WritableFileChecker(
+      const std::vector<base::FilePath>& paths,
+      Profile* profile,
+      const base::FilePath& extension_path,
+      const base::Closure& on_success,
+      const base::Callback<void(const std::string&)>& on_failure)
+      : outstanding_tasks_(1),
+        extension_path_(extension_path),
+        on_success_(on_success),
+        on_failure_(on_failure) {
+#if defined(OS_CHROMEOS)
+    if (drive::util::IsUnderDriveMountPoint(paths[0])) {
+      outstanding_tasks_ = paths.size();
+      for (std::vector<base::FilePath>::const_iterator it = paths.begin();
+           it != paths.end(); ++it) {
+        DCHECK(drive::util::IsUnderDriveMountPoint(*it));
+        drive::util::PrepareWritableFileAndRun(
+            profile,
+            *it,
+            base::Bind(&WritableFileChecker::CheckRemoteWritableFile, this));
+      }
+      return;
+    }
+#endif
+    content::BrowserThread::PostTask(
+        content::BrowserThread::FILE,
+        FROM_HERE,
+        base::Bind(&WritableFileChecker::CheckLocalWritableFiles, this, paths));
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<WritableFileChecker>;
+  virtual ~WritableFileChecker() {}
+
+  // Called when a work item is completed. If all work items are done, this
+  // posts a task to run AllTasksDone on the UI thread.
+  void TaskDone() {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+    if (--outstanding_tasks_ == 0) {
+      content::BrowserThread::PostTask(
+          content::BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(&WritableFileChecker::AllTasksDone, this));
+    }
+  }
+
+  // Called on the UI thread when all tasks are done.
+  void AllTasksDone() {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+    if (error_.empty())
+      on_success_.Run();
+    else
+      on_failure_.Run(error_);
+  }
+
+  // Reports an error in completing a work item. This may be called more than
+  // once, but only the last message will be retained.
+  void Error(const std::string& message) {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+    DCHECK(!message.empty());
+    error_ = message;
+    TaskDone();
+  }
+
+  void CheckLocalWritableFiles(const std::vector<base::FilePath>& paths) {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+    std::string error;
+    for (std::vector<base::FilePath>::const_iterator it = paths.begin();
+         it != paths.end(); ++it) {
+      if (!DoCheckWritableFile(*it, extension_path_, &error)) {
+        Error(error);
+        return;
+      }
+    }
+    TaskDone();
+  }
 
 #if defined(OS_CHROMEOS)
-void CheckRemoteWritableFile(const base::Closure& on_success,
-                             const base::Closure& on_failure,
-                             drive::FileError error,
-                             const base::FilePath& path) {
-  content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
-      error == drive::FILE_ERROR_OK ? on_success : on_failure);
-}
+  void CheckRemoteWritableFile(drive::FileError error,
+                               const base::FilePath& path) {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+    if (error == drive::FILE_ERROR_OK) {
+      TaskDone();
+    } else {
+      Error(base::StringPrintf(kWritableFileErrorFormat,
+                               path.BaseName().AsUTF8Unsafe().c_str()));
+    }
+  }
 #endif
 
+  int outstanding_tasks_;
+  const base::FilePath extension_path_;
+  std::string error_;
+  base::Closure on_success_;
+  base::Callback<void(const std::string&)> on_failure_;
+};
+
 // Expand the mime-types and extensions provided in an AcceptOption, returning
 // them within the passed extension vector. Returns false if no valid types
 // were found.
 bool GetFileTypesFromAcceptOption(
     const file_system::AcceptOption& accept_option,
     std::vector<base::FilePath::StringType>* extensions,
     string16* description) {
   std::set<base::FilePath::StringType> extension_set;
   int description_id = 0;
 
@@ skipping 93 matching lines @@
   base::FilePath file_path;
   if (!GetFilePathOfFileEntry(filesystem_name, filesystem_path,
                               render_view_host_, &file_path, &error_))
     return false;
 
   file_path = PrettifyPath(file_path);
   SetResult(base::Value::CreateStringValue(file_path.value()));
   return true;
 }
 
+FileSystemEntryFunction::FileSystemEntryFunction()
+    : multiple_(false),
+      entry_type_(READ_ONLY),
+      response_(NULL) {}
+
 bool FileSystemEntryFunction::HasFileSystemWritePermission() {
   const extensions::Extension* extension = GetExtension();
   if (!extension)
     return false;
 
   return extension->HasAPIPermission(APIPermission::kFileSystemWrite);
 }
 
-void FileSystemEntryFunction::CheckWritableFile(const base::FilePath& path) {
+void FileSystemEntryFunction::CheckWritableFiles(
+    const std::vector<base::FilePath>& paths) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  base::Closure on_success =
-      base::Bind(&FileSystemEntryFunction::RegisterFileSystemAndSendResponse,
-                 this, path, WRITABLE);
-  base::Closure on_failure =
-      base::Bind(&FileSystemEntryFunction::HandleWritableFileError, this);
-
-#if defined(OS_CHROMEOS)
-  if (drive::util::IsUnderDriveMountPoint(path)) {
-    drive::util::PrepareWritableFileAndRun(profile_, path,
-        base::Bind(&CheckRemoteWritableFile, on_success, on_failure));
-    return;
-  }
-#endif
-  content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&CheckLocalWritableFile, path, extension_->path(), on_success,
-                 on_failure));
+  scoped_refptr<WritableFileChecker> helper = new WritableFileChecker(
+      paths, profile_, extension_->path(),
+      base::Bind(
+          &FileSystemEntryFunction::RegisterFileSystemsAndSendResponse,
+          this, paths),
+      base::Bind(&FileSystemEntryFunction::HandleWritableFileError, this));
 }
 
-void FileSystemEntryFunction::RegisterFileSystemAndSendResponse(
-    const base::FilePath& path, EntryType entry_type) {
-  RegisterFileSystemAndSendResponseWithIdOverride(path, entry_type, "");
-}
-
-void FileSystemEntryFunction::RegisterFileSystemAndSendResponseWithIdOverride(
-    const base::FilePath& path, EntryType entry_type, const std::string& id) {
+void FileSystemEntryFunction::RegisterFileSystemsAndSendResponse(
+    const std::vector<base::FilePath>& paths) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
-  fileapi::IsolatedContext* isolated_context =
-      fileapi::IsolatedContext::GetInstance();
-  DCHECK(isolated_context);
-
-  bool writable = entry_type == WRITABLE;
-  extensions::app_file_handler_util::GrantedFileEntry file_entry =
-      extensions::app_file_handler_util::CreateFileEntry(profile(),
-          GetExtension()->id(), render_view_host_->GetProcess()->GetID(), path,
-          writable);
-
-  base::DictionaryValue* dict = new base::DictionaryValue();
-  SetResult(dict);
-  dict->SetString("fileSystemId", file_entry.filesystem_id);
-  dict->SetString("baseName", file_entry.registered_name);
-  if (id.empty())
-    dict->SetString("id", file_entry.id);
-  else
-    dict->SetString("id", id);
-
+  CreateResponse();
+  for (std::vector<base::FilePath>::const_iterator it = paths.begin();
+       it != paths.end(); ++it) {
+    AddEntryToResponse(*it, "");
+  }
   SendResponse(true);
 }
 
-void FileSystemEntryFunction::HandleWritableFileError() {
+void FileSystemEntryFunction::CreateResponse() {
+  DCHECK(!response_);
+  response_ = new base::DictionaryValue();
+  base::ListValue* list = new base::ListValue();
+  response_->Set("entries", list);
+  response_->SetBoolean("multiple", multiple_);
+  SetResult(response_);
+}
+
+void FileSystemEntryFunction::AddEntryToResponse(
+    const base::FilePath& path,
+    const std::string& id_override) {
+  DCHECK(response_);
+  bool writable = entry_type_ == WRITABLE;
+  extensions::app_file_handler_util::GrantedFileEntry file_entry =
+      extensions::app_file_handler_util::CreateFileEntry(
+          profile(),
+          GetExtension()->id(),
+          render_view_host_->GetProcess()->GetID(),
+          path,
+          writable);
+  base::ListValue* entries;
+  bool success = response_->GetList("entries", &entries);
+  DCHECK(success);
+
+  base::DictionaryValue* entry = new base::DictionaryValue();
+  entry->SetString("fileSystemId", file_entry.filesystem_id);
+  entry->SetString("baseName", file_entry.registered_name);
+  if (id_override.empty())
+    entry->SetString("id", file_entry.id);
+  else
+    entry->SetString("id", id_override);
+  entries->Append(entry);
+}
+
+void FileSystemEntryFunction::HandleWritableFileError(
+    const std::string& error) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
-  error_ = kWritableFileError;
+  error_ = error;
   SendResponse(false);
 }
 
 bool FileSystemGetWritableEntryFunction::RunImpl() {
   std::string filesystem_name;
   std::string filesystem_path;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &filesystem_name));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_path));
 
   if (!HasFileSystemWritePermission()) {
     error_ = kRequiresFileSystemWriteError;
     return false;
   }
+  entry_type_ = WRITABLE;
 
   base::FilePath path;
   if (!GetFilePathOfFileEntry(filesystem_name, filesystem_path,
                               render_view_host_, &path, &error_))
     return false;
 
-  CheckWritableFile(path);
+  std::vector<base::FilePath> paths;
+  paths.push_back(path);
+  CheckWritableFiles(paths);
   return true;
 }
 
 bool FileSystemIsWritableEntryFunction::RunImpl() {
   std::string filesystem_name;
   std::string filesystem_path;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &filesystem_name));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(1, &filesystem_path));
 
   std::string filesystem_id;
@@ skipping 14 matching lines @@
 
 // Handles showing a dialog to the user to ask for the filename for a file to
 // save or open.
 class FileSystemChooseEntryFunction::FilePicker
     : public ui::SelectFileDialog::Listener {
  public:
   FilePicker(FileSystemChooseEntryFunction* function,
              content::WebContents* web_contents,
              const base::FilePath& suggested_name,
              const ui::SelectFileDialog::FileTypeInfo& file_type_info,
-             ui::SelectFileDialog::Type picker_type,
-             EntryType entry_type)
-      : entry_type_(entry_type),
-        function_(function) {
+             ui::SelectFileDialog::Type picker_type)
+      : function_(function) {
     select_file_dialog_ = ui::SelectFileDialog::Create(
         this, new ChromeSelectFilePolicy(web_contents));
     gfx::NativeWindow owning_window = web_contents ?
         platform_util::GetTopLevel(web_contents->GetView()->GetNativeView()) :
         NULL;
 
     if (g_skip_picker_for_test) {
       if (g_use_suggested_path_for_test) {
         content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
             base::Bind(
                 &FileSystemChooseEntryFunction::FilePicker::FileSelected,
                 base::Unretained(this), suggested_name, 1,
                 static_cast<void*>(NULL)));
       } else if (g_path_to_be_picked_for_test) {
-        content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
+        content::BrowserThread::PostTask(
+            content::BrowserThread::UI, FROM_HERE,
             base::Bind(
                 &FileSystemChooseEntryFunction::FilePicker::FileSelected,
                 base::Unretained(this), *g_path_to_be_picked_for_test, 1,
                 static_cast<void*>(NULL)));
+      } else if (g_paths_to_be_picked_for_test) {
+        content::BrowserThread::PostTask(
+            content::BrowserThread::UI,
+            FROM_HERE,
+            base::Bind(
+                &FileSystemChooseEntryFunction::FilePicker::MultiFilesSelected,
+                base::Unretained(this),
+                *g_paths_to_be_picked_for_test,
+                static_cast<void*>(NULL)));
       } else {
         content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
             base::Bind(
                 &FileSystemChooseEntryFunction::FilePicker::
                     FileSelectionCanceled,
                 base::Unretained(this), static_cast<void*>(NULL)));
       }
       return;
     }
 
     select_file_dialog_->SelectFile(picker_type,
                                     string16(),
                                     suggested_name,
                                     &file_type_info,
                                     0,
                                     base::FilePath::StringType(),
                                     owning_window,
                                     NULL);
   }
 
   virtual ~FilePicker() {}
 
  private:
   // ui::SelectFileDialog::Listener implementation.
   virtual void FileSelected(const base::FilePath& path,
                             int index,
                             void* params) OVERRIDE {
-    function_->FileSelected(path, entry_type_);
-    delete this;
+    std::vector<base::FilePath> paths;
+    paths.push_back(path);
+    MultiFilesSelected(paths, params);
   }
 
   virtual void FileSelectedWithExtraInfo(const ui::SelectedFileInfo& file,
                                          int index,
                                          void* params) OVERRIDE {
     // Normally, file.local_path is used because it is a native path to the
     // local read-only cached file in the case of remote file system like
     // Chrome OS's Google Drive integration. Here, however, |file.file_path| is
     // necessary because we need to create a FileEntry denoting the remote file,
     // not its cache. On other platforms than Chrome OS, they are the same.
     //
     // TODO(kinaba): remove this, once after the file picker implements proper
     // switch of the path treatment depending on the |support_drive| flag.
-    function_->FileSelected(file.file_path, entry_type_);
+    FileSelected(file.file_path, index, params);
+  }
+
+  virtual void MultiFilesSelected(const std::vector<base::FilePath>& files,
+                                  void* params) OVERRIDE {
+    function_->FilesSelected(files);
     delete this;
   }
 
+  virtual void MultiFilesSelectedWithExtraInfo(
+      const std::vector<ui::SelectedFileInfo>& files,
+      void* params) OVERRIDE {
+    std::vector<base::FilePath> paths;
+    for (std::vector<ui::SelectedFileInfo>::const_iterator it = files.begin();
+         it != files.end(); ++it) {
+      paths.push_back(it->file_path);
+    }
+    MultiFilesSelected(paths, params);
+  }
+
   virtual void FileSelectionCanceled(void* params) OVERRIDE {
     function_->FileSelectionCanceled();
     delete this;
   }
 
-  EntryType entry_type_;
-
   scoped_refptr<ui::SelectFileDialog> select_file_dialog_;
   scoped_refptr<FileSystemChooseEntryFunction> function_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePicker);
 };
 
 void FileSystemChooseEntryFunction::ShowPicker(
     const ui::SelectFileDialog::FileTypeInfo& file_type_info,
-    ui::SelectFileDialog::Type picker_type,
-    EntryType entry_type) {
+    ui::SelectFileDialog::Type picker_type) {
   // TODO(asargent/benwells) - As a short term remediation for crbug.com/179010
   // we're adding the ability for a whitelisted extension to use this API since
   // chrome.fileBrowserHandler.selectFile is ChromeOS-only. Eventually we'd
   // like a better solution and likely this code will go back to being
   // platform-app only.
   content::WebContents* web_contents = NULL;
   if (extension_->is_platform_app()) {
     ShellWindowRegistry* registry = ShellWindowRegistry::Get(profile());
     DCHECK(registry);
     ShellWindow* shell_window = registry->GetShellWindowForRenderViewHost(
         render_view_host());
     if (!shell_window) {
       error_ = kInvalidCallingPage;
       SendResponse(false);
       return;
     }
     web_contents = shell_window->web_contents();
   } else {
     web_contents = GetAssociatedWebContents();
   }
   // The file picker will hold a reference to this function instance, preventing
   // its destruction (and subsequent sending of the function response) until the
   // user has selected a file or cancelled the picker. At that point, the picker
   // will delete itself, which will also free the function instance.
-  new FilePicker(this, web_contents, initial_path_, file_type_info,
-                 picker_type, entry_type);
+  new FilePicker(
+      this, web_contents, initial_path_, file_type_info, picker_type);
 }
 
 // static
 void FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
     base::FilePath* path) {
   g_skip_picker_for_test = true;
   g_use_suggested_path_for_test = false;
   g_path_to_be_picked_for_test = path;
+  g_paths_to_be_picked_for_test = NULL;
+}
+
+void FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathsForTest(
+    std::vector<base::FilePath>* paths) {
+  g_skip_picker_for_test = true;
+  g_use_suggested_path_for_test = false;
+  g_paths_to_be_picked_for_test = paths;
 }
 
 // static
 void FileSystemChooseEntryFunction::SkipPickerAndSelectSuggestedPathForTest() {
   g_skip_picker_for_test = true;
   g_use_suggested_path_for_test = true;
   g_path_to_be_picked_for_test = NULL;
+  g_paths_to_be_picked_for_test = NULL;
 }
 
 // static
 void FileSystemChooseEntryFunction::SkipPickerAndAlwaysCancelForTest() {
   g_skip_picker_for_test = true;
   g_use_suggested_path_for_test = false;
   g_path_to_be_picked_for_test = NULL;
+  g_paths_to_be_picked_for_test = NULL;
 }
 
 // static
 void FileSystemChooseEntryFunction::StopSkippingPickerForTest() {
   g_skip_picker_for_test = false;
 }
 
 // static
 void FileSystemChooseEntryFunction::RegisterTempExternalFileSystemForTest(
     const std::string& name, const base::FilePath& path) {
@@ skipping 13 matching lines @@
   } else {
     base::FilePath documents_dir;
     if (PathService::Get(chrome::DIR_USER_DOCUMENTS, &documents_dir)) {
       initial_path_ = documents_dir.Append(suggested_name);
     } else {
       initial_path_ = suggested_name;
     }
   }
 }
 
-void FileSystemChooseEntryFunction::FileSelected(const base::FilePath& path,
-                                                 EntryType entry_type) {
+void FileSystemChooseEntryFunction::FilesSelected(
+    const std::vector<base::FilePath>& paths) {
+  DCHECK(!paths.empty());
   file_system_api::SetLastChooseEntryDirectory(
-      ExtensionPrefs::Get(profile()),
-      GetExtension()->id(),
-      path.DirName());
-  if (entry_type == WRITABLE) {
-    CheckWritableFile(path);
+      ExtensionPrefs::Get(profile()), GetExtension()->id(), paths[0].DirName());
+  if (entry_type_ == WRITABLE) {
+    CheckWritableFiles(paths);
     return;
   }
 
   // Don't need to check the file, it's for reading.
-  RegisterFileSystemAndSendResponse(path, READ_ONLY);
+  RegisterFileSystemsAndSendResponse(paths);
 }
 
 void FileSystemChooseEntryFunction::FileSelectionCanceled() {
   error_ = kUserCancelled;
   SendResponse(false);
 }
 
 void FileSystemChooseEntryFunction::BuildFileTypeInfo(
     ui::SelectFileDialog::FileTypeInfo* file_type_info,
     const base::FilePath::StringType& suggested_extension,
@@ skipping 53 matching lines @@
       suggested_extension->erase(suggested_extension->begin());  // drop the .
   }
 }
 
 bool FileSystemChooseEntryFunction::RunImpl() {
   scoped_ptr<ChooseEntry::Params> params(ChooseEntry::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   base::FilePath suggested_name;
   ui::SelectFileDialog::FileTypeInfo file_type_info;
-  EntryType entry_type = READ_ONLY;
   ui::SelectFileDialog::Type picker_type =
       ui::SelectFileDialog::SELECT_OPEN_FILE;
 
   file_system::ChooseEntryOptions* options = params->options.get();
   if (options) {
+    multiple_ = options->accepts_multiple;
+    if (multiple_)
+      picker_type = ui::SelectFileDialog::SELECT_OPEN_MULTI_FILE;
     if (options->type == file_system::CHOOSE_ENTRY_TYPE_OPENWRITABLEFILE) {
-      entry_type = WRITABLE;
+      entry_type_ = WRITABLE;
     } else if (options->type == file_system::CHOOSE_ENTRY_TYPE_SAVEFILE) {
-      entry_type = WRITABLE;
+      if (multiple_) {
+        error_ = kMultipleUnsupportedError;
+        return false;
+      }
+      entry_type_ = WRITABLE;
       picker_type = ui::SelectFileDialog::SELECT_SAVEAS_FILE;
     }
 
     base::FilePath::StringType suggested_extension;
     BuildSuggestion(options->suggested_name.get(), &suggested_name,
         &suggested_extension);
 
     BuildFileTypeInfo(&file_type_info, suggested_extension,
         options->accepts.get(), options->accepts_all_types.get());
   }
 
-  if (entry_type == WRITABLE && !HasFileSystemWritePermission()) {
+  if (entry_type_ == WRITABLE && !HasFileSystemWritePermission()) {
     error_ = kRequiresFileSystemWriteError;
     return false;
   }
 
   file_type_info.support_drive = true;
 
   base::FilePath previous_path;
   file_system_api::GetLastChooseEntryDirectory(
       ExtensionPrefs::Get(profile()),
       GetExtension()->id(),
       &previous_path);
 
   content::BrowserThread::PostTaskAndReply(
       content::BrowserThread::FILE,
       FROM_HERE,
       base::Bind(
           &FileSystemChooseEntryFunction::SetInitialPathOnFileThread, this,
           suggested_name, previous_path),
       base::Bind(
           &FileSystemChooseEntryFunction::ShowPicker, this, file_type_info,
-          picker_type, entry_type));
+          picker_type));
   return true;
 }
 
 bool FileSystemRetainEntryFunction::RunImpl() {
   std::string entry_id;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &entry_id));
   SavedFilesService* saved_files_service = SavedFilesService::Get(profile());
   // Add the file to the retain list if it is not already on there.
   if (!saved_files_service->IsRegistered(extension_->id(), entry_id) &&
       !RetainFileEntry(entry_id)) {
@@ skipping 49 matching lines @@
     return false;
   }
 
   SavedFilesService::Get(profile())->EnqueueFileEntry(
       extension_->id(), entry_id);
 
   // Only create a new file entry if the renderer requests one.
   // |needs_new_entry| will be false if the renderer already has an Entry for
   // |entry_id|.
   if (needs_new_entry) {
-    // Reuse the ID of the retained file entry so retainEntry returns the same
-    // ID that was passed to restoreEntry.
-    RegisterFileSystemAndSendResponseWithIdOverride(
-        file_entry->path,
-        file_entry->writable ? WRITABLE : READ_ONLY,
-        file_entry->id);
+    entry_type_ = file_entry->writable ? WRITABLE : READ_ONLY;
+    CreateResponse();
+    AddEntryToResponse(file_entry->path, file_entry->id);
   }
+  SendResponse(true);
   return true;
 }
 
 }  // namespace extensions