Move storage-related files from webkit/ to new top-level directory storage/

storage/browser/fileapi/file_system_usage_cache.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/file_system_usage_cache.h"
+#include "storage/browser/fileapi/file_system_usage_cache.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/pickle.h"
 #include "base/stl_util.h"
-#include "webkit/browser/fileapi/timed_task_helper.h"
+#include "storage/browser/fileapi/timed_task_helper.h"
 
-namespace fileapi {
+namespace storage {
 
 namespace {
 const int64 kCloseDelaySeconds = 5;
 const size_t kMaxHandleCacheSize = 2;
 }  // namespace
 
 FileSystemUsageCache::FileSystemUsageCache(
     base::SequencedTaskRunner* task_runner)
-    : task_runner_(task_runner),
-      weak_factory_(this) {
+    : 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(Pickle::Header) +
-    FileSystemUsageCache::kUsageFileHeaderSize +
+    sizeof(Pickle::Header) + FileSystemUsageCache::kUsageFileHeaderSize +
     sizeof(int) + sizeof(int32) + sizeof(int64);  // NOLINT
 
 bool FileSystemUsageCache::GetUsage(const base::FilePath& usage_file_path,
                                     int64* usage_out) {
   TRACE_EVENT0("FileSystem", "UsageCache::GetUsage");
   DCHECK(CalledOnValidThread());
   DCHECK(usage_out);
   bool is_valid = true;
   uint32 dirty = 0;
   int64 usage = 0;
@@ skipping 67 matching lines @@
   DCHECK(CalledOnValidThread());
   bool is_valid = true;
   uint32 dirty = 0;
   int64 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 delta) {
+    const base::FilePath& usage_file_path,
+    int64 delta) {
   TRACE_EVENT0("FileSystem", "UsageCache::AtomicUpdateUsageByDelta");
   DCHECK(CalledOnValidThread());
   bool is_valid = true;
   uint32 dirty = 0;
-  int64 usage = 0;;
+  int64 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 fs_usage) {
   TRACE_EVENT0("FileSystem", "UsageCache::UpdateUsage");
   DCHECK(CalledOnValidThread());
   return Write(usage_file_path, true, 0, fs_usage);
@@ skipping 13 matching lines @@
 }
 
 void FileSystemUsageCache::CloseCacheFiles() {
   TRACE_EVENT0("FileSystem", "UsageCache::CloseCacheFiles");
   DCHECK(CalledOnValidThread());
   STLDeleteValues(&cache_files_);
   timer_.reset();
 }
 
 bool FileSystemUsageCache::Read(const base::FilePath& usage_file_path,
-                                 bool* is_valid,
-                                 uint32* dirty_out,
-                                 int64* usage_out) {
+                                bool* is_valid,
+                                uint32* dirty_out,
+                                int64* usage_out) {
   TRACE_EVENT0("FileSystem", "UsageCache::Read");
   DCHECK(CalledOnValidThread());
   DCHECK(is_valid);
   DCHECK(dirty_out);
   DCHECK(usage_out);
   char buffer[kUsageFileSize];
-  const char *header;
+  const char* header;
   if (usage_file_path.empty() ||
       !ReadBytes(usage_file_path, buffer, kUsageFileSize))
     return false;
   Pickle read_pickle(buffer, kUsageFileSize);
   PickleIterator iter(read_pickle);
   uint32 dirty = 0;
   int64 usage = 0;
 
   if (!read_pickle.ReadBytes(&iter, &header, kUsageFileHeaderSize) ||
       !read_pickle.ReadBool(&iter, is_valid) ||
       !read_pickle.ReadUInt32(&iter, &dirty) ||
       !read_pickle.ReadInt64(&iter, &usage))
     return false;
 
-  if (header[0] != kUsageFileHeader[0] ||
-      header[1] != kUsageFileHeader[1] ||
-      header[2] != kUsageFileHeader[2] ||
-      header[3] != kUsageFileHeader[3])
+  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 dirty,
@@ skipping 22 matching lines @@
   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);
+                                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;
 }
 
@@ skipping 45 matching lines @@
 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 ContainsKey(cache_files_, file_path);
 }
 
-}  // namespace fileapi
+}  // namespace storage