Simplify directory path accounting.

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"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/sys_string_conversions.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
+#include "webkit/fileapi/file_system_quota_util.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
+#include "webkit/quota/quota_manager.h"
 
 namespace {
 
 const int64 kFlushDelaySeconds = 10 * 60;  // 10 minutes
 
 const char kOriginDatabaseName[] = "Origins";
 const char kDirectoryDatabaseName[] = "Paths";
 
 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("/"));
 }
 
+// Costs computed as per crbug.com/86114, based on the LevelDB implementation of
+// path storage under Linux.  It's not clear if that will differ on Windows, on
+// which FilePath uses wide chars [since they're converted to UTF-8 for storage
+// anyway], but as long as the cost is high enough that one can't cheat on quota
+// by storing data in paths, it doesn't need to be all that accurate.
+const int64 kPathCreationQuotaCost = 146; // Bytes per inode, basically.
+const int64 kPathByteQuotaCost = 2; // Bytes per byte of path length in UTF-8.
+
+int64 GetPathQuotaUsage(
+    int growth_in_number_of_paths,
+    int64 growth_in_bytes_of_path_length) {
+  return growth_in_number_of_paths * kPathCreationQuotaCost +
+      growth_in_bytes_of_path_length * kPathByteQuotaCost;
+}
+
+bool AllocateQuotaForPath(
+    fileapi::FileSystemOperationContext* context,
+    int growth_in_number_of_paths,
+    int64 growth_in_bytes_of_path_length) {
+  int64 growth = GetPathQuotaUsage(growth_in_number_of_paths,
+      growth_in_bytes_of_path_length);
+  int64 new_quota = context->allowed_bytes_growth() - growth;
+
+  if (growth <= 0 || new_quota >= 0) {
+    context->set_allowed_bytes_growth(new_quota);
+    return true;
+  }
+  return false;
+}
+
+void UpdatePathQuotaUsage(
+    fileapi::FileSystemOperationContext* context,
+    const GURL& origin_url,
+    fileapi::FileSystemType type,
+    int growth_in_number_of_paths, // -1, 0, or 1
+    int64 growth_in_bytes_of_path_length) {
+  int64 growth = GetPathQuotaUsage(growth_in_number_of_paths,
+      growth_in_bytes_of_path_length);
+  fileapi::FileSystemQuotaUtil* quota_util =
+      context->file_system_context()->GetQuotaUtil(type);
+  quota::QuotaManagerProxy* quota_manager_proxy =
+      context->file_system_context()->quota_manager_proxy();
+  quota_util->UpdateOriginUsageOnFileThread(quota_manager_proxy, origin_url,
+      type, growth);
+}
+
 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;
@@ skipping 25 matching lines @@
   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))
       return base::PLATFORM_FILE_ERROR_NOT_FOUND;
     FileInfo file_info;
     InitFileInfo(&file_info, parent_id, virtual_path.BaseName().value());
+    if (!AllocateQuotaForPath(context, 1, file_info.name.size()))
+      return base::PLATFORM_FILE_ERROR_NO_SPACE;
     PlatformFileError error = CreateFile(
         context, context->src_origin_url(), context->src_type(), FilePath(),
         &file_info, file_flags, file_handle);
     if (created && base::PLATFORM_FILE_OK == error)
       *created = true;
     return error;
   }
   if (file_flags & base::PLATFORM_FILE_CREATE)
     return base::PLATFORM_FILE_ERROR_EXISTS;
 
