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

[Matt Giuca, 2013/07/25 08:31:09]

If it "is" not a symlink.

[Sam McNally, 2013/07/26 03:58:04]

Done.

+// 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>;

[Matt Giuca, 2013/07/25 08:31:09]

Can't you just make ~WritableFileChecker protected and then the base class will
have access? Maybe protected does not work that way.

In which case,
// Needed for base class access to ~WritableFileChecker.

[Sam McNally, 2013/07/26 03:58:04]

This is what the instructions say to do:
https://code.google.com/p/chromium/codesearch#chromium/src/base/memory/ref_co...

+  virtual ~WritableFileChecker() {}
+
+  void TaskDone() {

[Matt Giuca, 2013/07/25 08:31:09]

Comment.

[Sam McNally, 2013/07/26 03:58:04]

Done.

+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+    if (!--outstanding_tasks_) {

[Matt Giuca, 2013/07/25 08:31:09]

--outstanding_tasks_ == 0

[Sam McNally, 2013/07/26 03:58:04]

Done.

+      if (error_.empty())
+        on_success_.Run();
+      else
+        on_failure_.Run(error_);
+    }
+  }
+
+  void Error(const std::string& message) {

[Matt Giuca, 2013/07/25 08:31:09]

Comment. Include the fact that it must only be called once.

Actually: Can you guarantee this will only be called once? Looks like
CheckLocalWritableFiles can call it as well as CheckRemoteWritableFile, so we
could potentially get two calls to Error, the second of which will fail.

(Though I haven't yet read the code that calls into this class, I shouldn't have
to.)

[Sam McNally, 2013/07/26 03:58:04]

Done.

+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+    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)) {
+        content::BrowserThread::PostTask(
+            content::BrowserThread::UI,
+            FROM_HERE,
+            base::Bind(&WritableFileChecker::Error, this, error));
+        return;
+      }
+    }
+    content::BrowserThread::PostTask(
+        content::BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&WritableFileChecker::TaskDone, this));
+  }
 
 #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) {
+    if (error == drive::FILE_ERROR_OK) {
+      content::BrowserThread::PostTask(
+          content::BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(&WritableFileChecker::TaskDone, this));
+    } else {
+      content::BrowserThread::PostTask(
+          content::BrowserThread::UI,
+          FROM_HERE,
+          base::Bind(
+              &WritableFileChecker::Error,
+              this,
+              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 102 matching lines @@
 
 bool FileSystemEntryFunction::HasFileSystemWritePermission() {
   const extensions::Extension* extension = GetExtension();
   if (!extension)
     return false;
 
   return extension->HasAPIPermission(APIPermission::kFileSystemWrite);
 }
 
 void FileSystemEntryFunction::CheckWritableFile(const base::FilePath& path) {
-  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));
+  std::vector<base::FilePath> paths;
+  paths.push_back(path);
+  CheckWritableFiles(paths, false);
 }
 
-void FileSystemEntryFunction::RegisterFileSystemAndSendResponse(
-    const base::FilePath& path, EntryType entry_type) {
-  RegisterFileSystemAndSendResponseWithIdOverride(path, entry_type, "");
+void FileSystemEntryFunction::CheckWritableFiles(
+    const std::vector<base::FilePath>& paths, bool multiple) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  scoped_refptr<WritableFileChecker> helper = new WritableFileChecker(
+      paths, profile_, extension_->path(),
+      base::Bind(
+          &FileSystemEntryFunction::RegisterFileSystemsAndSendResponse,
+          this, paths, WRITABLE, multiple),
+      base::Bind(&FileSystemEntryFunction::HandleWritableFileError, this));
+}
+
+void FileSystemEntryFunction::RegisterFileSystemsAndSendResponse(

[Matt Giuca, 2013/07/25 08:31:09]

This used to use RegisterFileSystemAndSendResponseWithIdOverride to avoid code
duplication. Now it doesn't. Any reason why? Can you rearrange it so they are
sharing code again?

[Sam McNally, 2013/07/26 03:58:04]

Done.

+    const std::vector<base::FilePath>& paths,
+    EntryType entry_type,
+    bool multiple) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  base::DictionaryValue* response = new base::DictionaryValue();
+  base::ListValue* list = new base::ListValue();
+  response->Set("entries", list);
+  response->SetBoolean("multiple", multiple);
+  SetResult(response);
+  for (std::vector<base::FilePath>::const_iterator it = paths.begin();
+       it != paths.end(); ++it) {
+    list->Append(BuildEntryDict(*it, entry_type));
+  }
+
+  SendResponse(true);
 }
 
 void FileSystemEntryFunction::RegisterFileSystemAndSendResponseWithIdOverride(
     const base::FilePath& path, EntryType entry_type, const std::string& id) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
