Cleanup: Prefix HTML5 Sandbox FileSystem related files with 'sandbox_'

webkit/fileapi/obfuscated_file_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 "webkit/fileapi/obfuscated_file_util.h"
 
 #include <queue>
 #include <string>
 #include <vector>
 
@@ skipping 24 matching lines @@
 //     base::FilePath local_path = GetLocalFilePath(url);
 //
 //     NativeFileUtil::DoSomething(local_path);
 //     file_util::DoAnother(local_path);
 //  }
 
 namespace fileapi {
 
 namespace {
 
-typedef FileSystemDirectoryDatabase::FileId FileId;
-typedef FileSystemDirectoryDatabase::FileInfo FileInfo;
+typedef SandboxDirectoryDatabase::FileId FileId;
+typedef SandboxDirectoryDatabase::FileInfo FileInfo;
 
 const int64 kFlushDelaySeconds = 10 * 60;  // 10 minutes
 
 void InitFileInfo(
-    FileSystemDirectoryDatabase::FileInfo* file_info,
-    FileSystemDirectoryDatabase::FileId parent_id,
+    SandboxDirectoryDatabase::FileInfo* file_info,
+    SandboxDirectoryDatabase::FileId parent_id,
     const base::FilePath::StringType& file_name) {
   DCHECK(file_info);
   file_info->parent_id = parent_id;
   file_info->name = file_name;
 }
 
 // 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 base::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
@@ skipping 18 matching lines @@
 }
 
 void UpdateUsage(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     int64 growth) {
   context->update_observers()->Notify(
       &FileUpdateObserver::OnUpdate, MakeTuple(url, growth));
 }
 
-void TouchDirectory(FileSystemDirectoryDatabase* db, FileId dir_id) {
+void TouchDirectory(SandboxDirectoryDatabase* db, FileId dir_id) {
   DCHECK(db);
   if (!db->UpdateModificationTime(dir_id, base::Time::Now()))
     NOTREACHED();
 }
 
 const base::FilePath::CharType kTemporaryDirectoryName[] = FILE_PATH_LITERAL("t");
 const base::FilePath::CharType kPersistentDirectoryName[] = FILE_PATH_LITERAL("p");
 const base::FilePath::CharType kSyncableDirectoryName[] = FILE_PATH_LITERAL("s");
 
 }  // namespace
 
 using base::PlatformFile;
 using base::PlatformFileError;
 
 class ObfuscatedFileEnumerator
     : public FileSystemFileUtil::AbstractFileEnumerator {
  public:
   ObfuscatedFileEnumerator(
-      FileSystemDirectoryDatabase* db,
+      SandboxDirectoryDatabase* db,
       FileSystemOperationContext* context,
       ObfuscatedFileUtil* obfuscated_file_util,
       const FileSystemURL& root_url,
       bool recursive)
       : db_(db),
         context_(context),
         obfuscated_file_util_(obfuscated_file_util),
         origin_(root_url.origin()),
         type_(root_url.type()),
         recursive_(recursive),
@@ skipping 42 matching lines @@
 
   virtual base::Time LastModifiedTime() OVERRIDE {
     return current_platform_file_info_.last_modified;
   }
 
   virtual bool IsDirectory() OVERRIDE {
     return current_platform_file_info_.is_directory;
   }
 
  private:
-  typedef FileSystemDirectoryDatabase::FileId FileId;
-  typedef FileSystemDirectoryDatabase::FileInfo FileInfo;
+  typedef SandboxDirectoryDatabase::FileId FileId;
+  typedef SandboxDirectoryDatabase::FileInfo FileInfo;
 
   struct FileRecord {
     FileId file_id;
     base::FilePath virtual_path;
   };
 
   void ProcessRecurseQueue() {
     while (display_stack_.empty() && !recurse_queue_.empty()) {
       FileRecord entry = recurse_queue_.front();
       recurse_queue_.pop();
       if (!db_->ListChildren(entry.file_id, &display_stack_)) {
         display_stack_.clear();
         return;
       }
       current_parent_virtual_path_ = entry.virtual_path;
     }
   }
 
-  FileSystemDirectoryDatabase* db_;
+  SandboxDirectoryDatabase* db_;
   FileSystemOperationContext* context_;
   ObfuscatedFileUtil* obfuscated_file_util_;
   GURL origin_;
   FileSystemType type_;
   bool recursive_;
 
   std::queue<FileRecord> recurse_queue_;
   std::vector<FileId> display_stack_;
   base::FilePath current_parent_virtual_path_;
 
   FileId current_file_id_;
   base::PlatformFileInfo current_platform_file_info_;
 };
 
 class ObfuscatedOriginEnumerator
     : public ObfuscatedFileUtil::AbstractOriginEnumerator {
  public:
-  typedef FileSystemOriginDatabase::OriginRecord OriginRecord;
+  typedef SandboxOriginDatabase::OriginRecord OriginRecord;
   ObfuscatedOriginEnumerator(
-      FileSystemOriginDatabase* origin_database,
+      SandboxOriginDatabase* origin_database,
       const base::FilePath& base_file_path)
       : base_file_path_(base_file_path) {
     if (origin_database)
       origin_database->ListAllOrigins(&origins_);
   }
 
   virtual ~ObfuscatedOriginEnumerator() {}
 
   // Returns the next origin.  Returns empty if there are no more origins.
   virtual GURL Next() OVERRIDE {
@@ skipping 55 matching lines @@
 PlatformFileError ObfuscatedFileUtil::Close(
     FileSystemOperationContext* context,
     base::PlatformFile file) {
   return NativeFileUtil::Close(file);
 }
 
 PlatformFileError ObfuscatedFileUtil::EnsureFileExists(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     bool* created) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       url.origin(), url.type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
 
   FileId file_id;
   if (db->GetFileWithPath(url.path(), &file_id)) {
     FileInfo file_info;
     if (!db->GetFileInfo(file_id, &file_info)) {
       NOTREACHED();
       return base::PLATFORM_FILE_ERROR_FAILED;
@@ skipping 24 matching lines @@
         &FileChangeObserver::OnCreateFile, MakeTuple(url));
   }
   return error;
 }
 
 PlatformFileError ObfuscatedFileUtil::CreateDirectory(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     bool exclusive,
     bool recursive) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       url.origin(), url.type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
 
   // TODO(kinuko): Remove this dirty hack when we fully support directory
   // operations or clean up the code if we decided not to support directory
   // operations. (http://crbug.com/161442)
   if (url.type() == kFileSystemTypeSyncable &&
       !sync_file_system::IsSyncDirectoryOperationEnabled()) {
     return base::PLATFORM_FILE_ERROR_INVALID_OPERATION;
@@ skipping 50 matching lines @@
     }
   }
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileUtil::GetFileInfo(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     base::PlatformFileInfo* file_info,
     base::FilePath* platform_file_path) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       url.origin(), url.type(), false);
   if (!db)
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileId file_id;
   if (!db->GetFileWithPath(url.path(), &file_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileInfo local_info;
   return GetFileInfoInternal(db, context,
                              url.origin(), url.type(),
                              file_id, &local_info,
                              file_info, platform_file_path);
 }
 
 scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator>
     ObfuscatedFileUtil::CreateFileEnumerator(
     FileSystemOperationContext* context,
     const FileSystemURL& root_url) {
   return CreateFileEnumerator(context, root_url, false /* recursive */);
 }
 
 PlatformFileError ObfuscatedFileUtil::GetLocalFilePath(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     base::FilePath* local_path) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       url.origin(), url.type(), false);
   if (!db)
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileId file_id;
   if (!db->GetFileWithPath(url.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();
     // Directories have no local file path.
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   }
   *local_path = DataPathToLocalPath(
       url.origin(), url.type(), file_info.data_path);
 
   if (local_path->empty())
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileUtil::Touch(
     FileSystemOperationContext* context,
     const FileSystemURL& url,
     const base::Time& last_access_time,
     const base::Time& last_modified_time) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       url.origin(), url.type(), false);
   if (!db)
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileId file_id;
   if (!db->GetFileWithPath(url.path(), &file_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info)) {
     NOTREACHED();
@@ skipping 35 matching lines @@
 
 PlatformFileError ObfuscatedFileUtil::CopyOrMoveFile(
     FileSystemOperationContext* context,
     const FileSystemURL& src_url,
     const FileSystemURL& dest_url,
     bool copy) {
   // Cross-filesystem copies and moves should be handled via CopyInForeignFile.
   DCHECK(src_url.origin() == dest_url.origin());
   DCHECK(src_url.type() == dest_url.type());
 
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       src_url.origin(), src_url.type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
 
   FileId src_file_id;
   if (!db->GetFileWithPath(src_url.path(), &src_file_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   FileId dest_file_id;
   bool overwrite = db->GetFileWithPath(dest_url.path(),
@@ skipping 115 matching lines @@
   TouchDirectory(db, dest_file_info.parent_id);
 
   UpdateUsage(context, dest_url, growth);
   return error;
 }
 
 PlatformFileError ObfuscatedFileUtil::CopyInForeignFile(
     FileSystemOperationContext* context,
     const base::FilePath& src_file_path,
     const FileSystemURL& dest_url) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       dest_url.origin(), dest_url.type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
 
   base::PlatformFileInfo src_platform_file_info;
   if (!file_util::GetFileInfo(src_file_path, &src_platform_file_info))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   FileId dest_file_id;
   bool overwrite = db->GetFileWithPath(dest_url.path(),
@@ skipping 57 matching lines @@
   }
 
   UpdateUsage(context, dest_url, growth);
   TouchDirectory(db, dest_file_info.parent_id);
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileUtil::DeleteFile(
     FileSystemOperationContext* context,
     const FileSystemURL& url) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       url.origin(), url.type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
   FileId file_id;
   if (!db->GetFileWithPath(url.path(), &file_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
 
   FileInfo file_info;
   base::PlatformFileInfo platform_file_info;
   base::FilePath local_path;
@@ skipping 24 matching lines @@
 
   error = NativeFileUtil::DeleteFile(local_path);
   if (base::PLATFORM_FILE_OK != error)
     LOG(WARNING) << "Leaked a backing file.";
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileUtil::DeleteDirectory(
     FileSystemOperationContext* context,
     const FileSystemURL& url) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       url.origin(), url.type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
 
   FileId file_id;
   if (!db->GetFileWithPath(url.path(), &file_id))
     return base::PLATFORM_FILE_ERROR_NOT_FOUND;
   FileInfo file_info;
   if (!db->GetFileInfo(file_id, &file_info)) {
     NOTREACHED();
@@ skipping 25 matching lines @@
     *error = base::PLATFORM_FILE_ERROR_NOT_A_FILE;
   }
   return webkit_blob::ScopedFile();
 }
 
 scoped_ptr<FileSystemFileUtil::AbstractFileEnumerator>
     ObfuscatedFileUtil::CreateFileEnumerator(
     FileSystemOperationContext* context,
     const FileSystemURL& root_url,
     bool recursive) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       root_url.origin(), root_url.type(), false);
   if (!db) {
     return scoped_ptr<AbstractFileEnumerator>(new EmptyFileEnumerator());
   }
   return scoped_ptr<AbstractFileEnumerator>(
       new ObfuscatedFileEnumerator(db, context, this, root_url, recursive));
 }
 
 bool ObfuscatedFileUtil::IsDirectoryEmpty(
     FileSystemOperationContext* context,
     const FileSystemURL& url) {
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       url.origin(), url.type(), false);
   if (!db)
     return true;  // Not a great answer, but it's what others do.
   FileId file_id;
   if (!db->GetFileWithPath(url.path(), &file_id))
     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.
@@ skipping 103 matching lines @@
     case kFileSystemTypeSyncable:
       return kSyncableDirectoryName;
     case kFileSystemTypeUnknown:
     default:
       return base::FilePath::StringType();
   }
 }
 
 ObfuscatedFileUtil::AbstractOriginEnumerator*
 ObfuscatedFileUtil::CreateOriginEnumerator() {
-  std::vector<FileSystemOriginDatabase::OriginRecord> origins;
+  std::vector<SandboxOriginDatabase::OriginRecord> origins;
 
   InitOriginDatabase(false);
   return new ObfuscatedOriginEnumerator(
       origin_database_.get(), file_system_directory_);
 }
 
 bool ObfuscatedFileUtil::DestroyDirectoryDatabase(
     const GURL& origin, FileSystemType type) {
   std::string type_string = GetFileSystemTypeString(type);
   if (type_string.empty()) {
     LOG(WARNING) << "Unknown filesystem type requested:" << type;
     return true;
   }
   std::string key =
       UTF16ToUTF8(webkit_base::GetOriginIdentifierFromURL(origin)) +
       type_string;
   DirectoryMap::iterator iter = directories_.find(key);
   if (iter != directories_.end()) {
-    FileSystemDirectoryDatabase* database = iter->second;
+    SandboxDirectoryDatabase* database = iter->second;
     directories_.erase(iter);
     delete database;
   }
 
   PlatformFileError error = base::PLATFORM_FILE_OK;
   base::FilePath path = GetDirectoryForOriginAndType(origin, type, false, &error);
   if (path.empty() || error == base::PLATFORM_FILE_ERROR_NOT_FOUND)
     return true;
-  return FileSystemDirectoryDatabase::DestroyDatabase(path);
+  return SandboxDirectoryDatabase::DestroyDatabase(path);
 }
 
 // static
 int64 ObfuscatedFileUtil::ComputeFilePathCost(const base::FilePath& path) {
   return UsageForPath(VirtualPath::BaseName(path).value().size());
 }
 
 PlatformFileError ObfuscatedFileUtil::GetFileInfoInternal(
-    FileSystemDirectoryDatabase* db,
+    SandboxDirectoryDatabase* db,
     FileSystemOperationContext* context,
     const GURL& origin,
     FileSystemType type,
     FileId file_id,
     FileInfo* local_info,
     base::PlatformFileInfo* file_info,
     base::FilePath* platform_file_path) {
   DCHECK(db);
   DCHECK(context);
   DCHECK(file_info);
@@ skipping 36 matching lines @@
 }
 
 PlatformFileError ObfuscatedFileUtil::CreateFile(
     FileSystemOperationContext* context,
     const base::FilePath& src_file_path,
     const GURL& dest_origin,
     FileSystemType dest_type,
     FileInfo* dest_file_info, int file_flags, PlatformFile* handle) {
   if (handle)
     *handle = base::kInvalidPlatformFileValue;
-  FileSystemDirectoryDatabase* db = GetDirectoryDatabase(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       dest_origin, dest_type, true);
 
   PlatformFileError error = base::PLATFORM_FILE_OK;
   base::FilePath root = GetDirectoryForOriginAndType(dest_origin, dest_type, false,
                                                &error);
   if (error != base::PLATFORM_FILE_OK)
     return error;
 
   base::FilePath dest_local_path;
   error = GenerateNewLocalPath(db, context, dest_origin, dest_type,
@@ skipping 65 matching lines @@
   base::FilePath root = GetDirectoryForOriginAndType(origin, type, false, &error);
   if (error != base::PLATFORM_FILE_OK)
     return base::FilePath();
   return root.Append(data_path);
 }
 
 // TODO(ericu): 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* ObfuscatedFileUtil::GetDirectoryDatabase(
+SandboxDirectoryDatabase* ObfuscatedFileUtil::GetDirectoryDatabase(
     const GURL& origin, FileSystemType type, bool create) {
   std::string type_string = GetFileSystemTypeString(type);
   if (type_string.empty()) {
     LOG(WARNING) << "Unknown filesystem type requested:" << type;
     return NULL;
   }
   std::string key =
       UTF16ToUTF8(webkit_base::GetOriginIdentifierFromURL(origin)) +
       type_string;
   DirectoryMap::iterator iter = directories_.find(key);
   if (iter != directories_.end()) {
     MarkUsed();
     return iter->second;
   }
 
   PlatformFileError error = base::PLATFORM_FILE_OK;
   base::FilePath path = GetDirectoryForOriginAndType(origin, type, create, &error);
   if (error != base::PLATFORM_FILE_OK) {
     LOG(WARNING) << "Failed to get origin+type directory: " << path.value();
     return NULL;
   }
   MarkUsed();
-  FileSystemDirectoryDatabase* database = new FileSystemDirectoryDatabase(path);
+  SandboxDirectoryDatabase* database = new SandboxDirectoryDatabase(path);
   directories_[key] = database;
   return database;
 }
 
 base::FilePath ObfuscatedFileUtil::GetDirectoryForOrigin(
     const GURL& origin, bool create, base::PlatformFileError* error_code) {
   if (!InitOriginDatabase(create)) {
     if (error_code) {
       *error_code = create ?
           base::PLATFORM_FILE_ERROR_FAILED :
@@ skipping 69 matching lines @@
 bool ObfuscatedFileUtil::InitOriginDatabase(bool create) {
   if (!origin_database_) {
     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_));
+        new SandboxOriginDatabase(file_system_directory_));
   }
   return true;
 }
 
 PlatformFileError ObfuscatedFileUtil::GenerateNewLocalPath(
-    FileSystemDirectoryDatabase* db,
+    SandboxDirectoryDatabase* db,
     FileSystemOperationContext* context,
     const GURL& origin,
     FileSystemType type,
     base::FilePath* local_path) {
   DCHECK(local_path);
   int64 number;
   if (!db || !db->GetNextInteger(&number))
     return base::PLATFORM_FILE_ERROR_FAILED;
 
   PlatformFileError error = base::PLATFORM_FILE_OK;
@@ skipping 17 matching lines @@
   return base::PLATFORM_FILE_OK;
 }
 
 PlatformFileError ObfuscatedFileUtil::CreateOrOpenInternal(
     FileSystemOperationContext* context,
     const FileSystemURL& url, 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(
+  SandboxDirectoryDatabase* db = GetDirectoryDatabase(
       url.origin(), url.type(), true);
   if (!db)
     return base::PLATFORM_FILE_ERROR_FAILED;
   FileId file_id;
   if (!db->GetFileWithPath(url.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;
@@ skipping 55 matching lines @@
   // If truncating we need to update the usage.
   if (error == base::PLATFORM_FILE_OK && delta) {
     UpdateUsage(context, url, delta);
     context->change_observers()->Notify(
         &FileChangeObserver::OnModifyFile, MakeTuple(url));
   }
   return error;
 }
 
 }  // namespace fileapi