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
+  // calls the success or failure callback.
+  void TaskDone() {
+    DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));

[benwells, 2013/08/01 07:48:33]

Can you reduce the amount of task posting by executing TaskDone and Error on the
FILE thread, posting back to the UI thread once all tasks are done? I think that
would make the code clearer and reduce the amount of work overall.

[Sam McNally, 2013/08/02 05:35:31]

Done.

+    if (--outstanding_tasks_ == 0) {
+      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(!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 101 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) {

[benwells, 2013/08/01 07:48:33]

Optional: I think you should remove this and put the implementation in the one
caller. It is only used in GetWritableFile which we're planning to remove.

[Sam McNally, 2013/08/02 05:35:31]

Done.

-  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) {

[benwells, 2013/08/01 07:48:33]

Instead of plumbing multiple through everywhere you should be able to just have
a field on FileSystemEntryFunction. There is one FileSystemEntryFunction created
for every invocation of the function.

Maybe we could also do that for entry type, but keep it separate if you want to
do that to keep this patch asap (as simple as possible).

[Sam McNally, 2013/08/02 05:35:31]

Done.

+  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(
+    const std::vector<base::FilePath>& paths,
+    EntryType entry_type,
+    bool multiple) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  std::vector<std::pair<base::FilePath, std::string> > paths_and_overrides;
+  for (std::vector<base::FilePath>::const_iterator it = paths.begin();
+       it != paths.end(); ++it) {
+    paths_and_overrides.push_back(std::make_pair(*it, ""));
+  }
+  RegisterFileSystemsAndSendResponseWithIdOverrides(
+      paths_and_overrides, entry_type, multiple);
 }
 
 void FileSystemEntryFunction::RegisterFileSystemAndSendResponseWithIdOverride(

[benwells, 2013/08/01 07:48:33]

Same for this as CheckWritableFileEntry: it is only used once, do we need a
wrapper function?

Alternatively, since the only thing that uses an id override doesn't handle
multiple can we not worry with a multiple capable send response with id
override? This would remove a lot of code, and if you instead have functions
like CreateResponse and AddEntryToResponse you can reduce duplication.

[Sam McNally, 2013/08/02 05:35:31]

Done.

     const base::FilePath& path, EntryType entry_type, const std::string& id) {
+  std::vector<std::pair<base::FilePath, std::string> > paths_and_overrides;
+  paths_and_overrides.push_back(std::make_pair(path, id));
+  RegisterFileSystemsAndSendResponseWithIdOverrides(
+      paths_and_overrides, entry_type, false);
+}
+
+void FileSystemEntryFunction::RegisterFileSystemsAndSendResponseWithIdOverrides(
+    const std::vector<std::pair<base::FilePath, std::string> >&
+        paths_and_overrides,
+    EntryType entry_type,
+    bool multiple) {
   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", multiple);
+  SetResult(response);
+  for (std::vector<std::pair<base::FilePath, std::string> >::const_iterator it =
+           paths_and_overrides.begin();
+       it != paths_and_overrides.end(); ++it) {
+    list->Append(BuildEntryDict(it->first, entry_type, it->second));
+  }
 
+  SendResponse(true);
+}
+
+base::DictionaryValue* FileSystemEntryFunction::BuildEntryDict(
+    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() {
+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(

[benwells, 2013/08/01 07:48:33]

Add DCHECK that there is at least one path.

[Sam McNally, 2013/08/02 05:35:31]

Done.

-      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