Collapse fileapi, webkit_blob, webkit_database, quota, and webkit_common namespaces into single sto…

webkit/browser/fileapi/sandbox_directory_database.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/browser/fileapi/sandbox_directory_database.h"
 
 #include <math.h>
 #include <algorithm>
 #include <set>
 #include <stack>
 
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 #include "webkit/browser/fileapi/file_system_usage_cache.h"
 #include "webkit/common/fileapi/file_system_util.h"
 
 namespace {
 
-bool PickleFromFileInfo(
-    const fileapi::SandboxDirectoryDatabase::FileInfo& info,
-    Pickle* pickle) {
+bool PickleFromFileInfo(const storage::SandboxDirectoryDatabase::FileInfo& info,
+                        Pickle* pickle) {
   DCHECK(pickle);
   std::string data_path;
   // Round off here to match the behavior of the filesystem on real files.
   base::Time time =
       base::Time::FromDoubleT(floor(info.modification_time.ToDoubleT()));
   std::string name;
 
-  data_path = fileapi::FilePathToString(info.data_path);
-  name = fileapi::FilePathToString(base::FilePath(info.name));
+  data_path = storage::FilePathToString(info.data_path);
+  name = storage::FilePathToString(base::FilePath(info.name));
 
   if (pickle->WriteInt64(info.parent_id) &&
       pickle->WriteString(data_path) &&
       pickle->WriteString(name) &&
       pickle->WriteInt64(time.ToInternalValue()))
     return true;
 
   NOTREACHED();
   return false;
 }
 
-bool FileInfoFromPickle(
-    const Pickle& pickle,
-    fileapi::SandboxDirectoryDatabase::FileInfo* info) {
+bool FileInfoFromPickle(const Pickle& pickle,
+                        storage::SandboxDirectoryDatabase::FileInfo* info) {
   PickleIterator iter(pickle);
   std::string data_path;
   std::string name;
   int64 internal_time;
 
   if (pickle.ReadInt64(&iter, &info->parent_id) &&
       pickle.ReadString(&iter, &data_path) &&
       pickle.ReadString(&iter, &name) &&
       pickle.ReadInt64(&iter, &internal_time)) {
-    info->data_path = fileapi::StringToFilePath(data_path);
-    info->name = fileapi::StringToFilePath(name).value();
+    info->data_path = storage::StringToFilePath(data_path);
+    info->name = storage::StringToFilePath(name).value();
     info->modification_time = base::Time::FromInternalValue(internal_time);
     return true;
   }
   LOG(ERROR) << "Pickle could not be digested!";
   return false;
 }
 
 const base::FilePath::CharType kDirectoryDatabaseName[] =
     FILE_PATH_LITERAL("Paths");
 const char kChildLookupPrefix[] = "CHILD_OF:";
@@ skipping 13 matching lines @@
   INIT_STATUS_MAX
 };
 
 enum RepairResult {
   DB_REPAIR_SUCCEEDED = 0,
   DB_REPAIR_FAILED,
   DB_REPAIR_MAX
 };
 
 std::string GetChildLookupKey(
-    fileapi::SandboxDirectoryDatabase::FileId parent_id,
+    storage::SandboxDirectoryDatabase::FileId parent_id,
     const base::FilePath::StringType& child_name) {
   std::string name;
-  name = fileapi::FilePathToString(base::FilePath(child_name));
+  name = storage::FilePathToString(base::FilePath(child_name));
   return std::string(kChildLookupPrefix) + base::Int64ToString(parent_id) +
       std::string(kChildLookupSeparator) + name;
 }
 
 std::string GetChildListingKeyPrefix(
-    fileapi::SandboxDirectoryDatabase::FileId parent_id) {
+    storage::SandboxDirectoryDatabase::FileId parent_id) {
   return std::string(kChildLookupPrefix) + base::Int64ToString(parent_id) +
       std::string(kChildLookupSeparator);
 }
 
 const char* LastFileIdKey() {
   return kLastFileIdKey;
 }
 
 const char* LastIntegerKey() {
   return kLastIntegerKey;
 }
 
 std::string GetFileLookupKey(
-    fileapi::SandboxDirectoryDatabase::FileId file_id) {
+    storage::SandboxDirectoryDatabase::FileId file_id) {
   return base::Int64ToString(file_id);
 }
 
 // Assumptions:
 //  - Any database entry is one of:
 //    - ("CHILD_OF:|parent_id|:<name>", "|file_id|"),
 //    - ("LAST_FILE_ID", "|last_file_id|"),
 //    - ("LAST_INTEGER", "|last_integer|"),
 //    - ("|file_id|", "pickled FileInfo")
 //        where FileInfo has |parent_id|, |data_path|, |name| and
 //        |modification_time|,
 // Constraints:
 //  - Each file in the database has unique backing file.
 //  - Each file in |filesystem_data_directory_| has a database entry.
 //  - Directory structure is tree, i.e. connected and acyclic.
 class DatabaseCheckHelper {
  public:
-  typedef fileapi::SandboxDirectoryDatabase::FileId FileId;
-  typedef fileapi::SandboxDirectoryDatabase::FileInfo FileInfo;
+  typedef storage::SandboxDirectoryDatabase::FileId FileId;
+  typedef storage::SandboxDirectoryDatabase::FileInfo FileInfo;
 
-  DatabaseCheckHelper(fileapi::SandboxDirectoryDatabase* dir_db,
+  DatabaseCheckHelper(storage::SandboxDirectoryDatabase* dir_db,
                       leveldb::DB* db,
                       const base::FilePath& path);
 
   bool IsFileSystemConsistent() {
     return IsDatabaseEmpty() ||
         (ScanDatabase() && ScanDirectory() && ScanHierarchy());
   }
 
  private:
   bool IsDatabaseEmpty();
   // These 3 methods need to be called in the order.  Each method requires its
   // previous method finished successfully. They also require the database is
   // not empty.
   bool ScanDatabase();
   bool ScanDirectory();
   bool ScanHierarchy();
 
-  fileapi::SandboxDirectoryDatabase* dir_db_;
+  storage::SandboxDirectoryDatabase* dir_db_;
   leveldb::DB* db_;
   base::FilePath path_;
 
   std::set<base::FilePath> files_in_db_;
 
   size_t num_directories_in_db_;
   size_t num_files_in_db_;
   size_t num_hierarchy_links_in_db_;
 
   FileId last_file_id_;
   FileId last_integer_;
 };
 
 DatabaseCheckHelper::DatabaseCheckHelper(
-    fileapi::SandboxDirectoryDatabase* dir_db,
+    storage::SandboxDirectoryDatabase* dir_db,
     leveldb::DB* db,
     const base::FilePath& path)
-    : dir_db_(dir_db), db_(db), path_(path),
+    : dir_db_(dir_db),
+      db_(db),
+      path_(path),
       num_directories_in_db_(0),
       num_files_in_db_(0),
       num_hierarchy_links_in_db_(0),
-      last_file_id_(-1), last_integer_(-1) {
+      last_file_id_(-1),
+      last_integer_(-1) {
   DCHECK(dir_db_);
   DCHECK(db_);
   DCHECK(!path_.empty() && base::DirectoryExists(path_));
 }
 
 bool DatabaseCheckHelper::IsDatabaseEmpty() {
   scoped_ptr<leveldb::Iterator> itr(db_->NewIterator(leveldb::ReadOptions()));
   itr->SeekToFirst();
   return !itr->Valid();
 }
@@ skipping 73 matching lines @@
 
   // TODO(tzik): Add constraint for |last_integer_| to avoid possible
   // data path confliction on ObfuscatedFileUtil.
   return max_file_id <= last_file_id_;
 }
 
 bool DatabaseCheckHelper::ScanDirectory() {
   // TODO(kinuko): Scans all local file system entries to verify each of them
   // has a database entry.
   const base::FilePath kExcludes[] = {
-    base::FilePath(kDirectoryDatabaseName),
-    base::FilePath(fileapi::FileSystemUsageCache::kUsageFileName),
+      base::FilePath(kDirectoryDatabaseName),
+      base::FilePath(storage::FileSystemUsageCache::kUsageFileName),
   };
 
   // Any path in |pending_directories| is relative to |path_|.
   std::stack<base::FilePath> pending_directories;
   pending_directories.push(base::FilePath());
 
   while (!pending_directories.empty()) {
     base::FilePath dir_path = pending_directories.top();
     pending_directories.pop();
 
@@ skipping 96 matching lines @@
 // and does not refer to special system files.
 // This is called in GetFileInfo, AddFileInfo and UpdateFileInfo to
 // ensure we're only dealing with valid data paths.
 bool VerifyDataPath(const base::FilePath& data_path) {
   // |data_path| should not contain any ".." and should be a relative path
   // (to the filesystem_data_directory_).
   if (data_path.ReferencesParent() || data_path.IsAbsolute())
     return false;
   // See if it's not pointing to the special system paths.
   const base::FilePath kExcludes[] = {
-    base::FilePath(kDirectoryDatabaseName),
-    base::FilePath(fileapi::FileSystemUsageCache::kUsageFileName),
+      base::FilePath(kDirectoryDatabaseName),
+      base::FilePath(storage::FileSystemUsageCache::kUsageFileName),
   };
   for (size_t i = 0; i < arraysize(kExcludes); ++i) {
     if (data_path == kExcludes[i] || kExcludes[i].IsParent(data_path))
       return false;
   }
   return true;
 }
 
 }  // namespace
 
-namespace fileapi {
+namespace storage {
 
 SandboxDirectoryDatabase::FileInfo::FileInfo() : parent_id(0) {
 }
 
 SandboxDirectoryDatabase::FileInfo::~FileInfo() {
 }
 
 SandboxDirectoryDatabase::SandboxDirectoryDatabase(
     const base::FilePath& filesystem_data_directory,
     leveldb::Env* env_override)
@@ skipping 513 matching lines @@
 }
 
 void SandboxDirectoryDatabase::HandleError(
     const tracked_objects::Location& from_here,
     const leveldb::Status& status) {
   LOG(ERROR) << "SandboxDirectoryDatabase failed at: "
              << from_here.ToString() << " with error: " << status.ToString();
   db_.reset();
 }
 
-}  // namespace fileapi
+}  // namespace storage