Integrated obfuscation with quota; all unit tests now pass

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/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/sys_string_conversions.h"
 #include "base/stl_util-inl.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_util.h"
 #include "webkit/fileapi/quota_file_util.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 
-// TODO(ericu): Every instance of FileSystemFileUtil in this file should switch
-// to QuotaFileUtil as soon as I sort out FileSystemPathManager's and
-// SandboxMountPointProvider's lookups of the root path for a filesystem.
+// TODO(ericu): Make deleting an origin [or a type under the origin, if it's the
+// last type] remove the origin from origin_database_ as well.
 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,
@@ skipping 58 matching lines @@
 
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info)) {
     NOTREACHED();
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   if (file_info.is_directory())
     return base::PLATFORM_FILE_ERROR_NOT_A_FILE;
   FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
     context->src_type(), file_info.data_path);
-  return FileSystemFileUtil::GetInstance()->CreateOrOpen(
+  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());
   if (!db)
@@ skipping 60 matching lines @@
     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 FileSystemFileUtil::GetInstance()->GetFileInfo(
+  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());
@@ skipping 126 matching lines @@
    *  Delete target entry's old backing file
    * Move-without-overwrite
    *  Just update metadata
    */
   if (copy) {
     FilePath src_data_path = DataPathToLocalPath(context->src_origin_url(),
       context->src_type(), src_file_info.data_path);
     if (overwrite) {
       FilePath dest_data_path = DataPathToLocalPath(context->src_origin_url(),
         context->src_type(), dest_file_info.data_path);
-      return FileSystemFileUtil::GetInstance()->CopyOrMoveFile(context,
+      return QuotaFileUtil::GetInstance()->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());
       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) {
       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 !=
-          FileSystemFileUtil::GetInstance()->DeleteFile(
-              context, dest_data_path))
+          QuotaFileUtil::GetInstance()->DeleteFile(context, dest_data_path))
         LOG(WARNING) << "Leaked a backing file.";
       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;
       }
       src_file_info.parent_id = dest_parent_id;
       src_file_info.name = dest_file_path.BaseName().value();
@@ skipping 21 matching lines @@
     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 !=
-      FileSystemFileUtil::GetInstance()->DeleteFile(context, data_path))
+      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());
   if (!db)
@@ skipping 28 matching lines @@
       return base::PLATFORM_FILE_ERROR_FAILED;
     }
     if (file_info.is_directory()) {
       file_info.modification_time = last_modified_time;
       if (!db->UpdateFileInfo(file_id, file_info))
         return base::PLATFORM_FILE_ERROR_FAILED;
       return base::PLATFORM_FILE_OK;
     }
     FilePath data_path = DataPathToLocalPath(context->src_origin_url(),
       context->src_type(), file_info.data_path);
-    return FileSystemFileUtil::GetInstance()->Touch(
+    return QuotaFileUtil::GetInstance()->Touch(
         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.
   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 FileSystemFileUtil::GetInstance()->Touch(context, data_path,
+  return QuotaFileUtil::GetInstance()->Touch(context, data_path,
     last_access_time, last_modified_time);
 }
 
 PlatformFileError ObfuscatedFileSystemFileUtil::Truncate(
     FileSystemOperationContext* context,
     const FilePath& virtual_path,
     int64 length) {
   FilePath local_path =
       GetLocalPath(context->src_origin_url(), context->src_type(),
           virtual_path);
   if (local_path.empty())
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
-  return FileSystemFileUtil::GetInstance()->Truncate(
+  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());
   if (!db)
     return false;
@@ skipping 108 matching lines @@
       }
     }
   }
 
   std::queue<FileRecord> display_queue_;
   std::queue<FileRecord> recurse_queue_;
   FileRecord current_;
   FileSystemDirectoryDatabase* db_;
 };
 
