[Offline pages] Moving disk size related calls to Archive Manager, reorganizing UMA

components/offline_pages/archive_manager_unittest.cc

 // Copyright 2015 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/offline_pages/archive_manager.h"
 
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <vector>
@@ skipping 23 matching lines @@
  public:
   ArchiveManagerTest();
   void SetUp() override;
 
   void PumpLoop();
   void ResetResults();
 
   void ResetManager(const base::FilePath& file_path);
   void Callback(bool result);
   void GetAllArchivesCallback(const std::set<base::FilePath>& archive_paths);
+  void GetStorageStatsCallback(
+      const ArchiveManager::StorageStats& storage_sizes);
 
   ArchiveManager* manager() { return manager_.get(); }
   const base::FilePath& temp_path() const { return temp_dir_.path(); }
   CallbackStatus callback_status() const { return callback_status_; }
   const std::set<base::FilePath>& last_archive_paths() const {
     return last_archvie_paths_;
   }
+  ArchiveManager::StorageStats last_storage_sizes() const {
+    return last_storage_sizes_;
+  }
 
  private:
   scoped_refptr<base::TestSimpleTaskRunner> task_runner_;
   base::ThreadTaskRunnerHandle task_runner_handle_;
   base::ScopedTempDir temp_dir_;
 
   std::unique_ptr<ArchiveManager> manager_;
   CallbackStatus callback_status_;
   std::set<base::FilePath> last_archvie_paths_;
+  ArchiveManager::StorageStats last_storage_sizes_;
 };
 
 ArchiveManagerTest::ArchiveManagerTest()
     : task_runner_(new base::TestSimpleTaskRunner),
       task_runner_handle_(task_runner_),
-      callback_status_(CallbackStatus::NOT_CALLED) {}
+      callback_status_(CallbackStatus::NOT_CALLED),
+      last_storage_sizes_({0, 0}) {}
 
 void ArchiveManagerTest::SetUp() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
   ResetManager(temp_dir_.path());
 }
 
 void ArchiveManagerTest::PumpLoop() {
   task_runner_->RunUntilIdle();
 }
 
@@ skipping 10 matching lines @@
 void ArchiveManagerTest::Callback(bool result) {
   callback_status_ =
       result ? CallbackStatus::CALLED_TRUE : CallbackStatus::CALLED_FALSE;
 }
 
 void ArchiveManagerTest::GetAllArchivesCallback(
     const std::set<base::FilePath>& archive_paths) {
   last_archvie_paths_ = archive_paths;
 }
 
+void ArchiveManagerTest::GetStorageStatsCallback(
+    const ArchiveManager::StorageStats& storage_sizes) {
+  last_storage_sizes_ = storage_sizes;
+}
+
 TEST_F(ArchiveManagerTest, EnsureArchivesDirCreated) {
   base::FilePath archive_dir =
       temp_path().Append(FILE_PATH_LITERAL("test_path"));
   ResetManager(archive_dir);
   EXPECT_FALSE(base::PathExists(archive_dir));
 
   // Ensure archives dir exists, when it doesn't.
   manager()->EnsureArchivesDirCreated(
       base::Bind(&ArchiveManagerTest::Callback, base::Unretained(this), true));
   PumpLoop();
@@ skipping 132 matching lines @@
   std::vector<base::FilePath> actual_paths(last_archive_paths().begin(),
                                            last_archive_paths().end());
   // Comparing one to one works because last_archive_paths set is sorted.
   // Because some windows bots provide abbreviated path (e.g. chrome-bot becomes
   // CHROME~2), this test only focuses on file name.
   EXPECT_EQ(expected_paths[0].BaseName(), actual_paths[0].BaseName());
   EXPECT_EQ(expected_paths[1].BaseName(), actual_paths[1].BaseName());
   EXPECT_EQ(expected_paths[2].BaseName(), actual_paths[2].BaseName());
 }
 
+TEST_F(ArchiveManagerTest, GetStorageStats) {
+  base::FilePath archive_path_1;
+  EXPECT_TRUE(base::CreateTemporaryFileInDir(temp_path(), &archive_path_1));
+  base::FilePath archive_path_2;
+  EXPECT_TRUE(base::CreateTemporaryFileInDir(temp_path(), &archive_path_2));
+
+  manager()->GetStorageStats(base::Bind(
+      &ArchiveManagerTest::GetStorageStatsCallback, base::Unretained(this)));
+  PumpLoop();
+  EXPECT_GT(last_storage_sizes().free_disk_space, 0);
+  EXPECT_EQ(last_storage_sizes().total_archives_size,
+            base::ComputeDirectorySize(temp_path()));
+}
+
 }  // namespace offline_pages