Merge 91814 - Do not create a new directory database for read operations.

webkit/fileapi/obfuscated_file_system_file_util.cc

 // Copyright (c) 2011 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 "webkit/fileapi/obfuscated_file_system_file_util.h"
 
 #include <queue>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 23 matching lines @@
 
 void InitFileInfo(
     fileapi::FileSystemDirectoryDatabase::FileInfo* file_info,
     fileapi::FileSystemDirectoryDatabase::FileId parent_id,
     const FilePath::StringType& file_name) {
   DCHECK(file_info);
   file_info->parent_id = parent_id;
   file_info->name = file_name;
 }
 
+bool IsRootDirectory(const FilePath& virtual_path) {
+  return (virtual_path.empty() ||
+          virtual_path.value() == FILE_PATH_LITERAL("/"));
+}
+
 const FilePath::CharType kLegacyDataDirectory[] = FILE_PATH_LITERAL("Legacy");
 
 const FilePath::CharType kTemporaryDirectoryName[] = FILE_PATH_LITERAL("t");
 const FilePath::CharType kPersistentDirectoryName[] = FILE_PATH_LITERAL("p");
 
 }  // namespace
 
 namespace fileapi {
 
 using base::PlatformFile;
 using base::PlatformFileError;
 
 ObfuscatedFileSystemFileUtil::ObfuscatedFileSystemFileUtil(
     const FilePath& file_system_directory)
     : file_system_directory_(file_system_directory) {
 }
 
 ObfuscatedFileSystemFileUtil::~ObfuscatedFileSystemFileUtil() {
   DropDatabases();
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::CreateOrOpen(
     FileSystemOperationContext* context,
     const FilePath& virtual_path, int file_flags,
     PlatformFile* file_handle, bool* created) {
   DCHECK(!(file_flags & (base::PLATFORM_FILE_DELETE_ON_CLOSE |
         base::PLATFORM_FILE_HIDDEN | base::PLATFORM_FILE_EXCLUSIVE_READ |
         base::PLATFORM_FILE_EXCLUSIVE_WRITE)));
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
   FileId file_id;
   if (!db->GetFileWithPath(virtual_path, &file_id)) {
     // The file doesn't exist.
     if (!(file_flags & (base::PLATFORM_FILE_CREATE |
         base::PLATFORM_FILE_CREATE_ALWAYS | base::PLATFORM_FILE_OPEN_ALWAYS)))
       return base::PLATFORM_FILE_ERROR_NOT_FOUND;
     FileId parent_id;
     if (!db->GetFileWithPath(virtual_path.DirName(), &parent_id))
@@ skipping 20 matching lines @@
   FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
     context->src_type(), file_info.data_path);
   return QuotaFileUtil::GetInstance()->CreateOrOpen(
       context, data_path, file_flags, file_handle, created);
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::EnsureFileExists(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
     bool* created) {
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
   FileId file_id;
   if (db->GetFileWithPath(virtual_path, &file_id)) {
     FileInfo file_info;
     if (!db->GetFileInfo(file_id, &file_info)) {
       NOTREACHED();
       return base::PLATFORM_FILE_ERROR_FAILED;
     }
     if (file_info.is_directory())
@@ skipping 27 matching lines @@
 
   *local_path = path;
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::GetFileInfo(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
     base::PlatformFileInfo* file_info,
     FilePath* platform_file_path) {
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), false);
   if (!db)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileId file_id;
   if (!db->GetFileWithPath(virtual_path, &file_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileInfo local_info;
   if (!db->GetFileInfo(file_id, &local_info)) {
     NOTREACHED();
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   if (local_info.is_directory()) {
     file_info->is_directory = true;
     file_info->is_symbolic_link = false;
     file_info->last_modified = local_info.modification_time;
     *platform_file_path = FilePath();
     // We don't fill in ctime or atime.
     return base::PLATFORM_FILE_OK;
   }
   if (local_info.data_path.empty())
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
   FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
     context->src_type(), local_info.data_path);
   return QuotaFileUtil::GetInstance()->GetFileInfo(
       context, data_path, file_info, platform_file_path);
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::ReadDirectory(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
     std::vector<base::FileUtilProxy::Entry>* entries) {
   // TODO(kkanetkar): Implement directory read in multiple chunks.
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
-  if (!db)
-    return base::PLATFORM_FILE_ERROR_FAILED;
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), false);
+  if (!db) {
+    if (IsRootDirectory(virtual_path)) {
+      // It's the root directory and the database hasn't been initialized yet.
+      entries->clear();
+      return base::PLATFORM_FILE_OK;
+    }
+    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
+  }
   FileId file_id;
   if (!db->GetFileWithPath(virtual_path, &file_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info)) {
     DCHECK(!file_id);
     // It's the root directory and the database hasn't been initialized yet.
     entries->clear();
     return base::PLATFORM_FILE_OK;
   }
@@ skipping 16 matching lines @@
     entries->push_back(entry);
   }
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::CreateDirectory(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
     bool exclusive,
     bool recursive) {
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
   FileId file_id;
   if (db->GetFileWithPath(virtual_path, &file_id)) {
     FileInfo file_info;
     if (exclusive)
       return base::PLATFORM_FILE_ERROR_EXISTS;
     if (!db->GetFileInfo(file_id, &file_info)) {
       NOTREACHED();
       return base::PLATFORM_FILE_ERROR_FAILED;
@@ skipping 29 matching lines @@
     }
   }
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::CopyOrMoveFile(
     FileSystemOperationContext* context,
     const FilePath& src_file_path,
     const FilePath& dest_file_path,
     bool copy) {
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
   FileId src_file_id;
   if (!db->GetFileWithPath(src_file_path, &src_file_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileId dest_file_id;
   bool overwrite = db->GetFileWithPath(dest_file_path, &dest_file_id);
   FileInfo src_file_info;
   FileInfo dest_file_info;
   if (!db->GetFileInfo(src_file_id, &src_file_info) ||
@@ skipping 66 matching lines @@
     }
   }
   NOTREACHED();
   return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::CopyInForeignFile(
     FileSystemOperationContext* context,
     const FilePath& src_file_path,
     const FilePath& dest_file_path) {
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->dest_origin_url(), context->dest_type());
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->dest_origin_url(), context->dest_type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
   FileId dest_file_id;
   bool overwrite = db->GetFileWithPath(dest_file_path, &dest_file_id);
   FileInfo dest_file_info;
   if (overwrite) {
     if (!db->GetFileInfo(dest_file_id, &dest_file_info) ||
         dest_file_info.is_directory()) {
       NOTREACHED();
       return base::PLATFORM_FILE_ERROR_FAILED;
@@ skipping 12 matching lines @@
         dest_file_path.BaseName().value());
     return CreateFile(context, context->dest_origin_url(),
         context->dest_type(), src_file_path, &dest_file_info, 0, NULL);
   }
   return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::DeleteFile(
     FileSystemOperationContext* context,
     const FilePath& virtual_path) {
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
   FileId file_id;
   if (!db->GetFileWithPath(virtual_path, &file_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info) || file_info.is_directory()) {
     NOTREACHED();
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   if (!db->RemoveFileInfo(file_id)) {
     NOTREACHED();
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
     context->src_type(), file_info.data_path);
   if (base::PLATFORM_FILE_OK !=
       QuotaFileUtil::GetInstance()->DeleteFile(context, data_path))
     LOG(WARNING) << "Leaked a backing file.";
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::DeleteSingleDirectory(
     FileSystemOperationContext* context,
     const FilePath& virtual_path) {
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
   FileId file_id;
   if (!db->GetFileWithPath(virtual_path, &file_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info) || !file_info.is_directory()) {
     NOTREACHED();
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   if (!db->RemoveFileInfo(file_id))
     return base::PLATFORM_FILE_ERROR_NOT_EMPTY;
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::Touch(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
   FileId file_id;
   if (db->GetFileWithPath(virtual_path, &file_id)) {
     FileInfo file_info;
     if (!db->GetFileInfo(file_id, &file_info)) {
       NOTREACHED();
       return base::PLATFORM_FILE_ERROR_FAILED;
     }
     if (file_info.is_directory()) {
@@ skipping 35 matching lines @@
           virtual_path);
   if (local_path.empty())
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   return QuotaFileUtil::GetInstance()->Truncate(
       context, local_path, length);
 }
 
 bool ObfuscatedFileSystemFileUtil::PathExists(
     FileSystemOperationContext* context,
     const FilePath& virtual_path) {
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), false);
   if (!db)
     return false;
   FileId file_id;
   return db->GetFileWithPath(virtual_path, &file_id);
 }
 
 bool ObfuscatedFileSystemFileUtil::DirectoryExists(
     FileSystemOperationContext* context,
     const FilePath& virtual_path) {
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
+  if (IsRootDirectory(virtual_path)) {
+    // It's questionable whether we should return true or false for the
+    // root directory of nonexistent origin, but here we return true
+    // as the current implementation of ReadDirectory always returns an empty
+    // array (rather than erroring out with NOT_FOUND_ERR even) for
+    // nonexistent origins.
+    // Note: if you're going to change this behavior please also consider
+    // changiing the ReadDirectory's behavior!
+    return true;
+  }
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), false);
   if (!db)
     return false;
   FileId file_id;
   if (!db->GetFileWithPath(virtual_path, &file_id))
     return false;
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info)) {
     NOTREACHED();
     return false;
   }
   return file_info.is_directory();
 }
 
 bool ObfuscatedFileSystemFileUtil::IsDirectoryEmpty(
     FileSystemOperationContext* context,
     const FilePath& virtual_path) {
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), false);
   if (!db)
-    return false;
+    return true;  // Not a great answer, but it's what others do.
   FileId file_id;
   if (!db->GetFileWithPath(virtual_path, &file_id))
-    return true;  // Not a great answer, but it's what others do.
+    return true;  // Ditto.
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info)) {
     DCHECK(!file_id);
     // It's the root directory and the database hasn't been initialized yet.
     return true;
   }
   if (!file_info.is_directory())
     return true;
   std::vector<FileId> children;
   // TODO(ericu): This could easily be made faster with help from the database.
@@ skipping 124 matching lines @@
 
   InitOriginDatabase(false);
   return new ObfuscatedFileSystemOriginEnumerator(
       origin_database_.get(), file_system_directory_);
 }
 
 FileSystemFileUtil::AbstractFileEnumerator*
 ObfuscatedFileSystemFileUtil::CreateFileEnumerator(
     FileSystemOperationContext* context,
     const FilePath& root_path) {
-  FileSystemDirectoryDatabase* db =
-      GetDirectoryDatabase(context->src_origin_url(), context->src_type());
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      context->src_origin_url(), context->src_type(), false);
   if (!db)
     return new FileSystemFileUtil::EmptyFileEnumerator();
   return new ObfuscatedFileSystemFileEnumerator(db, root_path);
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::CreateFile(
     FileSystemOperationContext* context,
     const GURL& origin_url, FileSystemType type, const FilePath& source_path,
     FileInfo* file_info, int file_flags, PlatformFile* handle) {
   if (handle)
     *handle = base::kInvalidPlatformFileValue;
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(origin_url, type);
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      origin_url, type, true);
   int64 number;
   if (!db || !db->GetNextInteger(&number))
     return base::PLATFORM_FILE_ERROR_FAILED;
   // We use the third- and fourth-to-last digits as the directory.
   int64 directory_number = number % 10000 / 100;
   FilePath path =
       GetDirectoryForOriginAndType(origin_url, type, false);
   if (path.empty())
     return base::PLATFORM_FILE_ERROR_FAILED;
 
@@ skipping 45 matching lines @@
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
 
   return base::PLATFORM_FILE_OK;
 }
 
 FilePath ObfuscatedFileSystemFileUtil::GetLocalPath(
     const GURL& origin_url,
     FileSystemType type,
     const FilePath& virtual_path) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(origin_url, type);
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      origin_url, type, false);
   if (!db)
     return FilePath();
   FileId file_id;
   if (!db->GetFileWithPath(virtual_path, &file_id))
     return FilePath();
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info) || file_info.is_directory()) {
     NOTREACHED();
     return FilePath();  // Directories have no local path.
   }