-  fileapi::IsolatedContext* isolated_context =
-      fileapi::IsolatedContext::GetInstance();
-  DCHECK(isolated_context);
+  base::DictionaryValue* response = new base::DictionaryValue();
+  base::ListValue* list = new base::ListValue();
+  response->Set("entries", list);
+  response->SetBoolean("multiple", false);
+  SetResult(response);
+  list->Append(BuildEntryDictWithIdOverride(path, entry_type, id));
 
+  SendResponse(true);
+}
+
+base::DictionaryValue* FileSystemEntryFunction::BuildEntryDictWithIdOverride(
+    const base::FilePath& path, EntryType entry_type, const std::string& id) {
   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);
-
-  SendResponse(true);
+  return dict;
 }
 
-void FileSystemEntryFunction::HandleWritableFileError() {
+base::DictionaryValue* FileSystemEntryFunction::BuildEntryDict(
+    const base::FilePath& path, EntryType entry_type) {
+  return BuildEntryDictWithIdOverride(path, entry_type, "");
+}
+
+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()) {
@@ skipping 35 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)
+             EntryType entry_type,
+             bool multiple)
       : entry_type_(entry_type),
+        multiple_(multiple),
         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, entry_type_, multiple_);
     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_;
+  bool multiple_;
 
   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) {
+    EntryType entry_type,
+    bool multiple) {
   // 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);
+                 picker_type, entry_type, multiple);
 }
 
 // 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,
+    EntryType entry_type,
+    bool multiple) {
   file_system_api::SetLastChooseEntryDirectory(
-      ExtensionPrefs::Get(profile()),
-      GetExtension()->id(),
-      path.DirName());
+      ExtensionPrefs::Get(profile()), GetExtension()->id(), paths[0].DirName());
   if (entry_type == WRITABLE) {
-    CheckWritableFile(path);
+    CheckWritableFiles(paths, multiple);
     return;
   }
 
   // Don't need to check the file, it's for reading.
-  RegisterFileSystemAndSendResponse(path, READ_ONLY);
+  RegisterFileSystemsAndSendResponse(paths, READ_ONLY, multiple);
 }
 
 void FileSystemChooseEntryFunction::FileSelectionCanceled() {
   error_ = kUserCancelled;
   SendResponse(false);
 }
 
 void FileSystemChooseEntryFunction::BuildFileTypeInfo(
     ui::SelectFileDialog::FileTypeInfo* file_type_info,
     const base::FilePath::StringType& suggested_extension,
@@ skipping 58 matching lines @@
   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();
+  bool multiple = false;
   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;
     } else if (options->type == file_system::CHOOSE_ENTRY_TYPE_SAVEFILE) {
+      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());
@@ skipping 13 matching lines @@
       &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, entry_type, multiple));
   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 60 matching lines @@
     // ID that was passed to restoreEntry.
     RegisterFileSystemAndSendResponseWithIdOverride(
         file_entry->path,
         file_entry->writable ? WRITABLE : READ_ONLY,
         file_entry->id);
   }
   return true;
 }
 
 }  // namespace extensions