+class ObfuscatedFileSystemOriginEnumerator
+    : public ObfuscatedFileSystemFileUtil::AbstractOriginEnumerator {
+ public:
+  typedef FileSystemOriginDatabase::OriginRecord OriginRecord;
+  ObfuscatedFileSystemOriginEnumerator(
+      FileSystemOriginDatabase* origin_database,
+      const FilePath& base_path)
+      : base_path_(base_path) {
+    if (origin_database)
+      origin_database->ListAllOrigins(&origins_);
+  }
+
+  ~ObfuscatedFileSystemOriginEnumerator() {}
+
+  // Returns the next origin.  Returns empty if there are no more origins.
+  virtual GURL Next() OVERRIDE {
+    OriginRecord record;
+    if (!origins_.empty()) {
+      record = origins_.back();
+      origins_.pop_back();
+    }
+    current_ = record;
+    return GetOriginURLFromIdentifier(record.origin);
+  }
+
+  // Returns the current origin's information.
+  virtual bool HasFileSystemType(FileSystemType type) const OVERRIDE {
+    if (current_.path.empty())
+      return false;
+    FilePath::StringType type_string =
+        ObfuscatedFileSystemFileUtil::GetDirectoryNameForType(type);
+    if (type_string.empty()) {
+      NOTREACHED();
+      return false;
+    }
+    FilePath path = base_path_.Append(current_.path).Append(type_string);
+    return file_util::DirectoryExists(path);
+  }
+
+ private:
+  std::vector<OriginRecord> origins_;
+  OriginRecord current_;
+  FilePath base_path_;
+};
+
+ObfuscatedFileSystemFileUtil::AbstractOriginEnumerator*
+ObfuscatedFileSystemFileUtil::CreateOriginEnumerator() {
+  std::vector<FileSystemOriginDatabase::OriginRecord> origins;
+
+  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());
   if (!db)
     return new FileSystemFileUtil::EmptyFileEnumerator();
   return new ObfuscatedFileSystemFileEnumerator(db, root_path);
 }
@@ skipping 10 matching lines @@
     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));
   PlatformFileError error;
