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

webkit/fileapi/obfuscated_file_util.h

 // 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.
 
 #ifndef WEBKIT_FILEAPI_OBFUSCATED_FILE_UTIL_H_
 #define WEBKIT_FILEAPI_OBFUSCATED_FILE_UTIL_H_
 
 #include <map>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util_proxy.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/platform_file.h"
 #include "base/timer.h"
 #include "webkit/blob/shareable_file_reference.h"
-#include "webkit/fileapi/file_system_directory_database.h"
 #include "webkit/fileapi/file_system_file_util.h"
-#include "webkit/fileapi/file_system_origin_database.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_url.h"
+#include "webkit/fileapi/sandbox_directory_database.h"
+#include "webkit/fileapi/sandbox_origin_database.h"
 #include "webkit/storage/webkit_storage_export.h"
 
 namespace base {
 class Time;
 }
 
 class GURL;
 
 namespace fileapi {
 
@@ skipping 132 matching lines @@
   bool DestroyDirectoryDatabase(const GURL& origin, FileSystemType type);
 
   // Computes a cost for storing a given file in the obfuscated FSFU.
   // As the cost of a file is independent of the cost of its parent directories,
   // this ignores all but the BaseName of the supplied path.  In order to
   // compute the cost of adding a multi-segment directory recursively, call this
   // on each path segment and add the results.
   static int64 ComputeFilePathCost(const base::FilePath& path);
 
  private:
-  typedef FileSystemDirectoryDatabase::FileId FileId;
-  typedef FileSystemDirectoryDatabase::FileInfo FileInfo;
+  typedef SandboxDirectoryDatabase::FileId FileId;
+  typedef SandboxDirectoryDatabase::FileInfo FileInfo;
 
   friend class ObfuscatedFileEnumerator;
 
   base::PlatformFileError 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);
 
   // Creates a new file, both the underlying backing file and the entry in the
   // database.  |dest_file_info| is an in-out parameter.  Supply the name and
@@ skipping 19 matching lines @@
   // field] to an absolute platform path that can be given to the native
   // filesystem.
   base::FilePath DataPathToLocalPath(
       const GURL& origin,
       FileSystemType type,
       const base::FilePath& data_file_path);
 
   // This returns NULL if |create| flag is false and a filesystem does not
   // exist for the given |origin_url| and |type|.
   // For read operations |create| should be false.
-  FileSystemDirectoryDatabase* GetDirectoryDatabase(
+  SandboxDirectoryDatabase* GetDirectoryDatabase(
       const GURL& origin_url, FileSystemType type, bool create);
 
   // Gets the topmost directory specific to this origin.  This will
   // contain both the filesystem type subdirectories.
   base::FilePath GetDirectoryForOrigin(const GURL& origin,
                                  bool create,
                                  base::PlatformFileError* error_code);
 
   void InvalidateUsageCache(FileSystemOperationContext* context,
                             const GURL& origin,
                             FileSystemType type);
 
   void MarkUsed();
   void DropDatabases();
   bool InitOriginDatabase(bool create);
 
   base::PlatformFileError GenerateNewLocalPath(
-      FileSystemDirectoryDatabase* db,
+      SandboxDirectoryDatabase* db,
       FileSystemOperationContext* context,
       const GURL& origin,
       FileSystemType type,
       base::FilePath* local_path);
 
   base::PlatformFileError CreateOrOpenInternal(
       FileSystemOperationContext* context,
       const FileSystemURL& url,
       int file_flags,
       base::PlatformFile* file_handle,
       bool* created);
 
-  typedef std::map<std::string, FileSystemDirectoryDatabase*> DirectoryMap;
+  typedef std::map<std::string, SandboxDirectoryDatabase*> DirectoryMap;
   DirectoryMap directories_;
-  scoped_ptr<FileSystemOriginDatabase> origin_database_;
+  scoped_ptr<SandboxOriginDatabase> origin_database_;
   base::FilePath file_system_directory_;
   base::OneShotTimer<ObfuscatedFileUtil> timer_;
 
   DISALLOW_COPY_AND_ASSIGN(ObfuscatedFileUtil);
 };
 
 }  // namespace fileapi
 
 #endif  // WEBKIT_FILEAPI_OBFUSCATED_FILE_UTIL_H_