Add an API to get total size of Drive cache including non-evictable ones.

components/drive/chromeos/file_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 "components/drive/chromeos/file_cache.h"
 
 #include <linux/fs.h>
 #include <sys/ioctl.h>
 #include <sys/xattr.h>
 
@@ skipping 106 matching lines @@
       && SetExtendedFileAttributes(path, FileCache::kGCacheFilesAttribute, "");
 }
 
 class CacheInfoLatestCompare {
  public:
   bool operator()(const CacheInfo& info_a, const CacheInfo& info_b) {
     return info_a.first.last_accessed < info_b.first.last_accessed;
   }
 };
 
+// Returns true if the cache file is present.
+bool IsPresent(const ResourceEntry& entry) {
+  return entry.has_file_specific_info() &&
+         entry.file_specific_info().has_cache_state() &&
+         entry.file_specific_info().cache_state().is_present();
+}
+
 const size_t kMaxNumOfEvictedCacheFiles = 30000;
 
 }  // namespace
 
 // static
 const char FileCache::kGCacheFilesAttribute[] = "user.GCacheFiles";
 
 FileCache::FileCache(ResourceMetadataStorage* storage,
                      const base::FilePath& cache_file_directory,
                      base::SequencedTaskRunner* blocking_task_runner,
@@ skipping 120 matching lines @@
     if (base::DeleteFile(path, false /* recursive */))
       evicted_cache_size += cache_info.first.size;
 
     ++iter;
   }
 
   // Check the disk space again.
   return GetAvailableSpace() >= num_bytes;
 }
 
-uint64_t FileCache::CalculateEvictableCacheSize() {
+int64_t FileCache::CalculateCacheSize() {
   AssertOnSequencedWorkerPool();
 
-  uint64_t evictable_cache_size = 0;
+  int64_t total_cache_size = 0;
   int64_t cache_size = 0;
 
   std::unique_ptr<ResourceMetadataStorage::Iterator> it =
+      storage_->GetIterator();
+  for (; !it->IsAtEnd(); it->Advance()) {
+    if (IsPresent(it->GetValue()) &&
+        base::GetFileSize(GetCacheFilePath(it->GetID()), &cache_size)) {
+      DCHECK_GE(cache_size, 0);
+      total_cache_size += cache_size;
+    }
+  }
+
+  if (it->HasError())
+    return 0;
+
+  return total_cache_size;
+}
+
+int64_t FileCache::CalculateEvictableCacheSize() {
+  AssertOnSequencedWorkerPool();
+
+  int64_t evictable_cache_size = 0;
+  int64_t cache_size = 0;
+
+  std::unique_ptr<ResourceMetadataStorage::Iterator> it =
       storage_->GetIterator();
   for (; !it->IsAtEnd(); it->Advance()) {
     if (IsEvictable(it->GetID(), it->GetValue()) &&
         base::GetFileSize(GetCacheFilePath(it->GetID()), &cache_size)) {
       DCHECK_GE(cache_size, 0);
       evictable_cache_size += cache_size;
     }
   }
 
   if (it->HasError())
@@ skipping 584 matching lines @@
   entry.mutable_file_info()->set_last_modified(
       base::Time::Now().ToInternalValue());
   error = storage_->PutEntry(entry);
   if (error != FILE_ERROR_OK) {
     LOG(ERROR) << "Failed to put entry: " << id << ", "
                << FileErrorToString(error);
   }
 }
 
 bool FileCache::IsEvictable(const std::string& id, const ResourceEntry& entry) {
-  return entry.file_specific_info().has_cache_state() &&
+  return IsPresent(entry) &&
          !entry.file_specific_info().cache_state().is_pinned() &&
          !entry.file_specific_info().cache_state().is_dirty() &&
          !mounted_files_.count(id);
 }
 
 }  // namespace internal
 }  // namespace drive