@@ skipping 30 matching lines @@
     if (created)
       *created = false;
     return base::PLATFORM_FILE_OK;
   }
   FileId parent_id;
   if (!db->GetFileWithPath(virtual_path.DirName(), &parent_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   FileInfo file_info;
   InitFileInfo(&file_info, parent_id, virtual_path.BaseName().value());
+  if (!AllocateQuotaForPath(context, 1, file_info.name.size()))
+    return base::PLATFORM_FILE_ERROR_NO_SPACE;
   PlatformFileError error = CreateFile(context, context->src_origin_url(),
       context->src_type(), FilePath(), &file_info, 0, NULL);
   if (created && base::PLATFORM_FILE_OK == error)
     *created = true;
   return error;
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::GetLocalFilePath(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
@@ skipping 107 matching lines @@
   size_t index;
   for (index = 0; index < components.size(); ++index) {
     FilePath::StringType name = components[index];
     if (name == FILE_PATH_LITERAL("/"))
       continue;
     if (!db->GetChildWithName(parent_id, name, &parent_id))
       break;
   }
   if (!recursive && components.size() - index > 1)
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  // TODO(dmikurube): Eliminate do_not_write_actually in future.
-  bool do_not_write_actually = context->do_not_write_actually();
-  context->set_do_not_write_actually(true);
-  underlying_file_util_->CreateDirectory(context,
-      FilePath(), exclusive, recursive);
-  context->set_do_not_write_actually(do_not_write_actually);
   for (; index < components.size(); ++index) {
     FileInfo file_info;
     file_info.name = components[index];
     if (file_info.name == FILE_PATH_LITERAL("/"))
       continue;
     file_info.modification_time = base::Time::Now();
     file_info.parent_id = parent_id;
+    if (!AllocateQuotaForPath(context, 1, file_info.name.size()))
+      return base::PLATFORM_FILE_ERROR_NO_SPACE;
     if (!db->AddFileInfo(file_info, &parent_id)) {
       NOTREACHED();
       return base::PLATFORM_FILE_ERROR_FAILED;
     }
+    UpdatePathQuotaUsage(context, context->src_origin_url(),
+      context->src_type(), 1, file_info.name.size());
   }
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::CopyOrMoveFile(
     FileSystemOperationContext* context,
     const FilePath& src_file_path,
     const FilePath& dest_file_path,
     bool copy) {
+  // Cross-filesystem copies and moves should be handled via CopyInForeignFile.
+  DCHECK(context->src_origin_url() == context->dest_origin_url());
+  DCHECK(context->src_type() == context->dest_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;
@@ skipping 33 matching lines @@
       return underlying_file_util_->CopyOrMoveFile(context,
           src_data_path, dest_data_path, copy);
     } else {
       FileId dest_parent_id;
       if (!db->GetFileWithPath(dest_file_path.DirName(), &dest_parent_id)) {
         NOTREACHED();  // We shouldn't be called in this case.
         return base::PLATFORM_FILE_ERROR_NOT_FOUND;
       }
       InitFileInfo(&dest_file_info, dest_parent_id,
           dest_file_path.BaseName().value());
+      if (!AllocateQuotaForPath(context, 1, dest_file_info.name.size()))
+        return base::PLATFORM_FILE_ERROR_NO_SPACE;
       return CreateFile(context, context->dest_origin_url(),
           context->dest_type(), src_data_path, &dest_file_info, 0,
           NULL);
     }
   } else {  // It's a move.
     if (overwrite) {
+      AllocateQuotaForPath(context, -1,
+          -static_cast<int64>(src_file_info.name.size()));
       if (!db->OverwritingMoveFile(src_file_id, dest_file_id))
         return base::PLATFORM_FILE_ERROR_FAILED;
       FilePath dest_data_path = DataPathToLocalPath(context->src_origin_url(),
         context->src_type(), dest_file_info.data_path);
       if (base::PLATFORM_FILE_OK !=
           underlying_file_util_->DeleteFile(context, dest_data_path))
         LOG(WARNING) << "Leaked a backing file.";
+      UpdatePathQuotaUsage(context, context->src_origin_url(),
+          context->src_type(), -1,
+          -static_cast<int64>(src_file_info.name.size()));
       return base::PLATFORM_FILE_OK;
     } else {
       FileId dest_parent_id;
       if (!db->GetFileWithPath(dest_file_path.DirName(), &dest_parent_id)) {
         NOTREACHED();
         return base::PLATFORM_FILE_ERROR_FAILED;
       }
+      if (!AllocateQuotaForPath(
+          context, 0,
+          static_cast<int64>(dest_file_path.BaseName().value().size())
+              - static_cast<int64>(src_file_info.name.size())))
+        return base::PLATFORM_FILE_ERROR_NO_SPACE;
       src_file_info.parent_id = dest_parent_id;
       src_file_info.name = dest_file_path.BaseName().value();
       if (!db->UpdateFileInfo(src_file_id, src_file_info))
         return base::PLATFORM_FILE_ERROR_FAILED;
+      UpdatePathQuotaUsage(
+          context, context->src_origin_url(), context->src_type(), 0,
+          static_cast<int64>(dest_file_path.BaseName().value().size()) -
+              static_cast<int64>(src_file_path.BaseName().value().size()));
       return base::PLATFORM_FILE_OK;
     }
   }
   NOTREACHED();
   return base::PLATFORM_FILE_ERROR_FAILED;
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::CopyInForeignFile(
     FileSystemOperationContext* context,
     const FilePath& src_file_path,
@@ skipping 16 matching lines @@
     return underlying_file_util_->CopyOrMoveFile(context,
         src_file_path, dest_data_path, true /* copy */);
   } else {
     FileId dest_parent_id;
     if (!db->GetFileWithPath(dest_file_path.DirName(), &dest_parent_id)) {
       NOTREACHED();  // We shouldn't be called in this case.
       return base::PLATFORM_FILE_ERROR_NOT_FOUND;
     }
     InitFileInfo(&dest_file_info, dest_parent_id,
         dest_file_path.BaseName().value());
+    if (!AllocateQuotaForPath(context, 1, dest_file_info.name.size()))
+      return base::PLATFORM_FILE_ERROR_NO_SPACE;
     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(), 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;
   }
+  AllocateQuotaForPath(context, -1, -static_cast<int64>(file_info.name.size()));
+  UpdatePathQuotaUsage(context, context->src_origin_url(), context->src_type(),
+      -1, -static_cast<int64>(file_info.name.size()));
   FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
     context->src_type(), file_info.data_path);
   if (base::PLATFORM_FILE_OK !=
       underlying_file_util_->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(), 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;
+  AllocateQuotaForPath(context, -1, -static_cast<int64>(file_info.name.size()));
+  UpdatePathQuotaUsage(context, context->src_origin_url(), context->src_type(),
+      -1, -static_cast<int64>(file_info.name.size()));
   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(), true);
@@ skipping 18 matching lines @@
         context, data_path, last_access_time, last_modified_time);
   }
   FileId parent_id;
   if (!db->GetFileWithPath(virtual_path.DirName(), &parent_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   FileInfo file_info;
   InitFileInfo(&file_info, parent_id, virtual_path.BaseName().value());
   // In the event of a sporadic underlying failure, we might create a new file,
   // but fail to update its mtime + atime.
+  if (!AllocateQuotaForPath(context, 1, file_info.name.size()))
+    return base::PLATFORM_FILE_ERROR_NO_SPACE;
   PlatformFileError error = CreateFile(context, context->src_origin_url(),
       context->src_type(), FilePath(), &file_info, 0, NULL);
   if (base::PLATFORM_FILE_OK != error)
     return error;
 
   FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
     context->src_type(), file_info.data_path);
   return underlying_file_util_->Touch(context, data_path,
     last_access_time, last_modified_time);
 }
