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

webkit/fileapi/sandbox_origin_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/fileapi/file_system_origin_database.h"
+#include "webkit/fileapi/sandbox_origin_database.h"
 
 #include <set>
 
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "base/string_util.h"
 #include "base/stringprintf.h"
-#include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 #include "webkit/fileapi/file_system_util.h"
 
 namespace {
 
 const base::FilePath::CharType kOriginDatabaseName[] =
     FILE_PATH_LITERAL("Origins");
 const char kOriginKeyPrefix[] = "ORIGIN:";
@@ skipping 22 matching lines @@
 }
 
 const char* LastPathKey() {
   return kLastPathKey;
 }
 
 }  // namespace
 
 namespace fileapi {
 
-FileSystemOriginDatabase::OriginRecord::OriginRecord() {
+SandboxOriginDatabase::OriginRecord::OriginRecord() {
 }
 
-FileSystemOriginDatabase::OriginRecord::OriginRecord(
+SandboxOriginDatabase::OriginRecord::OriginRecord(
     const std::string& origin_in, const base::FilePath& path_in)
     : origin(origin_in), path(path_in) {
 }
 
-FileSystemOriginDatabase::OriginRecord::~OriginRecord() {
+SandboxOriginDatabase::OriginRecord::~OriginRecord() {
 }
 
-FileSystemOriginDatabase::FileSystemOriginDatabase(
+SandboxOriginDatabase::SandboxOriginDatabase(
     const base::FilePath& file_system_directory)
     : file_system_directory_(file_system_directory) {
 }
 
-FileSystemOriginDatabase::~FileSystemOriginDatabase() {
+SandboxOriginDatabase::~SandboxOriginDatabase() {
 }
 
-bool FileSystemOriginDatabase::Init(RecoveryOption recovery_option) {
+bool SandboxOriginDatabase::Init(RecoveryOption recovery_option) {
   if (db_)
     return true;
 
   std::string path =
       FilePathToString(file_system_directory_.Append(kOriginDatabaseName));
   leveldb::Options options;
   options.create_if_missing = true;
   leveldb::DB* db;
   leveldb::Status status = leveldb::DB::Open(options, path, &db);
   ReportInitStatus(status);
   if (status.ok()) {
     db_.reset(db);
     return true;
   }
   HandleError(FROM_HERE, status);
 
   // Corruption due to missing necessary MANIFEST-* file causes IOError instead
   // of Corruption error.
   // Try to repair database even when IOError case.
   if (!status.IsCorruption() && !status.IsIOError())
     return false;
 
   switch (recovery_option) {
     case FAIL_ON_CORRUPTION:
       return false;
     case REPAIR_ON_CORRUPTION:
-      LOG(WARNING) << "Attempting to repair FileSystemOriginDatabase.";
+      LOG(WARNING) << "Attempting to repair SandboxOriginDatabase.";
 
       if (RepairDatabase(path)) {
         UMA_HISTOGRAM_ENUMERATION(kDatabaseRepairHistogramLabel,
                                   DB_REPAIR_SUCCEEDED, DB_REPAIR_MAX);
-        LOG(WARNING) << "Repairing FileSystemOriginDatabase completed.";
+        LOG(WARNING) << "Repairing SandboxOriginDatabase completed.";
         return true;
       }
       UMA_HISTOGRAM_ENUMERATION(kDatabaseRepairHistogramLabel,
                                 DB_REPAIR_FAILED, DB_REPAIR_MAX);
       // fall through
     case DELETE_ON_CORRUPTION:
       if (!file_util::Delete(file_system_directory_, true))
         return false;
       if (!file_util::CreateDirectory(file_system_directory_))
         return false;
       return Init(FAIL_ON_CORRUPTION);
   }
   NOTREACHED();
   return false;
 }
 
-bool FileSystemOriginDatabase::RepairDatabase(const std::string& db_path) {
+bool SandboxOriginDatabase::RepairDatabase(const std::string& db_path) {
   DCHECK(!db_.get());
   if (!leveldb::RepairDB(db_path, leveldb::Options()).ok() ||
       !Init(FAIL_ON_CORRUPTION)) {
-    LOG(WARNING) << "Failed to repair FileSystemOriginDatabase.";
+    LOG(WARNING) << "Failed to repair SandboxOriginDatabase.";
     return false;
   }
 
   // See if the repaired entries match with what we have on disk.
   std::set<base::FilePath> directories;
   file_util::FileEnumerator file_enum(file_system_directory_,
                                       false /* recursive */,
                                       file_util::FileEnumerator::DIRECTORIES);
   base::FilePath path_each;
   while (!(path_each = file_enum.Next()).empty())
@@ skipping 34 matching lines @@
     if (!file_util::Delete(file_system_directory_.Append(*dir_itr),
                            true /* recursive */)) {
       DropDatabase();
       return false;
     }
   }
 
   return true;
 }
 
-void FileSystemOriginDatabase::HandleError(
+void SandboxOriginDatabase::HandleError(
     const tracked_objects::Location& from_here,
     const leveldb::Status& status) {
   db_.reset();
-  LOG(ERROR) << "FileSystemOriginDatabase failed at: "
+  LOG(ERROR) << "SandboxOriginDatabase failed at: "
              << from_here.ToString() << " with error: " << status.ToString();
 }
 
-void FileSystemOriginDatabase::ReportInitStatus(const leveldb::Status& status) {
+void SandboxOriginDatabase::ReportInitStatus(const leveldb::Status& status) {
   base::Time now = base::Time::Now();
   base::TimeDelta minimum_interval =
       base::TimeDelta::FromHours(kMinimumReportIntervalHours);
   if (last_reported_time_ + minimum_interval >= now)
     return;
   last_reported_time_ = now;
 
   if (status.ok()) {
     UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel,
                               INIT_STATUS_OK, INIT_STATUS_MAX);
   } else if (status.IsCorruption()) {
     UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel,
                               INIT_STATUS_CORRUPTION, INIT_STATUS_MAX);
   } else if (status.IsIOError()) {
     UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel,
                               INIT_STATUS_IO_ERROR, INIT_STATUS_MAX);
   } else {
     UMA_HISTOGRAM_ENUMERATION(kInitStatusHistogramLabel,
                               INIT_STATUS_UNKNOWN_ERROR, INIT_STATUS_MAX);
   }
 }
 
-bool FileSystemOriginDatabase::HasOriginPath(const std::string& origin) {
+bool SandboxOriginDatabase::HasOriginPath(const std::string& origin) {
   if (!Init(REPAIR_ON_CORRUPTION))
     return false;
   if (origin.empty())
     return false;
   std::string path;
   leveldb::Status status =
       db_->Get(leveldb::ReadOptions(), OriginToOriginKey(origin), &path);
   if (status.ok())
     return true;
   if (status.IsNotFound())
     return false;
   HandleError(FROM_HERE, status);
   return false;
 }
 
-bool FileSystemOriginDatabase::GetPathForOrigin(
+bool SandboxOriginDatabase::GetPathForOrigin(
     const std::string& origin, base::FilePath* directory) {
   if (!Init(REPAIR_ON_CORRUPTION))
     return false;
   DCHECK(directory);
   if (origin.empty())
     return false;
   std::string path_string;
   std::string origin_key = OriginToOriginKey(origin);
   leveldb::Status status =
       db_->Get(leveldb::ReadOptions(), origin_key, &path_string);
@@ skipping 13 matching lines @@
     }
   }
   if (status.ok()) {
     *directory = StringToFilePath(path_string);
     return true;
   }
   HandleError(FROM_HERE, status);
   return false;
 }
 
-bool FileSystemOriginDatabase::RemovePathForOrigin(const std::string& origin) {
+bool SandboxOriginDatabase::RemovePathForOrigin(const std::string& origin) {
   if (!Init(REPAIR_ON_CORRUPTION))
     return false;
   leveldb::Status status =
       db_->Delete(leveldb::WriteOptions(), OriginToOriginKey(origin));
   if (status.ok() || status.IsNotFound())
     return true;
   HandleError(FROM_HERE, status);
   return false;
 }
 
-bool FileSystemOriginDatabase::ListAllOrigins(
+bool SandboxOriginDatabase::ListAllOrigins(
     std::vector<OriginRecord>* origins) {
   if (!Init(REPAIR_ON_CORRUPTION))
     return false;
   DCHECK(origins);
   scoped_ptr<leveldb::Iterator> iter(db_->NewIterator(leveldb::ReadOptions()));
   std::string origin_key_prefix = OriginToOriginKey(std::string());
   iter->Seek(origin_key_prefix);
   origins->clear();
   while (iter->Valid() &&
       StartsWithASCII(iter->key().ToString(), origin_key_prefix, true)) {
     std::string origin =
       iter->key().ToString().substr(origin_key_prefix.length());
     base::FilePath path = StringToFilePath(iter->value().ToString());
     origins->push_back(OriginRecord(origin, path));
     iter->Next();
   }
   return true;
 }
 
-void FileSystemOriginDatabase::DropDatabase() {
+void SandboxOriginDatabase::DropDatabase() {
   db_.reset();
 }
 
-bool FileSystemOriginDatabase::GetLastPathNumber(int* number) {
+bool SandboxOriginDatabase::GetLastPathNumber(int* number) {
   if (!Init(REPAIR_ON_CORRUPTION))
     return false;
   DCHECK(number);
   std::string number_string;
   leveldb::Status status =
       db_->Get(leveldb::ReadOptions(), LastPathKey(), &number_string);
   if (status.ok())
     return base::StringToInt(number_string, number);
   if (!status.IsNotFound()) {
     HandleError(FROM_HERE, status);
@@ skipping 12 matching lines @@
       db_->Put(leveldb::WriteOptions(), LastPathKey(), std::string("-1"));
   if (!status.ok()) {
     HandleError(FROM_HERE, status);
     return false;
   }
   *number = -1;
   return true;
 }
 
 }  // namespace fileapi