Add UMA stats for ExtensionCache

chrome/browser/extensions/updater/local_extension_cache.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_UPDATER_LOCAL_EXTENSION_CACHE_H_
 #define CHROME_BROWSER_EXTENSIONS_UPDATER_LOCAL_EXTENSION_CACHE_H_
 
 #include <map>
 #include <string>
 
@@ skipping 14 matching lines @@
   // Callback invoked on UI thread when PutExtension is completed.
   typedef base::Callback<void(const base::FilePath& file_path,
                               bool file_ownership_passed)> PutExtensionCallback;
 
   // |cache_dir| - directory that will be used for caching CRX files.
   // |max_cache_size| - maximum disk space that cache can use, 0 means no limit.
   // |max_cache_age| - maximum age that unused item can be kept in cache, 0 age
   // means that all unused cache items will be removed on Shutdown.
   // All file I/O is done via the |backend_task_runner|.
   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);
   ~LocalExtensionCache();
 
   // Name of flag file that indicates that cache is ready (import finished).
   static const char kCacheReadyFlagFileName[];
 
   // Initialize cache. If |wait_for_cache_initialization| is |true|, the cache
   // contents will not be read until a flag file appears in the cache directory,
@@ skipping 20 matching lines @@
   // of |file_path| or return it back via |callback|.
   void PutExtension(const std::string& id,
                     const base::FilePath& file_path,
                     const std::string& version,
                     const PutExtensionCallback& callback);
 
   // Remove extension with |id| from local cache, corresponding crx file will be
   // removed from disk too.
   bool RemoveExtension(const std::string& id);
 
+  // Return cache statistics. Returns |false| if cache is not ready.
+  bool GetStatistics(uint64* cache_size,
+                     size_t* extensions_count);
+
   bool is_ready() const { return state_ == kReady; }
   bool is_uninitialized() const { return state_ == kUninitialized; }
   bool is_shutdown() const { return state_ == kShutdown; }
 
   // For tests only!
   void SetCacheStatusPollingDelayForTests(const base::TimeDelta& delay);
 
  private:
   struct CacheItemInfo {
     std::string version;
     base::Time last_used;
-    int64 size;
+    uint64 size;
     base::FilePath file_path;
 
     CacheItemInfo(const std::string& version,
                   const base::Time& last_used,
-                  const size_t size,
+                  const uint64 size,
                   const base::FilePath& file_path);
   };
   typedef std::map<std::string, CacheItemInfo> CacheMap;
 
   enum State {
     kUninitialized,
     kWaitInitialization,
     kReady,
     kShutdown
   };
@@ skipping 65 matching lines @@
   static bool CompareCacheItemsAge(const CacheMap::iterator& lhs,
                                    const CacheMap::iterator& rhs);
 
   // Calculate which files need to be deleted and schedule files deletion.
   void CleanUp();
 
   // Path to the directory where the extension cache is stored.
   base::FilePath cache_dir_;
 
   // Maximum size of cache dir on disk.
-  size_t max_cache_size_;
+  uint64 max_cache_size_;
 
   // Minimal age of unused item in cache, items prior to this age will be
   // deleted on shutdown.
   base::Time min_cache_age_;
 
   // Task runner for executing file I/O tasks.
   scoped_refptr<base::SequencedTaskRunner> backend_task_runner_;
 
   // Track state of the instance.
   State state_;
 
   // This contains info about all cached extensions.
   CacheMap cached_extensions_;
 
   // Weak factory for callbacks from the backend and delayed tasks.
   base::WeakPtrFactory<LocalExtensionCache> weak_ptr_factory_;
 
   // Delay between polling cache status.
   base::TimeDelta cache_status_polling_delay_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalExtensionCache);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_UPDATER_LOCAL_EXTENSION_CACHE_H_