Rename chrome.fileSystem apis to be expandable to directories if we wish.

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 "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 20 matching lines @@
 
 using fileapi::IsolatedContext;
 
 const char kInvalidParameters[] = "Invalid parameters";
 const char kSecurityError[] = "Security error";
 const char kInvalidCallingPage[] = "Invalid calling page";
 const char kUserCancelled[] = "User cancelled";
 const char kWritableFileError[] = "Invalid file for writing";
 const char kRequiresFileSystemWriteError[] =
     "Operation requires fileSystemWrite permission";
-const char kUnknownChooseFileType[] = "Unknown type";
+const char kUnknownChooseEntryType[] = "Unknown type";
 
 const char kOpenFileOption[] = "openFile";
 const char kOpenWritableFileOption[] ="openWritableFile";
 const char kSaveFileOption[] = "saveFile";
 
 namespace file_system = extensions::api::file_system;
-namespace ChooseFile = file_system::ChooseFile;
+namespace ChooseEntry = file_system::ChooseEntry;
 
 namespace {
 
 struct RewritePair {
   int path_key;
   const char* output;
 };
 
 const RewritePair g_rewrite_pairs[] = {
 #if defined(OS_WIN)
@@ skipping 214 matching lines @@
   dict->SetString("baseName", registered_name);
   SendResponse(true);
 }
 
 void FileSystemEntryFunction::HandleWritableFileError() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   error_ = kWritableFileError;
   SendResponse(false);
 }
 
-bool FileSystemGetWritableFileEntryFunction::RunImpl() {
+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;
   }
 
   FilePath path;
   if (!GetFilePathOfFileEntry(filesystem_name, filesystem_path,
                               render_view_host_, &path, &error_))
     return false;
 
   content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&FileSystemGetWritableFileEntryFunction::CheckWritableFile,
+      base::Bind(&FileSystemGetWritableEntryFunction::CheckWritableFile,
           this, path));
   return true;
 }
 
-bool FileSystemIsWritableFileEntryFunction::RunImpl() {
+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;
   if (!fileapi::CrackIsolatedFileSystemName(filesystem_name, &filesystem_id)) {
     error_ = kInvalidParameters;
     return false;
   }
 
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   int renderer_id = render_view_host_->GetProcess()->GetID();
   bool is_writable = policy->CanReadWriteFileSystem(renderer_id,
                                                     filesystem_id);
 
   SetResult(base::Value::CreateBooleanValue(is_writable));
   return true;
 }
 
 // Handles showing a dialog to the user to ask for the filename for a file to
 // save or open.
-class FileSystemChooseFileFunction::FilePicker
+class FileSystemChooseEntryFunction::FilePicker
     : public ui::SelectFileDialog::Listener {
  public:
-  FilePicker(FileSystemChooseFileFunction* function,
+  FilePicker(FileSystemChooseEntryFunction* function,
              content::WebContents* web_contents,
              const FilePath& suggested_name,
              const ui::SelectFileDialog::FileTypeInfo& file_type_info,
              ui::SelectFileDialog::Type picker_type,
              EntryType entry_type)
       : suggested_name_(suggested_name),
         entry_type_(entry_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->GetNativeView()) : NULL;
 
     if (g_skip_picker_for_test) {
       if (g_path_to_be_picked_for_test) {
         content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
             base::Bind(
-                &FileSystemChooseFileFunction::FilePicker::FileSelected,
+                &FileSystemChooseEntryFunction::FilePicker::FileSelected,
                 base::Unretained(this), *g_path_to_be_picked_for_test, 1,
                 static_cast<void*>(NULL)));
       } else {
         content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
             base::Bind(
-                &FileSystemChooseFileFunction::FilePicker::
+                &FileSystemChooseEntryFunction::FilePicker::
                     FileSelectionCanceled,
                 base::Unretained(this), static_cast<void*>(NULL)));
       }
       return;
     }
 
     select_file_dialog_->SelectFile(picker_type,
                                     string16(),
                                     suggested_name,
                                     &file_type_info, 0, FILE_PATH_LITERAL(""),
@@ skipping 14 matching lines @@
   virtual void FileSelectionCanceled(void* params) OVERRIDE {
     function_->FileSelectionCanceled();
     delete this;
   }
 
   FilePath suggested_name_;
 
   EntryType entry_type_;
 
   scoped_refptr<ui::SelectFileDialog> select_file_dialog_;
-  scoped_refptr<FileSystemChooseFileFunction> function_;
+  scoped_refptr<FileSystemChooseEntryFunction> function_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePicker);
 };
 
