blob: 44d291fc60aa48378beb2df5eca427bc3c751a62 [file] [log] [blame]
// 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 "storage/browser/fileapi/file_system_usage_cache.h"
#include <stddef.h>
#include <stdint.h>
#include <utility>
#include "base/bind.h"
#include "base/files/file_util.h"
#include "base/pickle.h"
#include "base/stl_util.h"
#include "base/trace_event/trace_event.h"
#include "storage/browser/fileapi/timed_task_helper.h"
namespace storage {
namespace {
const int64_t kCloseDelaySeconds = 5;
const size_t kMaxHandleCacheSize = 2;
} // namespace
FileSystemUsageCache::FileSystemUsageCache(
base::SequencedTaskRunner* task_runner)
: task_runner_(task_runner),
weak_factory_(this) {
}
FileSystemUsageCache::~FileSystemUsageCache() {
task_runner_ = NULL;
CloseCacheFiles();
}
const base::FilePath::CharType FileSystemUsageCache::kUsageFileName[] =
FILE_PATH_LITERAL(".usage");
const char FileSystemUsageCache::kUsageFileHeader[] = "FSU5";
const int FileSystemUsageCache::kUsageFileHeaderSize = 4;
// Pickle::{Read,Write}Bool treat bool as int
const int FileSystemUsageCache::kUsageFileSize =
sizeof(base::Pickle::Header) + FileSystemUsageCache::kUsageFileHeaderSize +
sizeof(int) + sizeof(int32_t) + sizeof(int64_t); // NOLINT
bool FileSystemUsageCache::GetUsage(const base::FilePath& usage_file_path,
int64_t* usage_out) {
TRACE_EVENT0("FileSystem", "UsageCache::GetUsage");
DCHECK(CalledOnValidThread());
DCHECK(usage_out);
bool is_valid = true;
uint32_t dirty = 0;
int64_t usage = 0;
if (!Read(usage_file_path, &is_valid, &dirty, &usage))
return false;
*usage_out = usage;
return true;
}
bool FileSystemUsageCache::GetDirty(const base::FilePath& usage_file_path,
uint32_t* dirty_out) {
TRACE_EVENT0("FileSystem", "UsageCache::GetDirty");
DCHECK(CalledOnValidThread());
DCHECK(dirty_out);
bool is_valid = true;
uint32_t dirty = 0;
int64_t usage = 0;
if (!Read(usage_file_path, &is_valid, &dirty, &usage))
return false;
*dirty_out = dirty;
return true;
}
bool FileSystemUsageCache::IncrementDirty(
const base::FilePath& usage_file_path) {
TRACE_EVENT0("FileSystem", "UsageCache::IncrementDirty");
DCHECK(CalledOnValidThread());
bool is_valid = true;
uint32_t dirty = 0;
int64_t usage = 0;
bool new_handle = !HasCacheFileHandle(usage_file_path);
if (!Read(usage_file_path, &is_valid, &dirty, &usage))
return false;
bool success = Write(usage_file_path, is_valid, dirty + 1, usage);
if (success && dirty == 0 && new_handle)
FlushFile(usage_file_path);
return success;
}
bool FileSystemUsageCache::DecrementDirty(
const base::FilePath& usage_file_path) {
TRACE_EVENT0("FileSystem", "UsageCache::DecrementDirty");
DCHECK(CalledOnValidThread());
bool is_valid = true;
uint32_t dirty = 0;
int64_t usage = 0;
if (!Read(usage_file_path, &is_valid, &dirty, &usage) || dirty == 0)
return false;
return Write(usage_file_path, is_valid, dirty - 1, usage);
}
bool FileSystemUsageCache::Invalidate(const base::FilePath& usage_file_path) {
TRACE_EVENT0("FileSystem", "UsageCache::Invalidate");
DCHECK(CalledOnValidThread());
bool is_valid = true;
uint32_t dirty = 0;
int64_t usage = 0;
if (!Read(usage_file_path, &is_valid, &dirty, &usage))
return false;
return Write(usage_file_path, false, dirty, usage);
}
bool FileSystemUsageCache::IsValid(const base::FilePath& usage_file_path) {
TRACE_EVENT0("FileSystem", "UsageCache::IsValid");
DCHECK(CalledOnValidThread());
bool is_valid = true;
uint32_t dirty = 0;
int64_t usage = 0;
if (!Read(usage_file_path, &is_valid, &dirty, &usage))
return false;
return is_valid;
}
bool FileSystemUsageCache::AtomicUpdateUsageByDelta(
const base::FilePath& usage_file_path,
int64_t delta) {
TRACE_EVENT0("FileSystem", "UsageCache::AtomicUpdateUsageByDelta");
DCHECK(CalledOnValidThread());
bool is_valid = true;
uint32_t dirty = 0;
int64_t usage = 0;
if (!Read(usage_file_path, &is_valid, &dirty, &usage))
return false;
return Write(usage_file_path, is_valid, dirty, usage + delta);
}
bool FileSystemUsageCache::UpdateUsage(const base::FilePath& usage_file_path,
int64_t fs_usage) {
TRACE_EVENT0("FileSystem", "UsageCache::UpdateUsage");
DCHECK(CalledOnValidThread());
return Write(usage_file_path, true, 0, fs_usage);
}
bool FileSystemUsageCache::Exists(const base::FilePath& usage_file_path) {
TRACE_EVENT0("FileSystem", "UsageCache::Exists");
DCHECK(CalledOnValidThread());
return base::PathExists(usage_file_path);
}
bool FileSystemUsageCache::Delete(const base::FilePath& usage_file_path) {
TRACE_EVENT0("FileSystem", "UsageCache::Delete");
DCHECK(CalledOnValidThread());
CloseCacheFiles();
return base::DeleteFile(usage_file_path, false);
}
void FileSystemUsageCache::CloseCacheFiles() {
TRACE_EVENT0("FileSystem", "UsageCache::CloseCacheFiles");
DCHECK(CalledOnValidThread());
base::STLDeleteValues(&cache_files_);
timer_.reset();
}
bool FileSystemUsageCache::Read(const base::FilePath& usage_file_path,
bool* is_valid,
uint32_t* dirty_out,
int64_t* usage_out) {
TRACE_EVENT0("FileSystem", "UsageCache::Read");
DCHECK(CalledOnValidThread());
DCHECK(is_valid);
DCHECK(dirty_out);
DCHECK(usage_out);
char buffer[kUsageFileSize];
const char *header;
if (usage_file_path.empty() ||
!ReadBytes(usage_file_path, buffer, kUsageFileSize))
return false;
base::Pickle read_pickle(buffer, kUsageFileSize);
base::PickleIterator iter(read_pickle);
uint32_t dirty = 0;
int64_t usage = 0;
if (!iter.ReadBytes(&header, kUsageFileHeaderSize) ||
!iter.ReadBool(is_valid) ||
!iter.ReadUInt32(&dirty) ||
!iter.ReadInt64(&usage))
return false;
if (header[0] != kUsageFileHeader[0] ||
header[1] != kUsageFileHeader[1] ||
header[2] != kUsageFileHeader[2] ||
header[3] != kUsageFileHeader[3])
return false;
*dirty_out = dirty;
*usage_out = usage;
return true;
}
bool FileSystemUsageCache::Write(const base::FilePath& usage_file_path,
bool is_valid,
int32_t dirty,
int64_t usage) {
TRACE_EVENT0("FileSystem", "UsageCache::Write");
DCHECK(CalledOnValidThread());
base::Pickle write_pickle;
write_pickle.WriteBytes(kUsageFileHeader, kUsageFileHeaderSize);
write_pickle.WriteBool(is_valid);
write_pickle.WriteUInt32(dirty);
write_pickle.WriteInt64(usage);
if (!WriteBytes(usage_file_path,
static_cast<const char*>(write_pickle.data()),
write_pickle.size())) {
Delete(usage_file_path);
return false;
}
return true;
}
base::File* FileSystemUsageCache::GetFile(const base::FilePath& file_path) {
DCHECK(CalledOnValidThread());
if (cache_files_.size() >= kMaxHandleCacheSize)
CloseCacheFiles();
ScheduleCloseTimer();
base::File* new_file = NULL;
std::pair<CacheFiles::iterator, bool> inserted =
cache_files_.insert(std::make_pair(file_path, new_file));
if (!inserted.second)
return inserted.first->second;
new_file = new base::File(file_path,
base::File::FLAG_OPEN_ALWAYS |
base::File::FLAG_READ |
base::File::FLAG_WRITE);
if (!new_file->IsValid()) {
cache_files_.erase(inserted.first);
delete new_file;
return NULL;
}
inserted.first->second = new_file;
return new_file;
}
bool FileSystemUsageCache::ReadBytes(const base::FilePath& file_path,
char* buffer,
int64_t buffer_size) {
DCHECK(CalledOnValidThread());
base::File* file = GetFile(file_path);
if (!file)
return false;
return file->Read(0, buffer, buffer_size) == buffer_size;
}
bool FileSystemUsageCache::WriteBytes(const base::FilePath& file_path,
const char* buffer,
int64_t buffer_size) {
DCHECK(CalledOnValidThread());
base::File* file = GetFile(file_path);
if (!file)
return false;
return file->Write(0, buffer, buffer_size) == buffer_size;
}
bool FileSystemUsageCache::FlushFile(const base::FilePath& file_path) {
TRACE_EVENT0("FileSystem", "UsageCache::FlushFile");
DCHECK(CalledOnValidThread());
base::File* file = GetFile(file_path);
if (!file)
return false;
return file->Flush();
}
void FileSystemUsageCache::ScheduleCloseTimer() {
DCHECK(CalledOnValidThread());
if (!timer_)
timer_.reset(new TimedTaskHelper(task_runner_.get()));
if (timer_->IsRunning()) {
timer_->Reset();
return;
}
timer_->Start(FROM_HERE,
base::TimeDelta::FromSeconds(kCloseDelaySeconds),
base::Bind(&FileSystemUsageCache::CloseCacheFiles,
weak_factory_.GetWeakPtr()));
}
bool FileSystemUsageCache::CalledOnValidThread() {
return !task_runner_.get() || task_runner_->RunsTasksOnCurrentThread();
}
bool FileSystemUsageCache::HasCacheFileHandle(const base::FilePath& file_path) {
DCHECK(CalledOnValidThread());
DCHECK_LE(cache_files_.size(), kMaxHandleCacheSize);
return base::ContainsKey(cache_files_, file_path);
}
} // namespace storage