[Offline pages] Adding ArchiveManager to abstract offline archives management

components/offline_pages/offline_page_storage_manager_unittest.cc

 // 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.
 
 #include "components/offline_pages/offline_page_storage_manager.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 32 matching lines @@
                            base::SimpleTestClock* clock,
                            TestOptions options = TestOptions::DEFAULT)
       : policy_controller_(new ClientPolicyController()),
         clock_(clock),
         options_(options),
         next_offline_id_(0) {
     for (const auto& setting : page_settings)
       AddPages(setting);
   }
 
+  ~StorageManagerTestClient() override;
+
   void GetAllPages(const MultipleOfflinePageItemCallback& callback) override {
     callback.Run(pages_);
   }
 
   void DeletePagesByOfflineId(const std::vector<int64_t>& offline_ids,
                               const DeletePageCallback& callback) override {
     if (options_ & TestOptions::DELETE_FAILED) {
       callback.Run(DeletePageResult::STORE_FAILURE);
     } else {
       callback.Run(DeletePageResult::SUCCESS);
     }
   }
 
   base::SimpleTestClock* clock() { return clock_; }
 
  private:
   void AddPages(const PageSettings& setting);
 
   std::vector<OfflinePageItem> pages_;
 
   std::unique_ptr<ClientPolicyController> policy_controller_;
 
   base::SimpleTestClock* clock_;
 
   TestOptions options_;
 
   int64_t next_offline_id_;
 };
 
+StorageManagerTestClient::~StorageManagerTestClient() {}
+
 void StorageManagerTestClient::AddPages(const PageSettings& setting) {
   std::string name_space = setting.name_space;
   int fresh_pages_count = setting.fresh_pages_count;
   int expired_pages_count = setting.expired_pages_count;
   base::Time now = clock()->Now();
   // Fresh pages.
   for (int i = 0; i < fresh_pages_count; i++) {
     OfflinePageItem page =
         OfflinePageItem(kTestUrl, next_offline_id_,
                         ClientId(name_space, std::to_string(next_offline_id_)),
@@ skipping 101 matching lines @@
   clock()->Advance(base::TimeDelta::FromMinutes(30));
   manager()->ClearPagesIfNeeded(base::Bind(
       &OfflinePageStorageManagerTest::OnPagesCleared, base::Unretained(this)));
   int last_n_page_limit = policy_controller()
                               ->GetPolicy(kLastNNamespace)
                               .lifetime_policy.page_limit;
   EXPECT_EQ(1 + (100 - last_n_page_limit), last_cleared_page_count());
   EXPECT_EQ(DeletePageResult::SUCCESS, last_delete_page_result());
 }
 }  // namespace offline_pages