[Offline Pages] Implement OfflinePageStorageManager.

components/offline_pages/offline_page_model.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/offline_page_model.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/optional.h"
 #include "base/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
+#include "components/offline_pages/client_policy_controller.h"
 #include "components/offline_pages/offline_page_item.h"
+#include "components/offline_pages/offline_page_storage_manager.h"
 #include "components/offline_pages/proto/offline_pages.pb.h"
 #include "url/gurl.h"
 
 using ArchiverResult = offline_pages::OfflinePageArchiver::ArchiverResult;
 using SavePageResult = offline_pages::OfflinePageModel::SavePageResult;
 
 namespace offline_pages {
 
 namespace {
 
@@ skipping 68 matching lines @@
   CHECK(base::CreateDirectory(archives_dir));
 }
 
 }  // namespace
 
 // static
 bool OfflinePageModel::CanSavePage(const GURL& url) {
   return url.SchemeIsHTTPOrHTTPS();
 }
 
+// protected
+OfflinePageModel::OfflinePageModel()
+    : is_loaded_(false), weak_ptr_factory_(this) {}
+
 OfflinePageModel::OfflinePageModel(
     std::unique_ptr<OfflinePageMetadataStore> store,
     const base::FilePath& archives_dir,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : store_(std::move(store)),
       archives_dir_(archives_dir),
       is_loaded_(false),
       task_runner_(task_runner),
+      policy_controller_(new ClientPolicyController()),
+      storage_manager_(new OfflinePageStorageManager(this)),
       weak_ptr_factory_(this) {
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(EnsureArchivesDirCreated, archives_dir_),
       base::Bind(&OfflinePageModel::OnEnsureArchivesDirCreatedDone,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 OfflinePageModel::~OfflinePageModel() {
 }
 
@@ skipping 362 matching lines @@
   // of total free space includes space taken by offline pages.
   if (reporting_after_delete && free_space_bytes > 0) {
     int percentage_of_free = static_cast<int>(
         1.0 * total_page_size / (total_page_size + free_space_bytes) * 100);
     UMA_HISTOGRAM_PERCENTAGE(
         "OfflinePages.DeletePage.TotalPageSizeAsPercentageOfFreeSpace",
         percentage_of_free);
   }
 }
 
+ClientPolicyController* OfflinePageModel::GetPolicyController() {
+  return policy_controller_.get();
+}
+
 OfflinePageMetadataStore* OfflinePageModel::GetStoreForTesting() {
   return store_.get();
 }
 
+OfflinePageStorageManager* OfflinePageModel::GetStorageManager() {
+  return storage_manager_.get();
+}
+
+bool OfflinePageModel::is_loaded() const {
+  return is_loaded_;
+}
+
 void OfflinePageModel::OnCreateArchiveDone(const GURL& requested_url,
                                            int64_t offline_id,
                                            const ClientId& client_id,
                                            const base::Time& start_time,
                                            const SavePageCallback& callback,
                                            OfflinePageArchiver* archiver,
                                            ArchiverResult archiver_result,
                                            const GURL& url,
                                            const base::FilePath& file_path,
                                            int64_t file_size) {
@@ skipping 264 matching lines @@
 void OfflinePageModel::RunWhenLoaded(const base::Closure& task) {
   if (!is_loaded_) {
     delayed_tasks_.push_back(task);
     return;
   }
 
   task_runner_->PostTask(FROM_HERE, task);
 }
 
 }  // namespace offline_pages