blob: 3a677a800b41223522c712f1dbbc6dddd8b7b927 [file] [log] [blame]
// Copyright 2013 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 "storage/browser/fileapi/sandbox_prioritized_origin_database.h"
#include "base/files/file.h"
#include "base/files/file_util.h"
#include "base/logging.h"
#include "base/pickle.h"
#include "storage/browser/fileapi/sandbox_isolated_origin_database.h"
#include "storage/browser/fileapi/sandbox_origin_database.h"
namespace storage {
const base::FilePath::CharType*
SandboxPrioritizedOriginDatabase::kPrimaryDirectory =
FILE_PATH_LITERAL("primary");
const base::FilePath::CharType*
SandboxPrioritizedOriginDatabase::kPrimaryOriginFile =
FILE_PATH_LITERAL("primary.origin");
namespace {
bool WritePrimaryOriginFile(const base::FilePath& path,
const std::string& origin) {
base::File file(path, base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE);
if (!file.IsValid())
return false;
if (!file.created())
file.SetLength(0);
base::Pickle pickle;
pickle.WriteString(origin);
file.Write(0, static_cast<const char*>(pickle.data()), pickle.size());
file.Flush();
return true;
}
bool ReadPrimaryOriginFile(const base::FilePath& path,
std::string* origin) {
std::string buffer;
if (!base::ReadFileToString(path, &buffer))
return false;
base::Pickle pickle(buffer.data(), buffer.size());
base::PickleIterator iter(pickle);
return iter.ReadString(origin) && !origin->empty();
}
} // namespace
SandboxPrioritizedOriginDatabase::SandboxPrioritizedOriginDatabase(
const base::FilePath& file_system_directory,
leveldb::Env* env_override)
: file_system_directory_(file_system_directory),
env_override_(env_override),
primary_origin_file_(
file_system_directory_.Append(kPrimaryOriginFile)) {
}
SandboxPrioritizedOriginDatabase::~SandboxPrioritizedOriginDatabase() {
}
bool SandboxPrioritizedOriginDatabase::InitializePrimaryOrigin(
const std::string& origin) {
if (!primary_origin_database_) {
if (!MaybeLoadPrimaryOrigin() && ResetPrimaryOrigin(origin)) {
MaybeMigrateDatabase(origin);
primary_origin_database_.reset(
new SandboxIsolatedOriginDatabase(
origin,
file_system_directory_,
base::FilePath(kPrimaryDirectory)));
return true;
}
}
if (primary_origin_database_)
return primary_origin_database_->HasOriginPath(origin);
return false;
}
std::string SandboxPrioritizedOriginDatabase::GetPrimaryOrigin() {
MaybeLoadPrimaryOrigin();
if (primary_origin_database_)
return primary_origin_database_->origin();
return std::string();
}
bool SandboxPrioritizedOriginDatabase::HasOriginPath(
const std::string& origin) {
MaybeInitializeDatabases(false);
if (primary_origin_database_ &&
primary_origin_database_->HasOriginPath(origin))
return true;
if (origin_database_)
return origin_database_->HasOriginPath(origin);
return false;
}
bool SandboxPrioritizedOriginDatabase::GetPathForOrigin(
const std::string& origin, base::FilePath* directory) {
MaybeInitializeDatabases(true);
if (primary_origin_database_ &&
primary_origin_database_->GetPathForOrigin(origin, directory))
return true;
DCHECK(origin_database_);
return origin_database_->GetPathForOrigin(origin, directory);
}
bool SandboxPrioritizedOriginDatabase::RemovePathForOrigin(
const std::string& origin) {
MaybeInitializeDatabases(false);
if (primary_origin_database_ &&
primary_origin_database_->HasOriginPath(origin)) {
primary_origin_database_.reset();
base::DeleteFile(file_system_directory_.Append(kPrimaryOriginFile),
true /* recursive */);
return true;
}
if (origin_database_)
return origin_database_->RemovePathForOrigin(origin);
return true;
}
bool SandboxPrioritizedOriginDatabase::ListAllOrigins(
std::vector<OriginRecord>* origins) {
// SandboxOriginDatabase may clear the |origins|, so call this before
// primary_origin_database_.
MaybeInitializeDatabases(false);
if (origin_database_ && !origin_database_->ListAllOrigins(origins))
return false;
if (primary_origin_database_)
return primary_origin_database_->ListAllOrigins(origins);
return true;
}
void SandboxPrioritizedOriginDatabase::DropDatabase() {
primary_origin_database_.reset();
origin_database_.reset();
}
bool SandboxPrioritizedOriginDatabase::MaybeLoadPrimaryOrigin() {
if (primary_origin_database_)
return true;
std::string saved_origin;
if (!ReadPrimaryOriginFile(primary_origin_file_, &saved_origin))
return false;
primary_origin_database_.reset(
new SandboxIsolatedOriginDatabase(
saved_origin,
file_system_directory_,
base::FilePath(kPrimaryDirectory)));
return true;
}
bool SandboxPrioritizedOriginDatabase::ResetPrimaryOrigin(
const std::string& origin) {
DCHECK(!primary_origin_database_);
if (!WritePrimaryOriginFile(primary_origin_file_, origin))
return false;
// We reset the primary origin directory too.
// (This means the origin file corruption causes data loss
// We could keep the directory there as the same origin will likely
// become the primary origin, but let's play conservatively.)
base::DeleteFile(file_system_directory_.Append(kPrimaryDirectory),
true /* recursive */);
return true;
}
void SandboxPrioritizedOriginDatabase::MaybeMigrateDatabase(
const std::string& origin) {
MaybeInitializeNonPrimaryDatabase(false);
if (!origin_database_)
return;
if (origin_database_->HasOriginPath(origin)) {
base::FilePath directory_name;
if (origin_database_->GetPathForOrigin(origin, &directory_name) &&
directory_name != base::FilePath(kPrimaryOriginFile)) {
base::FilePath from_path = file_system_directory_.Append(directory_name);
base::FilePath to_path = file_system_directory_.Append(kPrimaryDirectory);
if (base::PathExists(to_path))
base::DeleteFile(to_path, true /* recursive */);
base::Move(from_path, to_path);
}
origin_database_->RemovePathForOrigin(origin);
}
std::vector<OriginRecord> origins;
origin_database_->ListAllOrigins(&origins);
if (origins.empty()) {
origin_database_->RemoveDatabase();
origin_database_.reset();
}
}
void SandboxPrioritizedOriginDatabase::MaybeInitializeDatabases(
bool create) {
MaybeLoadPrimaryOrigin();
MaybeInitializeNonPrimaryDatabase(create);
}
void SandboxPrioritizedOriginDatabase::MaybeInitializeNonPrimaryDatabase(
bool create) {
if (origin_database_)
return;
origin_database_.reset(new SandboxOriginDatabase(file_system_directory_,
env_override_));
if (!create && !base::DirectoryExists(origin_database_->GetDatabasePath())) {
origin_database_.reset();
return;
}
}
SandboxOriginDatabase*
SandboxPrioritizedOriginDatabase::GetSandboxOriginDatabase() {
MaybeInitializeNonPrimaryDatabase(true);
return origin_database_.get();
}
} // namespace storage