-  error = FileSystemFileUtil::GetInstance()->CreateDirectory(
+  error = QuotaFileUtil::GetInstance()->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;
   bool created = false;
   if (!source_path.empty()) {
     DCHECK(!file_flags);
     DCHECK(!handle);
-    error = FileSystemFileUtil::GetInstance()->CopyOrMoveFile(
+    error = QuotaFileUtil::GetInstance()->CopyOrMoveFile(
       context, source_path, path, true /* copy */);
     created = true;
   } else {
     if (handle) {
-      error = FileSystemFileUtil::GetInstance()->CreateOrOpen(
+      error = QuotaFileUtil::GetInstance()->CreateOrOpen(
         context, path, file_flags, handle, &created);
       // If this succeeds, we must close handle on any subsequent error.
     } else {
       DCHECK(!file_flags);  // file_flags is only used by CreateOrOpen.
-      error = FileSystemFileUtil::GetInstance()->EnsureFileExists(
+      error = QuotaFileUtil::GetInstance()->EnsureFileExists(
           context, path, &created);
     }
   }
   if (error != base::PLATFORM_FILE_OK)
     return error;
 
   if (!created) {
     NOTREACHED();
     if (handle) {
       base::ClosePlatformFile(*handle);
-      FileSystemFileUtil::GetInstance()->DeleteFile(context, path);
+      QuotaFileUtil::GetInstance()->DeleteFile(context, path);
     }
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
   file_info->data_path = data_path;
   FileId file_id;
   if (!db->AddFileInfo(*file_info, &file_id)) {
     if (handle)
       base::ClosePlatformFile(*handle);
-    FileSystemFileUtil::GetInstance()->DeleteFile(context, path);
+    QuotaFileUtil::GetInstance()->DeleteFile(context, path);
     return base::PLATFORM_FILE_ERROR_FAILED;
   }
 
   return base::PLATFORM_FILE_OK;
 }
 
 FilePath ObfuscatedFileSystemFileUtil::GetLocalPath(
     const GURL& origin_url,
     FileSystemType type,
     const FilePath& virtual_path) {
@@ skipping 14 matching lines @@
 FilePath ObfuscatedFileSystemFileUtil::GetDirectoryForOriginAndType(
     const GURL& origin, FileSystemType type, bool create) {
   FilePath origin_dir = GetDirectoryForOrigin(origin, create);
   if (origin_dir.empty())
     return FilePath();
   FilePath::StringType type_string = GetDirectoryNameForType(type);
   if (type_string.empty()) {
     LOG(WARNING) << "Unknown filesystem type requested:" << type;
     return FilePath();
   }
-  return origin_dir.Append(type_string);
+  FilePath path = origin_dir.Append(type_string);
+  if (!file_util::DirectoryExists(path) &&
+      (!create || !file_util::CreateDirectory(path)))
+    return FilePath();
+  return path;
 }
 
 FilePath ObfuscatedFileSystemFileUtil::GetDirectoryForOrigin(
     const GURL& origin, bool create) {
-  if (!origin_database_.get()) {
-    if (!create && !file_util::DirectoryExists(file_system_directory_)) {
-      return FilePath();
-    }
-    if (!file_util::CreateDirectory(file_system_directory_)) {
-      LOG(WARNING) << "Failed to create FileSystem directory: " <<
-          file_system_directory_.value();
-      return FilePath();
-    }
-    origin_database_.reset(
-        new FileSystemOriginDatabase(
-            file_system_directory_.AppendASCII(kOriginDatabaseName)));
-  }
+  if (!InitOriginDatabase(create))
+    return FilePath();
   FilePath directory_name;
-  // TODO(ericu): This should probably be using GetOriginIdentifierFromURL from
-  // sandbox_mount_point_provider.cc, instead of just using origin.spec().
-  if (!create && !origin_database_->HasOriginPath(origin.spec()))
+  std::string id = GetOriginIdentifierFromURL(origin);
+  if (!create && !origin_database_->HasOriginPath(id))
     return FilePath();
-  if (!origin_database_->GetPathForOrigin(origin.spec(), &directory_name))
+  if (!origin_database_->GetPathForOrigin(id, &directory_name))
     return FilePath();
-  return file_system_directory_.Append(directory_name);
+  FilePath path = file_system_directory_.Append(directory_name);
+  if (!file_util::DirectoryExists(path) &&
+      (!create || !file_util::CreateDirectory(path)))
+    return FilePath();
+  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);
@@ skipping 44 matching lines @@
       NOTREACHED();
       return false;
     }
   }
   // TODO(ericu): Should we adjust the mtime of the root directory to match as
   // well?
   FilePath legacy_dest_dir = dest_root.Append(kLegacyDataDirectory);
   return file_util::Move(src_root, legacy_dest_dir);
 }
 
+// static
 FilePath::StringType ObfuscatedFileSystemFileUtil::GetDirectoryNameForType(
-    FileSystemType type) const {
+    FileSystemType type) {
   switch (type) {
     case kFileSystemTypeTemporary:
       return kTemporaryDirectoryName;
     case kFileSystemTypePersistent:
       return kPersistentDirectoryName;
     case kFileSystemTypeUnknown:
     default:
       return FilePath::StringType();
   }
 }
@@ skipping 22 matching lines @@
 FileSystemDirectoryDatabase* ObfuscatedFileSystemFileUtil::GetDirectoryDatabase(
     const GURL& origin, FileSystemType type) {
 
   MarkUsed();
   std::string type_string =
       FileSystemPathManager::GetFileSystemTypeString(type);
   if (type_string.empty()) {
     LOG(WARNING) << "Unknown filesystem type requested:" << type;
     return NULL;
   }
-  // TODO(ericu): This should probably be using GetOriginIdentifierFromURL from
-  // sandbox_mount_point_provider.cc, instead of just using origin.spec().
-  std::string key = origin.spec() + type_string;
+  std::string key = GetOriginIdentifierFromURL(origin) + type_string;
   DirectoryMap::iterator iter = directories_.find(key);
   if (iter != directories_.end())
     return iter->second;
 
   FilePath path = GetDirectoryForOriginAndType(origin, type, true);
   if (path.empty())
     return NULL;
   if (!file_util::DirectoryExists(path)) {
     if (!file_util::CreateDirectory(path)) {
       LOG(WARNING) << "Failed to origin+type directory: " << path.value();
@@ skipping 22 matching lines @@
 }
 
 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;
   }
-  // TODO(ericu): This should probably be using GetOriginIdentifierFromURL from
-  // sandbox_mount_point_provider.cc, instead of just using origin.spec().
-  std::string key = origin.spec() + type_string;
+  std::string key = GetOriginIdentifierFromURL(origin) + type_string;
   DirectoryMap::iterator iter = directories_.find(key);
   if (iter != directories_.end())
     directories_.erase(iter);
 
   FilePath path = GetDirectoryForOriginAndType(origin, type, false);
   if (path.empty())
     return true;
   if (!file_util::DirectoryExists(path))
     return true;
   path = path.AppendASCII(kDirectoryDatabaseName);
   return FileSystemDirectoryDatabase::DestroyDatabase(path);
 }
 
+bool ObfuscatedFileSystemFileUtil::InitOriginDatabase(bool create) {
+  if (!origin_database_.get()) {
+    if (!create && !file_util::DirectoryExists(file_system_directory_))
+      return false;
+    if (!file_util::CreateDirectory(file_system_directory_)) {
+      LOG(WARNING) << "Failed to create FileSystem directory: " <<
+          file_system_directory_.value();
+      return false;
+    }
+    origin_database_.reset(
+        new FileSystemOriginDatabase(
+            file_system_directory_.AppendASCII(kOriginDatabaseName)));
+  }
+  return true;
+}
+
 }  // namespace fileapi