storage/browser/fileapi/file_system_usage_cache.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "storage/browser/fileapi/file_system_usage_cache.h"
   6
   7 #include <utility>
   8
   9 #include "base/bind.h"
  10 #include "base/debug/trace_event.h"
  11 #include "base/files/file_path.h"
  12 #include "base/files/file_util.h"
  13 #include "base/pickle.h"
  14 #include "base/stl_util.h"
  15 #include "storage/browser/fileapi/timed_task_helper.h"
  16
  17 namespace storage {
  18
  19 namespace {
  20 const int64 kCloseDelaySeconds = 5;
  21 const size_t kMaxHandleCacheSize = 2;
  22 }  // namespace
  23
  24 FileSystemUsageCache::FileSystemUsageCache(
  25     base::SequencedTaskRunner* task_runner)
  26     : task_runner_(task_runner),
  27       weak_factory_(this) {
  28 }
  29
  30 FileSystemUsageCache::~FileSystemUsageCache() {
  31   task_runner_ = NULL;
  32   CloseCacheFiles();
  33 }
  34
  35 const base::FilePath::CharType FileSystemUsageCache::kUsageFileName[] =
  36     FILE_PATH_LITERAL(".usage");
  37 const char FileSystemUsageCache::kUsageFileHeader[] = "FSU5";
  38 const int FileSystemUsageCache::kUsageFileHeaderSize = 4;
  39
  40 // Pickle::{Read,Write}Bool treat bool as int
  41 const int FileSystemUsageCache::kUsageFileSize =
  42     sizeof(Pickle::Header) +
  43     FileSystemUsageCache::kUsageFileHeaderSize +
  44     sizeof(int) + sizeof(int32) + sizeof(int64);  // NOLINT
  45
  46 bool FileSystemUsageCache::GetUsage(const base::FilePath& usage_file_path,
  47                                     int64* usage_out) {
  48   TRACE_EVENT0("FileSystem", "UsageCache::GetUsage");
  49   DCHECK(CalledOnValidThread());
  50   DCHECK(usage_out);
  51   bool is_valid = true;
  52   uint32 dirty = 0;
  53   int64 usage = 0;
  54   if (!Read(usage_file_path, &is_valid, &dirty, &usage))
  55     return false;
  56   *usage_out = usage;
  57   return true;
  58 }
  59
  60 bool FileSystemUsageCache::GetDirty(const base::FilePath& usage_file_path,
  61                                     uint32* dirty_out) {
  62   TRACE_EVENT0("FileSystem", "UsageCache::GetDirty");
  63   DCHECK(CalledOnValidThread());
  64   DCHECK(dirty_out);
  65   bool is_valid = true;
  66   uint32 dirty = 0;
  67   int64 usage = 0;
  68   if (!Read(usage_file_path, &is_valid, &dirty, &usage))
  69     return false;
  70   *dirty_out = dirty;
  71   return true;
  72 }
  73
  74 bool FileSystemUsageCache::IncrementDirty(
  75     const base::FilePath& usage_file_path) {
  76   TRACE_EVENT0("FileSystem", "UsageCache::IncrementDirty");
  77   DCHECK(CalledOnValidThread());
  78   bool is_valid = true;
  79   uint32 dirty = 0;
  80   int64 usage = 0;
  81   bool new_handle = !HasCacheFileHandle(usage_file_path);
  82   if (!Read(usage_file_path, &is_valid, &dirty, &usage))
  83     return false;
  84
  85   bool success = Write(usage_file_path, is_valid, dirty + 1, usage);
  86   if (success && dirty == 0 && new_handle)
  87     FlushFile(usage_file_path);
  88   return success;
  89 }
  90
  91 bool FileSystemUsageCache::DecrementDirty(
  92     const base::FilePath& usage_file_path) {
  93   TRACE_EVENT0("FileSystem", "UsageCache::DecrementDirty");
  94   DCHECK(CalledOnValidThread());
  95   bool is_valid = true;
  96   uint32 dirty = 0;
  97   int64 usage = 0;
  98   if (!Read(usage_file_path, &is_valid, &dirty, &usage) || dirty <= 0)
  99     return false;
 100
 101   if (dirty <= 0)
 102     return false;
 103
 104   return Write(usage_file_path, is_valid, dirty - 1, usage);
 105 }
 106
 107 bool FileSystemUsageCache::Invalidate(const base::FilePath& usage_file_path) {
 108   TRACE_EVENT0("FileSystem", "UsageCache::Invalidate");
 109   DCHECK(CalledOnValidThread());
 110   bool is_valid = true;
 111   uint32 dirty = 0;
 112   int64 usage = 0;
 113   if (!Read(usage_file_path, &is_valid, &dirty, &usage))
 114     return false;
 115
 116   return Write(usage_file_path, false, dirty, usage);
 117 }
 118
 119 bool FileSystemUsageCache::IsValid(const base::FilePath& usage_file_path) {
 120   TRACE_EVENT0("FileSystem", "UsageCache::IsValid");
 121   DCHECK(CalledOnValidThread());
 122   bool is_valid = true;
 123   uint32 dirty = 0;
 124   int64 usage = 0;
 125   if (!Read(usage_file_path, &is_valid, &dirty, &usage))
 126     return false;
 127   return is_valid;
 128 }
 129
 130 bool FileSystemUsageCache::AtomicUpdateUsageByDelta(
 131     const base::FilePath& usage_file_path, int64 delta) {
 132   TRACE_EVENT0("FileSystem", "UsageCache::AtomicUpdateUsageByDelta");
 133   DCHECK(CalledOnValidThread());
 134   bool is_valid = true;
 135   uint32 dirty = 0;
 136   int64 usage = 0;;
 137   if (!Read(usage_file_path, &is_valid, &dirty, &usage))
 138     return false;
 139   return Write(usage_file_path, is_valid, dirty, usage + delta);
 140 }
 141
 142 bool FileSystemUsageCache::UpdateUsage(const base::FilePath& usage_file_path,
 143                                        int64 fs_usage) {
 144   TRACE_EVENT0("FileSystem", "UsageCache::UpdateUsage");
 145   DCHECK(CalledOnValidThread());
 146   return Write(usage_file_path, true, 0, fs_usage);
 147 }
 148
 149 bool FileSystemUsageCache::Exists(const base::FilePath& usage_file_path) {
 150   TRACE_EVENT0("FileSystem", "UsageCache::Exists");
 151   DCHECK(CalledOnValidThread());
 152   return base::PathExists(usage_file_path);
 153 }
 154
 155 bool FileSystemUsageCache::Delete(const base::FilePath& usage_file_path) {
 156   TRACE_EVENT0("FileSystem", "UsageCache::Delete");
 157   DCHECK(CalledOnValidThread());
 158   CloseCacheFiles();
 159   return base::DeleteFile(usage_file_path, true);
 160 }
 161
 162 void FileSystemUsageCache::CloseCacheFiles() {
 163   TRACE_EVENT0("FileSystem", "UsageCache::CloseCacheFiles");
 164   DCHECK(CalledOnValidThread());
 165   STLDeleteValues(&cache_files_);
 166   timer_.reset();
 167 }
 168
 169 bool FileSystemUsageCache::Read(const base::FilePath& usage_file_path,
 170                                  bool* is_valid,
 171                                  uint32* dirty_out,
 172                                  int64* usage_out) {
 173   TRACE_EVENT0("FileSystem", "UsageCache::Read");
 174   DCHECK(CalledOnValidThread());
 175   DCHECK(is_valid);
 176   DCHECK(dirty_out);
 177   DCHECK(usage_out);
 178   char buffer[kUsageFileSize];
 179   const char *header;
 180   if (usage_file_path.empty() ||
 181       !ReadBytes(usage_file_path, buffer, kUsageFileSize))
 182     return false;
 183   Pickle read_pickle(buffer, kUsageFileSize);
 184   PickleIterator iter(read_pickle);
 185   uint32 dirty = 0;
 186   int64 usage = 0;
 187
 188   if (!read_pickle.ReadBytes(&iter, &header, kUsageFileHeaderSize) ||
 189       !read_pickle.ReadBool(&iter, is_valid) ||
 190       !read_pickle.ReadUInt32(&iter, &dirty) ||
 191       !read_pickle.ReadInt64(&iter, &usage))
 192     return false;
 193
 194   if (header[0] != kUsageFileHeader[0] ||
 195       header[1] != kUsageFileHeader[1] ||
 196       header[2] != kUsageFileHeader[2] ||
 197       header[3] != kUsageFileHeader[3])
 198     return false;
 199
 200   *dirty_out = dirty;
 201   *usage_out = usage;
 202   return true;
 203 }
 204
 205 bool FileSystemUsageCache::Write(const base::FilePath& usage_file_path,
 206                                  bool is_valid,
 207                                  int32 dirty,
 208                                  int64 usage) {
 209   TRACE_EVENT0("FileSystem", "UsageCache::Write");
 210   DCHECK(CalledOnValidThread());
 211   Pickle write_pickle;
 212   write_pickle.WriteBytes(kUsageFileHeader, kUsageFileHeaderSize);
 213   write_pickle.WriteBool(is_valid);
 214   write_pickle.WriteUInt32(dirty);
 215   write_pickle.WriteInt64(usage);
 216
 217   if (!WriteBytes(usage_file_path,
 218                   static_cast<const char*>(write_pickle.data()),
 219                   write_pickle.size())) {
 220     Delete(usage_file_path);
 221     return false;
 222   }
 223   return true;
 224 }
 225
 226 base::File* FileSystemUsageCache::GetFile(const base::FilePath& file_path) {
 227   DCHECK(CalledOnValidThread());
 228   if (cache_files_.size() >= kMaxHandleCacheSize)
 229     CloseCacheFiles();
 230   ScheduleCloseTimer();
 231
 232   base::File* new_file = NULL;
 233   std::pair<CacheFiles::iterator, bool> inserted =
 234       cache_files_.insert(std::make_pair(file_path, new_file));
 235   if (!inserted.second)
 236     return inserted.first->second;
 237
 238   new_file = new base::File(file_path,
 239                             base::File::FLAG_OPEN_ALWAYS |
 240                             base::File::FLAG_READ |
 241                             base::File::FLAG_WRITE);
 242   if (!new_file->IsValid()) {
 243     cache_files_.erase(inserted.first);
 244     delete new_file;
 245     return NULL;
 246   }
 247
 248   inserted.first->second = new_file;
 249   return new_file;
 250 }
 251
 252 bool FileSystemUsageCache::ReadBytes(const base::FilePath& file_path,
 253                                      char* buffer,
 254                                      int64 buffer_size) {
 255   DCHECK(CalledOnValidThread());
 256   base::File* file = GetFile(file_path);
 257   if (!file)
 258     return false;
 259   return file->Read(0, buffer, buffer_size) == buffer_size;
 260 }
 261
 262 bool FileSystemUsageCache::WriteBytes(const base::FilePath& file_path,
 263                                       const char* buffer,
 264                                       int64 buffer_size) {
 265   DCHECK(CalledOnValidThread());
 266   base::File* file = GetFile(file_path);
 267   if (!file)
 268     return false;
 269   return file->Write(0, buffer, buffer_size) == buffer_size;
 270 }
 271
 272 bool FileSystemUsageCache::FlushFile(const base::FilePath& file_path) {
 273   TRACE_EVENT0("FileSystem", "UsageCache::FlushFile");
 274   DCHECK(CalledOnValidThread());
 275   base::File* file = GetFile(file_path);
 276   if (!file)
 277     return false;
 278   return file->Flush();
 279 }
 280
 281 void FileSystemUsageCache::ScheduleCloseTimer() {
 282   DCHECK(CalledOnValidThread());
 283   if (!timer_)
 284     timer_.reset(new TimedTaskHelper(task_runner_.get()));
 285
 286   if (timer_->IsRunning()) {
 287     timer_->Reset();
 288     return;
 289   }
 290
 291   timer_->Start(FROM_HERE,
 292                 base::TimeDelta::FromSeconds(kCloseDelaySeconds),
 293                 base::Bind(&FileSystemUsageCache::CloseCacheFiles,
 294                            weak_factory_.GetWeakPtr()));
 295 }
 296
 297 bool FileSystemUsageCache::CalledOnValidThread() {
 298   return !task_runner_.get() || task_runner_->RunsTasksOnCurrentThread();
 299 }
 300
 301 bool FileSystemUsageCache::HasCacheFileHandle(const base::FilePath& file_path) {
 302   DCHECK(CalledOnValidThread());
 303   DCHECK_LE(cache_files_.size(), kMaxHandleCacheSize);
 304   return ContainsKey(cache_files_, file_path);
 305 }
 306
 307 }  // namespace storage