Add support for directory access to the file system API.

chrome/browser/extensions/api/file_handlers/app_file_handler_util.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_handlers/app_file_handler_util.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 46 matching lines @@
       return true;
   }
   return false;
 }
 
 bool DoCheckWritableFile(const base::FilePath& path) {
   // Don't allow links.
   if (base::PathExists(path) && file_util::IsLink(path))
     return false;
 
+  if (base::DirectoryExists(path))
+    return base::PathIsWritable(path);

[Matt Giuca, 2013/08/27 04:30:53]

Do you handle the case of trying to write to a file that is actually a
directory, and vice versa?

(More generally, do you handle the case where you retain access to a file or
directory, then in between sessions, the file changes to a directory or vice
versa?)

[Sam McNally, 2013/08/27 05:16:37]

That would cause getFile/getDirectory to fail in the custom bindings.

+
   // 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);
@@ skipping 206 matching lines @@
     const std::string& mime_type,
     const base::FilePath& path) {
   return FileHandlerCanHandleFileWithMimeType(handler, mime_type) ||
       FileHandlerCanHandleFileWithExtension(handler, path);
 }
 
 GrantedFileEntry CreateFileEntry(
     Profile* profile,
     const Extension* extension,
     int renderer_id,
-    const base::FilePath& path) {
+    const base::FilePath& path,
+    bool is_directory) {
   GrantedFileEntry result;
   fileapi::IsolatedContext* isolated_context =
       fileapi::IsolatedContext::GetInstance();
   DCHECK(isolated_context);
 
   result.filesystem_id = isolated_context->RegisterFileSystemForPath(
       fileapi::kFileSystemTypeNativeForPlatformApp, path,
       &result.registered_name);
 
   content::ChildProcessSecurityPolicy* policy =
       content::ChildProcessSecurityPolicy::GetInstance();
   policy->GrantReadFileSystem(renderer_id, result.filesystem_id);
-  if (HasFileSystemWritePermission(extension))
+  if (HasFileSystemWritePermission(extension)) {
     policy->GrantWriteFileSystem(renderer_id, result.filesystem_id);
+    if (is_directory)
+      policy->GrantCreateFileForFileSystem(renderer_id, result.filesystem_id);
+  }
 
   result.id = result.filesystem_id + ":" + result.registered_name;
   return result;
 }
 
 void CheckWritableFiles(
     const std::vector<base::FilePath>& paths,
     Profile* profile,
     const base::Closure& on_success,
     const base::Callback<void(const base::FilePath&)>& on_failure) {
   scoped_refptr<WritableFileChecker> checker(
       new WritableFileChecker(paths, profile, on_success, on_failure));
   checker->Check();
 }
 
+GrantedFileEntry::GrantedFileEntry() {}
+
 bool HasFileSystemWritePermission(const Extension* extension) {
   return extension->HasAPIPermission(APIPermission::kFileSystemWrite);
 }
 
 }  // namespace app_file_handler_util
 
 }  // namespace extensions