Rename "CheckWritable" to "PrepareForWritableApp" to reflect the actual behavior.

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 "apps/browser/file_handler_util.h"
 #include "base/file_util.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
@@ skipping 59 matching lines @@
 
 bool DoCheckWritableFile(const base::FilePath& path, bool is_directory) {
   // Don't allow links.
   if (base::PathExists(path) && base::IsLink(path))
     return false;
 
   if (is_directory)
     return base::DirectoryExists(path);
 
   // Create the file if it doesn't already exist.
-  int creation_flags = base::File::FLAG_CREATE | base::File::FLAG_READ |
-                       base::File::FLAG_WRITE;
+  int creation_flags = base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_READ;
   base::File file(path, creation_flags);
-  if (file.IsValid())
-    return true;
-  return file.error_details() == base::File::FILE_ERROR_EXISTS;
+  return file.IsValid();
 }
 
 // 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(
@@ skipping 52 matching lines @@
     for (std::vector<base::FilePath>::const_iterator it = paths_.begin();
          it != paths_.end();
          ++it) {
       if (is_directory_) {
         file_manager::util::IsNonNativeLocalPathDirectory(
             profile_,
             *it,
             base::Bind(&WritableFileChecker::NonNativeLocalPathCheckDone,
                        this, *it));
       } else {
-        file_manager::util::PrepareNonNativeLocalPathWritableFile(
+        file_manager::util::PrepareNonNativeLocalFileForWritableApp(
             profile_,
             *it,
             base::Bind(&WritableFileChecker::NonNativeLocalPathCheckDone,
                        this, *it));
       }
     }
     return;
   }
 #endif
   content::BrowserThread::PostTask(
@@ skipping 144 matching lines @@
     } else {
       policy->GrantWriteFileSystem(renderer_id, result.filesystem_id);
       policy->GrantDeleteFromFileSystem(renderer_id, result.filesystem_id);
     }
   }
 
   result.id = result.filesystem_id + ":" + result.registered_name;
   return result;
 }
 
-void CheckWritableFiles(
+void PrepareFilesForWritableApp(
     const std::vector<base::FilePath>& paths,
     Profile* profile,
     bool is_directory,
     const base::Closure& on_success,
     const base::Callback<void(const base::FilePath&)>& on_failure) {
   scoped_refptr<WritableFileChecker> checker(new WritableFileChecker(
       paths, profile, is_directory, on_success, on_failure));
   checker->Check();
 }
 
@@ skipping 49 matching lines @@
     *error = kInvalidParameters;
     return false;
   }
 
   return true;
 }
 
 }  // namespace app_file_handler_util
 
 }  // namespace extensions