Add UMA stats for ExtensionCache

chrome/browser/extensions/updater/local_extension_cache.cc

 // Copyright 2014 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 "chrome/browser/extensions/updater/local_extension_cache.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/sequenced_task_runner.h"
@@ skipping 11 matching lines @@
 // Delay between checks for flag file presence when waiting for the cache to
 // become ready.
 const int64_t kCacheStatusPollingDelayMs = 1000;
 
 }  // namespace
 
 const char LocalExtensionCache::kCacheReadyFlagFileName[] = ".initialized";
 
 LocalExtensionCache::LocalExtensionCache(
     const base::FilePath& cache_dir,
-    size_t max_cache_size,
+    uint64 max_cache_size,
     const base::TimeDelta& max_cache_age,
     const scoped_refptr<base::SequencedTaskRunner>& backend_task_runner)
     : cache_dir_(cache_dir),
       max_cache_size_(max_cache_size),
       min_cache_age_(base::Time::Now() - max_cache_age),
       backend_task_runner_(backend_task_runner),
       state_(kUninitialized),
       weak_ptr_factory_(this),
       cache_status_polling_delay_(
           base::TimeDelta::FromMilliseconds(kCacheStatusPollingDelayMs)) {
@@ skipping 101 matching lines @@
 
   backend_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&LocalExtensionCache::BackendRemoveCacheEntry,
                  it->second.file_path));
 
   cached_extensions_.erase(it);
   return true;
 }
 
+bool LocalExtensionCache::GetStatistics(uint64* cache_size,
+                                        size_t* extensions_count) {
+  if (state_ != kReady)
+    return false;
+
+  *cache_size = 0;
+  for (CacheMap::iterator it = cached_extensions_.begin();
+       it != cached_extensions_.end(); ++it) {
+    *cache_size += it->second.size;
+  }
+  *extensions_count = cached_extensions_.size();
+
+  return true;
+}
+
 void LocalExtensionCache::SetCacheStatusPollingDelayForTests(
     const base::TimeDelta& delay) {
   cache_status_polling_delay_ = delay;
 }
 
 void LocalExtensionCache::CheckCacheStatus(const base::Closure& callback) {
   if (state_ == kShutdown) {
     callback.Run();
     return;
   }
@@ skipping 254 matching lines @@
 bool LocalExtensionCache::CompareCacheItemsAge(const CacheMap::iterator& lhs,
                                                const CacheMap::iterator& rhs) {
   return lhs->second.last_used < rhs->second.last_used;
 }
 
 void LocalExtensionCache::CleanUp() {
   DCHECK_EQ(state_, kReady);
 
   std::vector<CacheMap::iterator> items;
   items.reserve(cached_extensions_.size());
-  size_t total_size = 0;
+  uint64_t total_size = 0;
   for (CacheMap::iterator it = cached_extensions_.begin();
        it != cached_extensions_.end(); ++it) {
     items.push_back(it);
     total_size += it->second.size;
   }
   std::sort(items.begin(), items.end(), CompareCacheItemsAge);
 
   for (std::vector<CacheMap::iterator>::iterator it = items.begin();
        it != items.end(); ++it) {
     if ((*it)->second.last_used < min_cache_age_ ||
         (max_cache_size_ && total_size > max_cache_size_)) {
       total_size -= (*it)->second.size;
       VLOG(1) << "Clean up cached extension id " << (*it)->first;
       RemoveExtension((*it)->first);
     }
   }
 }
 
 LocalExtensionCache::CacheItemInfo::CacheItemInfo(
     const std::string& version,
     const base::Time& last_used,
-    const size_t size,
+    uint64 size,
     const base::FilePath& file_path)
     : version(version), last_used(last_used), size(size), file_path(file_path) {
 }
 
 }  // namespace extensions