@@ skipping 34 matching lines @@
   return path;
 }
 
 bool ObfuscatedFileSystemFileUtil::MigrateFromOldSandbox(
     const GURL& origin_url, FileSystemType type, const FilePath& src_root) {
   if (!DestroyDirectoryDatabase(origin_url, type))
     return false;
   FilePath dest_root = GetDirectoryForOriginAndType(origin_url, type, true);
   if (dest_root.empty())
     return false;
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(origin_url, type);
+  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+      origin_url, type, false);

[ericu, 2011/08/01 22:53:27]

While this code won't actually fail [due to the "true" in the call to
GetDirectoryForOriginType()], passing true would be more correct here, as we
will be creating a new directory database in all cases.

   if (!db)
     return false;
 
   file_util::FileEnumerator file_enum(src_root, true,
       static_cast<file_util::FileEnumerator::FILE_TYPE>(
           file_util::FileEnumerator::FILES |
           file_util::FileEnumerator::DIRECTORIES));
   FilePath src_full_path;
   size_t root_path_length = src_root.value().length() + 1;  // +1 for the slash
   while (!(src_full_path = file_enum.Next()).empty()) {
@@ skipping 78 matching lines @@
     return root;
   // This removes the root, including the trailing slash, leaving a relative
   // path.
   return FilePath(local_path.value().substr(root.value().length() + 1));
 }
 
 // TODO: How to do the whole validation-without-creation thing?  We may not have
 // quota even to create the database.  Ah, in that case don't even get here?
 // Still doesn't answer the quota issue, though.
 FileSystemDirectoryDatabase* ObfuscatedFileSystemFileUtil::GetDirectoryDatabase(
-    const GURL& origin, FileSystemType type) {
-
-  MarkUsed();
+    const GURL& origin, FileSystemType type, bool create) {
   std::string type_string =
       FileSystemPathManager::GetFileSystemTypeString(type);
   if (type_string.empty()) {
     LOG(WARNING) << "Unknown filesystem type requested:" << type;
     return NULL;
   }
   std::string key = GetOriginIdentifierFromURL(origin) + type_string;
   DirectoryMap::iterator iter = directories_.find(key);
-  if (iter != directories_.end())
+  if (iter != directories_.end()) {
+    MarkUsed();
     return iter->second;
+  }
 
-  FilePath path = GetDirectoryForOriginAndType(origin, type, true);
+  FilePath path = GetDirectoryForOriginAndType(origin, type, create);
   if (path.empty())
     return NULL;
   if (!file_util::DirectoryExists(path)) {
     if (!file_util::CreateDirectory(path)) {
       LOG(WARNING) << "Failed to origin+type directory: " << path.value();
       return NULL;
     }
   }
+  MarkUsed();
   path = path.AppendASCII(kDirectoryDatabaseName);
   FileSystemDirectoryDatabase* database = new FileSystemDirectoryDatabase(path);
   directories_[key] = database;
   return database;
 }
 
 void ObfuscatedFileSystemFileUtil::MarkUsed() {
   if (timer_.IsRunning())
     timer_.Reset();
   else
@@ skipping 40 matching lines @@
       return false;
     }
     origin_database_.reset(
         new FileSystemOriginDatabase(
             file_system_directory_.AppendASCII(kOriginDatabaseName)));
   }
   return true;
 }
 
 }  // namespace fileapi