@@ skipping 256 matching lines @@
   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;
 
   path = path.AppendASCII(StringPrintf("%02" PRIu64, directory_number));
-  if (file_util::DirectoryExists(path.DirName())) {
-    if (!file_util::DirectoryExists(path) && !file_util::CreateDirectory(path))
-      return base::PLATFORM_FILE_ERROR_FAILED;
-  } else {
-    return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  }
+  PlatformFileError error;
+  error = underlying_file_util_->CreateDirectory(
+      context, path, false /* exclusive */, false /* recursive */);
+  if (base::PLATFORM_FILE_OK != error)
+    return error;
   path = path.AppendASCII(StringPrintf("%08" PRIu64, number));
   FilePath data_path = LocalPathToDataPath(origin_url, type, path);
   if (data_path.empty())
     return base::PLATFORM_FILE_ERROR_FAILED;
-  PlatformFileError error;
   bool created = false;
   if (!source_path.empty()) {
     DCHECK(!file_flags);
     DCHECK(!handle);
     error = underlying_file_util_->CopyOrMoveFile(
       context, source_path, path, true /* copy */);
     created = true;
   } else {
     if (handle) {
       error = underlying_file_util_->CreateOrOpen(
@@ skipping 20 matching lines @@
   file_info->data_path = data_path;
   FileId file_id;
   if (!db->AddFileInfo(*file_info, &file_id)) {
     if (handle) {
       DCHECK_NE(base::kInvalidPlatformFileValue, *handle);
       base::ClosePlatformFile(*handle);
     }
     underlying_file_util_->DeleteFile(context, path);
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
+  UpdatePathQuotaUsage(context, origin_url, type, 1, file_info->name.size());
 
   return base::PLATFORM_FILE_OK;
 }
 
 FilePath ObfuscatedFileSystemFileUtil::GetLocalPath(
     const GURL& origin_url,
     FileSystemType type,
     const FilePath& virtual_path) {
   FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
       origin_url, type, false);
@@ skipping 219 matching lines @@
       &ObfuscatedFileSystemFileUtil::DropDatabases);
 }
 
 void ObfuscatedFileSystemFileUtil::DropDatabases() {
   origin_database_.reset();
   STLDeleteContainerPairSecondPointers(
       directories_.begin(), directories_.end());
   directories_.clear();
 }
 
+// static
+int64 ObfuscatedFileSystemFileUtil::ComputeFilePathCost(const FilePath& path) {
+  return GetPathQuotaUsage(1, path.BaseName().value().size());
+}
+
 bool ObfuscatedFileSystemFileUtil::DestroyDirectoryDatabase(
     const GURL& origin, FileSystemType type) {
   std::string type_string =
       FileSystemPathManager::GetFileSystemTypeString(type);
   if (type_string.empty()) {
     LOG(WARNING) << "Unknown filesystem type requested:" << type;
     return true;
   }
   std::string key = GetOriginIdentifierFromURL(origin) + type_string;
   DirectoryMap::iterator iter = directories_.find(key);
@@ skipping 22 matching lines @@
       return false;
     }
     origin_database_.reset(
         new FileSystemOriginDatabase(
             file_system_directory_.AppendASCII(kOriginDatabaseName)));
   }
   return true;
 }
 
 }  // namespace fileapi