-bool FileSystemChooseFileFunction::ShowPicker(
+bool FileSystemChooseEntryFunction::ShowPicker(
     const FilePath& suggested_name,
     const ui::SelectFileDialog::FileTypeInfo& file_type_info,
     ui::SelectFileDialog::Type picker_type,
     EntryType entry_type) {
   ShellWindowRegistry* registry = ShellWindowRegistry::Get(profile());
   DCHECK(registry);
   ShellWindow* shell_window = registry->GetShellWindowForRenderViewHost(
       render_view_host());
   if (!shell_window) {
     error_ = kInvalidCallingPage;
     return false;
   }
 
   // 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, shell_window->web_contents(), suggested_name,
       file_type_info, picker_type, entry_type);
   return true;
 }
 
 // static
-void FileSystemChooseFileFunction::SkipPickerAndAlwaysSelectPathForTest(
+void FileSystemChooseEntryFunction::SkipPickerAndAlwaysSelectPathForTest(
     FilePath* path) {
   g_skip_picker_for_test = true;
   g_path_to_be_picked_for_test = path;
 }
 
 // static
-void FileSystemChooseFileFunction::SkipPickerAndAlwaysCancelForTest() {
+void FileSystemChooseEntryFunction::SkipPickerAndAlwaysCancelForTest() {
   g_skip_picker_for_test = true;
   g_path_to_be_picked_for_test = NULL;
 }
 
 // static
-void FileSystemChooseFileFunction::StopSkippingPickerForTest() {
+void FileSystemChooseEntryFunction::StopSkippingPickerForTest() {
   g_skip_picker_for_test = false;
 }
 
-void FileSystemChooseFileFunction::FileSelected(const FilePath& path,
+void FileSystemChooseEntryFunction::FileSelected(const FilePath& path,
                                                 EntryType entry_type) {
   if (entry_type == WRITABLE) {
     content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
-        base::Bind(&FileSystemChooseFileFunction::CheckWritableFile,
+        base::Bind(&FileSystemChooseEntryFunction::CheckWritableFile,
             this, path));
     return;
   }
 
   // Don't need to check the file, it's for reading.
   RegisterFileSystemAndSendResponse(path, READ_ONLY);
 }
 
-void FileSystemChooseFileFunction::FileSelectionCanceled() {
+void FileSystemChooseEntryFunction::FileSelectionCanceled() {
   error_ = kUserCancelled;
   SendResponse(false);
 }
 
-void FileSystemChooseFileFunction::BuildFileTypeInfo(
+void FileSystemChooseEntryFunction::BuildFileTypeInfo(
     ui::SelectFileDialog::FileTypeInfo* file_type_info,
     const FilePath::StringType& suggested_extension,
     const AcceptOptions* accepts,
     const bool* acceptsAllTypes) {
   file_type_info->include_all_files = true;
   if (acceptsAllTypes)
     file_type_info->include_all_files = *acceptsAllTypes;
 
   bool need_suggestion = !file_type_info->include_all_files &&
                          !suggested_extension.empty();
@@ skipping 19 matching lines @@
       }
     }
   }
 
   // If there's nothing in our accepted extension list or we couldn't find the
   // suggested extension required, then default to accepting all types.
   if (file_type_info->extensions.empty() || need_suggestion)
     file_type_info->include_all_files = true;
 }
 
-void FileSystemChooseFileFunction::BuildSuggestion(
+void FileSystemChooseEntryFunction::BuildSuggestion(
     const std::string *opt_name,
     FilePath* suggested_name,
     FilePath::StringType* suggested_extension) {
   if (opt_name) {
     *suggested_name = FilePath::FromUTF8Unsafe(*opt_name);
 
     // Don't allow any path components; shorten to the base name. This should
     // result in a relative path, but in some cases may not. Clear the
     // suggestion for safety if this is the case.
     *suggested_name = suggested_name->BaseName();
     if (suggested_name->IsAbsolute())
       *suggested_name = FilePath();
 
     *suggested_extension = suggested_name->Extension();
     if (!suggested_extension->empty())
       suggested_extension->erase(suggested_extension->begin());  // drop the .
   }
 }
 
-bool FileSystemChooseFileFunction::RunImpl() {
-  scoped_ptr<ChooseFile::Params> params(ChooseFile::Params::Create(*args_));
+bool FileSystemChooseEntryFunction::RunImpl() {
+  scoped_ptr<ChooseEntry::Params> params(ChooseEntry::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   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::ChooseFileOptions* options = params->options.get();
+  file_system::ChooseEntryOptions* options = params->options.get();
   if (options) {
     if (options->type.get()) {
       if (*options->type == kOpenWritableFileOption) {
         entry_type = WRITABLE;
       } else if (*options->type == kSaveFileOption) {
         entry_type = WRITABLE;
         picker_type = ui::SelectFileDialog::SELECT_SAVEAS_FILE;
       } else if (*options->type != kOpenFileOption) {
-        error_ = kUnknownChooseFileType;
+        error_ = kUnknownChooseEntryType;
         return false;
       }
     }
 
     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()) {
     error_ = kRequiresFileSystemWriteError;
     return false;
   }
 
   return ShowPicker(suggested_name, file_type_info, picker_type, entry_type);
 }
 
 }  // namespace extensions