[Offline Pages] Linking storage manager and model with UMAs.

components/offline_pages/offline_page_storage_manager.h

 // Copyright 2016 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 COMPONENTS_OFFLINE_PAGES_OFFLINE_PAGE_STORAGE_MANAGER_H_
 #define COMPONENTS_OFFLINE_PAGES_OFFLINE_PAGE_STORAGE_MANAGER_H_
 
 #include <stdint.h>
 
 #include <vector>
@@ skipping 56 matching lines @@
                              const base::Time& expiration_time,
                              const base::Callback<void(bool)>& callback) = 0;
   };
 
   enum class ClearStorageResult {
     SUCCESS,         // Cleared successfully.
     UNNECESSARY,     // No expired pages.
     EXPIRE_FAILURE,  // Expiration failed.
     DELETE_FAILURE,  // Deletion failed.
     BOTH_FAILURE,    // Both expiration and deletion failed.
+    // NOTE: always keep this entry at the end. Add new result types only
+    // immediately above this line. Make sure to update the corresponding
+    // histogram enum accordingly.
+    RESULT_COUNT,
   };
 
   // Callback used when calling ClearPagesIfNeeded.
   // size_t: the number of expired pages.
   // ClearStorageResult: result of expiring pages in storage.
-  typedef base::Callback<void(size_t, ClearStorageResult)> ClearPagesCallback;
+  typedef base::Callback<void(size_t, ClearStorageResult)> ClearStorageCallback;
 
   explicit OfflinePageStorageManager(Client* client,
                                      ClientPolicyController* policy_controller,
                                      ArchiveManager* archive_manager);
 
   ~OfflinePageStorageManager();
 
   // The manager would *try* to clear pages when called. It may not delete any
   // pages (if clearing condition wasn't satisfied).
   // It clears the storage (expire pages) when it's using more disk space than a
   // certain limit, or the time elapsed from last time clearing is longer than a
   // certain interval. Both values are defined above.
-  void ClearPagesIfNeeded(const ClearPagesCallback& callback);
+  void ClearPagesIfNeeded(const ClearStorageCallback& callback);
 
   // Sets the clock for testing.
   void SetClockForTesting(std::unique_ptr<base::Clock> clock);
 
  private:
   // Enum indicating how to clear the pages.
   enum class ClearMode {
     // Using normal expiration logic to expire pages. Will reduce the storage
     // usage down below the threshold.
     DEFAULT,
     // No need to expire any page (no pages in the model or no expired
     // pages and we're not exceeding the storage limit.)
     NOT_NEEDED,
   };
 
   // Callback called after getting storage stats from archive manager.
   void OnGetStorageStatsDoneForClearingPages(
-      const ClearPagesCallback& callback,
+      const ClearStorageCallback& callback,
       const ArchiveManager::StorageStats& pages);
 
   // Callback called after getting all pages from client done.
   void OnGetAllPagesDoneForClearingPages(
-      const ClearPagesCallback& callback,
+      const ClearStorageCallback& callback,
       const ArchiveManager::StorageStats& storage_stats,
       const MultipleOfflinePageItemResult& pages);
 
   // Callback called after expired pages have been deleted.
-  void OnPagesExpired(const ClearPagesCallback& callback,
+  void OnPagesExpired(const ClearStorageCallback& callback,
                       size_t pages_to_clear,
                       const std::vector<int64_t>& page_ids_to_remove,
                       bool expiration_succeeded);
 
   // Callback called after clearing outdated pages from client.
-  void OnOutdatedPagesCleared(const ClearPagesCallback& callback,
+  void OnOutdatedPagesCleared(const ClearStorageCallback& callback,
                               size_t pages_cleared,
                               bool expiration_succeeded,
                               DeletePageResult result);
 
   // Gets offline IDs of both pages that should be expired and the ones that
   // need to be removed from metadata store. |page_ids_to_expire| will have
   // the pages to be expired, |page_ids_to_remove| will have the pages to be
   // removed.
   void GetPageIdsToClear(const MultipleOfflinePageItemResult& pages,
                          const ArchiveManager::StorageStats& stats,
@@ skipping 29 matching lines @@
   std::unique_ptr<base::Clock> clock_;
 
   base::WeakPtrFactory<OfflinePageStorageManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(OfflinePageStorageManager);
 };
 
 }  // namespace offline_pages
 
 #endif  // COMPONENTS_OFFLINE_PAGES_OFFLINE_PAGE_STORAGE_MANAGER_H_